def name_is_stds(name):
"""return True if the name given as input is a registered strds
False if not
"""
# make sure temporal module is initialized
tgis.init()
return bool(tgis.SpaceTimeRasterDataset(name).is_in_db())
def main():
# lazy imports
import grass.temporal as tgis
from grass.pygrass.modules import Module
# Get the options
input = options["input"]
output = options["output"]
start = options["start"]
stop = options["stop"]
base = options["basename"]
cycle = options["cycle"]
lower = options["lower"]
upper = options["upper"]
offset = options["offset"]
limits = options["limits"]
shift = options["shift"]
scale = options["scale"]
method = options["method"]
granularity = options["granularity"]
register_null = flags["n"]
reverse = flags["r"]
time_suffix = options["suffix"]
# Make sure the temporal database exists
tgis.init()
# We need a database interface
dbif = tgis.SQLDatabaseInterfaceConnection()
dbif.connect()
mapset = tgis.get_current_mapset()
if input.find("@") >= 0:
id = input
else:
id = input + "@" + mapset
input_strds = tgis.SpaceTimeRasterDataset(id)
if input_strds.is_in_db() == False:
dbif.close()
grass.fatal(_("Space time raster dataset <%s> not found") % (id))
input_strds.select(dbif)
if output.find("@") >= 0:
out_id = output
else:
out_id = output + "@" + mapset
# The output space time raster dataset
output_strds = tgis.SpaceTimeRasterDataset(out_id)
if output_strds.is_in_db(dbif):
if not grass.overwrite():
dbif.close()
grass.fatal(
_("Space time raster dataset <%s> is already in the "
"database, use overwrite flag to overwrite") % out_id)
if tgis.check_granularity_string(granularity,
input_strds.get_temporal_type()) == False:
dbif.close()
grass.fatal(_("Invalid granularity"))
if tgis.check_granularity_string(cycle,
input_strds.get_temporal_type()) == False:
dbif.close()
grass.fatal(_("Invalid cycle"))
if offset:
if tgis.check_granularity_string(
offset, input_strds.get_temporal_type()) == False:
dbif.close()
grass.fatal(_("Invalid offset"))
# The lower threshold space time raster dataset
if lower:
if not range:
dbif.close()
grass.fatal(
_("You need to set the range to compute the occurrence"
" space time raster dataset"))
if lower.find("@") >= 0:
lower_id = lower
else:
lower_id = lower + "@" + mapset
lower_strds = tgis.SpaceTimeRasterDataset(lower_id)
if lower_strds.is_in_db() == False:
dbif.close()
grass.fatal(
_("Space time raster dataset <%s> not found") %
(lower_strds.get_id()))
if lower_strds.get_temporal_type() != input_strds.get_temporal_type():
dbif.close()
grass.fatal(
_("Temporal type of input strds and lower strds must be equal")
)
lower_strds.select(dbif)
# The upper threshold space time raster dataset
if upper:
if not lower:
dbif.close()
grass.fatal(
_("The upper option works only in conjunction with the lower option"
))
if upper.find("@") >= 0:
upper = upper
else:
upper_id = upper + "@" + mapset
upper_strds = tgis.SpaceTimeRasterDataset(upper_id)
if upper_strds.is_in_db() == False:
dbif.close()
grass.fatal(
_("Space time raster dataset <%s> not found") %
(upper_strds.get_id()))
if upper_strds.get_temporal_type() != input_strds.get_temporal_type():
dbif.close()
grass.fatal(
_("Temporal type of input strds and upper strds must be equal")
)
upper_strds.select(dbif)
input_strds_start, input_strds_end = input_strds.get_temporal_extent_as_tuple(
)
if input_strds.is_time_absolute():
start = tgis.string_to_datetime(start)
if stop:
stop = tgis.string_to_datetime(stop)
else:
stop = input_strds_end
start = tgis.adjust_datetime_to_granularity(start, granularity)
else:
start = int(start)
if stop:
stop = int(stop)
else:
stop = input_strds_end
if input_strds.is_time_absolute():
end = tgis.increment_datetime_by_string(start, cycle)
else:
end = start + cycle
limit_relations = [
"EQUALS", "DURING", "OVERLAPS", "OVERLAPPING", "CONTAINS"
]
count = 1
output_maps = []
while input_strds_end > start and stop > start:
# Make sure that the cyclic computation will stop at the correct time
if stop and end > stop:
end = stop
where = "start_time >= \'%s\' AND start_time < \'%s\'" % (str(start),
str(end))
input_maps = input_strds.get_registered_maps_as_objects(where=where,
dbif=dbif)
grass.message(_("Processing cycle %s - %s" % (str(start), str(end))))
if len(input_maps) == 0:
continue
# Lets create a dummy list of maps with granularity conform intervals
gran_list = []
gran_list_low = []
gran_list_up = []
gran_start = start
while gran_start < end:
map = input_strds.get_new_map_instance("%i@%i" % (count, count))
if input_strds.is_time_absolute():
gran_end = tgis.increment_datetime_by_string(
gran_start, granularity)
map.set_absolute_time(gran_start, gran_end)
gran_start = tgis.increment_datetime_by_string(
gran_start, granularity)
else:
gran_end = gran_start + granularity
map.set_relative_time(gran_start, gran_end,
input_strds.get_relative_time_unit())
gran_start = gran_start + granularity
gran_list.append(copy(map))
gran_list_low.append(copy(map))
gran_list_up.append(copy(map))
# Lists to compute the topology with upper and lower datasets
# Create the topology between the granularity conform list and all maps
# of the current cycle
gran_topo = tgis.SpatioTemporalTopologyBuilder()
gran_topo.build(gran_list, input_maps)
if lower:
lower_maps = lower_strds.get_registered_maps_as_objects(dbif=dbif)
gran_lower_topo = tgis.SpatioTemporalTopologyBuilder()
gran_lower_topo.build(gran_list_low, lower_maps)
if upper:
upper_maps = upper_strds.get_registered_maps_as_objects(dbif=dbif)
gran_upper_topo = tgis.SpatioTemporalTopologyBuilder()
gran_upper_topo.build(gran_list_up, upper_maps)
old_map_name = None
# Aggregate
num_maps = len(gran_list)
for i in range(num_maps):
if reverse:
map = gran_list[num_maps - i - 1]
else:
map = gran_list[i]
# Select input maps based on temporal topology relations
input_maps = []
if map.get_equal():
input_maps += map.get_equal()
elif map.get_contains():
input_maps += map.get_contains()
elif map.get_overlaps():
input_maps += map.get_overlaps()
elif map.get_overlapped():
input_maps += map.get_overlapped()
elif map.get_during():
input_maps += map.get_during()
# Check input maps
if len(input_maps) == 0:
continue
# New output map
if input_strds.get_temporal_type(
) == 'absolute' and time_suffix == 'gran':
suffix = tgis.create_suffix_from_datetime(
map.temporal_extent.get_start_time(),
input_strds.get_granularity())
output_map_name = "{ba}_{su}".format(ba=base, su=suffix)
elif input_strds.get_temporal_type(
) == 'absolute' and time_suffix == 'time':
suffix = tgis.create_time_suffix(map)
output_map_name = "{ba}_{su}".format(ba=base, su=suffix)
else:
output_map_name = tgis.create_numeric_suffix(
base, count, time_suffix)
output_map_id = map.build_id(output_map_name, mapset)
output_map = input_strds.get_new_map_instance(output_map_id)
# Check if new map is in the temporal database
if output_map.is_in_db(dbif):
if grass.overwrite():
# Remove the existing temporal database entry
output_map.delete(dbif)
output_map = input_strds.get_new_map_instance(
output_map_id)
else:
grass.fatal(
_("Map <%s> is already registered in the temporal"
" database, use overwrite flag to overwrite.") %
(output_map.get_map_id()))
map_start, map_end = map.get_temporal_extent_as_tuple()
if map.is_time_absolute():
output_map.set_absolute_time(map_start, map_end)
else:
output_map.set_relative_time(map_start, map_end,
map.get_relative_time_unit())
limits_vals = limits.split(",")
limits_lower = float(limits_vals[0])
limits_upper = float(limits_vals[1])
lower_map_name = None
if lower:
relations = gran_list_low[i].get_temporal_relations()
for relation in limit_relations:
if relation in relations:
lower_map_name = str(relations[relation][0].get_id())
break
upper_map_name = None
if upper:
relations = gran_list_up[i].get_temporal_relations()
for relation in limit_relations:
if relation in relations:
upper_map_name = str(relations[relation][0].get_id())
break
input_map_names = []
for input_map in input_maps:
input_map_names.append(input_map.get_id())
# Set up the module
accmod = Module("r.series.accumulate",
input=input_map_names,
output=output_map_name,
run_=False)
if old_map_name:
accmod.inputs["basemap"].value = old_map_name
if lower_map_name:
accmod.inputs["lower"].value = lower_map_name
if upper_map_name:
accmod.inputs["upper"].value = upper_map_name
accmod.inputs["limits"].value = (limits_lower, limits_upper)
if shift:
accmod.inputs["shift"].value = float(shift)
if scale:
accmod.inputs["scale"].value = float(scale)
if method:
accmod.inputs["method"].value = method
print(accmod)
accmod.run()
if accmod.popen.returncode != 0:
dbif.close()
grass.fatal(_("Error running r.series.accumulate"))
output_maps.append(output_map)
old_map_name = output_map_name
count += 1
# Increment the cycle
start = end
if input_strds.is_time_absolute():
start = end
if offset:
start = tgis.increment_datetime_by_string(end, offset)
end = tgis.increment_datetime_by_string(start, cycle)
else:
if offset:
start = end + offset
end = start + cycle
# Insert the maps into the output space time dataset
if output_strds.is_in_db(dbif):
if grass.overwrite():
output_strds.delete(dbif)
output_strds = input_strds.get_new_instance(out_id)
temporal_type, semantic_type, title, description = input_strds.get_initial_values(
)
output_strds.set_initial_values(temporal_type, semantic_type, title,
description)
output_strds.insert(dbif)
empty_maps = []
# Register the maps in the database
count = 0
for output_map in output_maps:
count += 1
if count % 10 == 0:
grass.percent(count, len(output_maps), 1)
# Read the raster map data
output_map.load()
# In case of a empty map continue, do not register empty maps
if not register_null:
if output_map.metadata.get_min() is None and \
output_map.metadata.get_max() is None:
empty_maps.append(output_map)
continue
# Insert map in temporal database
output_map.insert(dbif)
output_strds.register_map(output_map, dbif)
# Update the spatio-temporal extent and the metadata table entries
output_strds.update_from_registered_maps(dbif)
grass.percent(1, 1, 1)
dbif.close()
# Remove empty maps
if len(empty_maps) > 0:
for map in empty_maps:
grass.run_command("g.remove",
flags='f',
type="raster",
name=map.get_name(),
quiet=True)
def main():
# Get the options
input = options["input"]
start = options["start"]
stop = options["stop"]
base = options["basename"]
cycle = options["cycle"]
offset = options["offset"]
minimum = options["minimum"]
maximum = options["maximum"]
occurrence = options["occurrence"]
range = options["range"]
indicator = options["indicator"]
staend = options["staend"]
register_null = flags["n"]
reverse = flags["r"]
grass.set_raise_on_error(True)
# Make sure the temporal database exists
tgis.init()
# We need a database interface
dbif = tgis.SQLDatabaseInterfaceConnection()
dbif.connect()
mapset = tgis.get_current_mapset()
if input.find("@") >= 0:
id = input
else:
id = input + "@" + mapset
input_strds = tgis.SpaceTimeRasterDataset(id)
if input_strds.is_in_db() == False:
dbif.close()
grass.fatal(
_("Space time %s dataset <%s> not found") %
(input_strds.get_output_map_instance(None).get_type(), id))
input_strds.select(dbif)
dummy = input_strds.get_new_map_instance(None)
# The occurrence space time raster dataset
if occurrence:
if not minimum or not maximum:
if not range:
dbif.close()
grass.fatal(
_("You need to set the range to compute the occurrence"
" space time raster dataset"))
if occurrence.find("@") >= 0:
occurrence_id = occurrence
else:
occurrence_id = occurrence + "@" + mapset
occurrence_strds = tgis.SpaceTimeRasterDataset(occurrence_id)
if occurrence_strds.is_in_db(dbif):
if not grass.overwrite():
dbif.close()
grass.fatal(
_("Space time raster dataset <%s> is already in the "
"database, use overwrite flag to overwrite") %
occurrence_id)
# The indicator space time raster dataset
if indicator:
if not occurrence:
dbif.close()
grass.fatal(
_("You need to set the occurrence to compute the indicator"
" space time raster dataset"))
if not staend:
dbif.close()
grass.fatal(
_("You need to set the staend options to compute the indicator"
" space time raster dataset"))
if indicator.find("@") >= 0:
indicator = indicator
else:
indicator_id = indicator + "@" + mapset
indicator_strds = tgis.SpaceTimeRasterDataset(indicator_id)
if indicator_strds.is_in_db(dbif):
if not grass.overwrite():
dbif.close()
grass.fatal(
_("Space time raster dataset <%s> is already in the "
"database, use overwrite flag to overwrite") %
indicator_id)
staend = staend.split(",")
indicator_start = int(staend[0])
indicator_mid = int(staend[1])
indicator_end = int(staend[2])
# The minimum threshold space time raster dataset
minimum_strds = None
if minimum:
if minimum.find("@") >= 0:
minimum_id = minimum
else:
minimum_id = minimum + "@" + mapset
minimum_strds = tgis.SpaceTimeRasterDataset(minimum_id)
if minimum_strds.is_in_db() == False:
dbif.close()
grass.fatal(
_("Space time raster dataset <%s> not found") %
(minimum_strds.get_id()))
if minimum_strds.get_temporal_type() != input_strds.get_temporal_type(
):
dbif.close()
grass.fatal(
_("Temporal type of input strds and minimum strds must be equal"
))
minimum_strds.select(dbif)
# The maximum threshold space time raster dataset
maximum_strds = None
if maximum:
if maximum.find("@") >= 0:
maximum_id = maximum
else:
maximum_id = maximum + "@" + mapset
maximum_strds = tgis.SpaceTimeRasterDataset(maximum_id)
if maximum_strds.is_in_db() == False:
dbif.close()
grass.fatal(
_("Space time raster dataset <%s> not found") %
(maximum_strds.get_id()))
if maximum_strds.get_temporal_type() != input_strds.get_temporal_type(
):
dbif.close()
grass.fatal(
_("Temporal type of input strds and maximum strds must be equal"
))
maximum_strds.select(dbif)
input_strds_start, input_strds_end = input_strds.get_temporal_extent_as_tuple(
)
if input_strds.is_time_absolute():
start = tgis.string_to_datetime(start)
if stop:
stop = tgis.string_to_datetime(stop)
else:
stop = input_strds_end
else:
start = int(start)
if stop:
stop = int(stop)
else:
stop = input_strds_end
if input_strds.is_time_absolute():
end = tgis.increment_datetime_by_string(start, cycle)
else:
end = start + cycle
count = 1
indi_count = 1
occurrence_maps = {}
indicator_maps = {}
while input_strds_end > start and stop > start:
# Make sure that the cyclic computation will stop at the correct time
if stop and end > stop:
end = stop
where = "start_time >= \'%s\' AND start_time < \'%s\'" % (str(start),
str(end))
input_maps = input_strds.get_registered_maps_as_objects(where=where,
dbif=dbif)
print len(input_maps)
input_topo = tgis.SpatioTemporalTopologyBuilder()
input_topo.build(input_maps, input_maps)
if len(input_maps) == 0:
continue
grass.message(_("Processing cycle %s - %s" % (str(start), str(end))))
count = compute_occurrence(occurrence_maps, input_strds, input_maps,
start, base, count, mapset, where, reverse,
range, minimum_strds, maximum_strds, dbif)
# Indicator computation is based on the occurrence so we need to start it after
# the occurrence cycle
if indicator:
num_maps = len(input_maps)
for i in xrange(num_maps):
if reverse:
map = input_maps[num_maps - i - 1]
else:
map = input_maps[i]
indicator_map_name = "%s_indicator_%i" % (base, indi_count)
indicator_map_id = dummy.build_id(indicator_map_name, mapset)
indicator_map = input_strds.get_new_map_instance(
indicator_map_id)
# Check if new map is in the temporal database
if indicator_map.is_in_db(dbif):
if grass.overwrite():
# Remove the existing temporal database entry
indicator_map.delete(dbif)
indicator_map = input_strds.get_new_map_instance(
indicator_map_id)
else:
grass.fatal(
_("Map <%s> is already registered in the temporal"
" database, use overwrite flag to overwrite.") %
(indicator_map.get_map_id()))
curr_map = occurrence_maps[map.get_id()].get_name()
# Reverse time
if reverse:
if i == 0:
prev_map = curr_map
subexpr1 = "null()"
subexpr3 = "%i" % (indicator_start)
elif i > 0 and i < num_maps - 1:
prev_map = occurrence_maps[
map.next().get_id()].get_name()
next_map = occurrence_maps[
map.prev().get_id()].get_name()
# In case the previous map is null() set null() or the start indicator
subexpr1 = "if(isnull(%s), null(), %i)" % (
curr_map, indicator_start)
# In case the previous map was not null() if the current map is null() set null()
# if the current map is not null() and the next map is not null() set
# intermediate indicator, if the next map is null set the end indicator
subexpr2 = "if(isnull(%s), %i, %i)" % (
next_map, indicator_end, indicator_mid)
subexpr3 = "if(isnull(%s), null(), %s)" % (curr_map,
subexpr2)
expression = "%s = if(isnull(%s), %s, %s)" % (
indicator_map_name, prev_map, subexpr1, subexpr3)
else:
prev_map = occurrence_maps[
map.next().get_id()].get_name()
subexpr1 = "if(isnull(%s), null(), %i)" % (
curr_map, indicator_start)
subexpr3 = "if(isnull(%s), null(), %i)" % (
curr_map, indicator_mid)
else:
if i == 0:
prev_map = curr_map
subexpr1 = "null()"
subexpr3 = "%i" % (indicator_start)
elif i > 0 and i < num_maps - 1:
prev_map = occurrence_maps[
map.prev().get_id()].get_name()
next_map = occurrence_maps[
map.next().get_id()].get_name()
# In case the previous map is null() set null() or the start indicator
subexpr1 = "if(isnull(%s), null(), %i)" % (
curr_map, indicator_start)
# In case the previous map was not null() if the current map is null() set null()
# if the current map is not null() and the next map is not null() set
# intermediate indicator, if the next map is null set the end indicator
subexpr2 = "if(isnull(%s), %i, %i)" % (
next_map, indicator_end, indicator_mid)
subexpr3 = "if(isnull(%s), null(), %s)" % (curr_map,
subexpr2)
expression = "%s = if(isnull(%s), %s, %s)" % (
indicator_map_name, prev_map, subexpr1, subexpr3)
else:
prev_map = occurrence_maps[
map.prev().get_id()].get_name()
subexpr1 = "if(isnull(%s), null(), %i)" % (
curr_map, indicator_start)
subexpr3 = "if(isnull(%s), null(), %i)" % (
curr_map, indicator_mid)
expression = "%s = if(isnull(%s), %s, %s)" % (
indicator_map_name, prev_map, subexpr1, subexpr3)
print expression
grass.mapcalc(expression, overwrite=True)
map_start, map_end = map.get_temporal_extent_as_tuple()
if map.is_time_absolute():
indicator_map.set_absolute_time(map_start, map_end)
else:
indicator_map.set_relative_time(
map_start, map_end, map.get_relative_time_unit())
indicator_maps[map.get_id()] = indicator_map
indi_count += 1
# Increment the cycle
start = end
if input_strds.is_time_absolute():
start = end
if offset:
start = tgis.increment_datetime_by_string(end, offset)
end = tgis.increment_datetime_by_string(start, cycle)
else:
if offset:
start = end + offset
end = start + cycle
empty_maps = []
create_strds_register_maps(input_strds, occurrence_strds, occurrence_maps,
register_null, empty_maps, dbif)
if indicator:
create_strds_register_maps(input_strds, indicator_strds,
indicator_maps, register_null, empty_maps,
dbif)
dbif.close()
# Remove empty maps
if len(empty_maps) > 0:
for map in empty_maps:
grass.run_command("g.remove",
flags='f',
type="rast",
pattern=map.get_name(),
quiet=True)