Datenschichtanfrage senden

Der Endpunkt dataLayers liefert detaillierte Solarinformationen für eine Region um einen bestimmten 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 identifiziert
• Der jährliche Sonnenstrom oder der jährliche Ertrag einer bestimmten Oberfläche
• Monatlicher Sonnenstrom oder monatlicher Ertrag einer bestimmten Oberfläche
• Stündliche Schattierung (24 Stunden)

Weitere Informationen dazu, wie der Fluss durch die Solar API definiert wird, finden Sie unter Solar API-Konzepte.

Datenebenenanfragen

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

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

Fügen Sie Ihre Anfrage-URL-Parameter ein, die Folgendes angeben:

• Breiten- und Längengradkoordinaten des Standorts
• Der Radius der Region, die den Standort umgibt
• 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
• Die minimale Skala der zurückzugebenden Daten in Metern pro Pixel.

Beispiel für eine Datenschichtanfrage

Im folgenden Beispiel werden alle Informationen zu Gebäudeinformationen in einem Radius von 100 Metern für den Standort mit 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&exactQualityRequired=true&pixelSizeMeters=0.5&key=YOUR_API_KEY"

Sie können auch HTTP-Anfragen stellen, indem Sie die URL aus der cURL-Anfrage in die URL-Leiste Ihres Browsers einfügen. Durch die Übergabe des API-Schlüssels erhalten Sie bessere Nutzungs- und Analysefunktionen sowie eine bessere Zugriffskontrolle 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&exactQualityRequired=true"
        

TypeScript

Wenn Sie eine Anfrage an die URL in der Antwort senden möchten, 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;
    },
  );
}
solar.ts

Hinweis: Lesen Sie hierzu den Leitfaden zur Verwendung von TypeScript und Google Maps.

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

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

Hinweis: Lesen Sie hierzu den Leitfaden zur Verwendung von TypeScript und Google Maps.

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;
  };
}
solar.ts

Hinweis: Lesen Sie hierzu den Leitfaden zur Verwendung von TypeScript und Google Maps.

Die API gibt URLs im folgenden Format zurück:

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

Über diese URLs kann auf GeoTIFF-Dateien mit den angeforderten Daten zugegriffen werden.

Beispielantwort

Die Anfrage liefert eine JSON-Antwort in folgendem Format:

{
  "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"
}

Auf Antwortdaten zugreifen

Für den Zugriff auf Daten über Antwort-URLs ist eine zusätzliche Authentifizierung erforderlich. 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 auch HTTP-Anfragen stellen, indem Sie die URL aus der cURL-Anfrage in die URL-Leiste Ihres Browsers einfügen. Durch die Übergabe des API-Schlüssels erhalten Sie bessere Nutzungs- und Analysefunktionen sowie eine bessere Zugriffskontrolle 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

Im folgenden Beispiel wird gezeigt, wie Sie Pixeldatenwerte (die in einzelnen Pixeln eines digitalen Bilds gespeicherten Informationen einschließlich Farbwerten und anderen Attributen) abrufen, den Breiten- und Längengrad aus dem GeoTIFF berechnen und in einem TypeScript-Objekt speichern.

In diesem konkreten Beispiel haben wir uns dafür entschieden, die Typprüfung zuzulassen. Dadurch werden Typfehler reduziert, der Code wurde zuverlässiger und die Wartung wird 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,
    },
  };
}
solar.ts

Hinweis: Lesen Sie hierzu den Leitfaden zur Verwendung von TypeScript und Google Maps.

Mit Ausnahme der RGB-Ebene werden alle TIFF-Dateien in Bildverarbeitungsanwendungen als leere Bilder angezeigt. Wenn Sie heruntergeladene TIFF-Dateien ansehen möchten, importieren Sie sie in eine Kartenanwendungssoftware wie QGIS.

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

Hinweis: Antwort-URLs sind nach der ersten Anfrage nur eine Stunde lang aktiv. Wenn Sie nach diesem Zeitraum auf URLs zugreifen möchten, müssen Sie noch einmal eine Anfrage an den dataLayers-Endpunkt senden.