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 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("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 """ 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, )