def __init__(self, start, finish, geo_json: json, weighted=False): self.weighted = weighted self.geo_json = geo_json logger.debug(geo_json["type"]) # A regionmask Object # A list of the Shapely.Polygons selections = list() count = 0 numbers = [] names = [] abbrevs = [] if geo_json["type"] == "FeatureCollection": logger.debug("Found a feature collection...") for p in geo_json["features"]: logger.debug("Found a Feature.") if p["geometry"]["type"] == "Polygon": logger.debug("Found Polygon #%s" % count) points = p["geometry"]["coordinates"] s = shapely.geometry.Polygon(*points) selections.append(s) numbers.append(count) names.append("Selection_%s" % count) abbrevs.append("SEL_%s" % count) count += 1 logger.debug("Making Region Mask with %s Polygons." % count) logger.debug("numbers: %s" % numbers) logger.debug("names: %s" % names) logger.debug("abbrevs: %s" % abbrevs) logger.debug("selections: %s" % selections) self.rmask = regionmask.Regions_cls(0, numbers, names, abbrevs, selections) self.selections = selections logger.debug(["%s" % sel for sel in selections]) # Do once and store # self.mask = self.get_super_sampled_mask() # TODO - remove default creation of mask and require setting the transform according to dataset projection hull = ShapeQuery.get_query_hull(self.rmask) lat1, lon2, lat2, lon1 = hull.bounds # logger.debug(lat1, lon1, lat2, lon2) self.spatio_temporal_query = SpatioTemporalQuery( lat1, lon1, lat2, lon2, start, finish) self.temporal = self.spatio_temporal_query.temporal self.spatial = self.spatio_temporal_query.spatial self.transform = [0.05, 0.0, 111.975, 0.0, -0.05, -9.974999999999994] self.schema = ShapeQuerySchema()
async def consolidate_year(self, y): with open(Model.path() + 'australia.pickle', 'rb') as pickled_australia: australia = pickle.load(pickled_australia) AUmask = regionmask.Regions_cls( 'AUmask', [0], ['Australia'], ['AU'], [australia.polygon]) for year in range(y, y + 1): with xr.open_mfdataset("%s%s_%s*" % (self.outputs['readings']['path'], self.outputs['readings']['prefix'], year), chunks={'time': 1}) as ds: ds['DFMC'] = ds['DFMC'].isel(observations=0, drop=True) dm = ds['DFMC'].isel(time=0) mask = AUmask.mask(dm['longitude'], dm['latitude']) mask_ma = np.ma.masked_invalid(mask) ds = ds.where(mask_ma == 0) logger.debug("--- Saving %s" % (year)) ds.attrs = dict() ds.attrs['crs'] = "+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs " ds.attrs['var_name'] = 'DFMC' ds['time'].attrs['long_name'] = 'time' ds['time'].attrs['name'] = 'time' ds['time'].attrs['standard_name'] = 'time' ds['DFMC'].attrs['units'] = 'z-scores' ds['DFMC'].attrs[ 'long_name'] = 'Dead Fine Fuels Moisture Content - (Percentage wet over dry by weight)' ds['DFMC'].attrs['name'] = self.outputs['readings']['prefix'] ds['DFMC'].attrs['standard_name'] = self.outputs['readings']['prefix'] # logger.debug(ds) # logger.debug(ds[self.outputs['readings']['prefix']]) # File is opened by itself, can't save because we're self locking temp = ds # close the handle first and then save tfile = "%s%s_%s.nc" % (self.path, self.outputs['readings']['prefix'], str(year)) try: os.rename(tfile, tfile + '.tmp') except e: logger.error(e) try: ds.to_netcdf(tfile, mode='w', format='NETCDF4') os.remove(tfile + '.tmp') except e: logger.error(e) return false return True
def state_mask(state, ds, name, abbr): """ create mask from a geodataframe Args: state (geodataframe): state to use ds (xarray.DataArray): DataArray with coords to match name (str): name of state abbr (str): abbreviation of state """ number = [0] region = regionmask.Regions_cls('statemask', number, [name], [abbr], state.geometry.values) mask = region.mask(ds, wrap_lon=True) + 1 return mask
def build_mask(dsbbox, mascon_gdf, dacoords, serialize=False, datadir=None): """ Builds a mask defining the spatial units over which aggregation will occur. Clips the boundaries of the mask to the spatial domain of the underlying dataset. Parameters ---------- dsbbox: List or Tuple representing the minx, miny, maxx, maxy This function currently not being called and should probably be decomissioned soon. """ # Build a polygon around the extent of the LIS output so we can subset the GRACE data coords = [(dsbbox[0], dsbbox[1]), (dsbbox[0], dsbbox[3]), (dsbbox[2], dsbbox[3]), (dsbbox[2], dsbbox[1])] # Create a Shapely polygon from the coordinate-tuple list lispoly = Polygon(coords) df = pd.DataFrame.from_records([{'region_name': 'dataset'}]) geometry = [lispoly] regiondf = gpd.GeoDataFrame(df, geometry=geometry, crs={'init': 'epsg4326'}) gpd_intersect = gpd.overlay(regiondf, mascon_gdf, how='intersection') # Create mask numbers = gpd_intersect.index.values names = gpd_intersect['mascon'].values abbrevs = gpd_intersect['mascon'].values m = regionmask.Regions_cls('region_mask', numbers, names, abbrevs, gpd_intersect.geometry.values) m.name = 'mascon' gracemsk = m.mask(dacoords, lon_name='longitude', lat_name='latitude') gracemsk.name = 'mask' if serialize: if datadir: fname = os.path.join(datadir, 'gracemsk.nc') with ProgressBar(): print('Exporting {}'.format(fname)) gracemsk.to_netcdf(fname) else: print('Need datadir to be specified.') return gracemsk, gpd_intersect
def apply_mask_to( self, result_cube: xr.DataArray) -> (xr.DataArray, xr.DataArray): rc = result_cube[result_cube.attrs['var_name']].isel(time=0) s = rc.shape pickled_aussie = open('./FuelModels/australia.pickle', 'rb') australia = pickle.load(pickled_aussie) numbers = [0] name = ['Australia'] abbrev = ['AU'] AUmask = regionmask.Regions_cls('AUmask', numbers, name, abbrev, [australia.polygon]) au_scaled_mask = AUmask.mask(rc['longitude'], rc['latitude']) au_masked = np.ma.masked_invalid(au_scaled_mask) result_cube = result_cube.where(au_masked == 0) mask = self.get_super_sampled_mask(transform=None, data_shape=s) result_cube['mask'] = xr.DataArray(mask, coords=[ result_cube['latitude'].data, result_cube['longitude'].data ], dims=['latitude', 'longitude']) return result_cube, result_cube['mask']
def build_mask(dsbbox, mascon_gdf, dacoords, serialize=False, datadir=None): """ dsbbox: List or Tuple minx, miny, maxx, maxy """ # Build a polygon around the extent of the LIS output so we can subset the GRACE data coords = [(dsbbox[0], dsbbox[1]), (dsbbox[0], dsbbox[3]), (dsbbox[2], dsbbox[3]), (dsbbox[2], dsbbox[1])] # Create a Shapely polygon from the coordinate-tuple list lispoly = Polygon(coords) df = pd.DataFrame.from_records([{'region_name': 'dataset'}]) geometry = [lispoly] regiondf = gpd.GeoDataFrame(df, geometry=geometry, crs={'init': 'epsg4326'}) gpd_intersect = gpd.overlay(regiondf, mascon_gdf, how='intersection') # Create mask numbers = gpd_intersect.index.values names = gpd_intersect['mascon'].values abbrevs = gpd_intersect['mascon'].values m = regionmask.Regions_cls('region_mask', numbers, names, abbrevs, gpd_intersect.geometry.values) m.name = 'mascon' gracemsk = m.mask(dacoords, lon_name='longitude', lat_name='latitude') gracemsk.name = 'mask' if serialize: if datadir: fname = os.path.join(datadir, 'gracemsk.nc') with ProgressBar(): print('Exporting {}'.format(fname)) gracemsk.to_netcdf(fname) else: print('Need datadir to be specified.') return gracemsk, gpd_intersect
def get_dra_mask(lons, lats): #get 'Data Release Area' mask for the Central Arctic, published by Rothrock et al, 2008 #this is the area for which submarine draft data is available (1979-2000) #and all Kwok papers use this area to show trend extended by IS and CS-2 data #regionmask does not handle well the circular polygons around the NP lon360 = np.where(lons < 0, 360 + lons, lons) poly1 = [[360., 90.], [360., 87.], [345., 87.], [300., 86.58], [230., 80.], [219., 80.], [219., 70.], [205., 72.], [180., 74.], [180., 90.], [360., 90.]] poly2 = [[0., 86.], [0., 90.], [180., 90.], [180., 74.], [175., 75.50], [172., 78.50], [163., 80.50], [126., 78.50], [110., 84.33], [80., 84.42], [57., 85.17], [33., 83.83], [8., 84.08], [0., 86.]] numbers = [0, 1] names = ['Arctic_west', 'Arctic_east'] abbrevs = ['Aw', 'Ae'] Arctic_mask = regionmask.Regions_cls('DRA_mask', numbers, names, abbrevs, [poly1, poly2]) #Make raster mask = Arctic_mask.mask(lons, lats, wrap_lon=True) #Merge mask mask = np.where(mask >= 0, 1, 0) # pcolormesh does not handle NaNs, requires masked array age_mask = np.ma.masked_invalid(mask) ##Plot mask #outpath_plots = 'plots/new/' #outname = outpath_plots+'age_mask_DRA.png' #plot_pcolormesh(lons,lats,age_mask,outname,cmap='viridis',label='Central Arctic Mask=1') #exit() return (age_mask)
def apply_mask_to(self, result_cube: xr.DataArray) -> xr.DataArray: rc = result_cube[result_cube.attrs['var_name']].isel(time=0) s = rc.shape logger.debug(s) australia = regionmask.defined_regions.natural_earth.countries_50.__getitem__( 'Australia') numbers = [0] name = ['Australia'] abbrev = ['AU'] AUmask = regionmask.Regions_cls('AUmask', numbers, name, abbrev, [australia.polygon]) au_scaled_mask = AUmask.mask(rc['longitude'], rc['latitude']) logger.debug('All NaN? %s', np.all(np.isnan(au_scaled_mask))) au_masked = np.ma.masked_invalid(au_scaled_mask) result_cube = result_cube.where(au_masked == 0) self.weighted = False # DEBUGGING!! if self.weighted: # Apply Spatial Mask on every timeslice. # TODO - DEBUG THIS - use the affine / transform of the resultcube to create and project the mask!!! mask = self.get_super_sampled_mask( transform=[0.05, 0.0, 111.975, 0.0, -0.05, -9.974999999999994], data_shape=s) logger.debug(mask) mask3d = np.broadcast_to( mask != 0, result_cube[result_cube.attrs['var_name']].shape) fuel_moistures = result_cube.where(mask3d != 0) * (mask3d / 255) logger.debug("Masked by weighted area!") else: # # Minimal case - shape is entirely contained in just one cell... # # TODO - remove hard-coded spatial resolution # if result_cube['longitude'].max() - result_cube['longitude'].min() <= 0.05 and \ # result_cube['latitude'].max() - result_cube['latitude'].min() <= 0.05: # # single latitude # else: # Binary Masking mask = self.rmask.mask(result_cube['longitude'], result_cube['latitude'], xarray=True) mask = mask.rename({'lat': 'latitude', 'lon': 'longitude'}) region = np.ma.filled(mask.astype(float), np.nan) # Set all values in the mask layer to either zero or NaN # Otherwise the selection indexes will determine the results region = region * 0 # Can then use WHERE to get Binary True/False masking for all parts # of the selection as a unified group... fuel_moistures = result_cube.where(region == 0) logger.debug("Masked by binary inclusion: ") # logger.debug('All NaN?', np.all(np.isnan(fuel_moistures.data))) return fuel_moistures
data = t_in + model + '_2018*_sfc.nc' ds = xr.open_mfdataset(data, chunks = {'time': 10}) # With the function assign_coords the longitude is converted from the 0-360 range to -180,180 ds = ds.assign_coords(longitude=(((ds.longitude + 180) % 360) - 180)).sortby('longitude') ############################## PART TO MASK THE WHOLE AFRICA CONTINENT #http://datapages.com/gis-map-publishing-program/gis-open-files/global-framework/global-heat-flow-database/shapefiles-list # Load the shapefile PATH_TO_SHAPEFILE = './continent_shapefile/continent.shp' nuts = gpd.read_file(PATH_TO_SHAPEFILE) nuts # CALCULATE MASK nuts_mask_poly = regionmask.Regions_cls(name = 'nuts_mask', numbers = list(range(0,8)), names = list(nuts.CONTINENT), abbrevs = list(nuts.CONTINENT), outlines = list(nuts.geometry.values[i] for i in range(0,8))) print(nuts_mask_poly) mask = nuts_mask_poly.mask(ds.isel(time = 0).sel(latitude = slice(39, -38), longitude = slice(-25, 55)), lat_name='latitude', lon_name='longitude') mask mask.to_netcdf('./mask_all_continent.nc') plt.figure(figsize=(12,8)) ax = plt.axes() mask.plot(ax = ax) nuts.plot(ax = ax, alpha = 0.8, facecolor = 'none', lw = 1) ID_COUNTRY = 3 print(nuts.CONTINENT[ID_COUNTRY]) lat = mask.latitude.values lon = mask.longitude.values
import matplotlib as mpl PATH_TO_SHAPEFILE = './shapefiles/Africa_Countries.shp' countries = gpd.read_file(PATH_TO_SHAPEFILE) countries.head() my_list = list(countries['CODE']) my_list_unique = set(list(countries['CODE'])) indexes = [my_list.index(x) for x in my_list_unique] model = 'D:/Utilisateurs/guillaume/Desktop/PROJET_AFR44/ARC2/netcdf/ARC2_198901.nc' data = model ds = xr.open_mfdataset(data, chunks={'time': 10}) countries_mask_poly = regionmask.Regions_cls( name='COUNTRY', numbers=indexes, names=countries.COUNTRY[indexes], abbrevs=countries.COUNTRY[indexes], outlines=list(countries.geometry.values[i] for i in range(0, countries.shape[0]))) mask = countries_mask_poly.mask(ds.isel(time=0), lat_name='lat', lon_name='lon') mask.to_netcdf('./mask_ARC2_by_countries.nc') mask_ouganda = mask.where(mask == 758) / mask.where(mask == 758) mask_ouganda.to_netcdf('./mask_ARC2_Ouganda.nc') np_points = (mask_ouganda.values == 1).sum() plt.figure(figsize=(16, 8))
def get_poly_mask(lons, lats): #create a geographical polygon for the Central Arctic (without the narrow band off the CAA) #https://regionmask.readthedocs.io/en/stable/_static/notebooks/create_own_regions.html #make two masks - one for W and one for E Arctic #regionmask does not handle well the circular polygons around the NP lon360 = np.where(lons < 0, 360 + lons, lons) #print(lon360) #i,j coordinates of corner points can be found by exploring display in ncview #W Arctic poly1 = [] pt = [360, 90] poly1.append(pt) pt = [360, lats[273, 115]] poly1.append(pt) pt = [lon360[273, 115], lats[273, 115]] poly1.append(pt) pt = [lon360[260, 128], lats[260, 128]] poly1.append(pt) pt = [lon360[239, 136], lats[239, 136]] poly1.append(pt) pt = [lon360[228, 145], lats[228, 145]] poly1.append(pt) pt = [lon360[210, 148], lats[210, 148]] poly1.append(pt) pt = [lon360[194, 147], lats[194, 147]] poly1.append(pt) pt = [lon360[157, 156], lats[157, 156]] poly1.append(pt) pt = [lon360[113, 174], lats[113, 174]] poly1.append(pt) pt = [lon360[89, 157], lats[89, 157]] poly1.append(pt) pt = [lon360[29, 123], lats[29, 123]] poly1.append(pt) ##more radical (even further away from the CAA coast) #pt = [lon360[260,132],lats[260,132]];poly1.append(pt) #pt = [lon360[239,140],lats[239,140]];poly1.append(pt) #pt = [lon360[228,149],lats[228,149]];poly1.append(pt) #pt = [lon360[210,152],lats[210,152]];poly1.append(pt) #pt = [lon360[194,151],lats[194,151]];poly1.append(pt) #pt = [lon360[157,160],lats[157,160]];poly1.append(pt) #pt = [lon360[113,178],lats[113,178]];poly1.append(pt) #pt = [lon360[65,160],lats[65,160]];poly1.append(pt) #pt = [lon360[24,162],lats[29,162]];poly1.append(pt) pt = [lon360[3, 194], lats[3, 194]] poly1.append(pt) pt = [lon360[3, 344], lats[3, 344]] poly1.append(pt) pt = [180, 65] poly1.append(pt) pt = [180, 90] poly1.append(pt) pt = [270, 90] poly1.append(pt) pt = [360, 90] poly1.append(pt) #print(poly1) #E Arctic poly2 = [] pt = [0, 90] poly2.append(pt) pt = [90, 90] poly2.append(pt) pt = [180, 90] poly2.append(pt) pt = [180, 65] poly2.append(pt) pt = [lon360[135, 386], lats[135, 386]] poly2.append(pt) pt = [lon360[238, 390], lats[238, 390]] poly2.append(pt) pt = [lon360[310, 344], lats[310, 344]] poly2.append(pt) pt = [lon360[449, 301], lats[449, 301]] poly2.append(pt) pt = [lon360[350, 122], lats[350, 122]] poly2.append(pt) pt = [0, lats[273, 115]] poly2.append(pt) pt = [0, 90] poly2.append(pt) #print(poly2) numbers = [0, 1] names = ['Arctic_west', 'Arctic_east'] abbrevs = ['Aw', 'Ae'] Arctic_mask = regionmask.Regions_cls('Arctic_mask', numbers, names, abbrevs, [poly1, poly2]) ##Plot polygons in Mercator projection #ax=Arctic_mask.plot() #ax.set_extent([-180, 180, 45, 90], ccrs.PlateCarree()) #plt.show() #Make raster mask = Arctic_mask.mask(lons, lats, wrap_lon=True) #Merge mask mask = np.where(mask >= 0, 1, 0) # pcolormesh does not handle NaNs, requires masked array age_mask = np.ma.masked_invalid(mask) ##Plot mask #outpath_plots = 'plots/run04/' #outname = outpath_plots+'age_mask_rest.png' #plot_pcolormesh(lons,lats,age_mask,outname,cmap='viridis',label='Central Arctic Mask=1') #exit() return (age_mask)
def getRegion( self, shape: gpd.GeoDataFrame, name_col: str, poly_index, buffer: float = 0.0 ) -> Tuple[Polygon,Regions_cls]: poly_name: str = [ shape[name_col].tolist()[poly_index] ] poly: Polygon = self.remove_third_dimension( shape.geometry.values[poly_index] ) if buffer > 0: poly = poly.buffer( buffer ) print( f" Creating region for polygon with bounds = {poly.envelope.bounds}" ) return poly, regionmask.Regions_cls( poly_name, [0], [poly_name], [poly_name], [poly] )
strlist = ['1', '1'] intlist = [1, 1] polygons = [Polygon(cham_geom), Polygon(neighbor_geom)] boundary = cascaded_union(polygons) # results in multipolygon sometimes if shape_mask.geom_type == 'MultiPolygon': # extract polygons out of multipolygon list = [] for polygon in boundary: list.append(polygon) mask_poly = regionmask.Regions_cls( name='FID_BV_Out', numbers=intlist, names=strlist, abbrevs=strlist, outlines=list(shape_mask.geometry.values[i] for i in range(0, len(shape_mask.FID_BV_Out)))) mask_poly = regionmask.Regions_cls(name='FID_BV_Out', numbers=intlist, names=strlist, abbrevs=strlist, outlines=list(shape_mask.geometry[0])[1]) outlines = list(shape_mask.geometry.values[i] for i in range(0, len(shape_mask.FID_BV_Out))) list(shape_mask.geometry[0])[1] mask = mask_poly.mask(ds.isel(time=0), lat_name='lat', lon_name='lon')
# obtain path and file name information of all *.nc files in '~/ConUS/Climate' for dirpath, dirnames, filenames in os.walk( "/data/rajagopalan/MC2/Harddrive_MC2/ConUS/Climate"): for filename in [f for f in filenames if f.endswith("ppt.nc")]: f_d.append(os.path.join(dirpath, filename)) all_f = len(f_d) # loop over all of these *.nc files for file in range(0, all_f): ncf = xr.open_dataset(f_d[file]) print(ncf) yr_len = len(ncf.time) lat_n = len(ncf.lat) lon_n = len(ncf.lon) rb_mask_poly = regionmask.Regions_cls( name='Rangelands Distrcits', numbers=list(range(0, rb_len)), names=list(rb.DISTRICTNA), abbrevs=list(rb.DISTRICTOR), outlines=list(rb.geometry.values[i] for i in range(0, rb_len))) mask = rb_mask_poly.mask(ncf.isel(lat=slice(0, lat_n), lon=slice(0, lon_n)), lat_name='lat', lon_name='lon') # public values lat = mask.lat.values lon = mask.lon.values v_m = [] # a tentitative run to find out the deadspots for r_d in range(0, rb_len): print("Rangeland district ID", r_d) print("Rangeland district name", rb.DISTRICTOR[r_d]) try:
def __init__(self, start, finish, geo_json, weighted=False): self.weighted = weighted if type(geo_json) == type(str()): # try: self.geo_json = geojson.loads(geo_json) # except: # try: # # Url Encoded? # self.geo_json = geojson.loads(urldecode(geojson)) # except: # pass elif type(geo_json) == type(dict()): self.geo_json = geojson.loads(geojson.dumps(geo_json)) elif type(geo_json) == geojson.feature.FeatureCollection: self.geo_json = geo_json else: logger.debug("Couldn't parse GeoJSON.") # logger.debug("We got:", type(geo_json)) raise ValueError("Couldn't parse GeoJSON: " + geo_json) lon1 = 180 lon2 = -180 lat1 = 90 lat2 = -90 # A regionmask Object # A list of the Shapely.Polygons selections = list() count = 0 numbers = [] names = [] abbrevs = [] for p in self.geo_json["features"]: min_lon, min_lat, max_lon, max_lat = self.bbox(p) lat1 = min(min_lat, lat1) lat2 = max(max_lat, lat2) lon1 = min(min_lon, lon1) lon2 = max(max_lon, lon2) logger.debug("Found a Feature.") if p["geometry"]["type"] == "Polygon" or p["geometry"][ "type"] == "MultiPolygon": logger.debug("Found Polygon/MultiPolygon #%s" % count) s = shape(p["geometry"]) selections.append(s) numbers.append(count) names.append("Selection_%s" % count) abbrevs.append("SEL_%s" % count) count += 1 logger.debug("Making Region Mask with %s Polygons." % count) logger.debug("numbers: %s" % numbers) logger.debug("names: %s" % names) logger.debug("abbrevs: %s" % abbrevs) logger.debug("selections: %s" % selections) self.rmask = regionmask.Regions_cls(0, numbers, names, abbrevs, selections) self.selections = selections logger.debug(["%s" % sel for sel in selections]) # Do once and store # self.mask = self.get_super_sampled_mask() # TODO - remove default creation of mask and require setting the transform according to dataset projection # hull = ShapeQuery.get_query_hull(self.rmask) # lat1, lon2, lat2, lon1 = hull.bounds self.spatio_temporal_query = SpatioTemporalQuery( lat1, lon1, lat2, lon2, start, finish) self.temporal = self.spatio_temporal_query.temporal self.spatial = self.spatio_temporal_query.spatial self.transform = [0.05, 0.0, 111.975, 0.0, -0.05, -9.974999999999994] self.schema = ShapeQuerySchema()
# format data into timeseries # ---------------------------------- lat_min1, lat_max1, lon_min1, lon_max1 = 70, 80, 90, 160 lat_min2, lat_max2, lon_min2, lon_max2 = 80, 87, 90, 170 lat_min1, lat_max1, lon_min1, lon_max1 = 79, 80.4, 112, 140 lat_min2, lat_max2, lon_min2, lon_max2 = 80.45, 87, 128, 155 roi1 = [[lon_min1, lat_min1], [lon_max1, lat_min1], [lon_max1, lat_max1], [lon_min1, lat_max1]] roi2 = [[lon_min2, lat_min2], [lon_max2, lat_min2], [lon_max2, lat_max2], [lon_min2, lat_max2]] roi = [roi1, roi2] id = [0, 1] name = ['roi_laptev', 'roi_laptev_north'] abbrev = ['roi1', 'roi2'] mask = regionmask.Regions_cls('roi', id, name, abbrev, roi) mask_ = mask.mask(ds, lon_name='longitude', lat_name='latitude') mask_ice = mask.mask(ds_ice, lon_name='longitude', lat_name='latitude') # ----- aod # ts_aod = ds.aod550.mean(dim=('latitude','longitude')) aod = ds.aod550.where(mask_ == 0) ts_aod_roi1 = aod.mean(dim=('latitude', 'longitude')) ts_aod25_roi1 = aod.quantile(0.25, dim=('latitude', 'longitude')) ts_aod75_roi1 = aod.quantile(0.75, dim=('latitude', 'longitude')) aod = ds.aod550.where(mask_ == 1) ts_aod25_roi2 = aod.quantile(0.25, dim=('latitude', 'longitude')) ts_aod75_roi2 = aod.quantile(0.75, dim=('latitude', 'longitude')) ts_aod_roi2 = aod.mean(dim=('latitude', 'longitude')) # ----- ice
def getRegions( self, region_name: str, name_col: str, shape: gpd.GeoDataFrame ) -> Regions_cls: poly_index = 6 names = [ shape[name_col].tolist()[poly_index] ] poly: Polygon = self.remove_third_dimension( shape.geometry.values[poly_index] ) print( f" Creating region for polygon with bounds = {poly.envelope.bounds}" ) return regionmask.Regions_cls( region_name, list(range(len(names))), names, names, [poly] )