def test_relative_time_strds_2(self):
"""Test the registration of maps with relative time in a
space time raster dataset. The timetsamps are set for the maps using the
C-interface before registration.
"""
ciface = tgis.get_tgis_c_library_interface()
ciface.write_raster_timestamp("register_map_1", tgis.get_current_mapset(), "1000000 seconds/1500000 seconds")
ciface.write_raster_timestamp("register_map_2", tgis.get_current_mapset(), "1500000 seconds/2000000 seconds")
tgis.register_maps_in_space_time_dataset(type="raster", name=self.strds_rel.get_name(),
maps="register_map_1,register_map_2")
map = tgis.RasterDataset("register_map_1@" + tgis.get_current_mapset())
map.select()
start, end, unit = map.get_relative_time()
self.assertEqual(start, 1000000)
self.assertEqual(end, 1500000)
self.assertEqual(unit, "seconds")
map = tgis.RasterDataset("register_map_2@" + tgis.get_current_mapset())
map.select()
start, end, unit = map.get_relative_time()
self.assertEqual(start, 1500000)
self.assertEqual(end, 2000000)
self.assertEqual(unit, "seconds")
self.strds_rel.select()
start, end, unit = self.strds_rel.get_relative_time()
self.assertEqual(start, 1000000)
self.assertEqual(end, 2000000)
self.assertEqual(unit, "seconds")
def test_absolute_time_strds_2(self):
"""Test the registration of maps with absolute time in a
space time raster dataset.
The timestamps are set using the C-Interface beforehand, so that the register function needs
to read the timetsamp from the map metadata.
"""
ciface = tgis.get_tgis_c_library_interface()
ciface.write_raster_timestamp("register_map_1", tgis.get_current_mapset(), "1 Jan 2001/2 Jan 2001")
ciface.write_raster_timestamp("register_map_2", tgis.get_current_mapset(), "2 Jan 2001/3 Jan 2001")
tgis.register_maps_in_space_time_dataset(type="raster", name=self.strds_abs.get_name(),
maps="register_map_1,register_map_2")
map = tgis.RasterDataset("register_map_1@" + tgis.get_current_mapset())
map.select()
start, end = map.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 1))
self.assertEqual(end, datetime.datetime(2001, 1, 2))
map = tgis.RasterDataset("register_map_2@" + tgis.get_current_mapset())
map.select()
start, end = map.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 2))
self.assertEqual(end, datetime.datetime(2001, 1, 3))
self.strds_abs.select()
start, end = self.strds_abs.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 1))
self.assertEqual(end, datetime.datetime(2001, 1, 3))
def registerToTemporal(basename, suffixes, mapset, start_day, day_step,
title, desc):
"""
Register daily output maps in spatio-temporal raster data set
"""
maps = ','.join(
[basename + suf + '@' + mapset for suf in suffixes])
tgis.open_new_stds(basename,
type='strds',
temporaltype='relative',
title=title,
descr=desc,
semantic='sum',
dbif=None,
overwrite=grass.overwrite())
tgis.register_maps_in_space_time_dataset(type='rast',
name=basename,
maps=maps,
start=start_day,
end=None,
unit='days',
increment=day_step,
dbif=None,
interval=False)
def test_relative_time_3(self):
"""Test the registration of maps with relative time. The timetsamps are set beforehand using
the C-interface.
"""
ciface = tgis.get_tgis_c_library_interface()
ciface.write_raster_timestamp(
"register_map_1",
tgis.get_current_mapset(),
"1000000 seconds/1500000 seconds",
)
ciface.write_raster_timestamp(
"register_map_2",
tgis.get_current_mapset(),
"1500000 seconds/2000000 seconds",
)
tgis.register_maps_in_space_time_dataset(
type="raster", name=None, maps="register_map_1,register_map_2"
)
map = tgis.RasterDataset("register_map_1@" + tgis.get_current_mapset())
map.select()
start, end, unit = map.get_relative_time()
self.assertEqual(start, 1000000)
self.assertEqual(end, 1500000)
self.assertEqual(unit, "seconds")
map = tgis.RasterDataset("register_map_2@" + tgis.get_current_mapset())
map.select()
start, end, unit = map.get_relative_time()
self.assertEqual(start, 1500000)
self.assertEqual(end, 2000000)
self.assertEqual(unit, "seconds")
def test_absolute_time_strds_1(self):
"""Test the registration of maps with absolute time in a
space time raster dataset
"""
tgis.register_maps_in_space_time_dataset(
type="raster",
name=self.strds_abs.get_name(),
maps="register_map_1,register_map_2",
start="2001-01-01",
increment="1 day",
interval=True,
)
map = tgis.RasterDataset("register_map_1@" + tgis.get_current_mapset())
map.select()
start, end = map.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 1))
self.assertEqual(end, datetime.datetime(2001, 1, 2))
map = tgis.RasterDataset("register_map_2@" + tgis.get_current_mapset())
map.select()
start, end = map.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 2))
self.assertEqual(end, datetime.datetime(2001, 1, 3))
self.strds_abs.select()
start, end = self.strds_abs.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 1))
self.assertEqual(end, datetime.datetime(2001, 1, 3))
def test_relative_time_strds_1(self):
"""Test the registration of maps with relative time in a
space time raster dataset
"""
tgis.register_maps_in_space_time_dataset(
type="raster",
name=self.strds_rel.get_name(),
maps="register_map_1,register_map_2",
start=0,
increment=1,
unit="day",
interval=True,
)
map = tgis.RasterDataset("register_map_1@" + tgis.get_current_mapset())
map.select()
start, end, unit = map.get_relative_time()
self.assertEqual(start, 0)
self.assertEqual(end, 1)
self.assertEqual(unit, "day")
map = tgis.RasterDataset("register_map_2@" + tgis.get_current_mapset())
map.select()
start, end, unit = map.get_relative_time()
self.assertEqual(start, 1)
self.assertEqual(end, 2)
self.assertEqual(unit, "day")
self.strds_rel.select()
start, end, unit = self.strds_rel.get_relative_time()
self.assertEqual(start, 0)
self.assertEqual(end, 2)
self.assertEqual(unit, "day")
def test_absolute_time_strds_4(self):
"""Test the registration of maps with absolute time in a
space time raster dataset. The timestamps are set via method arguments and with the
c-interface. The timestamps of the method arguments should overwrite the
time stamps set via the C-interface. The C-interface sets relative time stamps.
"""
ciface = tgis.get_tgis_c_library_interface()
ciface.write_raster_timestamp("register_map_1", tgis.get_current_mapset(), "1 day")
tgis.register_maps_in_space_time_dataset(type="raster", name=self.strds_abs.get_name(),
maps="register_map_1",
start="2001-02-01", increment="1 day",
interval=True)
map = tgis.RasterDataset("register_map_1@" + tgis.get_current_mapset())
map.select()
start, end = map.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 2, 1))
self.assertEqual(end, datetime.datetime(2001, 2, 2))
self.strds_abs.select()
start, end = self.strds_abs.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 2, 1))
self.assertEqual(end, datetime.datetime(2001, 2, 2))
def registerToTemporal(basename, suffixes, mapset, start_day, day_step,
title, desc):
"""
Register daily output maps in spatio-temporal raster data set
"""
maps = ",".join(
[basename + suf + "@" + mapset for suf in suffixes])
tgis.open_new_stds(
basename,
type="strds",
temporaltype="relative",
title=title,
descr=desc,
semantic="sum",
dbif=None,
overwrite=grass.overwrite(),
)
tgis.register_maps_in_space_time_dataset(
type="rast",
name=basename,
maps=maps,
start=start_day,
end=None,
unit="days",
increment=day_step,
dbif=None,
interval=False,
)
def test_absolute_time_3(self):
"""Test the registration of maps with absolute time.
The timestamps are set using the C-Interface beforehand, so that the register function needs
to read the timetsamp from the map metadata.
"""
ciface = tgis.get_tgis_c_library_interface()
ciface.write_raster_timestamp(
"register_map_1", tgis.get_current_mapset(), "1 Jan 2001 10:30:01"
)
ciface.write_raster_timestamp(
"register_map_2", tgis.get_current_mapset(), "1 Jan 2001 18:30:01"
)
tgis.register_maps_in_space_time_dataset(
type="raster", name=None, maps="register_map_1,register_map_2"
)
map = tgis.RasterDataset("register_map_1@" + tgis.get_current_mapset())
map.select()
start, end = map.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 1, 10, 30, 1))
map = tgis.RasterDataset("register_map_2@" + tgis.get_current_mapset())
map.select()
start, end = map.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 1, 18, 30, 1))
def test_mapset_access_1(self):
"""Test the registration of maps from a different mapset."""
self.strds_abs_2 = tgis.open_new_stds(
name="register_test_abs",
type="strds",
temporaltype="absolute",
title="Test strds",
descr="Test strds",
semantic="field",
overwrite=True,
)
# register maps from another mapset
# names are not fully qualified, maps are in a different mapset
strdsname = self.strds_abs_2.get_name() + "@" + self.newmapset
maps = "register_map_1,register_map_2"
tgis.register_maps_in_space_time_dataset(
type="raster",
name=strdsname,
maps=maps,
start="2001-01-01",
increment="1 day",
interval=True,
)
self.assertModule(
"t.remove",
type="strds",
inputs=strdsname,
flags="rf",
quiet=True,
)
def main():
import grass.temporal as tgis
tgis.init()
dbif = tgis.SQLDatabaseInterfaceConnection()
dbif.connect()
inp = tgis.open_old_stds(options['input'], 'raster')
temp_type, sem_type, title, descr = inp.get_initial_values()
out = tgis.open_new_stds(options['output'], 'strds', temp_type,
title, descr, sem_type, dbif=dbif,
overwrite=gcore.overwrite())
dates = []
for mapp in inp.get_registered_maps_as_objects():
if mapp.get_absolute_time() not in dates:
dates.append(mapp.get_absolute_time())
dates.sort()
idx = 1
out_maps = []
for dat in dates:
outraster = "{ba}_{su}".format(ba=options['basename'], su=idx)
out_maps.append(outraster)
calculate(inp, dat, out, outraster, options['method'])
idx += 1
queue.wait()
times = inp.get_absolute_time()
tgis.register_maps_in_space_time_dataset('raster', out.get_name(),
','.join(out_maps),
start=times[0].strftime(date_format),
end=times[1].strftime(date_format),
dbif=dbif)
def test_relative_time_2(self):
"""Test the registration of maps with relative time"""
tgis.register_maps_in_space_time_dataset(
type="raster",
name=None,
maps="register_map_1,register_map_2",
start=1000000,
increment=500000,
unit="seconds",
interval=True,
)
map = tgis.RasterDataset("register_map_1@" + tgis.get_current_mapset())
map.select()
start, end, unit = map.get_relative_time()
self.assertEqual(start, 1000000)
self.assertEqual(end, 1500000)
self.assertEqual(unit, "seconds")
map = tgis.RasterDataset("register_map_2@" + tgis.get_current_mapset())
map.select()
start, end, unit = map.get_relative_time()
self.assertEqual(start, 1500000)
self.assertEqual(end, 2000000)
self.assertEqual(unit, "seconds")
def main():
# Get the options
name = options["input"]
maps = options["maps"]
type = options["type"]
file = options["file"]
separator = grass.separator(options["separator"])
start = options["start"]
end = options["end"]
unit = options["unit"]
increment = options["increment"]
interval = flags["i"]
# Make sure the temporal database exists
tgis.init()
# Register maps
tgis.register_maps_in_space_time_dataset(type=type,
name=name,
maps=maps,
file=file,
start=start,
end=end,
unit=unit,
increment=increment,
dbif=None,
interval=interval,
fs=separator)
def test_absolute_time_stvds_3(self):
"""Test the registration of maps with absolute time in a
space time raster dataset. The timestamps are set via method arguments and with the
c-interface. The timestamps of the method arguments should overwrite the
time stamps set via the C-interface.
"""
ciface = tgis.get_tgis_c_library_interface()
ciface.write_vector_timestamp(
"register_map_1", tgis.get_current_mapset(), "1 Jan 2001/2 Jan 2001"
)
tgis.register_maps_in_space_time_dataset(
type="vector",
name=self.stvds_abs.get_name(),
maps="register_map_1",
start="2001-02-01",
increment="1 day",
interval=True,
)
map = tgis.VectorDataset("register_map_1@" + tgis.get_current_mapset())
map.select()
start, end = map.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 2, 1))
self.assertEqual(end, datetime.datetime(2001, 2, 2))
self.stvds_abs.select()
start, end = self.stvds_abs.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 2, 1))
self.assertEqual(end, datetime.datetime(2001, 2, 2))
def test_relative_time_strds_1(self):
"""Test the registration of maps with relative time in a
space time raster dataset
"""
tgis.register_maps_in_space_time_dataset(type="raster", name=self.strds_rel.get_name(),
maps="register_map_1,register_map_2", start=0,
increment=1, unit="day", interval=True)
map = tgis.RasterDataset("register_map_1@" + tgis.get_current_mapset())
map.select()
start, end, unit = map.get_relative_time()
self.assertEqual(start, 0)
self.assertEqual(end, 1)
self.assertEqual(unit, "day")
map = tgis.RasterDataset("register_map_2@" + tgis.get_current_mapset())
map.select()
start, end, unit = map.get_relative_time()
self.assertEqual(start, 1)
self.assertEqual(end, 2)
self.assertEqual(unit, "day")
self.strds_rel.select()
start, end, unit = self.strds_rel.get_relative_time()
self.assertEqual(start, 0)
self.assertEqual(end, 2)
self.assertEqual(unit, "day")
def setUpClass(cls):
"""Initiate the temporal GIS and set the region"""
tgis.init(True) # Raise on error instead of exit(1)
cls.use_temp_region()
cls.runModule("g.region",
n=80.0,
s=0.0,
e=120.0,
w=0.0,
t=1.0,
b=0.0,
res=10.0)
cls.runModule("r.mapcalc",
overwrite=True,
quiet=True,
expression="a1 = 1")
cls.runModule("r.mapcalc",
overwrite=True,
quiet=True,
expression="a2 = 2")
cls.runModule("r.mapcalc",
overwrite=True,
quiet=True,
expression="a3 = 3")
cls.runModule("r.mapcalc",
overwrite=True,
quiet=True,
expression="a4 = 4")
cls.runModule("r.mapcalc",
overwrite=True,
quiet=True,
expression="singletmap = 100")
cls.runModule("r.mapcalc",
overwrite=True,
quiet=True,
expression="singlemap = 1000")
tgis.open_new_stds(
name="A",
type="strds",
temporaltype="absolute",
title="A",
descr="A",
semantic="field",
overwrite=True,
)
tgis.register_maps_in_space_time_dataset(
type="raster",
name="A",
maps="a1,a2,a3,a4",
start="2001-01-01",
interval=False,
)
tgis.register_maps_in_space_time_dataset(type="raster",
name=None,
maps="singletmap",
start="2001-01-01")
def registerToTemporal(basename, suffixes, mapset, start_time,
time_step, title, desc):
maps = ','.join([basename + suf + '@' + mapset for suf in suffixes])
tgis.open_new_stds(basename, type='strds',
temporaltype='absolute',
title=title, descr=desc,
semantic='mean', dbif=None,
overwrite=grass.overwrite())
tgis.register_maps_in_space_time_dataset(
type='raster', name=basename, maps=maps, start=start_time,
end=None, increment=time_step, dbif=None, interval=False)
def registerToTemporal(basename, suffixes, mapset, start_time,
time_step, title, desc):
maps = ','.join([basename + suf + '@' + mapset for suf in suffixes])
tgis.open_new_stds(basename, type='strds',
temporaltype='absolute',
title=title, descr=desc,
semantic='mean', dbif=None,
overwrite=grass.overwrite())
tgis.register_maps_in_space_time_dataset(
type='raster', name=basename, maps=maps, start=start_time,
end=None, increment=time_step, dbif=None, interval=False)
def test_absolute_time_2(self):
"""Register vector maps in the temporal database and in addition
in a stvds using the object method deleting empty maps
:return:
"""
tgis.register_maps_in_space_time_dataset(
type="vector",
name=None,
maps="register_map_1,register_map_2,register_map_empty",
start="2001-01-01",
increment="1 day",
interval=True,
)
map_1 = tgis.VectorDataset("register_map_1@" +
tgis.get_current_mapset())
map_1.select()
start, end = map_1.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 1))
self.assertEqual(end, datetime.datetime(2001, 1, 2))
map_2 = tgis.VectorDataset("register_map_2@" +
tgis.get_current_mapset())
map_2.select()
start, end = map_2.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 2))
self.assertEqual(end, datetime.datetime(2001, 1, 3))
map_3 = tgis.VectorDataset("register_map_empty@" +
tgis.get_current_mapset())
map_3.select()
start, end = map_3.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 3))
self.assertEqual(end, datetime.datetime(2001, 1, 4))
map_list = [map_1, map_2, map_3]
tgis.register_map_object_list(
type="vector",
map_list=map_list,
output_stds=self.stvds_abs,
delete_empty=True,
)
self.stvds_abs.select()
start, end = self.stvds_abs.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 1))
self.assertEqual(end, datetime.datetime(2001, 1, 3))
map_3 = tgis.VectorDataset("register_map_empty@" +
tgis.get_current_mapset())
self.assertEqual(map_3.map_exists(), False)
def main():
# Get the options
name = options["dataset"]
maps = options["maps"]
start = options["start"]
increment = options["increment"]
interval = flags["i"]
# Make sure the temporal database exists
tgis.create_temporal_database()
# Register maps
tgis.register_maps_in_space_time_dataset("raster", name, maps, start, increment, None, interval)
def setUpClass(cls):
"""Initiate the temporal GIS and set the region"""
os.putenv("GRASS_OVERWRITE", "1")
tgis.init(True) # Raise on error instead of exit(1)
cls.use_temp_region()
ret = grass.script.run_command("g.region",
n=80.0,
s=0.0,
e=120.0,
w=0.0,
t=100.0,
b=0.0,
res=10.0)
cls.runModule("r3.mapcalc",
overwrite=True,
quiet=True,
expression="a1 = 1")
cls.runModule("r3.mapcalc",
overwrite=True,
quiet=True,
expression="a2 = 2")
cls.runModule("r3.mapcalc",
overwrite=True,
quiet=True,
expression="a3 = 3")
cls.runModule("r3.mapcalc",
overwrite=True,
quiet=True,
expression="a4 = 4")
tgis.open_new_stds(
name="A",
type="str3ds",
temporaltype="absolute",
title="A",
descr="A",
semantic="field",
overwrite=True,
)
tgis.register_maps_in_space_time_dataset(
type="raster_3d",
name="A",
maps="a1,a2,a3,a4",
start="2001-01-01",
increment="1 day",
interval=True,
)
def test_absolute_time_2(self):
"""Test the registration of maps with absolute time
"""
tgis.register_maps_in_space_time_dataset(type="raster", name=None,
maps="register_map_1,register_map_2",
start="2001-01-01 10:30:01", increment="8 hours", interval=False)
map = tgis.RasterDataset("register_map_1@" + tgis.get_current_mapset())
map.select()
start, end = map.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 1, 10, 30, 1))
map = tgis.RasterDataset("register_map_2@" + tgis.get_current_mapset())
map.select()
start, end = map.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 1, 18, 30, 1))
def setUp(self):
"""Create the space time raster dataset"""
self.strds_abs = tgis.open_new_stds(
name="register_test_abs",
type="strds",
temporaltype="absolute",
title="Test strds",
descr="Test strds",
semantic="field",
overwrite=True,
)
tgis.register_maps_in_space_time_dataset(
type="raster",
name=self.strds_abs.get_name(),
maps="register_map_1,register_map_2",
start="2001-01-01",
increment="1 day",
interval=True,
)
self.currmapset = tgis.get_current_mapset()
self.newmapset = "test_temporal_register_mapset_access"
# create and switch to new mapset
self.runModule(
"g.mapset",
mapset=self.newmapset,
flags="c",
quiet=True,
)
# add old mapset to search path
self.runModule(
"g.mapsets",
mapset=self.currmapset,
operation="add",
quiet=True,
)
self.runModule(
"g.mapsets",
flags="p",
verbose=True,
)
tgis.stop_subprocesses()
tgis.init()
self.assertNotEqual(self.currmapset, tgis.get_current_mapset())
def test_absolute_time_2(self):
"""Test the registration of maps with absolute time
using register_maps_in_space_time_dataset() and register_map_object_list() with empty map deletion
"""
tgis.register_maps_in_space_time_dataset(
type="raster",
name=None,
maps="register_map_1,register_map_2,register_map_null",
start="2001-01-01 10:30:01",
increment="8 hours",
interval=False,
)
map_1 = tgis.RasterDataset("register_map_1@" +
tgis.get_current_mapset())
map_1.select()
start, end = map_1.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 1, 10, 30, 1))
map_2 = tgis.RasterDataset("register_map_2@" +
tgis.get_current_mapset())
map_2.select()
start, end = map_2.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 1, 18, 30, 1))
map_3 = tgis.RasterDataset("register_map_null@" +
tgis.get_current_mapset())
map_3.select()
start, end = map_3.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 2, 2, 30, 1))
map_list = [map_1, map_2, map_3]
tgis.register_map_object_list(
type="raster",
map_list=map_list,
output_stds=self.strds_abs,
delete_empty=True,
)
self.strds_abs.select()
start, end = self.strds_abs.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 1, 10, 30, 1))
self.assertEqual(end, datetime.datetime(2001, 1, 1, 18, 30, 1))
map_3 = tgis.VectorDataset("register_map_null@" +
tgis.get_current_mapset())
self.assertEqual(map_3.map_exists(), False)
def setUpClass(cls):
"""Initiate the temporal GIS and set the region
"""
tgis.init(True) # Raise on error instead of exit(1)
cls.use_temp_region()
ret = grass.script.run_command("g.region", n=80.0, s=0.0, e=120.0,
w=0.0, t=100.0, b=0.0, res=10.0)
cls.runModule("r3.mapcalc", overwrite=True, quiet=True, expression="a1 = 1")
cls.runModule("r3.mapcalc", overwrite=True, quiet=True, expression="a2 = 2")
cls.runModule("r3.mapcalc", overwrite=True, quiet=True, expression="a3 = 3")
cls.runModule("r3.mapcalc", overwrite=True, quiet=True, expression="a4 = 4")
tgis.open_new_stds(name="A", type="str3ds", temporaltype="absolute",
title="A", descr="A", semantic="field", overwrite=True)
tgis.register_maps_in_space_time_dataset(type="raster_3d", name="A", maps="a1,a2,a3,a4",
start="2001-01-01", increment="1 day", interval=True)
def test_absolute_time_1(self):
"""!Test the registration of maps with absolute time
"""
tgis.register_maps_in_space_time_dataset(type="rast", name=None,
maps="register_map_1,register_map_2",
start="2001-01-01", increment="1 day", interval=True)
map = tgis.RasterDataset("register_map_1@" + tgis.get_current_mapset())
map.select()
start, end = map.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 1))
self.assertEqual(end, datetime.datetime(2001, 1, 2))
map = tgis.RasterDataset("register_map_2@" + tgis.get_current_mapset())
map.select()
start, end = map.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 2))
self.assertEqual(end, datetime.datetime(2001, 1, 3))
def setUpClass(cls):
"""Initiate the temporal GIS and set the region"""
os.putenv("GRASS_OVERWRITE", "1")
tgis.init(True) # Raise on error instead of exit(1)
cls.use_temp_region()
cls.runModule("g.region",
n=80.0,
s=0.0,
e=120.0,
w=0.0,
t=1.0,
b=0.0,
res=10.0)
cls.runModule("r.mapcalc",
overwrite=True,
quiet=True,
expression="a1 = 7")
cls.runModule("r.mapcalc",
overwrite=True,
quiet=True,
expression="a2 = 8")
tgis.open_new_stds(
name="A",
type="strds",
temporaltype="absolute",
title="A",
descr="A",
semantic="field",
overwrite=True,
)
tgis.register_maps_in_space_time_dataset(type="raster",
name="A",
maps="a1",
start="2001-02-01",
end="2001-04-01")
tgis.register_maps_in_space_time_dataset(type="raster",
name="A",
maps="a2",
start="2001-03-01",
end="2001-05-01")
def test_absolute_time_2(self):
"""!Test the registration of maps with absolute time
"""
tgis.register_maps_in_space_time_dataset(
type="rast",
name=None,
maps="register_map_1,register_map_2",
start="2001-01-01 10:30:01",
increment="8 hours",
interval=False)
map = tgis.RasterDataset("register_map_1@" + tgis.get_current_mapset())
map.select()
start, end = map.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 1, 10, 30, 1))
map = tgis.RasterDataset("register_map_2@" + tgis.get_current_mapset())
map.select()
start, end = map.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 1, 18, 30, 1))
def main():
# Get the options
name = options["input"]
maps = options["maps"]
type = options["type"]
file = options["file"]
separator = grass.separator(options["separator"])
start = options["start"]
end = options["end"]
unit = options["unit"]
increment = options["increment"]
interval = flags["i"]
# Make sure the temporal database exists
tgis.init()
# Register maps
tgis.register_maps_in_space_time_dataset(
type=type, name=name, maps=maps, file=file, start=start, end=end,
unit=unit, increment=increment, dbif=None, interval=interval, fs=separator)
def test_relative_time_2(self):
"""Test the registration of maps with relative time
"""
tgis.register_maps_in_space_time_dataset(type="raster", name=None,
maps="register_map_1,register_map_2",
start=1000000, increment=500000, unit="seconds", interval=True)
map = tgis.RasterDataset("register_map_1@" + tgis.get_current_mapset())
map.select()
start, end, unit = map.get_relative_time()
self.assertEqual(start, 1000000)
self.assertEqual(end, 1500000)
self.assertEqual(unit, "seconds")
map = tgis.RasterDataset("register_map_2@" + tgis.get_current_mapset())
map.select()
start, end, unit = map.get_relative_time()
self.assertEqual(start, 1500000)
self.assertEqual(end, 2000000)
self.assertEqual(unit, "seconds")
def setUpClass(cls):
"""Initiate the temporal GIS and set the region
"""
os.putenv("GRASS_OVERWRITE", "1")
tgis.init(True) # Raise on error instead of exit(1)
cls.use_temp_region()
cls.runModule("g.region", n=80.0, s=0.0, e=120.0,
w=0.0, t=1.0, b=0.0, res=10.0)
cls.runModule("r.mapcalc", overwrite=True, quiet=True, expression="a1 = 7")
cls.runModule("r.mapcalc", overwrite=True, quiet=True, expression="a2 = 8")
tgis.open_new_stds(name="A", type="strds", temporaltype="absolute",
title="A", descr="A", semantic="field", overwrite=True)
tgis.register_maps_in_space_time_dataset(type="raster", name="A", maps="a1",
start="2001-02-01", end="2001-04-01")
tgis.register_maps_in_space_time_dataset(type="raster", name="A", maps="a2",
start="2001-03-01", end="2001-05-01")
def setUpClass(cls):
"""Initiate the temporal GIS and set the region
"""
os.putenv("GRASS_OVERWRITE", "1")
tgis.init(True) # Raise on error instead of exit(1)
cls.use_temp_region()
cls.runModule("g.region", n=80.0, s=0.0, e=120.0,
w=0.0, t=1.0, b=0.0, res=10.0)
cls.runModule("r.mapcalc", quiet=True, expression="a1 = 1")
cls.runModule("r.mapcalc", quiet=True, expression="a2 = 2")
cls.runModule("r.mapcalc", quiet=True, expression="a3 = 3")
cls.runModule("r.mapcalc", quiet=True, expression="a4 = 4")
cls.runModule("r.mapcalc", quiet=True, expression="b1 = 5")
cls.runModule("r.mapcalc", quiet=True, expression="b2 = 6")
cls.runModule("r.mapcalc", quiet=True, expression="c1 = 7")
cls.runModule("r.mapcalc", quiet=True, expression="d1 = 8")
cls.runModule("r.mapcalc", quiet=True, expression="d2 = 9")
cls.runModule("r.mapcalc", quiet=True, expression="d3 = 10")
cls.runModule("r.mapcalc", quiet=True, expression="singletmap = 99")
cls.runModule("r.mapcalc", quiet=True, expression="singlemap = 100")
tgis.open_new_stds(name="A", type="strds", temporaltype="absolute",
title="A", descr="A", semantic="field")
tgis.open_new_stds(name="B", type="strds", temporaltype="absolute",
title="B", descr="B", semantic="field")
tgis.open_new_stds(name="C", type="strds", temporaltype="absolute",
title="B", descr="C", semantic="field")
tgis.open_new_stds(name="D", type="strds", temporaltype="absolute",
title="D", descr="D", semantic="field")
tgis.register_maps_in_space_time_dataset(type="raster", name="A", maps="a1,a2,a3,a4",
start="2001-01-01", increment="1 day", interval=True)
tgis.register_maps_in_space_time_dataset(type="raster", name="B", maps="b1,b2",
start="2001-01-01", increment="2 day", interval=True)
tgis.register_maps_in_space_time_dataset(type="raster", name="C", maps="c1",
start="2001-01-02", increment="2 day", interval=True)
tgis.register_maps_in_space_time_dataset(type="raster", name="D", maps="d1,d2,d3",
start="2001-01-03", increment="1 day", interval=True)
tgis.register_maps_in_space_time_dataset(type="raster", name=None, maps="singletmap",
start="2001-01-03", end="2001-01-04")
def setUpClass(cls):
"""Initiate the temporal GIS and set the region
"""
os.putenv("GRASS_OVERWRITE", "1")
tgis.init(True) # Raise on error instead of exit(1)
cls.use_temp_region()
cls.runModule("g.region", n=80.0, s=0.0, e=120.0,
w=0.0, t=1.0, b=0.0, res=10.0)
cls.runModule("r.mapcalc", quiet=True, expression="a1 = 1")
cls.runModule("r.mapcalc", quiet=True, expression="a2 = 2")
cls.runModule("r.mapcalc", quiet=True, expression="a3 = 3")
cls.runModule("r.mapcalc", quiet=True, expression="a4 = 4")
cls.runModule("r.mapcalc", quiet=True, expression="b1 = 5")
cls.runModule("r.mapcalc", quiet=True, expression="b2 = 6")
cls.runModule("r.mapcalc", quiet=True, expression="c1 = 7")
cls.runModule("r.mapcalc", quiet=True, expression="d1 = 8")
cls.runModule("r.mapcalc", quiet=True, expression="d2 = 9")
cls.runModule("r.mapcalc", quiet=True, expression="d3 = 10")
cls.runModule("r.mapcalc", quiet=True, expression="singletmap = 99")
cls.runModule("r.mapcalc", quiet=True, expression="singlemap = 100")
tgis.open_new_stds(name="A", type="strds", temporaltype="absolute",
title="A", descr="A", semantic="field")
tgis.open_new_stds(name="B", type="strds", temporaltype="absolute",
title="B", descr="B", semantic="field")
tgis.open_new_stds(name="C", type="strds", temporaltype="absolute",
title="B", descr="C", semantic="field")
tgis.open_new_stds(name="D", type="strds", temporaltype="absolute",
title="D", descr="D", semantic="field")
tgis.register_maps_in_space_time_dataset(type="raster", name="A", maps="a1,a2,a3,a4",
start="2001-01-01", increment="1 day", interval=True)
tgis.register_maps_in_space_time_dataset(type="raster", name="B", maps="b1,b2",
start="2001-01-01", increment="2 day", interval=True)
tgis.register_maps_in_space_time_dataset(type="raster", name="C", maps="c1",
start="2001-01-02", increment="2 day", interval=True)
tgis.register_maps_in_space_time_dataset(type="raster", name="D", maps="d1,d2,d3",
start="2001-01-03", increment="1 day", interval=True)
tgis.register_maps_in_space_time_dataset(type="raster", name=None, maps="singletmap",
start="2001-01-03", end="2001-01-04")
def setUpClass(cls):
"""Initiate the temporal GIS and set the region
"""
os.putenv("GRASS_OVERWRITE", "1")
tgis.init(True) # Raise on error instead of exit(1)
cls.use_temp_region()
cls.runModule("g.region", n=80.0, s=0.0, e=120.0,
w=0.0, t=1.0, b=0.0, res=10.0)
cls.runModule("v.random", quiet=True, npoints=20, seed=1, output='a1')
cls.runModule("v.random", quiet=True, npoints=20, seed=1, output='a2')
cls.runModule("v.random", quiet=True, npoints=20, seed=1, output='a3')
cls.runModule("v.random", quiet=True, npoints=20, seed=1, output='a4')
cls.runModule("v.random", quiet=True, npoints=20, seed=2, output='b1')
cls.runModule("v.random", quiet=True, npoints=20, seed=2, output='b2')
cls.runModule("v.random", quiet=True, npoints=20, seed=3, output='c1')
cls.runModule("v.random", quiet=True, npoints=20, seed=4, output='d1')
cls.runModule("v.random", quiet=True, npoints=20, seed=4, output='d2')
cls.runModule("v.random", quiet=True, npoints=20, seed=4, output='d3')
cls.runModule("v.random", quiet=True, npoints=20, seed=5, output='singletmap')
cls.runModule("v.random", quiet=True, npoints=20, seed=6, output='singlemap')
tgis.open_new_stds(name="A", type="stvds", temporaltype="absolute",
title="A", descr="A", semantic="field")
tgis.open_new_stds(name="B", type="stvds", temporaltype="absolute",
title="B", descr="B", semantic="field")
tgis.open_new_stds(name="C", type="stvds", temporaltype="absolute",
title="B", descr="C", semantic="field")
tgis.open_new_stds(name="D", type="stvds", temporaltype="absolute",
title="D", descr="D", semantic="field")
tgis.register_maps_in_space_time_dataset(type="vector", name="A", maps="a1,a2,a3,a4",
start="2001-01-01", increment="1 day", interval=True)
tgis.register_maps_in_space_time_dataset(type="vector", name="B", maps="b1,b2",
start="2001-01-01", increment="2 day", interval=True)
tgis.register_maps_in_space_time_dataset(type="vector", name="C", maps="c1",
start="2001-01-02", increment="2 day", interval=True)
tgis.register_maps_in_space_time_dataset(type="vector", name="D", maps="d1,d2,d3",
start="2001-01-03", increment="1 day", interval=True)
tgis.register_maps_in_space_time_dataset(type="vector", name=None, maps="singletmap",
start="2001-01-03", end="2001-01-04")
def setUpClass(cls):
"""Initiate the temporal GIS and set the region
"""
tgis.init(True) # Raise on error instead of exit(1)
cls.use_temp_region()
cls.runModule("g.region", n=80.0, s=0.0, e=120.0,
w=0.0, t=1.0, b=0.0, res=10.0)
cls.runModule("v.random", overwrite=True, quiet=True, npoints=20, seed=1, output='a1')
cls.runModule("v.random", overwrite=True, quiet=True, npoints=20, seed=1, output='a2')
cls.runModule("v.random", overwrite=True, quiet=True, npoints=20, seed=1, output='a3')
cls.runModule("v.random", overwrite=True, quiet=True, npoints=20, seed=1, output='a4')
cls.runModule("v.random", overwrite=True, quiet=True, npoints=20, seed=2, output='b1')
cls.runModule("v.random", overwrite=True, quiet=True, npoints=20, seed=2, output='b2')
cls.runModule("v.random", overwrite=True, quiet=True, npoints=20, seed=3, output='c1')
cls.runModule("v.random", overwrite=True, quiet=True, npoints=20, seed=4, output='d1')
cls.runModule("v.random", overwrite=True, quiet=True, npoints=20, seed=4, output='d2')
cls.runModule("v.random", overwrite=True, quiet=True, npoints=20, seed=4, output='d3')
cls.runModule("v.random", overwrite=True, quiet=True, npoints=20, seed=5, output='singletmap')
cls.runModule("v.random", overwrite=True, quiet=True, npoints=20, seed=6, output='singlemap')
tgis.open_new_stds(name="A", type="stvds", temporaltype="absolute",
title="A", descr="A", semantic="field", overwrite=True)
tgis.open_new_stds(name="B", type="stvds", temporaltype="absolute",
title="B", descr="B", semantic="field", overwrite=True)
tgis.open_new_stds(name="C", type="stvds", temporaltype="absolute",
title="B", descr="C", semantic="field", overwrite=True)
tgis.open_new_stds(name="D", type="stvds", temporaltype="absolute",
title="D", descr="D", semantic="field", overwrite=True)
tgis.register_maps_in_space_time_dataset(type="vector", name="A", maps="a1,a2,a3,a4",
start="2001-01-01", increment="1 day", interval=True)
tgis.register_maps_in_space_time_dataset(type="vector", name="B", maps="b1,b2",
start="2001-01-01", increment="2 day", interval=True)
tgis.register_maps_in_space_time_dataset(type="vector", name="C", maps="c1",
start="2001-01-02", increment="2 day", interval=True)
tgis.register_maps_in_space_time_dataset(type="vector", name="D", maps="d1,d2,d3",
start="2001-01-03", increment="1 day", interval=True)
tgis.register_maps_in_space_time_dataset(type="vector", name=None, maps="singletmap",
start="2001-01-03", end="2001-01-04")
def setUpClass(cls):
"""Initiate the temporal GIS and set the region
"""
tgis.init(True) # Raise on error instead of exit(1)
cls.use_temp_region()
cls.runModule("g.region", n=80.0, s=0.0, e=120.0,
w=0.0, t=1.0, b=0.0, res=10.0)
cls.runModule("r3.mapcalc", overwrite=True, quiet=True, expression="a1 = 1")
cls.runModule("r3.mapcalc", overwrite=True, quiet=True, expression="a2 = 2")
cls.runModule("r3.mapcalc", overwrite=True, quiet=True, expression="a3 = 3")
cls.runModule("r3.mapcalc", overwrite=True, quiet=True, expression="a4 = 4")
tgis.open_new_stds(name="A", type="str3ds", temporaltype="absolute",
title="A", descr="A", semantic="field", overwrite=True)
tgis.register_maps_in_space_time_dataset(type="raster3d", name="A", maps="a1,a2,a3,a4",
start="2001-01-01", increment="1 day", interval=True)
cls.runModule("r.mapcalc", overwrite=True, quiet=True, expression="b1 = 5")
cls.runModule("r.mapcalc", overwrite=True, quiet=True, expression="b2 = 6")
tgis.open_new_stds(name="B", type="strds", temporaltype="absolute",
title="B", descr="B", semantic="field", overwrite=True)
tgis.register_maps_in_space_time_dataset(type="raster", name="B", maps="b1,b2",
start="2001-01-01", increment="2 day", interval=True)
cls.runModule("v.random", overwrite=True, quiet=True, npoints=20, seed=3, output='c1')
tgis.open_new_stds(name="C", type="stvds", temporaltype="absolute",
title="B", descr="C", semantic="field", overwrite=True)
tgis.register_maps_in_space_time_dataset(type="vector", name="C", maps="c1",
start="2001-01-02", increment="2 day", interval=True)
def test_absolute_time_3(self):
"""!Test the registration of maps with absolute time.
The timestamps are set using the C-Interface beforehand, so that the register function needs
to read the timetsamp from the map metadata.
"""
ciface = tgis.get_tgis_c_library_interface()
ciface.write_raster_timestamp("register_map_1", tgis.get_current_mapset(), "1 Jan 2001 10:30:01")
ciface.write_raster_timestamp("register_map_2", tgis.get_current_mapset(), "1 Jan 2001 18:30:01")
tgis.register_maps_in_space_time_dataset(type="rast", name=None,
maps="register_map_1,register_map_2")
map = tgis.RasterDataset("register_map_1@" + tgis.get_current_mapset())
map.select()
start, end = map.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 1, 10, 30, 1))
map = tgis.RasterDataset("register_map_2@" + tgis.get_current_mapset())
map.select()
start, end = map.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 1, 18, 30, 1))
def test_absolute_time_1(self):
"""Test the registration of maps with absolute time
using register_maps_in_space_time_dataset() and register_map_object_list()
"""
tgis.register_maps_in_space_time_dataset(
type="raster",
name=None,
maps="register_map_1,register_map_2",
start="2001-01-01",
increment="1 day",
interval=True,
)
map_1 = tgis.RasterDataset("register_map_1@" +
tgis.get_current_mapset())
map_1.select()
start, end = map_1.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 1))
self.assertEqual(end, datetime.datetime(2001, 1, 2))
map_2 = tgis.RasterDataset("register_map_2@" +
tgis.get_current_mapset())
map_2.select()
start, end = map_2.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 2))
self.assertEqual(end, datetime.datetime(2001, 1, 3))
map_list = [map_1, map_2]
tgis.register_map_object_list(
type="raster",
map_list=map_list,
output_stds=self.strds_abs,
delete_empty=False,
)
self.strds_abs.select()
start, end = self.strds_abs.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 1))
self.assertEqual(end, datetime.datetime(2001, 1, 3))
def test_relative_time_strds_2(self):
"""!Test the registration of maps with relative time in a
space time raster dataset. The timetsamps are set for the maps using the
C-interface before registration.
"""
ciface = tgis.get_tgis_c_library_interface()
ciface.write_raster_timestamp("register_map_1",
tgis.get_current_mapset(),
"1000000 seconds/1500000 seconds")
ciface.write_raster_timestamp("register_map_2",
tgis.get_current_mapset(),
"1500000 seconds/2000000 seconds")
tgis.register_maps_in_space_time_dataset(
type="rast",
name=self.strds_rel.get_name(),
maps="register_map_1,register_map_2")
map = tgis.RasterDataset("register_map_1@" + tgis.get_current_mapset())
map.select()
start, end, unit = map.get_relative_time()
self.assertEqual(start, 1000000)
self.assertEqual(end, 1500000)
self.assertEqual(unit, "seconds")
map = tgis.RasterDataset("register_map_2@" + tgis.get_current_mapset())
map.select()
start, end, unit = map.get_relative_time()
self.assertEqual(start, 1500000)
self.assertEqual(end, 2000000)
self.assertEqual(unit, "seconds")
self.strds_rel.select()
start, end, unit = self.strds_rel.get_relative_time()
self.assertEqual(start, 1000000)
self.assertEqual(end, 2000000)
self.assertEqual(unit, "seconds")
def test_absolute_time_stvds_2(self):
"""Test the registration of maps with absolute time in a
space time raster dataset.
The timestamps are set using the C-Interface beforehand, so that the register function needs
to read the timetsamp from the map metadata.
"""
ciface = tgis.get_tgis_c_library_interface()
ciface.write_vector_timestamp(
"register_map_1", tgis.get_current_mapset(), "1 Jan 2001/2 Jan 2001"
)
ciface.write_vector_timestamp(
"register_map_2", tgis.get_current_mapset(), "2 Jan 2001/3 Jan 2001"
)
tgis.register_maps_in_space_time_dataset(
type="vector",
name=self.stvds_abs.get_name(),
maps="register_map_1,register_map_2",
)
map = tgis.VectorDataset("register_map_1@" + tgis.get_current_mapset())
map.select()
start, end = map.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 1))
self.assertEqual(end, datetime.datetime(2001, 1, 2))
map = tgis.VectorDataset("register_map_2@" + tgis.get_current_mapset())
map.select()
start, end = map.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 2))
self.assertEqual(end, datetime.datetime(2001, 1, 3))
self.stvds_abs.select()
start, end = self.stvds_abs.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 1))
self.assertEqual(end, datetime.datetime(2001, 1, 3))
def registerToTemporal(
basename, suffixes, mapset, start_time, time_step, title, desc
):
maps = ",".join([basename + suf + "@" + mapset for suf in suffixes])
tgis.open_new_stds(
basename,
type="strds",
temporaltype="absolute",
title=title,
descr=desc,
semantic="mean",
dbif=None,
overwrite=grass.overwrite(),
)
tgis.register_maps_in_space_time_dataset(
type="raster",
name=basename,
maps=maps,
start=start_time,
end=None,
increment=time_step,
dbif=None,
interval=False,
)
def setUpClass(cls):
"""Initiate the temporal GIS and set the region
"""
tgis.init(True) # Raise on error instead of exit(1)
cls.use_temp_region()
cls.runModule("g.region", n=80.0, s=0.0, e=120.0,
w=0.0, t=1.0, b=0.0, res=10.0)
cls.runModule("r3.mapcalc", overwrite=True, quiet=True, expression="a1 = 1")
cls.runModule("r3.mapcalc", overwrite=True, quiet=True, expression="a2 = 2")
cls.runModule("r3.mapcalc", overwrite=True, quiet=True, expression="a3 = 3")
cls.runModule("r3.mapcalc", overwrite=True, quiet=True, expression="a4 = 4")
tgis.open_new_stds(name="A", type="str3ds", temporaltype="absolute",
title="A", descr="A", semantic="field", overwrite=True)
tgis.register_maps_in_space_time_dataset(type="raster3d", name="A", maps="a1,a2,a3,a4",
start="2001-01-01", increment="1 day", interval=True)
cls.runModule("r.mapcalc", overwrite=True, quiet=True, expression="b1 = 5")
cls.runModule("r.mapcalc", overwrite=True, quiet=True, expression="b2 = 6")
tgis.open_new_stds(name="B", type="strds", temporaltype="absolute",
title="B", descr="B", semantic="field", overwrite=True)
tgis.register_maps_in_space_time_dataset(type="raster", name="B", maps="b1,b2",
start="2001-01-01", increment="2 day", interval=True)
cls.runModule("v.random", overwrite=True, quiet=True, npoints=20, seed=3, output='c1')
tgis.open_new_stds(name="C", type="stvds", temporaltype="absolute",
title="B", descr="C", semantic="field", overwrite=True)
tgis.register_maps_in_space_time_dataset(type="vector", name="C", maps="c1",
start="2001-01-02", increment="2 day", interval=True)
def setUpClass(cls):
"""!Initiate the temporal GIS and set the region
"""
os.putenv("GRASS_OVERWRITE", "1")
tgis.init(True) # Raise on error instead of exit(1)
grass.script.use_temp_region()
ret = grass.script.run_command("g.region", n=80.0, s=0.0, e=120.0, w=0.0, t=1.0, b=0.0, res=10.0)
ret += grass.script.run_command("r.mapcalc", overwrite=True, quiet=True, expression="a1 = 1")
ret += grass.script.run_command("r.mapcalc", overwrite=True, quiet=True, expression="a2 = 2")
ret += grass.script.run_command("r.mapcalc", overwrite=True, quiet=True, expression="a3 = 3")
ret += grass.script.run_command("r.mapcalc", overwrite=True, quiet=True, expression="a4 = 4")
ret += grass.script.run_command("r.mapcalc", overwrite=True, quiet=True, expression="b1 = 5")
ret += grass.script.run_command("r.mapcalc", overwrite=True, quiet=True, expression="b2 = 6")
ret += grass.script.run_command("r.mapcalc", overwrite=True, quiet=True, expression="c1 = 7")
tgis.open_new_stds(
name="A", type="strds", temporaltype="absolute", title="A", descr="A", semantic="field", overwrite=True
)
tgis.open_new_stds(
name="B", type="strds", temporaltype="absolute", title="B", descr="B", semantic="field", overwrite=True
)
tgis.open_new_stds(
name="C", type="strds", temporaltype="absolute", title="B", descr="C", semantic="field", overwrite=True
)
tgis.register_maps_in_space_time_dataset(
type="rast", name="A", maps="a1,a2,a3,a4", start="2001-01-01", increment="1 day", interval=True
)
tgis.register_maps_in_space_time_dataset(
type="rast", name="B", maps="b1,b2", start="2001-01-01", increment="2 day", interval=True
)
tgis.register_maps_in_space_time_dataset(
type="rast", name="C", maps="c1", start="2001-01-02", increment="2 day", interval=True
)
def setUpClass(cls):
"""Initiate the temporal GIS and set the region
"""
tgis.init(True) # Raise on error instead of exit(1)
cls.use_temp_region()
cls.runModule("g.region",
n=80.0,
s=0.0,
e=120.0,
w=0.0,
t=1.0,
b=0.0,
res=10.0)
cls.runModule("r.mapcalc",
overwrite=True,
quiet=True,
expression="a1 = 1")
cls.runModule("r.mapcalc",
overwrite=True,
quiet=True,
expression="a2 = 2")
cls.runModule("r.mapcalc",
overwrite=True,
quiet=True,
expression="a3 = 3")
cls.runModule("r.mapcalc",
overwrite=True,
quiet=True,
expression="a4 = 4")
cls.runModule("r.mapcalc",
overwrite=True,
quiet=True,
expression="a5 = 5")
cls.runModule("r.mapcalc",
overwrite=True,
quiet=True,
expression="a6 = 6")
cls.runModule("r.mapcalc",
overwrite=True,
quiet=True,
expression="b1 = 7")
cls.runModule("r.mapcalc",
overwrite=True,
quiet=True,
expression="b2 = 8")
cls.runModule("r.mapcalc",
overwrite=True,
quiet=True,
expression="c1 = 9")
cls.runModule("r.mapcalc",
overwrite=True,
quiet=True,
expression="d1 = 10")
cls.runModule("r.mapcalc",
overwrite=True,
quiet=True,
expression="d2 = 11")
cls.runModule("r.mapcalc",
overwrite=True,
quiet=True,
expression="d3 = 12")
cls.runModule("r.mapcalc",
overwrite=True,
quiet=True,
expression="singletmap = 99")
cls.runModule("r.mapcalc",
overwrite=True,
quiet=True,
expression="nullmap = null()")
tgis.open_new_stds(name="A",
type="strds",
temporaltype="absolute",
title="A",
descr="A",
semantic="field",
overwrite=True)
tgis.open_new_stds(name="B",
type="strds",
temporaltype="absolute",
title="B",
descr="B",
semantic="field",
overwrite=True)
tgis.open_new_stds(name="C",
type="strds",
temporaltype="absolute",
title="C",
descr="C",
semantic="field",
overwrite=True)
tgis.open_new_stds(name="D",
type="strds",
temporaltype="absolute",
title="D",
descr="D",
semantic="field",
overwrite=True)
tgis.register_maps_in_space_time_dataset(type="raster",
name="A",
maps="a1,a2,a3,a4,a5,a6",
start="2001-01-01",
increment="1 month",
interval=True)
tgis.register_maps_in_space_time_dataset(type="raster",
name="B",
maps="b1,b2",
start="2001-01-01",
increment="3 months",
interval=True)
tgis.register_maps_in_space_time_dataset(type="raster",
name="C",
maps="c1",
start="2001-01-01",
increment="1 year",
interval=True)
tgis.register_maps_in_space_time_dataset(type="raster",
name="D",
maps="d1",
start="2001-01-01",
increment="5 days",
interval=True)
tgis.register_maps_in_space_time_dataset(type="raster",
name="D",
maps="d2",
start="2001-03-01",
increment="5 days",
interval=True)
tgis.register_maps_in_space_time_dataset(type="raster",
name="D",
maps="d3",
start="2001-05-01",
increment="5 days",
interval=True)
tgis.register_maps_in_space_time_dataset(type="raster",
name=None,
maps="singletmap",
start="2001-03-01",
end="2001-04-01")
tgis.register_maps_in_space_time_dataset(type="raster",
name=None,
maps="nullmap",
start="2001-01-01",
end="2001-07-01")
def main():
options, flags = gcore.parser()
aspect = options['aspect']
speed = options['speed']
probability = options['probability']
if options['particle_base']:
particle_base = options['particle_base'] + '_'
else:
particle_base = None
if options['particles']:
particles = options['particles']
min_size = float(options['min_size'])
max_size = float(options['max_size'])
comet_length = int(options['comet_length'])
else:
particles = min_size = max_size = comet_length = None
try:
total_time = int(options['total_time'])
step = int(options['step'])
age = int(options['age'])
count = int(options['count'])
except ValueError:
gcore.fatal(_("Parameter should be integer"))
gcore.use_temp_region()
# create aspect in x and y direction
aspect_x = 'aspect_x_' + str(os.getpid())
aspect_y = 'aspect_y_' + str(os.getpid())
xshift_tmp = 'xshift_tmp_' + str(os.getpid())
yshift_tmp = 'yshift_tmp_' + str(os.getpid())
TMP_RAST.append(aspect_x)
TMP_RAST.append(aspect_y)
grast.mapcalc(exp="{aspect_x} = cos({aspect})".format(aspect_x=aspect_x, aspect=aspect))
grast.mapcalc(exp="{aspect_y} = sin({aspect})".format(aspect_y=aspect_y, aspect=aspect))
grast.mapcalc(exp="{xshift} = {aspect_x}*{speed}*{t}".format(xshift=xshift_tmp, t=step, speed=speed,
aspect_x=aspect_x), overwrite=True)
grast.mapcalc(exp="{yshift} = {aspect_y}*{speed}*{t}".format(yshift=yshift_tmp, t=step, speed=speed,
aspect_y=aspect_y), overwrite=True)
# initialize
vector_tmp1 = 'vector_tmp1_' + str(os.getpid())
vector_tmp2 = 'vector_tmp2_' + str(os.getpid())
vector_tmp3 = 'vector_tmp3_' + str(os.getpid())
vector_region = 'vector_region_' + str(os.getpid())
TMP_VECT.extend([vector_tmp1, vector_tmp2, vector_tmp3, vector_region])
random_tmp = 'random_tmp_' + str(os.getpid())
TMP_RAST.extend([xshift_tmp, yshift_tmp, random_tmp])
gcore.run_command('v.in.region', output=vector_region, type='area')
loop = 0
vector_1 = particle_base + "{0:03d}".format(loop)
generate_points(name=vector_1, probability_map=probability, count=count)
grast.mapcalc(exp="{random} = int(rand(1, {maxt}))".format(random=random_tmp, maxt=age + 1))
gcore.run_command('v.what.rast', map=vector_1, raster=random_tmp, column='t')
write_vect_history('v.particles', options, flags, vector_1)
vector_names = [vector_1, ]
for time in range(0, total_time + step, step):
vector_1 = particle_base + "{0:03d}".format(loop)
vector_2 = particle_base + "{0:03d}".format(loop + 1)
vector_names.append(vector_2)
gcore.run_command('v.what.rast', map=vector_1, raster=xshift_tmp, column='xshift')
gcore.run_command('v.what.rast', map=vector_1, raster=yshift_tmp, column='yshift')
gcore.run_command('v.transform', layer=1, input=vector_1, output=vector_2,
columns='xshift:xshift,yshift:yshift', quiet=True)
# increase age
gcore.info("Increasing age...")
sql = 'UPDATE {table} SET t=t+1;'.format(table=vector_2)
gcore.run_command('db.execute', sql=sql)
# remove old points
gcore.info("Removing old points...")
gcore.run_command('v.select', overwrite=True, ainput=vector_2, atype='point',
binput=vector_region, btype='area', operator='within', output=vector_tmp1)
gcore.run_command('v.extract', input=vector_tmp1, layer=1, type='point',
where="t <= " + str(age) + " AND xshift IS NOT NULL", output=vector_tmp2, overwrite=True)
# generate new points
gcore.info("Generating new points...")
count_to_generate = count - gvect.vector_info(vector_tmp2)['points']
if count_to_generate > 0:
generate_points(name=vector_tmp3, probability_map=probability,
count=count_to_generate, overwrite=True)
gcore.info("Patchig new and old points...")
gcore.run_command('v.patch', flags='e', input=[vector_tmp2, vector_tmp3],
output=vector_2, overwrite=True)
sql = 'UPDATE {table} SET t={t} WHERE t IS NULL;'.format(table=vector_2, t=0)
gcore.run_command('db.execute', sql=sql)
write_vect_history('v.particles', options, flags, vector_2)
loop += 1
# Make sure the temporal database exists
tgis.init()
tgis.open_new_space_time_dataset(particle_base[:-1], type='stvds',
temporaltype='relative',
title="title", descr='desc',
semantic='mean', dbif=None,
overwrite=gcore.overwrite())
# TODO: we must start from 1 because there is a bug in register_maps_in_space_time_dataset
tgis.register_maps_in_space_time_dataset(
type='vect', name=particle_base[:-1], maps=','.join(vector_names),
start=str(1), end=None, unit='seconds', increment=step,
interval=False, dbif=None)
# create one vector map with multiple layers
fd, path = tempfile.mkstemp(text=True)
tmpfile = open(path, 'w')
k = 0
for vector in vector_names:
k += 1
layers = [x for x in range(k - comet_length + 1, k + 1) if x > 0]
categories = list(range(len(layers), 0, -1))
text = ''
for layer, cat in zip(layers, categories):
text += '{l} {c}\n'.format(l=layer, c=cat)
coords = gcore.read_command('v.to.db', flags='p', quiet=True, map=vector,
type='point', option='coor', separator=" ").strip()
for coord in coords.split('\n'):
coord = coord.split()
tmpfile.write('P 1 {n_cat}\n{x} {y}\n'.format(n_cat=len(categories), x=coord[1], y=coord[2]))
tmpfile.write(text)
tmpfile.close()
gcore.run_command('v.in.ascii', flags='n', overwrite=True, input=path, output=particles,
format='standard', separator=" ")
os.close(fd)
os.remove(path)
k = 0
sql = []
sizes = get_sizes(max_size, min_size, comet_length)
temporal_maps = []
for vector in vector_names:
k += 1
table = 't' + str(k)
gcore.run_command('v.db.addtable', map=particles, table=table, layer=k,
column="width double precision")
temporal_maps.append(particles + ':' + str(k))
for i in range(comet_length):
sql.append("UPDATE {table} SET width={w:.1f} WHERE cat={c}".format(table=table,
w=sizes[i][1], c=sizes[i][0]))
gcore.write_command('db.execute', input='-', stdin=';\n'.join(sql))
tgis.open_new_space_time_dataset(particles, type='stvds',
temporaltype='relative',
title="title", descr='desc',
semantic='mean', dbif=None,
overwrite=True)
# TODO: we must start from 1 because there is a bug in register_maps_in_space_time_dataset
tgis.register_maps_in_space_time_dataset(
type='vect', name=particles, maps=','.join(temporal_maps),
start=str(1), end=None, unit='seconds', increment=step,
interval=False, dbif=None)
write_vect_history('v.particles', options, flags, particles)
def setUpClass(cls):
"""Initiate the temporal GIS and set the region
"""
tgis.init(True) # Raise on error instead of exit(1)
cls.use_temp_region()
cls.runModule("g.region", n=80.0, s=0.0, e=120.0,
w=0.0, t=1.0, b=0.0, res=10.0)
cls.runModule("r.mapcalc", overwrite=True, quiet=True, expression="a1 = 1")
cls.runModule("r.mapcalc", overwrite=True, quiet=True, expression="a2 = 2")
cls.runModule("r.mapcalc", overwrite=True, quiet=True, expression="a3 = 3")
cls.runModule("r.mapcalc", overwrite=True, quiet=True, expression="a4 = 4")
cls.runModule("r.mapcalc", overwrite=True, quiet=True, expression="a5 = 5")
cls.runModule("r.mapcalc", overwrite=True, quiet=True, expression="a6 = 6")
cls.runModule("r.mapcalc", overwrite=True, quiet=True, expression="b1 = 7")
cls.runModule("r.mapcalc", overwrite=True, quiet=True, expression="b2 = 8")
cls.runModule("r.mapcalc", overwrite=True, quiet=True, expression="c1 = 9")
cls.runModule("r.mapcalc", overwrite=True, quiet=True, expression="d1 = 10")
cls.runModule("r.mapcalc", overwrite=True, quiet=True, expression="d2 = 11")
cls.runModule("r.mapcalc", overwrite=True, quiet=True, expression="d3 = 12")
cls.runModule("r.mapcalc", overwrite=True, quiet=True, expression="singletmap = 99")
tgis.open_new_stds(name="A", type="strds", temporaltype="absolute",
title="A", descr="A", semantic="field", overwrite=True)
tgis.open_new_stds(name="B", type="strds", temporaltype="absolute",
title="B", descr="B", semantic="field", overwrite=True)
tgis.open_new_stds(name="C", type="strds", temporaltype="absolute",
title="C", descr="C", semantic="field", overwrite=True)
tgis.open_new_stds(name="D", type="strds", temporaltype="absolute",
title="D", descr="D", semantic="field", overwrite=True)
tgis.register_maps_in_space_time_dataset(type="raster", name="A", maps="a1,a2,a3,a4,a5,a6",
start="2001-01-01", increment="1 month", interval=True)
tgis.register_maps_in_space_time_dataset(type="raster", name="B", maps="b1,b2",
start="2001-01-01", increment="3 months", interval=True)
tgis.register_maps_in_space_time_dataset(type="raster", name="C", maps="c1",
start="2001-01-01", increment="1 year", interval=True)
tgis.register_maps_in_space_time_dataset(type="raster", name="D", maps="d1",
start="2001-01-01", increment="31 days", interval=True)
tgis.register_maps_in_space_time_dataset(type="raster", name="D", maps="d2",
start="2001-03-01", increment="31 days", interval=True)
tgis.register_maps_in_space_time_dataset(type="raster", name="D", maps="d3",
start="2001-05-01", increment="31 days", interval=True)
tgis.register_maps_in_space_time_dataset(type="raster", name=None, maps="singletmap",
start="2001-01-03", end="2001-01-04")
def main():
options, flags = gcore.parser()
elevation = options["elevation"]
strds = options["output"]
basename = strds
start_water_level = float(options["start_water_level"])
end_water_level = float(options["end_water_level"])
water_level_step = float(options["water_level_step"])
# if options['coordinates']:
# options['coordinates'].split(',')
# passing coordinates parameter as is
coordinates = options["coordinates"]
seed_raster = options["seed_raster"]
if seed_raster and coordinates:
gcore.fatal(
_("Both seed raster and coordinates cannot be specified"
" together, please specify only one of them."))
time_unit = options["time_unit"]
time_step = options[
"time_step"] # temporal fucntions accepts only string now
if int(time_step) <= 0:
gcore.fatal(
_("Time step must be greater than zero."
" Please specify number > 0."))
mapset = gcore.gisenv()["MAPSET"]
title = _("r.lake series")
desctiption = _("r.lake series")
water_levels = [
step for step in frange(start_water_level, end_water_level,
water_level_step)
]
outputs = [
"%s%s%s" % (basename, "_", water_level) for water_level in water_levels
]
if not gcore.overwrite():
check_maps_exist(outputs, mapset)
kwargs = {}
if seed_raster:
kwargs["seed"] = seed_raster
elif coordinates:
kwargs["coordinates"] = coordinates
if flags["n"]:
pass_flags = "n"
else:
pass_flags = None
for i, water_level in enumerate(water_levels):
try:
gcore.run_command(
"r.lake",
flags=pass_flags,
elevation=elevation,
lake=outputs[i],
water_level=water_level,
overwrite=gcore.overwrite(
), # TODO: really works? Its seems that hardcoding here False does not prevent overwriting.
**kwargs)
except CalledModuleError:
# remove maps created so far, try to remove also i-th map
remove_raster_maps(outputs[:i], quiet=True)
gcore.fatal(
_("r.lake command failed. Check above error messages."
" Try different water levels or seed points."))
gcore.info(_("Registering created maps into temporal dataset..."))
# Make sure the temporal database exists
tgis.init()
tgis.open_new_stds(
strds,
type="strds",
temporaltype="relative",
title=title,
descr=desctiption,
semantic="sum",
dbif=None,
overwrite=gcore.overwrite(),
)
# TODO: we must start from 1 because there is a bug in register_maps_in_space_time_dataset
tgis.register_maps_in_space_time_dataset(
type="raster",
name=basename,
maps=",".join(outputs),
start=str(1),
end=None,
unit=time_unit,
increment=time_step,
interval=False,
dbif=None,
)
