temporal modules: More tests; enabled temporal granularity algebra in t.rast3d.algebra

git-svn-id: https://svn.osgeo.org/grass/grass/trunk@62703 15284696-431f-4ddb-bdfa-cd5b030d7da7

temporal/t.rast.algebra/t.rast.algebra.py

@@ -87,7 +87,8 @@ def main():
     p = tgis.TemporalRasterAlgebraParser(run = True, debug=False, spatial = spatial, nprocs = nprocs, register_null = register_null)
     
     if granularity:
-        p.setup_common_granularity(expression=expression,  lexer = tgis.TemporalRasterAlgebraLexer())
+        if not p.setup_common_granularity(expression=expression,  lexer = tgis.TemporalRasterAlgebraLexer()):
+            grass.script.fatal(_("Unable to process the expression in granularity algebra mode"))
     
     p.parse(expression, basename, grass.script.overwrite())
 

temporal/t.rast.algebra/testsuite/test_raster_algebra_fails.py

@@ -0,0 +1,42 @@
+"""
+(C) 2013 by the GRASS Development Team
+This program is free software under the GNU General Public
+License (>=v2). Read the file COPYING that comes with GRASS
+for details.
+
+:authors: Soeren Gebbert
+"""
+
+import datetime
+import os
+import grass.script
+import grass.temporal as tgis
+import grass.gunittest as gunittest
+
+class TestTRastAlgebraFails(gunittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        """Initiate the temporal GIS and set the region
+        """
+        cls.use_temp_region()
+        cls.runModule("g.gisenv",  set="TGIS_USE_CURRENT_MAPSET=1")
+        cls.runModule("g.region",  s=0,  n=80,  w=0,  e=120,  b=0,  t=50,  res=10,  res3=10)
+
+    @classmethod
+    def tearDownClass(cls):
+        """Remove the temporary region
+        """
+        cls.del_temp_region()
+
+    def test_error_handling(self):        
+        # Syntax error
+        self.assertModuleFail("t.rast.algebra",  expression="R == A {+,equal| precedes| follows,l} B", basename="r")
+        # No STRDS
+        self.assertModuleFail("t.rast.algebra",  expression="R = NoSTRDS + NoSTRDS", basename="r")
+        # No basename
+        self.assertModuleFail("t.rast.algebra",  expression="R = A + B")
+
+
+if __name__ == '__main__':
+    gunittest.test()

temporal/t.rast.algebra/testsuite/test_raster_algebra_granularity_fails.py

@@ -0,0 +1,63 @@
+"""
+(C) 2014 by the GRASS Development Team
+This program is free software under the GNU General Public
+License (>=v2). Read the file COPYING that comes with GRASS
+for details.
+
+:authors: Soeren Gebbert and Thomas Leppelt
+"""
+
+import datetime
+import os
+import grass.script
+import grass.temporal as tgis
+import grass.gunittest as gunittest
+
+class TestTRastAlgebraGranularityFails(gunittest.TestCase):
+
+    @classmethod
+    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="rast", name="A",  maps="a1", 
+                                                start="2001-02-01", end="2001-04-01", interval=True)
+        tgis.register_maps_in_space_time_dataset(type="rast", name="A",  maps="a2", 
+                                                start="2001-03-01", end="2001-05-01", interval=True)
+        
+    @classmethod
+    def tearDownClass(cls):
+        """Remove the temporary region 
+        """
+        cls.runModule("t.remove", flags="rf", inputs="A", quiet=True)
+        cls.runModule("t.unregister", maps="singletmap", quiet=True)
+        cls.del_temp_region()
+
+    def test_error_handling(self):        
+        # Syntax error
+        self.assertModuleFail("t.rast.algebra", flags="g",  expression="R = A {+,equal| precedes| follows,l A", basename="r")     
+        # Syntax error
+        self.assertModuleFail("t.rast.algebra", flags="g",  expression="R = A {+,equal| precedes| follows,l} A", basename="r")
+        # Syntax error
+        self.assertModuleFail("t.rast.algebra", flags="g",  expression="R == A + A", basename="r")
+        # No STRDS
+        self.assertModuleFail("t.rast.algebra", flags="g",  expression="R = NoSTRDS + NoSTRDS", basename="r")
+        # No basename
+        self.assertModuleFail("t.rast.algebra", flags="g",  expression="R = A + A")
+        # Invalid temporal topology
+        self.assertModuleFail("t.rast.algebra", flags="g",  expression="R = A + A", basename="r")
+
+if __name__ == '__main__':
+    gunittest.test()

temporal/t.rast.extract/testsuite/test_extract.py

@@ -17,7 +17,7 @@ class TestRasterExtraction(TestCase):
 
     @classmethod
     def setUpClass(cls):
-        """!Initiate the temporal GIS and set the region
+        """Initiate the temporal GIS and set the region
         """
         cls.use_temp_region()
         cls.runModule("g.gisenv",  set="TGIS_USE_CURRENT_MAPSET=1")
@@ -25,7 +25,7 @@ class TestRasterExtraction(TestCase):
 
     @classmethod
     def tearDownClass(cls):
-        """!Remove the temporary region
+        """Remove the temporary region
         """
         cls.del_temp_region()
 
@@ -151,7 +151,7 @@ class TestRasterExtractionFails(TestCase):
 
     @classmethod
     def setUpClass(cls):
-        """!Initiate the temporal GIS and set the region
+        """Initiate the temporal GIS and set the region
         """
         cls.use_temp_region()
         cls.runModule("g.gisenv",  set="TGIS_USE_CURRENT_MAPSET=1")
@@ -159,7 +159,7 @@ class TestRasterExtractionFails(TestCase):
 
     @classmethod
     def tearDownClass(cls):
-        """!Remove the temporary region
+        """Remove the temporary region
         """
         cls.del_temp_region()
 

temporal/t.rast3d.algebra/t.rast3d.algebra.py

@@ -56,6 +56,11 @@
 #% description: Register Null maps
 #%end
 
+#%flag
+#% key: g
+#% description: Use granularity sampling instead of the temporal topology approach
+#%end
+
 
 import grass.script
 import grass.temporal as tgis
@@ -67,6 +72,7 @@ def main():
     nprocs = options["nprocs"]
     spatial = flags["s"]
     register_null = flags["n"]
+    granularity = flags["g"]
 
     # Check for PLY istallation
     try:
@@ -79,6 +85,11 @@ def main():
 
     tgis.init(True)
     p = tgis.TemporalRaster3DAlgebraParser(run = True, debug=False, spatial = spatial, nprocs = nprocs, register_null = register_null)
+    
+    if granularity:
+        if not p.setup_common_granularity(expression=expression,  stdstype = 'str3ds',  lexer = tgis.TemporalRasterAlgebraLexer()):
+            grass.script.fatal(_("Unable to process the expression in granularity algebra mode"))
+            
     p.parse(expression, basename, grass.script.overwrite())
 
 if __name__ == "__main__":

temporal/t.rast3d.algebra/testsuite/test_raster3d_algebra.py

@@ -77,6 +77,49 @@ class TestTRast3dAlgebra(gunittest.TestCase):
         self.assertEqual(start, datetime.datetime(2001, 1, 2))
         self.assertEqual(end, datetime.datetime(2001, 1, 4))
 
+    def test_temporal_neighbors_granularity(self):
+        """Simple temporal neighborhood computation test with granularity algebra"""
+        
+        self.assertModule("t.rast3d.algebra",  flags="g",  expression='D = A[0,0,0,-1] + A[0,0,0,1]',
+                  basename="d")
+
+        D = tgis.open_old_stds("D", type="str3ds")
+        
+        self.assertEqual(D.metadata.get_number_of_maps(), 2)
+        self.assertEqual(D.metadata.get_min_min(), 4)  # 1 + 3
+        self.assertEqual(D.metadata.get_max_max(), 6) # 2 + 4
+        start, end = D.get_absolute_time()
+        self.assertEqual(start, datetime.datetime(2001, 1, 2))
+        self.assertEqual(end, datetime.datetime(2001, 1, 4))
+
+
+class TestTRast3dAlgebraFails(gunittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        """Set the region
+        """
+        cls.use_temp_region()
+        cls.runModule("g.gisenv",  set="TGIS_USE_CURRENT_MAPSET=1")
+        cls.runModule("g.region",  s=0,  n=80,  w=0,  e=120,  b=0,  t=50,  res=10,  res3=10)
+
+    @classmethod
+    def tearDownClass(cls):
+        """Remove the temporary region
+        """
+        cls.del_temp_region()
+
+    def test_error_handling(self):        
+        # Syntax error
+        self.assertModuleFail("t.rast3d.algebra",  expression="R = A {+,equal| precedes| follows,l B", basename="r")       
+        # Granularity syntax error
+        self.assertModuleFail("t.rast3d.algebra",  flags="g",  expression="R = A {+,equal| precedes| follows,l} B", basename="r")
+        # No STRDS
+        self.assertModuleFail("t.rast3d.algebra",  expression="R = NoSTR3DS + NoSTR3DS", basename="r")
+        # No basename
+        self.assertModuleFail("t.rast3d.algebra",  expression="R = A + B")
+
+
 if __name__ == '__main__':
     grass.gunittest.test()
 

temporal/t.rast3d.extract/testsuite/test_extract.py

@@ -0,0 +1,146 @@
+"""Test t.rast3d.extract
+
+(C) 2014 by the GRASS Development Team
+This program is free software under the GNU General Public
+License (>=v2). Read the file COPYING that comes with GRASS
+for details.
+
+:authors: Soeren Gebbert
+"""
+
+import grass.pygrass.modules as pymod
+import subprocess
+from grass.gunittest.case import TestCase
+from grass.gunittest.gmodules import SimpleModule
+
+class TestRaster3dExtraction(TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        """Initiate the temporal GIS and set the region
+        """
+        cls.use_temp_region()
+        cls.runModule("g.region",  s=0,  n=80,  w=0,  e=120,  b=0,  t=50,  res=10,  res3=10)
+
+    @classmethod
+    def tearDownClass(cls):
+        """Remove the temporary region
+        """
+        cls.del_temp_region()
+
+    def setUp(self):
+        """Create input data for transient groundwater flow computation
+        """
+        # Use always the current mapset as temporal database
+        self.runModule("r3.mapcalc", expression="a1 = 100",  overwrite=True)
+        self.runModule("r3.mapcalc", expression="a2 = 200",  overwrite=True)
+        self.runModule("r3.mapcalc", expression="a3 = 300",  overwrite=True)
+        self.runModule("r3.mapcalc", expression="a4 = 400",  overwrite=True)
+        self.runModule("r3.mapcalc", expression="a5 = 500",  overwrite=True)
+        self.runModule("r3.mapcalc", expression="a6 = 600",  overwrite=True)
+
+        self.runModule("t.create",  type="str3ds",  temporaltype="absolute",  
+                                     output="A",  title="A test",  description="A test",  overwrite=True)
+        self.runModule("t.register",  flags="i",  type="rast3d",  input="A",  
+                                     maps="a1,a2,a3,a4,a5,a6",  
+                                     start="2001-01-01", increment="3 months",  overwrite=True)
+
+    def tearDown(self):
+        """Remove generated data"""
+        self.runModule("t.remove",  flags="rf",  type="str3ds",  
+                                   inputs="A,B")
+
+    def test_selection(self):
+        """Perform a simple selection by datetime"""
+        self.assertModule("t.rast3d.extract",  input="A",  output="B", 
+                                      where="start_time > '2001-06-01'")
+
+        #self.assertModule("t.info",  flags="g",  input="B")
+
+        tinfo_string="""start_time=2001-07-01 00:00:00
+        end_time=2002-07-01 00:00:00
+        granularity=3 months
+        map_time=interval
+        aggregation_type=None
+        number_of_maps=4
+        min_min=300.0
+        min_max=600.0
+        max_min=300.0
+        max_max=600.0"""
+
+        info = SimpleModule("t.info", flags="g",  type="str3ds", input="B")
+        self.assertModuleKeyValue(module=info, reference=tinfo_string, precision=2, sep="=")
+
+    def test_selection_and_expression(self):
+        """Perform a selection by datetime and a r3.mapcalc expression"""
+        self.assertModule("t.rast3d.extract",  input="A",  output="B", 
+                                      where="start_time > '2001-06-01'",  
+                                      expression=" if(A > 400, A, null())", 
+                                      basename="b",  nprocs=2,  overwrite=True)
+
+        #self.assertModule("t.info",  flags="g",  input="B")
+
+        tinfo_string="""start_time=2002-01-01 00:00:00
+        end_time=2002-07-01 00:00:00
+        granularity=3 months
+        map_time=interval
+        aggregation_type=None
+        number_of_maps=2
+        min_min=500.0
+        min_max=600.0
+        max_min=500.0
+        max_max=600.0"""
+
+        info = SimpleModule("t.info", flags="g", type="str3ds", input="B")
+        self.assertModuleKeyValue(module=info, reference=tinfo_string, precision=2, sep="=")
+
+    def test_expression_with_empty_maps(self):
+        """Perform r3.mapcalc expression and register empty maps"""
+        self.assertModule("t.rast3d.extract",  flags="n",  input="A",  output="B",
+                                      expression=" if(A > 400, A, null())", 
+                                      basename="b",  nprocs=2,  overwrite=True)
+
+        #self.assertModule("t.info",  flags="g",  input="B")
+
+        tinfo_string="""start_time=2001-01-01 00:00:00
+        end_time=2002-07-01 00:00:00
+        granularity=3 months
+        map_time=interval
+        aggregation_type=None
+        number_of_maps=6
+        min_min=500.0
+        min_max=600.0
+        max_min=500.0
+        max_max=600.0"""
+
+        info = SimpleModule("t.info", flags="g", type="str3ds", input="B")
+        self.assertModuleKeyValue(module=info, reference=tinfo_string, precision=2, sep="=")
+
+class TestRaster3dExtractionFails(TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        """Initiate the temporal GIS and set the region
+        """
+        cls.use_temp_region()
+        cls.runModule("g.region",  s=0,  n=80,  w=0,  e=120,  b=0,  t=50,  res=10,  res3=10)
+
+    @classmethod
+    def tearDownClass(cls):
+        """Remove the temporary region
+        """
+        cls.del_temp_region()
+
+    def test_error_handling(self):
+        """Perform r3.mapcalc expression and register empty maps"""
+        # No input
+        self.assertModuleFail("t.rast3d.extract",  output="B", basename="b")
+        # No output
+        self.assertModuleFail("t.rast3d.extract",  input="A",  basename="b")
+        # No basename
+        self.assertModuleFail("t.rast3d.extract",  input="A",  output="B", 
+                          expression=" if(A > 400, A, null())")
+
+if __name__ == '__main__':
+    from grass.gunittest.main import test
+    test()