def test_ExclusionCalculator_excludeVectorType(): # exclude all features directly ec = gl.ExclusionCalculator(aachenShape) ec.excludeVectorType(cddaVector) assert np.isclose(np.nanmean(ec.availability), 76.47581482) assert np.isclose(np.nanstd(ec.availability), 42.41498947) # exclude all features directly, new srs ec = gl.ExclusionCalculator(aachenShape, srs='latlon', pixelRes=0.005) ec.excludeVectorType(cddaVector) assert np.isclose(np.nanmean(ec.availability), 76.31578827) assert np.isclose(np.nanstd(ec.availability), 42.51445770) # exclude a selection of features ec = gl.ExclusionCalculator(aachenShape) ec.excludeVectorType(cddaVector, where="YEAR>2000") assert np.isclose(np.nanmean(ec.availability), 86.89811707) assert np.isclose(np.nanstd(ec.availability), 33.74209595) # exclude a selection of features with buffer ec = gl.ExclusionCalculator(aachenShape) ec.excludeVectorType(cddaVector, where="YEAR>2000", buffer=400) assert np.isclose(np.nanmean(ec.availability), 77.95021057) assert np.isclose(np.nanstd(ec.availability), 41.45823669)
def calculate_pv_area(region): # Quaschning, Volker. Systemtechnik einer klimaverträglichen Elektrizitätsversorgung in Deutschland für # das 21. Jahrhundert. Düsseldorf, 2000 # Fraunhofer Institut für Windenergie und Energiesystemtechnik (IWES). Vorstudie zur Integration großer # Anteile Photovoltaik in die elektrische Energieversorgung – Studie im Auftrag des BSW - Bundesverband # Solarwirtschaft e.V. – ergänzte Fassung vom 29.05.2012. 2012 # WG: 818.31 km² und NWG: 698 km² Gesamt: 1516 km² # Divide Potential by eligible area in Germany share_pv = 1516 / 43677 # Intialise ExclusionCalculator object ecPV = gl.ExclusionCalculator(region, srs=3035, pixelSize=100, limitOne=False) # Perform exclusion ecPV.excludePrior("settlement_proximity", value=0) ecPV.excludePrior("settlement_urban_proximity", value=0) # Calculate area eligible for pv area_total = (float(ecPV.maskPixels) / 100) * 1e6 # Fläche in m² area_excluded = ecPV.areaAvailable area_available = area_total - area_excluded area_pv = area_available * share_pv return area_pv
def calculate_potential(gid, save_map=None): feature = gk.vector.extractFeature(paths["regions"], where=gid) ec = gl.ExclusionCalculator(feature.geom) corine = config.get("corine", {}) if isinstance(corine, list): corine = {'grid_codes': corine} if "grid_codes" in corine: ec.excludeRasterType(clc, value=corine["grid_codes"], invert=True) if corine.get("distance", 0.) > 0.: ec.excludeRasterType(clc, value=corine["distance_grid_codes"], buffer=corine["distance"]) if config.get("natura", False): ec.excludeRasterType(natura, value=1) if "max_depth" in config: ec.excludeRasterType(gebco, (None, -config["max_depth"])) # TODO compute a distance field as a raster beforehand if 'max_shore_distance' in config: ec.excludeVectorType(paths["country_shapes"], buffer=config['max_shore_distance'], invert=True) if 'min_shore_distance' in config: ec.excludeVectorType(paths["country_shapes"], buffer=config['min_shore_distance']) if save_map is not None: ec.draw() plt.savefig(save_map, transparent=True) plt.close() availability = downsample_to_coarse_grid(bounds, dx, dy, ec.region, np.where(ec.region.mask, ec._availability, 0)) return csr_matrix(gk.raster.extractMatrix(availability).flatten() / 100.)
def test_ExclusionCalculator_excludePrior(): # make a prior source pr = gl.core.priors.PriorSource(priorSample) # test same srs ec = gl.ExclusionCalculator(aachenShape) ec.excludePrior(pr, value=(400, None)) assert np.isclose(np.nanmean(ec.availability), 24.77587891) assert np.isclose(np.nanstd(ec.availability), 43.17109680) # test different srs and resolution ec = gl.ExclusionCalculator(aachenShape, srs='latlon', pixelRes=0.001) ec.excludePrior(pr, value=(400, None)) assert np.isclose(np.nanmean(ec.availability), 24.83173180) assert np.isclose(np.nanstd(ec.availability), 41.84893036)
def test_ExclusionCalculator_save(): ec = gl.ExclusionCalculator(aachenShape) ec.save(join(RESULTDIR, "save1.tif")) mat = gk.raster.extractMatrix(join(RESULTDIR, "save1.tif")) assert np.nansum(mat - ec.availability) == 0 assert np.isclose(np.nansum(mat), 28461360) assert np.isclose(np.nanstd(mat), 77.2323849648)
def test_ExclusionCalculator_draw(): ec = gl.ExclusionCalculator(aachenShape) ec._availability[:, 140:160] = 0 ec._availability[140:160, :] = 0 ec.draw() plt.savefig(join(RESULTDIR, "DrawnImage.png"), dpi=200) plt.close()
def test_ExclusionCalculator_pruneIsolatedAreas(): # make a prior source pr = gl.core.priors.PriorSource(priorSample) ec = gl.ExclusionCalculator(aachenShape) ec.excludePrior(pr, value=(None, 400)) ec.pruneIsolatedAreas(12000000) assert np.isclose(np.nanmean(ec.availability), 65.41215515) assert np.isclose(np.nanstd(ec.availability), 47.56538391)
def test_ExclusionCalculator_shrinkAvailability(): # make a prior source pr = gl.core.priors.PriorSource(priorSample) ec = gl.ExclusionCalculator(aachenShape) ec.excludePrior(pr, value=(None, 400)) ec.shrinkAvailability(500) assert np.isclose(np.nanmean(ec.availability), 41.88655853) assert np.isclose(np.nanstd(ec.availability), 49.33732986)
def test_ExclusionCalculator_excludeRegionEdge(): # make a prior source pr = gl.core.priors.PriorSource(priorSample) ec = gl.ExclusionCalculator(aachenShape) ec.excludePrior(pr, value=(None, 400)) ec.excludeRegionEdge(500) assert np.isclose(np.nanmean(ec.availability), 63.68544388) assert np.isclose(np.nanstd(ec.availability), 48.09062958)
def test_multiple_exclusions(): pr = gl.core.priors.PriorSource(priorSample) ec = gl.ExclusionCalculator(aachenShape) # apply exclusions ec.excludePrior(pr, value=(None, 400)) ec.excludeVectorType(cddaVector, where="YEAR>2000") ec.excludeRasterType(clcRaster, value=(None, 12)) assert np.isclose(np.nanmean(ec.availability), 37.1109619141, 1e-6) assert np.isclose(np.nanstd(ec.availability), 48.3101692200, 1e-6)
def test_ExclusionCalculator_excludeVectorType(): # exclude all features directly ec = gl.ExclusionCalculator(aachenShape) ec.excludeVectorType(cddaVector) assert np.isclose(np.nanmean(ec.availability), 76.47581482) assert np.isclose(np.nanstd(ec.availability), 42.41498947) # exclude all features directly, new srs ec = gl.ExclusionCalculator(aachenShape, srs='latlon', pixelRes=0.005) ec.excludeVectorType(cddaVector) assert np.isclose(np.nanmean(ec.availability), 76.31578827) assert np.isclose(np.nanstd(ec.availability), 42.51445770) # exclude a selection of features ec = gl.ExclusionCalculator(aachenShape) ec.excludeVectorType(cddaVector, where="YEAR>2000") assert np.isclose(np.nanmean(ec.availability), 86.89811707) assert np.isclose(np.nanstd(ec.availability), 33.74209595) # exclude a selection of features with buffer ec = gl.ExclusionCalculator(aachenShape) ec.excludeVectorType(cddaVector, where="YEAR>2000", buffer=400) assert np.isclose(np.nanmean(ec.availability), 77.95021057) assert np.isclose(np.nanstd(ec.availability), 41.45823669) # test with intermediate functionality for i in range(2): ec = gl.ExclusionCalculator(aachenShape) ec.excludeVectorType( cddaVector, where="YEAR>2000", buffer=400, intermediate=join(RESULTDIR, "exclude_vector_intermediate.tif")) assert isfile(join(RESULTDIR, "exclude_vector_intermediate.tif")) assert np.isclose(np.nanmean(ec.availability), 77.95021057) assert np.isclose(np.nanstd(ec.availability), 41.45823669)
def test_ExclusionCalculator_excludeSet(): ec = gl.ExclusionCalculator(aachenShape) exclusion_set = pd.read_csv(gl._test_data_["sample_exclusion_set.csv"]) ec.excludeSet( exclusion_set=exclusion_set, clc=gl._test_data_['clc-aachen_clipped.tif'], osm_roads=gl._test_data_["aachenRoads.shp"], verbose=False, ) assert np.isclose(np.nanmean(ec.availability), 15.231732) assert np.isclose(np.nanstd(ec.availability), 35.93282)
def test_ExclusionCalculator___init__(): # Test by giving a shapefile ec = gl.ExclusionCalculator(aachenShape) assert ec.region.mask.shape == (509, 304) assert np.isclose(ec.region.mask.sum(), 70944) assert np.isclose(ec.region.mask.std(), 0.498273451386) # Test by giving a region mask rm = gk.RegionMask.load(aachenShape, padExtent=5000) ec = gl.ExclusionCalculator(rm) assert ec.region.mask.shape == (609, 404) assert np.isclose(ec.region.mask.sum(), 70944) assert np.isclose(ec.region.mask.std(), 0.45299387483) # Test by giving a region mask with different resolution and srs rm = gk.RegionMask.load(aachenShape, srs=gk.srs.EPSG4326, pixelRes=0.001) ec = gl.ExclusionCalculator(rm) assert ec.region.mask.shape == (457, 446) assert np.isclose(ec.region.mask.sum(), 90296) assert np.isclose(ec.region.mask.std(), 0.496741981394)
def test_ExclusionCalculator_distributeItems(): # make a prior source pr = gl.core.priors.PriorSource(priorSample) ec = gl.ExclusionCalculator(aachenShape) ec.excludePrior(pr, value=(400, None)) # Do a regular distribution ec.distributeItems(1000, output=join(RESULTDIR, "distributeItems1.shp"), outputSRS=3035) geoms = gk.vector.extractFeatures(join(RESULTDIR, "distributeItems1.shp")) assert geoms.shape[0] == 287 minDist = 1000000 for gi in range(geoms.shape[0] - 1): for gj in range(gi + 1, geoms.shape[0]): d = geoms.geom[gi].Distance(geoms.geom[gj]) if d < minDist: minDist = d I = (gi, gj) assert minDist >= 999 # Do an axial distribution ec.distributeItems((1000, 300), axialDirection=180, output=join(RESULTDIR, "distributeItems2.shp"), outputSRS=3035) geoms = gk.vector.extractFeatures(join(RESULTDIR, "distributeItems2.shp")) assert geoms.shape[0] == 882 x = np.array([g.GetX() for g in geoms.geom]) y = np.array([g.GetY() for g in geoms.geom]) for gi in range(geoms.shape[0] - 1): d = (x[gi] - x[gi + 1:])**2 / 1000**2 + (y[gi] - y[gi + 1:])**2 / 300**2 assert (d >= 1).all() # Axial objects too close # Do make areas ec.distributeItems(2000, asArea=True, output=join(RESULTDIR, "distributeItems3.shp"), outputSRS=4326) geoms = gk.vector.extractFeatures(join(RESULTDIR, "distributeItems3.shp")) assert np.isclose(geoms.shape[0], 97) assert np.isclose(geoms.area.mean(), 0.000230714164474) assert np.isclose(geoms.area.std(), 8.2766693979e-05)
def calculate_PV_sites(region, invert=True, separation=1000, name='NoRegion', convert2epsg=True): # Choose Region ecPV = gl.ExclusionCalculator(region, srs=3035, pixelSize=100, limitOne=False) # Apply selected exclusion criteria ecPV.excludePrior(pr.settlement_proximity, value=None) ecPV.excludePrior(pr.settlement_urban_proximity, value=None) ecPV.excludePrior(pr.industrial_proximity, value=None) # Placement Algorithm ecPV.distributeItems(separation=1000, invert=invert, outputSRS=4326) # Extract and convert site coords of turbines site_coords = pd.DataFrame(ecPV.itemCoords) site_coords.columns = ['latitude','longitude'] site_coords_gdf = geom.create_geo_df(site_coords, wkt_column=None, lon_column="longitude", lat_column='latitude') # Convert2epsg for plotting purposes if convert2epsg==True: trsf= site_coords_gdf["geometry"] site_coords_gdf_epsg3857 = trsf.to_crs(epsg=3857) # Save coords in EPSG3587 to hard disk site_coords_gdf_epsg3857.to_file("site_coordsPV_epsg3857_" + name + ".geojson", driver='GeoJSON') site_coords_gdf.to_file("site_coordsPV_WGS84_" + name + ".geojson", driver='GeoJSON') elif convert2epsg==False: site_coords_gdf.to_file("site_coordsPV_WGS84_" + name + ".geojson", driver='GeoJSON') # Calculate Power per Site in MW p_mean = 300000 / len(site_coords) #Total possible PV-Power in MW divided by site count # Write turbines to power plants df res_df_PV = pd.DataFrame(columns=["energy_source_level_1", "energy_source_level_2", "technology", "electrical_capacity", "lon", "lat", "data_source"]) res_df_PV["lon"] = site_coords["latitude"] res_df_PV["lat"] = site_coords["longitude"] res_df_PV["energy_source_level_1"] = 'Renewable energy' res_df_PV["energy_source_level_2"] = 'Solar' res_df_PV["technology"] = 'Photovoltaics' res_df_PV["electrical_capacity"] = p_mean res_df_PV["data_source"] = 'GLAES' return res_df_PV, ecPV
def test_ExclusionCalculator_distributeItems(): # make a prior source pr = gl.core.priors.PriorSource(priorSample) ec = gl.ExclusionCalculator(aachenShape) ec.excludePrior(pr, value=(400, None)) # Do a regular distribution ec.distributeItems(1000, output=join(RESULTDIR, "distributeItems1.shp"), outputSRS=3035) geoms = gk.vector.extractFeatures(join(RESULTDIR, "distributeItems1.shp")) assert geoms.shape[0] == 287 minDist = 1000000 for gi in range(geoms.shape[0] - 1): for gj in range(gi + 1, geoms.shape[0]): d = geoms.geom[gi].Distance(geoms.geom[gj]) if d < minDist: minDist = d I = (gi, gj) assert minDist >= 999 # Do an axial distribution ec.distributeItems((1000, 300), axialDirection=180, output=join(RESULTDIR, "distributeItems2.shp"), outputSRS=3035) geoms = gk.vector.extractFeatures(join(RESULTDIR, "distributeItems2.shp")) assert geoms.shape[0] == 882 x = np.array([g.GetX() for g in geoms.geom]) y = np.array([g.GetY() for g in geoms.geom]) for gi in range(geoms.shape[0] - 1): d = (x[gi] - x[gi + 1:])**2 / 1000**2 + (y[gi] - y[gi + 1:])**2 / 300**2 assert (d >= 1).all() # Axial objects too close # Do make areas ec.distributeItems(2000, asArea=True, output=join(RESULTDIR, "distributeItems3.shp"), outputSRS=4326) geoms = gk.vector.extractFeatures(join(RESULTDIR, "distributeItems3.shp")) assert np.isclose(geoms.shape[0], 97) assert np.isclose(geoms.area.mean(), 0.000230714164474) assert np.isclose(geoms.area.std(), 8.2766693979e-05) # Do a variable separation distance placement ec = gl.ExclusionCalculator(gl._test_data_['aachenShapefile.shp'], pixelRes=25, srs="LAEA") ec.excludeRasterType(gl._test_data_['clc-aachen_clipped.tif'], value=(1, 2), invert=True) mat = np.zeros_like(ec.region.mask, dtype=np.uint16) for i in range(mat.shape[0]): mat[i, :] = (300 - 50) * i / mat.shape[0] + 100 ras = ec.region.createRaster(data=mat) points = ec.distributeItems(separation=5, sepScaling=ras, _stamping=False) assert points.shape[0] == 335 points = ec.distributeItems(separation=(8, 3), sepScaling=ras, axialDirection=0) assert points.shape[0] == 389
def calculate_wind_sites(region, invert=False, separation=700, name='NoRegion', convert2epsg=True): # Choose Region ecWind = gl.ExclusionCalculator(region, srs=3035, pixelSize=100, limitOne=False) # Define Exclusion Criteria selExlWind = { "access_distance": (5000, None ), #"agriculture_proximity": (None, 50 ), #"agriculture_arable_proximity": (None, 50 ), #"agriculture_pasture_proximity": (None, 50 ), #"agriculture_permanent_crop_proximity": (None, 50 ), #"agriculture_heterogeneous_proximity": (None, 50 ), "airfield_proximity": (None, 1760 ), # Diss WB "airport_proximity": (None, 5000 ), # Diss WB "connection_distance": (10000, None ), #"dni_threshold": (None, 3.0 ), "elevation_threshold": (1500, None ), #"ghi_threshold": (None, 3.0 ), "industrial_proximity": (None, 250 ), # Diss Wingenbach / UBA 2013 "lake_proximity": (None, 0 ), "mining_proximity": (None, 100 ), "ocean_proximity": (None, 10 ), "power_line_proximity": (None, 120 ), # Diss WB "protected_biosphere_proximity": (None, 5 ), # UBA 2013 "protected_bird_proximity": (None, 200 ), # UBA 2013 "protected_habitat_proximity": (None, 5 ), # UBA 2013 "protected_landscape_proximity": (None, 5 ), # UBA 2013 "protected_natural_monument_proximity": (None, 200 ), # UBA 2013 "protected_park_proximity": (None, 5 ), # UBA 2013 "protected_reserve_proximity": (None, 200 ), # UBA 2013 "protected_wilderness_proximity": (None, 200 ), # UBA 2013 "camping_proximity": (None, 900), # UBA 2013) #"touristic_proximity": (None, 800), #"leisure_proximity": (None, 1000), "railway_proximity": (None, 250 ), # Diss WB "river_proximity": (None, 5 ), # Abweichung vom standardwert (200) "roads_proximity": (None, 80 ), # Diss WB "roads_main_proximity": (None, 80 ), # Diss WB "roads_secondary_proximity": (None, 80 ),# Diss WB #"sand_proximity": (None, 5 ), "settlement_proximity": (None, 600 ), # Diss WB "settlement_urban_proximity": (None, 1000 ), "slope_threshold": (10, None ), #"slope_north_facing_threshold": (3, None ), "wetland_proximity": (None, 5 ), # Diss WB / UBA 2013 "waterbody_proximity": (None, 5 ), # Diss WB / UBA 2013 "windspeed_100m_threshold": (None, 4.5 ), "windspeed_50m_threshold": (None, 4.5 ), "woodland_proximity": (None, 0 ), # Abweichung vom standardwert (300) / Diss WB "woodland_coniferous_proximity": (None, 0 ), # Abweichung vom standardwert (300) "woodland_deciduous_proximity": (None, 0 ), # Abweichung vom standardwert (300) "woodland_mixed_proximity": (None, 0 ) # Abweichung vom standardwert (300) } # Apply selected exclusion criteria for key in selExlWind: ecWind.excludePrior(pr[key], value=ecWind.typicalExclusions[key]) # Placement Algorithm ecWind.distributeItems(separation=separation, outputSRS=4326) # Extract and convert site coords of turbines site_coords = pd.DataFrame(ecWind.itemCoords) site_coords.columns = ['latitude','longitude'] site_coords_gdf = geom.create_geo_df(site_coords, wkt_column=None, lon_column="longitude", lat_column='latitude') # Convert2epsg for plotting purposes if convert2epsg==True: trsf= site_coords_gdf["geometry"] site_coords_gdf_epsg3857 = trsf.to_crs(epsg=3857) # Save coords in EPSG3587 to hard disk site_coords_gdf_epsg3857.to_file("site_coordsWind_epsg3857_" + name + ".geojson", driver='GeoJSON') site_coords_gdf.to_file("site_coordsWind_WGS84_" + name + ".geojson", driver='GeoJSON') elif convert2epsg==False: site_coords_gdf.to_file("site_coordsWind_WGS84_" + name + ".geojson", driver='GeoJSON') # Write turbines to power plants df res_df_Wind = pd.DataFrame(columns=["energy_source_level_1", "energy_source_level_2", "technology", "electrical_capacity", "lon", "lat", "data_source"]) res_df_Wind["lon"] = site_coords["latitude"] res_df_Wind["lat"] = site_coords["longitude"] res_df_Wind["energy_source_level_1"] = 'Renewable energy' res_df_Wind["energy_source_level_2"] = 'Wind' res_df_Wind["technology"] = 'Onshore' res_df_Wind["electrical_capacity"] = 3.5 res_df_Wind["data_source"] = 'GLAES' return res_df_Wind, ecWind
import glaes as gl import pandas as pd PARAMS = pd.read_csv('input_data/landEligibilityParameters.csv', index_col='name')['value'] gl.Priors.loadDirectory("input_data") # INPUTS regionFile = "output_data/gadm36_DEU_1.shp" regionID = int(PARAMS.loc['regionID']) settlement_proximity = int(PARAMS.loc['exc_settlement_proximity']) # OUTPUTS outputFile = "output_data/eligibility_result.tif" # Initiate Exclusion Calculator object ec = gl.ExclusionCalculator(regionFile, where=regionID) # Do a simple exclusion ec.excludePrior("settlement_proximity", value=(0, settlement_proximity)) # Exclude urban areas # TODO: Add into inputs ec.excludePrior("roads_main_proximity", value=(0, 200)) # Exclude urban areas ec.excludePrior("roads_secondary_proximity", value=(0, 200)) # Exclude urban areas ec.excludePrior("protected_landscape_proximity", value=(0, 1000)) # Exclude urban areas # Save result ec.save(outputFile)
def calculate_wind_area(region): # Choose Region ecWind = gl.ExclusionCalculator(region, srs=3035, pixelSize=100, limitOne=False) # Define Exclusion Criteria selExlWind = { "access_distance": (5000, None), #"agriculture_proximity": (None, 50 ), #"agriculture_arable_proximity": (None, 50 ), #"agriculture_pasture_proximity": (None, 50 ), #"agriculture_permanent_crop_proximity": (None, 50 ), #"agriculture_heterogeneous_proximity": (None, 50 ), "airfield_proximity": (None, 1760), # Diss WB "airport_proximity": (None, 5000), # Diss WB "connection_distance": (10000, None), #"dni_threshold": (None, 3.0 ), "elevation_threshold": (1500, None), #"ghi_threshold": (None, 3.0 ), "industrial_proximity": (None, 250), # Diss Wingenbach / UBA 2013 "lake_proximity": (None, 0), "mining_proximity": (None, 100), "ocean_proximity": (None, 10), "power_line_proximity": (None, 120), # Diss WB "protected_biosphere_proximity": (None, 5), # UBA 2013 "protected_bird_proximity": (None, 200), # UBA 2013 "protected_habitat_proximity": (None, 5), # UBA 2013 "protected_landscape_proximity": (None, 5), # UBA 2013 "protected_natural_monument_proximity": (None, 200), # UBA 2013 "protected_park_proximity": (None, 5), # UBA 2013 "protected_reserve_proximity": (None, 200), # UBA 2013 "protected_wilderness_proximity": (None, 200), # UBA 2013 "camping_proximity": (None, 900), # UBA 2013) #"touristic_proximity": (None, 800), #"leisure_proximity": (None, 1000), "railway_proximity": (None, 250), # Diss WB "river_proximity": (None, 5), # Abweichung vom standardwert (200) "roads_proximity": (None, 80), # Diss WB "roads_main_proximity": (None, 80), # Diss WB "roads_secondary_proximity": (None, 80), # Diss WB #"sand_proximity": (None, 5 ), "settlement_proximity": (None, 600), # Diss WB "settlement_urban_proximity": (None, 1000), "slope_threshold": (10, None), #"slope_north_facing_threshold": (3, None ), "wetland_proximity": (None, 5), # Diss WB / UBA 2013 "waterbody_proximity": (None, 5), # Diss WB / UBA 2013 "windspeed_100m_threshold": (None, 5.5), # Wert angepasst. Bei Nabenhöhe >100m realistisch? #"windspeed_50m_threshold": (None, 4.5), "woodland_proximity": (None, 0), # Abweichung vom standardwert (300) / Diss WB "woodland_coniferous_proximity": (None, 0), # Abweichung vom standardwert (300) "woodland_deciduous_proximity": (None, 0), # Abweichung vom standardwert (300) "woodland_mixed_proximity": (None, 0 ) # Abweichung vom standardwert (300) } # Apply selected exclusion criteria # for key in selExlWind: # ecWind.excludePrior(pr[key], value=ecWind.typicalExclusions[key]) for key in selExlWind.keys(): ecWind.excludePrior(key, value=selExlWind[key]) area = ecWind.areaAvailable return area
def Holtinger2016_max(reg): """ SOURCE: Holtinger2016 EXCLUSIONS: - Areas above the alpine forest line - Maximum slope (11.3 degrees) - Water bodies - Settlement areas - 1000m buffer - Buildings outside of settlement areas - 750m buffer - Building land outside of settlement areas - 750m buffer - Built-up areas - 300m buffer * Industrial, commercial, and mining areas - Railways - 300m buffer - Motorways, primary, and secondary roads - 300m buffer - Airport public safety zones - 5100m buffer - Power grid( >110kV) - 250m buffer - National parks - 1000m buffer - Natura 2000 - habitats directive sites * Potentially - Natura 2000 - birds directive sites - Other protected areas * Biosphere reserves, landscape protection areas, natural monuments and sites, - Important birdlife areas * Potentially - Major migration routes for wild animals * Potentially - Lakes (> 50 ha) - 1000m buffer """ ec = gl.ExclusionCalculator(reg) ##### do exclusions ##### # "Areas above the alpine forest line ec.excludePrior("elevation_threshold", value=(1750, None)) # alpine forest line assumed at 1750 m # "maximum slope (degrees)" ec.excludePrior("slope_threshold", value=(11.3, None)) # "water bodies" ec.excludePrior("river_proximity", value=0) #ec.excludePrior("lake_proximity", value=0 ) # commented out since it is included late with a buffer # "settlement areas - 1000m buffer" ec.excludePrior("settlement_proximity", value=(None, 1000)) # "buildings outside of settlement areas - 750m buffer" # "building land outside of settlement areas - 750m buffer" # "built up areas - 300m buffer" # " * industrial, commercial, and mining areas" ec.excludePrior("industrial_proximity", value=(None, 300)) ec.excludePrior("mining_proximity", value=(None, 300)) # "railways - 300m buffer" ec.excludePrior("railway_proximity", value=(None, 300)) # "motorways, primary, and secondary roads - 300m buffer" ec.excludePrior("roads_main_proximity", value=(None, 300)) ec.excludePrior("roads_secondary_proximity", value=(None, 300)) # "airport public safety zones - 5100m buffer" ec.excludePrior("airport_proximity", value=(None, 5100)) # "power grid( >110kV) - 250m buffer" ec.excludePrior("power_line_proximity", value=(None, 250)) # "national parks - 1000m buffer" ec.excludePrior("protected_park_proximity", value=(None, 1000)) # "Natura 2000 - habitats directive sites" # "*potentially" ec.excludePrior("protected_habitat_proximity", value=0) # "Natura 2000 - birds directive sites" ec.excludePrior("protected_bird_proximity", value=0) # "Other protected areas" # "*Biosphere reserves, landscape protection areas, natural monuments and sites, # protected habitats, and landscape section" ec.excludePrior("protected_biosphere_proximity", value=0) ec.excludePrior("protected_landscape_proximity", value=0) ec.excludePrior("protected_natural_monument_proximity", value=0) # "important birdlife areas" # "*potentially" # "major migration routes for wild animals" # "*potentially" # "lakes (> 50 ha) - 1000m buffer" ec.excludePrior("lake_proximity", value=(None, 1000)) # All done return ec
def compute_land_availability(shape: Union[Polygon, MultiPolygon]) -> float: """ Compute land availability in (km2) of a geographical shape. Parameters ---------- shape: Union[Polygon, MultiPolygon] Geographical shape Returns ------- float Available area in (km2) Notes ----- spatial_ref, filters, natura, clc and gebco must have been previously initialized as global variables """ import matplotlib.pyplot as plt poly_wkt = shapely.wkt.dumps(shape) poly = ogr.CreateGeometryFromWkt(poly_wkt, spatial_ref_) # Compute rooftop area using ESM (European Settlement Map) if filters_.get("esm", 0): path_cop = f"{data_path}generation/vres/potentials/source/ESM/ESM_class50_100m/ESM_class50_100m.tif" ec = gl.ExclusionCalculator(poly, pixelRes=100, initialValue=path_cop) return ec.areaAvailable / 1e6 ec = gl.ExclusionCalculator(poly, pixelRes=100) # GLAES priors if 'glaes_prior_defaults' in filters_: prior_defaults_params = filters_['glaes_prior_defaults'] prior_config = prior_defaults_params["config"] priors = prior_defaults_params[ "priors"] if 'priors' in prior_defaults_params else None filters_["glaes_priors"] = get_glaes_prior_defaults( prior_config, priors) if 'glaes_priors' in filters_: priors_filters = filters_["glaes_priors"] for prior_name in priors_filters.keys(): prior_value = priors_filters[prior_name] if isinstance(prior_value, str): prior_value = literal_eval(prior_value) # Can receive a tuple or a list of tuples if not isinstance(prior_value, list): prior_value = [prior_value] for value in prior_value: ec.excludePrior(prior_name, value=value) #ec.draw() #plt.title(prior_name) #print(prior_name) #plt.show() # Exclude protected areas if 'natura' in filters_: ec.excludeRasterType(natura_, value=filters_["natura"]) # Depth and altitude filters if 'depth_thresholds' in filters_: depth_thresholds = filters_["depth_thresholds"] # Keep points between two depth thresholds for gebco in gebcos_: ec.excludeRasterType(gebco, (-1e4, depth_thresholds["low"])) ec.excludeRasterType(gebco, (depth_thresholds["high"], 0)) elif 'altitude_threshold' in filters_ and filters_[ 'altitude_threshold'] > 0.: for gebco in gebcos_: ec.excludeRasterType(gebco, (filters_['altitude_threshold'], 1e6)) # Corine filters if 'clc' in filters_: clc_filters = filters_["clc"] if "remove_codes" in clc_filters and "remove_distance" in clc_filters and clc_filters[ "remove_distance"] > 0.: # for remove_code in clc_filters["remove_codes"]: # ec.excludeRasterType(clc_, value=remove_code, buffer=clc_filters["remove_distance"]) ec.excludeRasterType(clc_, value=clc_filters["remove_codes"], buffer=clc_filters["remove_distance"]) if "keep_codes" in clc_filters: # Invert True indicates code that need to be kept # for keep_code in clc_filters["keep_codes"]: # ec.excludeRasterType(clc_, value=keep_code, mode='include') ec.excludeRasterType(clc_, value=clc_filters["keep_codes"], mode='include') if 'shipping' in filters_: value = filters_['shipping'] value = literal_eval(value) if isinstance(value, str) else value ec.excludeRasterType(cargo_, value=value) ec.excludeRasterType(tanker_, value=value) if 'cables' in filters_: ec.excludeVectorType(cables_, buffer=filters_['cables']) if 'pipelines' in filters_: ec.excludeVectorType(pipelines_, buffer=filters_['pipelines']) # ax = ec.draw() # ec.pruneIsolatedAreas(0.9*1e6, 50) # ec.draw() # plt.show() # plt.savefig("test.png") return ec.areaAvailable / 1e6
def test_ExclusionCalculator_excludeRasterType(): # exclude single value ec = gl.ExclusionCalculator(aachenShape) ec.excludeRasterType(clcRaster, 12) assert np.isclose(np.nanmean(ec.availability), 82.8033) assert np.isclose(np.nanstd(ec.availability), 37.73514175) # exclude value range ec = gl.ExclusionCalculator(aachenShape) ec.excludeRasterType(clcRaster, (5, 12)) assert np.isclose(np.nanmean(ec.availability), 81.16260529) assert np.isclose(np.nanstd(ec.availability), 39.10104752) # Exclude iterable (should have the same result as the test above) ec = gl.ExclusionCalculator(gl._test_data_["aachenShapefile.shp"], srs=gk.srs.EPSG3035, pixelRes=100) ec.excludeRasterType( gl._test_data_['clc-aachen_clipped.tif'], value=[5, 6, 7, 8, 9, 10, 11, 12]) assert np.isclose(np.nanmean(ec.availability), 81.16260529) assert np.isclose(np.nanstd(ec.availability), 39.10104752) # exclude value maximum ecMax12 = gl.ExclusionCalculator(aachenShape) ecMax12.excludeRasterType(clcRaster, (None, 12)) assert np.isclose(np.nanmean(ecMax12.availability), 58.52362442) assert np.isclose(np.nanstd(ecMax12.availability), 49.26812363) # exclude value minimum ecMin13 = gl.ExclusionCalculator(aachenShape) ecMin13.excludeRasterType(clcRaster, (13, None)) assert np.isclose(np.nanmean(ecMin13.availability), 41.47637558) assert np.isclose(np.nanstd(ecMin13.availability), 49.26812363) # Make sure min and max align s1 = ecMax12.availability[ecMax12.region.mask] > 0 s2 = ecMin13.availability[ecMax12.region.mask] > 0 assert np.logical_xor(s1, s2).all() # Test with a different projection system # exclude single value ec = gl.ExclusionCalculator(aachenShape, srs='latlon', pixelRes=0.005) ec.excludeRasterType(clcRaster, 12) print("AVAIL MEAN:", np.nanmean(ec.availability)) assert np.isclose(np.nanmean(ec.availability), 82.95262909) assert np.isclose(np.nanstd(ec.availability), 32.26681137) # Test with complex value input ec = gl.ExclusionCalculator(gl._test_data_["aachenShapefile.shp"], srs='latlon', pixelRes=0.005) ec.excludeRasterType( gl._test_data_['clc-aachen_clipped.tif'], value="[-2),[5-7),12,(22-26],29,33,[40-]") assert np.isclose(np.nanmean(ec.availability), 49.5872573853) assert np.isclose(np.nanstd(ec.availability), 41.2754364014) # Test with intermediate functionaliy (creation and re-use) for i in range(2): ec = gl.ExclusionCalculator( gl._test_data_["aachenShapefile.shp"], srs='latlon', pixelRes=0.005,) ec.excludeRasterType( gl._test_data_['clc-aachen_clipped.tif'], value="[-2),[5-7),12,(22-26],29,33,[40-]", intermediate=join(RESULTDIR, "exclude_raster_intermediate.tif")) assert isfile(join(RESULTDIR, "exclude_raster_intermediate.tif")) assert np.isclose(np.nanmean(ec.availability), 49.5872573853) assert np.isclose(np.nanstd(ec.availability), 41.2754364014)
import glaes as gl import geokit as gk from os.path import join from matplotlib import pyplot as plt # Choose a region to operate on (Here, a predefined region for Aachen, Germany is used) regionPath = '/home/dbeier/git-projects/glaes/glaes/test/data/aachenShapefile.shp' #['aachenShapefile.shp'] # Initialize ExclusionCalculator object ec = gl.ExclusionCalculator(regionPath, srs=3035, pixelSize=100) # Visualize avilability plot = ec.draw() # Set a path to a local copy of the CLC raster dataset (Here, a small sample is provided around Aachen) clcRasterPath = gl._test_data_["clc-aachen_clipped.tif"] # Apply exclusion ec.excludeRasterType(clcRasterPath, value=(12,22)) # Visualize ec.draw() # Apply exclusion ec.excludeRasterType(clcRasterPath, value=(1,2), buffer=1000) # Visualize ec.draw() # Set a path to a local copy of the OSM roads dataset (Here, a small sample is provided around Aachen) roadwaysPath = gl._test_data_["aachenRoads.shp"] # Apply Exclusion whereStatement = "type='motorway' OR type='primary' OR type='trunk'" ec.excludeVectorType(roadwaysPath, where=whereStatement, buffer=200) # Visualize