Struct google_api_proto::google::maps::solar::v1::DataLayers

pub struct DataLayers {
    pub imagery_date: Option<Date>,
    pub imagery_processed_date: Option<Date>,
    pub dsm_url: String,
    pub rgb_url: String,
    pub mask_url: String,
    pub annual_flux_url: String,
    pub monthly_flux_url: String,
    pub hourly_shade_urls: Vec<String>,
    pub imagery_quality: i32,
}

Information about the solar potential of a region. The actual data are contained in a number of GeoTIFF files covering the requested region, for which this message contains URLs: Each string in the DataLayers message contains a URL from which the corresponding GeoTIFF can be fetched. These URLs are valid for a few hours after they’ve been generated. Most of the GeoTIFF files are at a resolution of 0.1m/pixel, but the monthly flux file is at 0.5m/pixel, and the hourly shade files are at 1m/pixel. If a pixel_size_meters value was specified in the GetDataLayersRequest, then the minimum resolution in the GeoTIFF files will be that value.

Fields

imagery_date: Option<Date>

When the source imagery (from which all the other data are derived) in this region was taken. It is necessarily somewhat approximate, as the images may have been taken over more than one day.

imagery_processed_date: Option<Date>

When processing was completed on this imagery.

dsm_url: String

The URL for an image of the DSM (Digital Surface Model) of the region. Values are in meters above EGM96 geoid (i.e., sea level). Invalid locations (where we don’t have data) are stored as -9999.

rgb_url: String

The URL for an image of RGB data (aerial photo) of the region.

mask_url: String

The URL for the building mask image: one bit per pixel saying whether that pixel is considered to be part of a rooftop or not.

annual_flux_url: String

The URL for the annual flux map (annual sunlight on roofs) of the region. Values are kWh/kW/year. This is unmasked flux: flux is computed for every location, not just building rooftops. Invalid locations are stored as -9999: locations outside our coverage area will be invalid, and a few locations inside the coverage area, where we were unable to calculate flux, will also be invalid.

monthly_flux_url: String

The URL for the monthly flux map (sunlight on roofs, broken down by month) of the region. Values are kWh/kW/year. The GeoTIFF pointed to by this URL will contain twelve bands, corresponding to January…December, in order.

hourly_shade_urls: Vec<String>

Twelve URLs for hourly shade, corresponding to January…December, in order. Each GeoTIFF will contain 24 bands, corresponding to the 24 hours of the day. Each pixel is a 32 bit integer, corresponding to the (up to) 31 days of that month; a 1 bit means that the corresponding location is able to see the sun at that day, of that hour, of that month. Invalid locations are stored as -9999 (since this is negative, it has bit 31 set, and no valid value could have bit 31 set as that would correspond to the 32nd day of the month).

An example may be useful. If you want to know whether a point (at pixel location (x, y)) saw sun at 4pm on the 22nd of June you would:

1. fetch the sixth URL in this list (corresponding to June).
2. look up the 17th channel (corresponding to 4pm).
3. read the 32-bit value at (x, y).
4. read bit 21 of the value (corresponding to the 22nd of the month).
5. if that bit is a 1, then that spot saw the sun at 4pm 22 June.

More formally: Given month (1-12), day (1…month max; February has 28 days) and hour (0-23), the shade/sun for that month/day/hour at a position (x, y) is the bit

(hourly_shade\[month - 1\])(x, y)\[hour\] & (1 << (day - 1))

where (x, y) is spatial indexing, \[month - 1\] refers to fetching the month - 1st URL (indexing from zero), \[hour\] is indexing into the channels, and a final non-zero result means “sunny”. There are no leap days, and DST doesn’t exist (all days are 24 hours long; noon is always “standard time” noon).

imagery_quality: i32

The quality of the result’s imagery.

Implementations

impl DataLayers

pub fn imagery_quality(&self) -> ImageryQuality

Returns the enum value of imagery_quality, or the default if the field is set to an invalid enum value.

pub fn set_imagery_quality(&mut self, value: ImageryQuality)

Sets imagery_quality to the provided enum value.

Trait Implementations

impl Clone for DataLayers

fn clone(&self) -> DataLayers

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DataLayers

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for DataLayers

fn default() -> Self

Returns the “default value” for a type.

impl Message for DataLayers

fn encoded_len(&self) -> usize

Returns the encoded length of the message without a length delimiter.

fn clear(&mut self)

Clears the message, resetting all fields to their default.

fn encode<B>(&self, buf: &mut B) -> Result<(), EncodeError>

where B: BufMut, Self: Sized,

Encodes the message to a buffer.

fn encode_to_vec(&self) -> Vec<u8>

where Self: Sized,

Encodes the message to a newly allocated buffer.

fn encode_length_delimited<B>(&self, buf: &mut B) -> Result<(), EncodeError>

where B: BufMut, Self: Sized,

Encodes the message with a length-delimiter to a buffer.

fn encode_length_delimited_to_vec(&self) -> Vec<u8>

where Self: Sized,

Encodes the message with a length-delimiter to a newly allocated buffer.

fn decode<B>(buf: B) -> Result<Self, DecodeError>

where B: Buf, Self: Default,

Decodes an instance of the message from a buffer.

fn decode_length_delimited<B>(buf: B) -> Result<Self, DecodeError>

where B: Buf, Self: Default,

Decodes a length-delimited instance of the message from the buffer.

fn merge<B>(&mut self, buf: B) -> Result<(), DecodeError>

where B: Buf, Self: Sized,

Decodes an instance of the message from a buffer, and merges it into self.

fn merge_length_delimited<B>(&mut self, buf: B) -> Result<(), DecodeError>

where B: Buf, Self: Sized,

Decodes a length-delimited instance of the message from buffer, and merges it into self.

impl PartialEq for DataLayers

fn eq(&self, other: &DataLayers) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for DataLayers