def test_4(self):
"""Simple arithmetik test"""
tra = tgis.TemporalRasterAlgebraParser(run=True, debug=True)
expr = "R = if(D == 11, A - 1, A + 1)"
ret = tra.setup_common_granularity(
expression=expr, lexer=tgis.TemporalRasterAlgebraLexer())
self.assertEqual(ret, True)
tra.parse(expression=expr, basename="r", overwrite=True)
D = tgis.open_old_stds("R", type="strds")
self.assertEqual(D.metadata.get_number_of_maps(), 15)
self.assertEqual(D.metadata.get_min_min(), 2) # 1 - 1
self.assertEqual(D.metadata.get_max_max(), 6) # 5 + 1
start, end = D.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 1))
self.assertEqual(end, datetime.datetime(2001, 5, 6))
self.assertEqual(D.check_temporal_topology(), True)
self.assertEqual(D.get_granularity(), u'1 day')
def test_spatiotemporal_conditional_numeric_2(self):
"""Testing the spatial conditionals with numeric conclusions"""
tra = tgis.TemporalRasterAlgebraParser(run=True, debug=True)
tra.parse(
expression=
'R = if(A > 2 || start_date(A) > "2001-01-01" && start_date(A) < "2001-01-04", A, 8)',
basename="r",
overwrite=True,
)
R = tgis.open_old_stds("R", type="strds")
R.select()
self.assertEqual(R.metadata.get_number_of_maps(), 4)
self.assertEqual(R.metadata.get_min_min(), 2)
self.assertEqual(R.metadata.get_max_max(), 8)
start, end = R.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 1))
self.assertEqual(end, datetime.datetime(2001, 1, 5))
self.assertEqual(R.check_temporal_topology(), True)
self.assertEqual(R.get_granularity(), "1 day")
def test_raster_arithmetic_relation_5(self):
"""Complex arithmetic test with temporal intersection"""
tra = tgis.TemporalRasterAlgebraParser(run=True, debug=True)
tra.parse(
expression=
"R = tmap(singletmap) {+,equal| precedes| follows,l} A + map(singlemap)",
basename="r",
overwrite=True,
)
D = tgis.open_old_stds("R", type="strds")
D.select()
self.assertEqual(D.metadata.get_number_of_maps(), 1)
self.assertEqual(D.metadata.get_min_min(), 208)
self.assertEqual(D.metadata.get_max_max(), 208)
start, end = D.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 3))
self.assertEqual(end, datetime.datetime(2001, 1, 4))
self.assertEqual(D.check_temporal_topology(), True)
self.assertEqual(D.get_granularity(), "1 day")
def test_spatial_conditional_numeric_relation_2(self):
"""Testing the spatial conditionals combined by AND/OR operators.
Evaluation"""
tra = tgis.TemporalRasterAlgebraParser(run=True, debug=True)
tra.parse(
expression="R = if({contains},B > 5, A + 2 / 4.0)",
basename="r",
overwrite=True,
)
R = tgis.open_old_stds("R", type="strds")
R.select()
self.assertEqual(R.metadata.get_number_of_maps(), 4)
self.assertEqual(R.metadata.get_min_min(), 0)
self.assertEqual(R.metadata.get_max_max(), 4.5)
start, end = R.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 1))
self.assertEqual(end, datetime.datetime(2001, 1, 5))
self.assertEqual(R.check_temporal_topology(), True)
self.assertEqual(R.get_granularity(), "1 day")
def test_tmap_map(self):
"""Test STDS + single map with and without timestamp"""
tra = tgis.TemporalRasterAlgebraParser(run=True, debug=True)
expr = "R = tmap(singletmap) + A + map(singletmap)"
ret = tra.setup_common_granularity(
expression=expr, lexer=tgis.TemporalRasterAlgebraLexer())
self.assertEqual(ret, True)
tra.parse(expression=expr, basename="r", overwrite=True)
D = tgis.open_old_stds("R", type="strds")
self.assertEqual(D.metadata.get_number_of_maps(), 1)
self.assertEqual(D.metadata.get_min_min(), 201)
self.assertEqual(D.metadata.get_max_max(), 201)
start, end = D.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 3, 1))
self.assertEqual(end, datetime.datetime(2001, 4, 1))
self.assertEqual(D.check_temporal_topology(), True)
self.assertEqual(D.get_granularity(), u'1 month')
def test_simple_arith_td_1(self):
"""Simple arithmetic test with time suffix option
R = A + td(A)
Since maps in A have a length of one day, th expression equals:
R = A + 1
r1 = a1 + 1
r2 = a2 + 1
r3 = a3 + 1
r4 = a4 + 1
"""
tra = tgis.TemporalRasterAlgebraParser(run=True,
debug=True,
time_suffix="time")
tra.parse(expression='R = A + td(A)', basename="r", overwrite=True)
D = tgis.open_old_stds("R", type="strds")
D.select()
maps = D.get_registered_maps_as_objects()
# Test for map names resulting from the time suffix option
#r_2001_01_01T00_00_00
#r_2001_01_02T00_00_00
#r_2001_01_03T00_00_00
#r_2001_01_04T00_00_00
count = 1
for map in maps:
map_name = "r_2001_01_0%iT00_00_00" % count
self.assertEqual(map.get_name(), map_name)
count += 1
self.assertEqual(D.metadata.get_number_of_maps(), 4)
self.assertEqual(D.metadata.get_min_min(), 2)
self.assertEqual(D.metadata.get_max_max(), 5)
start, end = D.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 1))
self.assertEqual(end, datetime.datetime(2001, 1, 5))
def test_temporal_conditional_time_dimension_bug(self):
"""Testing the conditional time dimension bug, that uses the time
dimension of the conditional statement instead the time dimension
of the then/else statement."""
tra = tgis.TemporalRasterAlgebraParser(run=True, debug=True)
tra.parse(
expression="R = if({contains}, B == 5, A - 1, A + 1)",
basename="r",
overwrite=True,
)
D = tgis.open_old_stds("R", type="strds")
D.select()
self.assertEqual(D.metadata.get_number_of_maps(), 4)
self.assertEqual(D.metadata.get_min_min(), 0) # 1 - 1
self.assertEqual(D.metadata.get_max_max(), 5) # 4 + 1
start, end = D.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 1))
self.assertEqual(end, datetime.datetime(2001, 1, 5))
self.assertEqual(D.check_temporal_topology(), True)
self.assertEqual(D.get_granularity(), "1 day")
def test_temporal_conditional_relation_1(self):
"""Testing the conditional time dimension bug, that uses the time
dimension of the conditional statement instead the time dimension
of the then/else statement."""
tra = tgis.TemporalRasterAlgebraParser(run=True, debug=True)
tra.parse(
expression="R = if({during},exist(A), B - 1, B + 1)",
basename="r",
overwrite=True,
)
R = tgis.open_old_stds("R", type="strds")
R.select()
self.assertEqual(R.metadata.get_number_of_maps(), 4)
self.assertEqual(R.metadata.get_min_min(), 4)
self.assertEqual(R.metadata.get_max_max(), 5)
start, end = R.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 1))
self.assertEqual(end, datetime.datetime(2001, 1, 5))
self.assertEqual(R.check_temporal_topology(), False)
self.assertEqual(R.get_granularity(), "2 days")
def test_temporal_conditional_complement_right_side_timestamps(self):
"""Test the conditional expression that evaluate if then else statements
so that the else statement is a complement operation
R = if({equal|contains|during}, B {#,contains,r} A == 2, B {+,contains,r} A, A)
IF B contains two maps from A
THEN add maps from A and B that fulfill the B contains A condition using the right side timestamps
ELSE copy the maps from A
The connection between the if then else statements are the
topological relations equal, contains and during
r0 = a1 # 1
r1 = b1 + a2 + a3 # 12
r2 = b1 + a2 + a3 # 12
r3 = b2 + a4 + a5 # 16
r4 = b2 + a4 + a5 # 16
r5 = a6 # 6
"""
tra = tgis.TemporalRasterAlgebraParser(run=True, debug=True)
tra.parse(
expression=
"R = if({equal|contains|during}, B {#,contains,r} A == 2, B {+,contains,r} A, A)",
basename="r",
overwrite=True,
)
R = tgis.open_old_stds("R", type="strds")
R.select()
self.assertEqual(R.metadata.get_number_of_maps(), 6)
self.assertEqual(R.metadata.get_min_min(), 1)
self.assertEqual(R.metadata.get_max_max(), 16)
start, end = R.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 1))
self.assertEqual(end, datetime.datetime(2001, 1, 7))
self.assertEqual(R.check_temporal_topology(), True)
self.assertEqual(R.get_granularity(), "1 day")
def test_temporal_select_operators4(self):
"""Testing the temporal select operator. Including temporal relations and
different temporal operators (lr|+&)"""
tra = tgis.TemporalRasterAlgebraParser(run=True, debug=True)
tra.parse(expression="R = A {:,equal|during,r} C",
basename="r",
overwrite=True)
D = tgis.open_old_stds("R", type="strds")
D.select()
maplist = D.get_registered_maps_as_objects()
for map_i in maplist:
start_map, end_map = map_i.get_absolute_time()
self.assertEqual(start_map, datetime.datetime(2001, 1, 2))
self.assertEqual(end_map, datetime.datetime(2001, 1, 4))
self.assertEqual(D.metadata.get_number_of_maps(), 2)
self.assertEqual(D.metadata.get_min_min(), 2)
self.assertEqual(D.metadata.get_max_max(), 3)
start, end = D.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 2))
self.assertEqual(end, datetime.datetime(2001, 1, 4))
self.assertEqual(D.check_temporal_topology(), False)
self.assertEqual(D.get_granularity(), u'2 days')
def main():
expression = options['expression']
basename = options['basename']
nprocs = options["nprocs"]
spatial = flags["s"]
register_null = flags["n"]
# Check for PLY istallation
try:
import ply.lex as lex
import ply.yacc as yacc
except:
grass.script.fatal(
_("Please install PLY (Lex and Yacc Python implementation) to use the temporal algebra modules. "
"You can use t.rast.mapcalc that provides a limited but useful alternative to "
"t.rast.mapcalc2 without PLY requirement."))
tgis.init(True)
p = tgis.TemporalRasterAlgebraParser(run=True,
debug=False,
spatial=spatial,
nprocs=nprocs,
register_null=register_null)
p.parse(expression, basename, grass.script.overwrite())
def test_equal_equivalent_compare(self):
"""Test implicit aggregation
STRDS A and B have identical time stamps, hence the differentiation
is based on the spatial topological relations
R = if({equal|equivalent}, A > 0 {&&,equal|equivalent} B < 10, A {+,equal|equivalent,l} B
spatial equal extents pairs: a1,b1 a2,b2 a3,b3 a4,b4
r0 = a1 + b1 # 2
r1 = a2 + b2 # 4
r2 = a3 + b3 # 6
r3 = a4 + b4 # 8
"""
ta = tgis.TemporalRasterAlgebraParser(run=True,
debug=True,
spatial=True)
ta.parse(
expression=
"R = if({equal|equivalent}, A > 0 {&&,equal|equivalent} B < 10, A {+,equal|equivalent,l} B)",
basename="r",
overwrite=True,
)
D = tgis.open_old_stds("R", type="strds")
D.select()
self.assertEqual(D.metadata.get_number_of_maps(), 4)
self.assertEqual(D.metadata.get_min_min(), 2)
self.assertEqual(D.metadata.get_max_max(), 8)
start, end = D.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 1))
self.assertEqual(D.check_temporal_topology(), False)
self.assertEqual(D.get_granularity(), None)
