Make a data layers request

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"

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"
 

/**
 * 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.
 */
exportasyncfunctiongetDataLayerUrls(
location:LatLng,
radiusMeters:number,
apiKey:string,
):Promise<DataLayersResponse>{
constargs={
'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 BASE quality, it won't return anything.
// Here we ask for *at least* BASE quality, but if there's a higher quality available,
// the Solar API will return us the highest quality available.
required_quality:'BASE',
};
console.log('GET dataLayers\n',args);
constparams=newURLSearchParams({...args,key:apiKey});
// https://developers.google.com/maps/documentation/solar/reference/rest/v1/dataLayers/get
returnfetch(`https://solar.googleapis.com/v1/dataLayers:get?${params}`).then(
async(response)=>{
constcontent=awaitresponse.json();
if(response.status!=200){
console.error('getDataLayerUrls\n',content);
throwcontent;
}
console.log('dataLayersResponse',content);
returncontent;
},
);
}
solar.ts 

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

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

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"
 

// npm install geotiff geotiff-geokeys-to-proj4 proj4
import*asgeotifffrom'geotiff';
import*asgeokeysToProj4from'geotiff-geokeys-to-proj4';
importproj4from'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.
 */
exportasyncfunctiondownloadGeoTIFF(url:string,apiKey:string):Promise<GeoTiff>{
console.log(`Downloading data layer: ${url}`);
// Include your Google Cloud API key in the Data Layers URL.
constsolarUrl=url.includes('solar.googleapis.com')?url+`&key=${apiKey}`:url;
constresponse=awaitfetch(solarUrl);
if(response.status!=200){
consterror=awaitresponse.json();
console.error(`downloadGeoTIFF failed: ${url}\n`,error);
throwerror;
}
// Get the GeoTIFF rasters, which are the pixel values for each band.
constarrayBuffer=awaitresponse.arrayBuffer();
consttiff=awaitgeotiff.fromArrayBuffer(arrayBuffer);
constimage=awaittiff.getImage();
constrasters=awaitimage.readRasters();
// Reproject the bounding box into lat/lon coordinates.
constgeoKeys=image.getGeoKeys();
constprojObj=geokeysToProj4.toProj4(geoKeys);
constprojection=proj4(projObj.proj4,'WGS84');
constbox=image.getBoundingBox();
constsw=projection.forward({
x:box[0]*projObj.coordinatesConversionParameters.x,
y:box[1]*projObj.coordinatesConversionParameters.y,
});
constne=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]asgeotiff.TypedArray),
),
// The bounding box as a lat/lon rectangle.
bounds:{
north:ne.y,
south:sw.y,
east:ne.x,
west:sw.x,
},
};
}
solar.ts