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_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 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_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()
# Set the timestamp as relative time
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 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_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 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_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="rast",
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 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"]
vector_output = options["vector_output"]
strds = options["strds"]
where = options["where"]
columns = options["columns"]
if where == "" or where == " " or where == "\n":
where = None
overwrite = grass.overwrite()
# Check the number of sample strds and the number of columns
strds_names = strds.split(",")
column_names = columns.split(",")
if len(strds_names) != len(column_names):
grass.fatal(_("The number of columns must be equal to the number of space time raster datasets"))
# Make sure the temporal database exists
tgis.init()
# We need a database interface
dbif = tgis.SQLDatabaseInterfaceConnection()
dbif.connect()
mapset = grass.gisenv()["MAPSET"]
out_sp = tgis.check_new_stds(output, "stvds", dbif, overwrite)
samples = []
first_strds = tgis.open_old_stds(strds_names[0], "strds", dbif)
# Single space time raster dataset
if len(strds_names) == 1:
rows = first_strds.get_registered_maps(
columns="name,mapset,start_time,end_time",
order="start_time", dbif=dbif)
if not rows:
dbif.close()
grass.fatal(_("Space time raster dataset <%s> is empty") %
out_sp.get_id())
for row in rows:
start = row["start_time"]
end = row["end_time"]
raster_maps = [row["name"] + "@" + row["mapset"],]
s = Sample(start, end, raster_maps)
samples.append(s)
else:
# Multiple space time raster datasets
for name in strds_names[1:]:
dataset = tgis.open_old_stds(name, "strds", dbif)
if dataset.get_temporal_type() != first_strds.get_temporal_type():
grass.fatal(_("Temporal type of space time raster datasets must be equal\n"
"<%(a)s> of type %(type_a)s do not match <%(b)s> of type %(type_b)s"%
{"a":first_strds.get_id(),
"type_a":first_strds.get_temporal_type(),
"b":dataset.get_id(),
"type_b":dataset.get_temporal_type()}))
mapmatrizes = tgis.sample_stds_by_stds_topology("strds", "strds", strds_names,
strds_names[0], False, None,
"equal", False, False)
for i in range(len(mapmatrizes[0])):
isvalid = True
mapname_list = []
for mapmatrix in mapmatrizes:
entry = mapmatrix[i]
if entry["samples"]:
sample = entry["samples"][0]
name = sample.get_id()
if name is None:
isvalid = False
break
else:
mapname_list.append(name)
if isvalid:
entry = mapmatrizes[0][i]
map = entry["granule"]
start, end = map.get_temporal_extent_as_tuple()
s = Sample(start, end, mapname_list)
samples.append(s)
num_samples = len(samples)
# Get the layer and database connections of the input vector
vector_db = grass.vector.vector_db(input)
# We copy the vector table and create the new layers
if vector_db:
# Use the first layer to copy the categories from
layers = "1,"
else:
layers = ""
first = True
for layer in range(num_samples):
layer += 1
# Skip existing layer
if vector_db and layer in vector_db and \
vector_db[layer]["layer"] == layer:
continue
if first:
layers += "%i" % (layer)
first = False
else:
layers += ",%i" % (layer)
vectmap = vector_output
# We create a new vector map using the categories of the original map
try:
grass.run_command("v.category", input=input, layer=layers,
output=vectmap, option="transfer",
overwrite=overwrite)
except CalledModuleError:
grass.fatal(_("Unable to create new layers for vector map <%s>")
% (vectmap))
title = _("Observaion of space time raster dataset(s) <%s>") % (strds)
description= _("Observation of space time raster dataset(s) <%s>"
" with vector map <%s>") % (strds, input)
# Create the output space time vector dataset
out_sp = tgis.open_new_stds(output, "stvds",
first_strds.get_temporal_type(),
title, description,
first_strds.get_semantic_type(),
dbif, overwrite)
dummy = out_sp.get_new_map_instance(None)
# Sample the space time raster dataset with the vector
# map at specific layer with v.what.rast
count = 1
for sample in samples:
raster_names = sample.raster_names
if len(raster_names) != len(column_names):
grass.fatal(_("The number of raster maps in a granule must "
"be equal to the number of column names"))
# Create the columns creation string
columns_string = ""
for name, column in zip(raster_names, column_names):
# The column is by default double precision
coltype = "DOUBLE PRECISION"
# Get raster map type
raster_map = tgis.RasterDataset(name)
raster_map.load()
if raster_map.metadata.get_datatype() == "CELL":
coltype = "INT"
tmp_string = "%s %s," %(column, coltype)
columns_string += tmp_string
# Remove last comma
columns_string = columns_string[0:len(columns_string) - 1]
# Try to add a column
if vector_db and count in vector_db and vector_db[count]["table"]:
try:
grass.run_command("v.db.addcolumn", map=vectmap,
layer=count, column=columns_string,
overwrite=overwrite)
except CalledModuleError:
dbif.close()
grass.fatal(_("Unable to add column %s to vector map <%s> "
"with layer %i") % (columns_string, vectmap, count))
else:
# Try to add a new table
grass.message("Add table to layer %i" % (count))
try:
grass.run_command("v.db.addtable", map=vectmap, layer=count,
columns=columns_string, overwrite=overwrite)
except CalledModuleError:
dbif.close()
grass.fatal(_("Unable to add table to vector map "
"<%s> with layer %i") % (vectmap, count))
# Call v.what.rast for each raster map
for name, column in zip(raster_names, column_names):
try:
grass.run_command("v.what.rast", map=vectmap,
layer=count, raster=name,
column=column, where=where)
except CalledModuleError:
dbif.close()
grass.fatal(_("Unable to run v.what.rast for vector map <%s> "
"with layer %i and raster map <%s>") %
(vectmap, count, str(raster_names)))
vect = out_sp.get_new_map_instance(dummy.build_id(vectmap,
mapset, str(count)))
vect.load()
start = sample.start
end = sample.end
if out_sp.is_time_absolute():
vect.set_absolute_time(start, end)
else:
vect.set_relative_time(
start, end, first_strds.get_relative_time_unit())
if vect.is_in_db(dbif):
vect.update_all(dbif)
else:
vect.insert(dbif)
out_sp.register_map(vect, dbif)
count += 1
out_sp.update_from_registered_maps(dbif)
dbif.close()
def main():
# lazy imports
import grass.temporal as tgis
from grass.pygrass.utils import copy as gcopy
from grass.pygrass.messages import Messenger
from grass.pygrass.vector import Vector
# Get the options
input = options["input"]
output = options["output"]
strds = options["strds"]
where = options["where"]
tempwhere = options["t_where"]
if output and flags['u']:
grass.fatal(_("Cannot combine 'output' option and 'u' flag"))
elif not output and not flags['u']:
grass.fatal(_("'output' option or 'u' flag must be given"))
elif not output and flags['u']:
grass.warning(
_("Attribute table of vector {name} will be updated...").format(
name=input))
if where == "" or where == " " or where == "\n":
where = None
overwrite = grass.overwrite()
quiet = True
if grass.verbosity() > 2:
quiet = False
# Check the number of sample strds and the number of columns
strds_names = strds.split(",")
# Make sure the temporal database exists
tgis.init()
# We need a database interface
dbif = tgis.SQLDatabaseInterfaceConnection()
dbif.connect()
samples = []
first_strds = tgis.open_old_stds(strds_names[0], "strds", dbif)
# Single space time raster dataset
if len(strds_names) == 1:
granu = first_strds.get_granularity()
rows = first_strds.get_registered_maps(
"name,mapset,start_time,end_time", tempwhere, "start_time", dbif)
if not rows:
dbif.close()
grass.fatal(
_("Space time raster dataset <%s> is empty") %
first_strds.get_id())
for row in rows:
start = row["start_time"]
end = row["end_time"]
raster_maps = [
row["name"] + "@" + row["mapset"],
]
s = Sample(start, end, raster_maps, first_strds.get_name(), granu)
samples.append(s)
else:
# Multiple space time raster datasets
for name in strds_names[1:]:
dataset = tgis.open_old_stds(name, "strds", dbif)
if dataset.get_temporal_type() != first_strds.get_temporal_type():
grass.fatal(
_(
"Temporal type of space time raster "
"datasets must be equal\n<%(a)s> of type "
"%(type_a)s do not match <%(b)s> of type "
"%(type_b)s" % {
"a": first_strds.get_id(),
"type_a": first_strds.get_temporal_type(),
"b": dataset.get_id(),
"type_b": dataset.get_temporal_type()
}))
mapmatrizes = tgis.sample_stds_by_stds_topology(
"strds", "strds", strds_names, strds_names[0], False, None,
"equal", False, False)
#TODO check granularity for multiple STRDS
for i in range(len(mapmatrizes[0])):
isvalid = True
mapname_list = []
for mapmatrix in mapmatrizes:
entry = mapmatrix[i]
if entry["samples"]:
sample = entry["samples"][0]
name = sample.get_id()
if name is None:
isvalid = False
break
else:
mapname_list.append(name)
if isvalid:
entry = mapmatrizes[0][i]
map = entry["granule"]
start, end = map.get_temporal_extent_as_tuple()
s = Sample(start, end, mapname_list, name)
samples.append(s)
# Get the layer and database connections of the input vector
if output:
gcopy(input, output, 'vector')
else:
output = input
msgr = Messenger()
perc_curr = 0
perc_tot = len(samples)
pymap = Vector(output)
try:
pymap.open('r')
except:
dbif.close()
grass.fatal(_("Unable to create vector map <%s>" % output))
if len(pymap.dblinks) == 0:
try:
pymap.close()
grass.run_command("v.db.addtable", map=output)
except CalledModuleError:
dbif.close()
grass.fatal(
_("Unable to add table <%s> to vector map <%s>" % output))
if pymap.is_open():
pymap.close()
for sample in samples:
raster_names = sample.raster_names
# Call v.what.rast for each raster map
for name in raster_names:
coltype = "DOUBLE PRECISION"
# Get raster map type
raster_map = tgis.RasterDataset(name)
raster_map.load()
if raster_map.metadata.get_datatype() == "CELL":
coltype = "INT"
day = sample.printDay()
column_name = "%s_%s" % (sample.strds_name, day)
column_string = "%s %s" % (column_name, coltype)
column_string.replace('.', '_')
try:
grass.run_command("v.db.addcolumn",
map=output,
column=column_string,
overwrite=overwrite)
except CalledModuleError:
dbif.close()
grass.fatal(
_("Unable to add column %s to vector map "
"<%s> ") % (column_string, output))
try:
grass.run_command("v.what.rast",
map=output,
raster=name,
column=column_name,
where=where,
quiet=quiet)
except CalledModuleError:
dbif.close()
grass.fatal(
_("Unable to run v.what.rast for vector map"
" <%s> and raster map <%s>") %
(output, str(raster_names)))
msgr.percent(perc_curr, perc_tot, 1)
perc_curr += 1
dbif.close()
def main():
# Get the options
file = options["file"]
input = options["input"]
maps = options["maps"]
type = options["type"]
# Make sure the temporal database exists
tgis.init()
if maps and file:
grass.fatal(_(
"%s= and %s= are mutually exclusive") % ("input", "file"))
if not maps and not file:
grass.fatal(_("%s= or %s= must be specified") % ("input", "file"))
mapset = grass.gisenv()["MAPSET"]
dbif = tgis.SQLDatabaseInterfaceConnection()
dbif.connect()
# In case a space time dataset is specified
if input:
sp = tgis.open_old_stds(input, type, dbif)
maplist = []
dummy = tgis.RasterDataset(None)
# Map names as comma separated string
if maps is not None and maps != "":
if maps.find(",") == -1:
maplist = [maps, ]
else:
maplist = maps.split(",")
# Build the maplist
for count in range(len(maplist)):
mapname = maplist[count]
mapid = dummy.build_id(mapname, mapset)
maplist[count] = mapid
# Read the map list from file
if file:
fd = open(file, "r")
line = True
while True:
line = fd.readline()
if not line:
break
mapname = line.strip()
mapid = dummy.build_id(mapname, mapset)
maplist.append(mapid)
num_maps = len(maplist)
update_dict = {}
count = 0
statement = ""
# Unregister already registered maps
grass.message(_("Unregister maps"))
for mapid in maplist:
if count%10 == 0:
grass.percent(count, num_maps, 1)
map = tgis.dataset_factory(type, mapid)
# Unregister map if in database
if map.is_in_db(dbif) == True:
# Unregister from a single dataset
if input:
# Collect SQL statements
statement += sp.unregister_map(
map=map, dbif=dbif, execute=False)
# Unregister from temporal database
else:
# We need to update all datasets after the removement of maps
map.metadata.select(dbif)
datasets = map.get_registered_stds(dbif)
# Store all unique dataset ids in a dictionary
if datasets:
for dataset in datasets:
update_dict[dataset] = dataset
# Collect SQL statements
statement += map.delete(dbif=dbif, update=False, execute=False)
else:
grass.warning(_("Unable to find %s map <%s> in temporal database" %
(map.get_type(), map.get_id())))
count += 1
# Execute the collected SQL statenents
if statement:
dbif.execute_transaction(statement)
grass.percent(num_maps, num_maps, 1)
# Update space time datasets
if input:
grass.message(_("Unregister maps from space time dataset <%s>"%(input)))
else:
grass.message(_("Unregister maps from the temporal database"))
if input:
sp.update_from_registered_maps(dbif)
sp.update_command_string(dbif=dbif)
elif len(update_dict) > 0:
count = 0
for key in update_dict.keys():
id = update_dict[key]
sp = tgis.open_old_stds(id, type, dbif)
sp.update_from_registered_maps(dbif)
grass.percent(count, len(update_dict), 1)
count += 1
dbif.close()
