def processHistoricHarvestDisturbances(self, dist, sb_percent, cc_dt, sb_dt):
pp = self.ProgressPrinter.newProcess(inspect.stack()[0][3], 1).start()
harvest_poly_shp = self.scan_for_layers(dist.getWorkspace(), dist.getFilter())[0]
_, rollback_end_year = self.rollback_range
_, historic_end_year = self.historic_range
year_range = range(rollback_end_year + 1, historic_end_year + 1)
workspace = self.inventory.getWorkspace()
if year_range:
sb = GenerateSlashburn(self.ProgressPrinter)
sb_shp = sb.generateSlashburn(self.inventory, harvest_poly_shp, dist.getYearField(), year_range, sb_percent)
for year in year_range:
self.layers.append(DisturbanceLayer(
self.rule_manager,
VectorLayer("harvest_{}".format(year),
workspace,
Attribute(dist.getYearField(), filter=ValueFilter(year, True)),
layer='MergedDisturbances'),
year=year,
disturbance_type=cc_dt,
transition=TransitionRule(
regen_delay=0,
age_after=0)))
self.layers.append(DisturbanceLayer(
self.rule_manager,
VectorLayer("slashburn_{}".format(year),
sb_shp,
Attribute(dist.getYearField(), filter=ValueFilter(year, True))),
year=year,
disturbance_type=sb_dt,
transition=TransitionRule(
regen_delay=0,
age_after=0)))
pp.finish()
def processRollbackDisturbances(self):
rollback_dist_lookup = {
1: "Wild Fires",
2: "Clearcut harvesting with salvage"
}
rollback_name_lookup = {
1: "fire",
2: "harvest"
}
pp = self.ProgressPrinter.newProcess(inspect.stack()[0][3], 1).start()
for year in range(self.rollback_range[0], self.rollback_range[1]+1):
for dist_code in rollback_dist_lookup:
label = rollback_dist_lookup[dist_code]
name = rollback_name_lookup[dist_code]
self.layers.append(DisturbanceLayer(
self.rule_manager,
VectorLayer("rollback_{}_{}".format(name, year),
self.rollback_disturbances.getPath(),
[
Attribute("DistYEAR_n", filter=lambda v, yr=year: v == yr),
Attribute("DistType", filter=lambda v, dt=dist_code: v == dt, substitutions=rollback_dist_lookup),
Attribute("RegenDelay")
]),
year=year,
disturbance_type=Attribute("DistType"),
transition=TransitionRule(
regen_delay=Attribute("RegenDelay"),
age_after=0)))
pp.finish()
def processHistoricInsectDisturbances(self, dist):
pp = self.ProgressPrinter.newProcess(inspect.stack()[0][3], 1).start()
mpb_shp_severity_to_dist_type_lookup = {
"V": "Mountain Pine Beetle - Very Severe Impact",
"S": "Mountain Pine Beetle - Severe Impact",
"M": "Mountain Pine Beetle - Moderate Impact",
"L": "Mountain Pine Beetle - Low Impact",
"4": "Mountain Pine Beetle - Very Severe Impact",
"3": "Mountain Pine Beetle - Severe Impact",
"2": "Mountain Pine Beetle - Moderate Impact",
"1": "Mountain Pine Beetle - Low Impact"
}
for file_name in self.scan_for_layers(dist.getWorkspace(), dist.getFilter()):
file_name_no_ext = os.path.basename(os.path.splitext(file_name)[0])
year = int(file_name_no_ext[-4:])
if year in range(self.historic_range[0], self.historic_range[1]+1):
self.layers.append(DisturbanceLayer(
self.rule_manager,
VectorLayer("insect_{}".format(year), file_name, Attribute("Severity", substitutions=mpb_shp_severity_to_dist_type_lookup)),
year=year,
disturbance_type=Attribute("Severity"),
transition=TransitionRule(
regen_delay=0,
age_after=-1)))
pp.finish()
def processProjectedDisturbancesRasters(self, scenario, base_raster_dir, scenario_raster_dir, params):
#not at the top so we dont break existing things for everyone (gdal will be imported)
from future_raster_processor import FutureRasterProcessor
from random_raster_subset import RandomRasterSubset
"""
append existing raster disturbance layers to the tiler instance
@param scenario str name of the scenario
@param base_raster_dir directory containing future disturbance rasters
ex "<tsaname>\01a_pretiled_layers\03_disturbances\02_future\inputs\base"
@param scenario_raster_dir directory where the processed rasters are written
ex. "<tsaname>\01a_pretiled_layers\03_disturbances\02_future\outputs\<scenario>"
@param params a triple: (slashburn percent, slashburn activity percent, harvest activity percent)
"""
pp = self.ProgressPrinter.newProcess("{}_{}".format(inspect.stack()[0][3], scenario), 1).start()
projected_dist_lookup = {
"fire": "Wild Fires",
"harvest": "{} CC".format("Base" if scenario.lower() == "base" else "CBM_{}".format(scenario)),
"slashburn": "SlashBurning"
}
projected_name_lookup = {
7: "fire",
6: "harvest",
13: "slashburn"
}
percent_sb = params[0]
actv_percent_sb = params[1]
actv_percent_harv = params[2]
f = FutureRasterProcessor(
base_raster_dir,
list(range(self.historic_range[1]+1, self.future_range[1]+1)),
scenario_raster_dir,
"fire", "harvest", "slashburn",
"projected_fire_{}.tif",
"projected_harvest_{}.tif",
"projected_slashburn_{}.tif")
result = []
result.extend(f.processFire())
result.extend(f.processHarvest(self.activity_start_year, actv_percent_harv, RandomRasterSubset()))
result.extend(f.processSlashburn(percent_sb, self.activity_start_year, actv_percent_sb, RandomRasterSubset()))
for item in result:
self.layers.append(DisturbanceLayer(
self.rule_manager,
RasterLayer(item["Path"],
attributes="event",
attribute_table={1: [1]}),
year=item["Year"],
disturbance_type=projected_dist_lookup[item["DisturbanceName"]]))
pp.finish()
def processHistoricHarvestDisturbances(self, dist):
pp = self.ProgressPrinter.newProcess(inspect.stack()[0][3], 1).start()
cutblock_shp = self.scan_for_layers(dist.getWorkspace(), dist.getFilter())[0]
for year in range(self.rollback_range[1]+1, self.historic_range[1]+1):
self.layers.append(DisturbanceLayer(
self.rule_manager,
VectorLayer("harvest_{}".format(year), cutblock_shp, Attribute("HARV_YR", filter=lambda v, yr=year: v == yr)),
year=year,
disturbance_type="Clearcut harvesting with salvage",
transition=TransitionRule(
regen_delay=0,
age_after=0)))
pp.finish()
def processGenericHistoricDisturbances(self, dist, dist_type_attr, year_attr, dist_type_lookup):
pp = self.ProgressPrinter.newProcess(inspect.stack()[0][3], 1).start()
historic_start_year, _ = self.historic_range
_, future_end_year = self.future_range
year_range = range(historic_start_year, future_end_year + 1)
for file_name in self.scan_for_layers(dist.getWorkspace(), dist.getFilter()):
for year in year_range:
self.layers.append(DisturbanceLayer(
self.rule_manager,
VectorLayer("insect_{}".format(year), file_name, Attribute(dist_type_attr, substitutions=dist_type_lookup)),
year=Attribute(year_attr, filter=ValueFilter(year, True)),
disturbance_type=Attribute(dist_type_attr)))
pp.finish()
def processHistoricFireDisturbances(self, dist):
pp = self.ProgressPrinter.newProcess(inspect.stack()[0][3], 1).start()
for file_name in self.scan_for_layers(dist.getWorkspace(), dist.getFilter()):
# Assume filenames are like "Wildfire_1990.shp", "Wildfire_NBAC_1991.shp"
# i.e. the last 4 characters before the extension are the year.
file_name_no_ext = os.path.basename(os.path.splitext(file_name)[0])
year = file_name_no_ext[-4:]
if year in range(self.rollback_range[1]+1, self.historic_range[1]+1):
self.layers.append(DisturbanceLayer(
self.rule_manager,
VectorLayer("fire_{}".format(year), file_name, Attribute("Shape_Leng")),
year=year,
disturbance_type="Wild Fires",
transition=TransitionRule(
regen_delay=0,
age_after=0)))
pp.finish()
def processProjectedDisturbances(self, dist):
pp = self.ProgressPrinter.newProcess("{}_{}".format(inspect.stack()[0][3],dist.getScenario()), 1).start()
futureDistTypeLookup = dist.getLookupTable()
future_start_year = self.future_range[0]
for file_name in self.scan_for_layers(dist.getWorkspace(), dist.getFilter()):
file_name_no_ext = os.path.basename(os.path.splitext(file_name)[0])
year = future_start_year + int(file_name_no_ext.split("_")[-1])
if year in range(self.historic_range[1]+1, self.future_range[1]+1):
self.layers.append(DisturbanceLayer(
self.rule_manager,
VectorLayer("Proj{}_{}".format("Disturbance", year), file_name, Attribute("dist_type_", substitutions=futureDistTypeLookup)),
year=year,
disturbance_type=Attribute("dist_type_"),
transition=TransitionRule(
regen_delay=0,
age_after=0)))
pp.finish()
def processProjectedDisturbances(self, scenario, params):
future_start_year, future_end_year = self.future_range
if future_start_year > future_end_year:
return
pp = self.ProgressPrinter.newProcess("{}_{}".format(inspect.stack()[0][3], scenario), 1).start()
percent_sb = params[0]
actv_percent_sb = params[1]
actv_percent_harv = params[2]
placeholder = ProjectedDisturbancesPlaceholder(self.inventory, self.rollback_disturbances,
self.future_range, self.rollback_range, self.activity_start_year, self.ProgressPrinter)
projectedDisturbances = placeholder.generateProjectedDisturbances(scenario, percent_sb, actv_percent_sb, actv_percent_harv)
projected_dist_lookup = {
7: "Wild Fires",
6: "{} CC".format("Base" if scenario.lower() == "base" else "CBM_{}".format(scenario)),
13: "SlashBurning"
}
projected_name_lookup = {
7: "fire",
6: "harvest",
13: "slashburn"
}
for year in range(self.historic_range[1]+1, self.future_range[1]+1):
for dist_code in projected_dist_lookup:
label = projected_dist_lookup[dist_code]
name = projected_name_lookup[dist_code]
self.layers.append(DisturbanceLayer(
self.rule_manager,
VectorLayer("projected_{}_{}".format(name, year),
projectedDisturbances,
[
Attribute("DistYEAR_n", filter=ValueFilter(year)),
Attribute("DistType", filter=ValueFilter(dist_code), substitutions=projected_dist_lookup),
Attribute("RegenDelay")
]),
year=year,
disturbance_type=Attribute("DistType"),
transition=TransitionRule(
regen_delay=Attribute("RegenDelay"),
age_after=0)))
pp.finish()
def processHistoricInsectDisturbances(self, dist, attr, dist_type_lookup):
pp = self.ProgressPrinter.newProcess(inspect.stack()[0][3], 1).start()
historic_start_year, _ = self.historic_range
_, future_end_year = self.future_range
year_range = range(historic_start_year, future_end_year + 1)
for file_name in self.scan_for_layers(dist.getWorkspace(), dist.getFilter()):
file_name_no_ext = os.path.basename(os.path.splitext(file_name)[0])
year = int(file_name_no_ext[-4:])
if year in year_range:
self.layers.append(DisturbanceLayer(
self.rule_manager,
VectorLayer("insect_{}".format(year), file_name, Attribute(attr, substitutions=dist_type_lookup)),
year=year,
disturbance_type=Attribute(attr),
transition=TransitionRule(
regen_delay=0,
age_after=-1)))
pp.finish()
def processHistoricFireDisturbances(self, dist, dt):
pp = self.ProgressPrinter.newProcess(inspect.stack()[0][3], 1).start()
_, rollback_end_year = self.rollback_range
_, historic_end_year = self.historic_range
workspace = self.inventory.getWorkspace()
for year in range(rollback_end_year + 1, historic_end_year + 1):
self.layers.append(DisturbanceLayer(
self.rule_manager,
# The [:4] is specifically to deal with the case of NBAC where the year is followed by the date and time
VectorLayer("fire_{}".format(year),
workspace,
Attribute(dist.getYearField(), filter=SliceValueFilter(year, slice_len=4)),
layer='MergedDisturbances'),
year=year,
disturbance_type=dt,
transition=TransitionRule(
regen_delay=0,
age_after=0)))
pp.finish()
def processRollbackDisturbances(self, dist_lookup, name_lookup):
pp = self.ProgressPrinter.newProcess(inspect.stack()[0][3], 1).start()
for year in range(self.rollback_range[0], self.rollback_range[1] + 1):
for dist_code in dist_lookup:
label = dist_lookup[dist_code]
name = name_lookup[dist_code]
self.layers.append(DisturbanceLayer(
self.rule_manager,
VectorLayer("rollback_{}_{}".format(name, year),
self.rollback_disturbances.getPath(),
[
Attribute("DistYEAR_n", filter=ValueFilter(year)),
Attribute("DistType", filter=ValueFilter(dist_code), substitutions=dist_lookup),
Attribute("RegenDelay")
]),
year=year,
disturbance_type=Attribute("DistType"),
transition=TransitionRule(
regen_delay=Attribute("RegenDelay"),
age_after=0)))
pp.finish()
attribute_table=csv_to_dict(os.path.join(layer_root, "last_pass_disturbance", "last_pass_disturbance_type_AT.csv"),
"ID", ["value"]))
] + classifier_layers
# Disturbances
dist = ['fire', 'cc', 'salv']
distName = ["Wild Fire", "97% clearcut", "Fire with salvage logging"]
for i in range(0, len(dist)):
d = dist[i]
dName = distName[i]
for layer_path in scan_for_layers(os.path.join(layer_root, "disturbances"), d + "_*.tif"):
# Extract the year from the filename.
layer_name = os.path.basename(os.path.splitext(layer_path)[0])
year = layer_name[-4:]
layers.append(DisturbanceLayer(
rule_manager,
RasterLayer(
os.path.abspath(layer_path),
attributes=["disturbed"],
attribute_table={
1: [1]
}),
year=year,
disturbance_type=dName))
tiler.tile(layers)
rule_manager.write_rules()
layers.append(
DisturbanceLayer(
rule_manager,
RasterLayer(
os.path.abspath(layer_path),
attributes=[
"type", "disturbanceType",
"relDensityUpdate", "fertilityUpdate",
"coverTypeUpdate"
],
attribute_table=csv_to_dict(
os.path.join(layer_root, "disturbances",
"fire_AT.csv"), "ID",
[
"type", "disturbanceType",
"relDensityUpdate", "fertilityUpdate",
"coverTypeUpdate"
])),
year=year,
disturbance_type=Attribute("disturbanceType"),
transition=TransitionRule(regen_delay=0,
age_after=0,
classifiers=[
"type",
"disturbanceType",
"coverTypeUpdate",
"fertilityUpdate",
"relDensityUpdate"
])))
else: