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 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 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 main(): # Get the options input = options["input"] output = options["output"] where = options["where"] gran = options["granularity"] base = options["basename"] register_null = flags["n"] method = options["method"] sampling = options["sampling"] offset = options["offset"] nprocs = options["nprocs"] time_suffix = flags["s"] topo_list = sampling.split(",") tgis.init() dbif = tgis.SQLDatabaseInterfaceConnection() dbif.connect() sp = tgis.open_old_stds(input, "strds", dbif) map_list = sp.get_registered_maps_as_objects(where=where, order="start_time", dbif=dbif) if not map_list: dbif.close() gcore.fatal(_("Space time raster dataset <%s> is empty") % input) # We will create the strds later, but need to check here tgis.check_new_stds(output, "strds", dbif, gcore.overwrite()) start_time = map_list[0].temporal_extent.get_start_time() if sp.is_time_absolute(): start_time = tgis.adjust_datetime_to_granularity(start_time, gran) # We use the end time first end_time = map_list[-1].temporal_extent.get_end_time() has_end_time = True # In case no end time is available, then we use the start time of the last map layer if end_time is None: end_time = map_list[- 1].temporal_extent.get_start_time() has_end_time = False granularity_list = [] # Build the granularity list while True: if has_end_time is True: if start_time >= end_time: break else: if start_time > end_time: break granule = tgis.RasterDataset(None) start = start_time if sp.is_time_absolute(): end = tgis.increment_datetime_by_string(start_time, gran) granule.set_absolute_time(start, end) else: end = start_time + int(gran) granule.set_relative_time(start, end, sp.get_relative_time_unit()) start_time = end granularity_list.append(granule) output_list = tgis.aggregate_by_topology(granularity_list=granularity_list, granularity=gran, map_list=map_list, topo_list=topo_list, basename=base, time_suffix=time_suffix, offset=offset, method=method, nprocs=nprocs, spatial=None, overwrite=gcore.overwrite()) if output_list: temporal_type, semantic_type, title, description = sp.get_initial_values() output_strds = tgis.open_new_stds(output, "strds", temporal_type, title, description, semantic_type, dbif, gcore.overwrite()) tgis.register_map_object_list("rast", output_list, output_strds, register_null, sp.get_relative_time_unit(), dbif) # Update the raster metadata table entries with aggregation type output_strds.set_aggregation_type(method) output_strds.metadata.update(dbif) dbif.close()
def main(): # lazy imports import grass.temporal as tgis # Get the options input = options["input"] output = options["output"] sampler = options["sample"] where = options["where"] base = options["basename"] register_null = flags["n"] method = options["method"] sampling = options["sampling"] offset = options["offset"] nprocs = options["nprocs"] time_suffix = options["suffix"] type = options["type"] topo_list = sampling.split(",") tgis.init() dbif = tgis.SQLDatabaseInterfaceConnection() dbif.connect() sp = tgis.open_old_stds(input, "strds", dbif) sampler_sp = tgis.open_old_stds(sampler, type, dbif) if sampler_sp.get_temporal_type() != sp.get_temporal_type(): dbif.close() gcore.fatal( _("Input and aggregation dataset must have " "the same temporal type")) # Check if intervals are present if sampler_sp.temporal_extent.get_map_time() != "interval": dbif.close() gcore.fatal( _("All registered maps of the aggregation dataset " "must have time intervals")) # We will create the strds later, but need to check here tgis.check_new_stds(output, "strds", dbif, gcore.overwrite()) map_list = sp.get_registered_maps_as_objects(where=where, order="start_time", dbif=dbif) if not map_list: dbif.close() gcore.fatal(_("Space time raster dataset <%s> is empty") % input) granularity_list = sampler_sp.get_registered_maps_as_objects( where=where, order="start_time", dbif=dbif) if not granularity_list: dbif.close() gcore.fatal(_("Space time raster dataset <%s> is empty") % sampler) gran = sampler_sp.get_granularity() output_list = tgis.aggregate_by_topology( granularity_list=granularity_list, granularity=gran, map_list=map_list, topo_list=topo_list, basename=base, time_suffix=time_suffix, offset=offset, method=method, nprocs=nprocs, spatial=None, overwrite=gcore.overwrite(), ) if output_list: temporal_type, semantic_type, title, description = sp.get_initial_values( ) output_strds = tgis.open_new_stds( output, "strds", temporal_type, title, description, semantic_type, dbif, gcore.overwrite(), ) tgis.register_map_object_list( "rast", output_list, output_strds, register_null, sp.get_relative_time_unit(), dbif, ) # Update the raster metadata table entries with aggregation type output_strds.set_aggregation_type(method) output_strds.metadata.update(dbif) dbif.close()
def main(): # Get the options input = options["input"] output = options["output"] sampler = options["sample"] where = options["where"] base = options["basename"] register_null = flags["n"] method = options["method"] sampling = options["sampling"] offset = options["offset"] nprocs = options["nprocs"] time_suffix = flags["s"] type = options["type"] topo_list = sampling.split(",") tgis.init() dbif = tgis.SQLDatabaseInterfaceConnection() dbif.connect() sp = tgis.open_old_stds(input, "strds", dbif) sampler_sp = tgis.open_old_stds(sampler, type, dbif) if sampler_sp.get_temporal_type() != sp.get_temporal_type(): dbif.close() gcore.fatal(_("Input and aggregation dataset must have " "the same temporal type")) # Check if intervals are present if sampler_sp.temporal_extent.get_map_time() != "interval": dbif.close() gcore.fatal(_("All registered maps of the aggregation dataset " "must have time intervals")) # We will create the strds later, but need to check here tgis.check_new_stds(output, "strds", dbif, gcore.overwrite()) map_list = sp.get_registered_maps_as_objects(where=where, order="start_time", dbif=dbif) if not map_list: dbif.close() gcore.fatal(_("Space time raster dataset <%s> is empty") % input) granularity_list = sampler_sp.get_registered_maps_as_objects(where=where, order="start_time", dbif=dbif) if not granularity_list: dbif.close() gcore.fatal(_("Space time raster dataset <%s> is empty") % sampler) gran = sampler_sp.get_granularity() output_list = tgis.aggregate_by_topology(granularity_list=granularity_list, granularity=gran, map_list=map_list, topo_list=topo_list, basename=base, time_suffix=time_suffix, offset=offset, method=method, nprocs=nprocs, spatial=None, overwrite=gcore.overwrite()) if output_list: temporal_type, semantic_type, title, description = sp.get_initial_values() output_strds = tgis.open_new_stds(output, "strds", temporal_type, title, description, semantic_type, dbif, gcore.overwrite()) tgis.register_map_object_list("rast", output_list, output_strds, register_null, sp.get_relative_time_unit(), dbif) # Update the raster metadata table entries with aggregation type output_strds.set_aggregation_type(method) output_strds.metadata.update(dbif) dbif.close()
def main(): # Get the options inputs = options["inputs"] output = options["output"] basename = options["basename"] where = options["where"] pyfile = options["pyfile"] nrows = int(options["nrows"]) input_name_list = inputs.split(",") input_strds: List[StrdsEntry] = [] # Import the python code into the current function context code = open(pyfile, "r").read() projection_kv = gcore.parse_command("g.proj", flags="g") epsg_code = projection_kv["epsg"] tgis.init() mapset = gcore.gisenv()["MAPSET"] dbif = tgis.SQLDatabaseInterfaceConnection() dbif.connect() region = Region() num_input_maps = 0 open_output_maps = [] for input_name in input_name_list: sp = tgis.open_old_stds(input_name, "strds", dbif) map_list = sp.get_registered_maps_as_objects(where=where, order="start_time", dbif=dbif) if not map_list: dbif.close() gcore.fatal(_("Space time raster dataset <%s> is empty") % input) if nrows == 0: dbif.close() gcore.fatal(_("Number of rows for the udf must be greater 0.")) num_input_maps = len(map_list) input_strds.append( StrdsEntry(dbif=dbif, strds=sp, map_list=map_list, region=region)) for strds in input_strds: if len(strds.map_list) != num_input_maps: dbif.close() gcore.fatal( _("The number of maps in the input STRDS must be equal")) # Setup the input strds to compute the output maps and the resulting strds mtype = None for strds in input_strds: strds.setup() mtype = strds.mtype num_output_maps = count_resulting_maps(input_strds=input_strds, code=code, epsg_code=epsg_code) if num_output_maps == 1: output_map = RasterRow(name=basename) output_map.open(mode="w", mtype=mtype, overwrite=gcore.overwrite()) open_output_maps.append(output_map) elif num_output_maps > 1: for index in range(num_output_maps): output_map = RasterRow(name=basename + f"_{index}", mapset=mapset) output_map.open(mode="w", mtype=mtype, overwrite=gcore.overwrite()) open_output_maps.append(output_map) else: dbif.close() gcore.fatal(_("No result generated") % input) # Workaround because time reduction will remove the timestamp result_start_times = [datetime.now()] first = False # Read several rows for each map of each input strds and load them into the udf for index in range(0, region.rows, nrows): if index + nrows > region.rows: usable_rows = index + nrows - region.rows + 1 else: usable_rows = nrows # Read all input strds as cubes datacubes = [] for strds in input_strds: datacube = strds.to_datacube(index=index, usable_rows=usable_rows) datacubes.append(datacube) # Run the UDF code data = run_udf(code=code, epsg_code=epsg_code, datacube_list=datacubes) # Read only the first cube datacubes = data.get_datacube_list() first_cube_array: xarray.DataArray = datacubes[0].get_array() if first is False: if 't' in first_cube_array.coords: result_start_times = first_cube_array.coords['t'] # Three dimensions if first_cube_array.ndim == 3: for count, slice in enumerate(first_cube_array): output_map = open_output_maps[count] # print(f"Write slice at index {index} \n{slice} for map {output_map.name}") for row in slice: # Write the result into the output raster map b = Buffer(shape=(region.cols, ), mtype=mtype) b[:] = row[:] output_map.put_row(b) # Two dimensions elif first_cube_array.ndim == 2: output_map = open_output_maps[0] # print(f"Write slice at index {index} \n{slice} for map {output_map.name}") for row in first_cube_array: # Write the result into the output raster map b = Buffer(shape=(region.cols, ), mtype=mtype) b[:] = row[:] output_map.put_row(b) first = True # Create new STRDS new_sp = open_new_stds( name=output, type="strds", temporaltype=input_strds[0].strds.get_temporal_type(), title="new STRDS", descr="New STRDS from UDF", semantic="UDF", overwrite=gcore.overwrite(), dbif=dbif) maps_to_register = [] for count, output_map in enumerate(open_output_maps): output_map.close() print(output_map.fullname()) rd = RasterDataset(output_map.fullname()) if input_strds[0].strds.is_time_absolute(): if hasattr(result_start_times, "data"): d = pandas.to_datetime(result_start_times.data[count]) else: d = result_start_times[count] rd.set_absolute_time(start_time=d) elif input_strds[0].strds.is_time_relative(): if hasattr(result_start_times, "data"): d = result_start_times.data[count] else: d = result_start_times[count] rd.set_relative_time(start_time=d, end_time=None, unit="seconds") rd.load() if rd.is_in_db(dbif=dbif): rd.update(dbif=dbif) else: rd.insert(dbif=dbif) maps_to_register.append(rd) rd.print_info() register_map_object_list(type="raster", map_list=maps_to_register, output_stds=new_sp, dbif=dbif) dbif.close()