temporal framework: Fixing the framework caused by option renaming

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

lib/python/temporal/aggregation.py

@@ -228,7 +228,7 @@ def aggregate_by_topology(granularity_list, granularity, map_list, topo_list,
     r_series = pymod.Module("r.series", output="spam", method=[method],
                             overwrite=overwrite, quiet=True, run_=False,
                             finish_=False)
-    g_copy = pymod.Module("g.copy", rast=['spam', 'spamspam'],
+    g_copy = pymod.Module("g.copy", raster=['spam', 'spamspam'],
                           quiet=True, run_=False, finish_=False)
     output_list = []
     count = 0
@@ -308,7 +308,7 @@ def aggregate_by_topology(granularity_list, granularity, map_list, topo_list,
                 process_queue.put(mod)
             else:
                 mod = copy.deepcopy(g_copy)
-                mod(rast=[aggregation_list[0],  output_name])
+                mod(raster=[aggregation_list[0],  output_name])
                 process_queue.put(mod)
 
     if connected:

lib/python/temporal/extract.py

@@ -234,13 +234,13 @@ def extract_dataset(input, output, type, where, expression, base, nprocs=1,
                     names += ",%s" % (map.get_name())
                 count += 1
             if type == "raster":
-                gscript.run_command("g.remove", flags='f', type='rast',
+                gscript.run_command("g.remove", flags='f', type='raster',
                                     name=names, quiet=True)
             elif type == "raster3d":
                 gscript.run_command("g.remove", flags='f', type='3draster',
                                     name=names, quiet=True)
             elif type == "vector":
-                gscript.run_command("g.remove", flags='f', type='vect',
+                gscript.run_command("g.remove", flags='f', type='vector',
                                     name=names, quiet=True)
 
     dbif.close()

lib/python/temporal/factory.py

@@ -26,8 +26,8 @@ from space_time_datasets import *
 def dataset_factory(type, id):
     """A factory functions to create space time or map datasets
 
-       :param type: the dataset type: rast or raster, 3draster,
-                    vect or vector, strds, str3ds, stvds
+       :param type: the dataset type: rast or raster; rast3d, raster3d or 3draster;
+                    vect or vector; strds; str3ds; stvds
        :param id: The id of the dataset ("name@mapset")
     """
     if type == "strds":
@@ -38,7 +38,7 @@ def dataset_factory(type, id):
         sp = SpaceTimeVectorDataset(id)
     elif type == "rast" or type == "raster":
         sp = RasterDataset(id)
-    elif type == "3draster":
+    elif type == "3draster" or type == "rast3d" or type == "raster3d":
         sp = Raster3DDataset(id)
     elif type == "vect" or type == "vector":
         sp = VectorDataset(id)

lib/python/temporal/mapcalc.py

@@ -328,7 +328,7 @@ def dataset_mapcalculator(inputs, output, type, expression, base, method,
                     names += ",%s" % (map.get_name())
                 count += 1
             if type == "raster":
-                gscript.run_command("g.remove", flags='f', type='rast',
+                gscript.run_command("g.remove", flags='f', type='raster',
                                     name=names, quiet=True)
             elif type == "raster3d":
                 gscript.run_command("g.remove", flags='f', type='3draster',

lib/python/temporal/open_stds.py

@@ -52,7 +52,7 @@ def open_old_stds(name, type, dbif=None):
 
     if type == "strds" or type == "rast" or type == "raster":
         sp = dataset_factory("strds", id)
-    elif type == "str3ds" or type == "3draster" or type == "3draster":
+    elif type == "str3ds" or type == "raster3d" or type == "rast3d" or type == "3draster":
         sp = dataset_factory("str3ds", id)
     elif type == "stvds" or type == "vect" or type == "vector":
         sp = dataset_factory("stvds", id)
@@ -108,7 +108,7 @@ def check_new_stds(name, type, dbif=None, overwrite=False):
 
     if type == "strds" or type == "rast" or type == "raster":
         sp = dataset_factory("strds", id)
-    elif type == "str3ds" or type == "3draster" or type == "3draster":
+    elif type == "str3ds" or type == "raster3d" or type == "rast3d "or type == "3draster":
         sp = dataset_factory("str3ds", id)
     elif type == "stvds" or type == "vect" or type == "vector":
         sp = dataset_factory("stvds", id)
@@ -235,7 +235,7 @@ def open_new_map_dataset(name, layer=None, type="raster",
     mapset = get_current_mapset()
 
     dbif, connected = init_dbif(dbif)
-    new_map = check_new_map_dataset(name, layer, "raster", overwrite, dbif)
+    new_map = check_new_map_dataset(name, layer, type, overwrite, dbif)
 
     # Check if new map is in the temporal database
     if new_map.is_in_db(dbif):

lib/python/temporal/register.py

@@ -35,17 +35,17 @@ def register_maps_in_space_time_dataset(
        It takes care of the correct update of the space time datasets from all
        registered maps.
 
-       :param type: The type of the maps rast, 3draster or vect
+       :param type: The type of the maps raster, 3draster or vector
        :param name: The name of the space time dataset. Maps will be
                     registered in the temporal database if the name was set
                     to None
        :param maps: A comma separated list of map names
        :param file: Input file, one map per line map with start and optional
                    end time
-       :param start: The start date and time of the first raster map
+       :param start: The start date and time of the first map
                     (format absolute: "yyyy-mm-dd HH:MM:SS" or "yyyy-mm-dd",
                     format relative is integer 5)
-       :param end: The end date and time of the first raster map
+       :param end: The end date and time of the first map
                   (format absolute: "yyyy-mm-dd HH:MM:SS" or "yyyy-mm-dd",
                   format relative is integer 5)
        :param unit: The unit of the relative time: years, months, days,
@@ -308,7 +308,7 @@ def register_maps_in_space_time_dataset(
     if name and map_object_list:
         count = 0
         num_maps = len(map_object_list)
-        msgr.message(_("Registering maps in the space time raster dataset..."))
+        msgr.message(_("Registering maps in the space time dataset..."))
         for map in map_object_list:
             if count % 50 == 0:
                 msgr.percent(count, num_maps, 1)
@@ -317,7 +317,7 @@ def register_maps_in_space_time_dataset(
 
     # Update the space time tables
     if name and map_object_list:
-        msgr.message(_("Updating space time raster dataset..."))
+        msgr.message(_("Updating space time dataset..."))
         sp.update_from_registered_maps(dbif)
         if update_cmd_list is True:
             sp.update_command_string(dbif=dbif)
@@ -327,7 +327,7 @@ def register_maps_in_space_time_dataset(
         for dataset in datatsets_to_modify:
             if type == "rast" or type == "raster":
                 ds = dataset_factory("strds", dataset)
-            elif type == "3draster":
+            elif type == "3draster" or type == "rast3d" or type == "raster3d":
                 ds = dataset_factory("str3ds", dataset)
             elif type == "vect" or type == "vector":
                 ds = dataset_factory("stvds", dataset)
@@ -349,10 +349,10 @@ def assign_valid_time_to_map(ttype, map, start, end, unit, increment=None,
        :param ttype: The temporal type which should be assigned
                      and which the time format is of
        :param map: A map dataset object derived from abstract_map_dataset
-       :param start: The start date and time of the first raster map
+       :param start: The start date and time of the first map
                      (format absolute: "yyyy-mm-dd HH:MM:SS" or "yyyy-mm-dd",
                      format relative is integer 5)
-       :param end: The end date and time of the first raster map
+       :param end: The end date and time of the first map
                    (format absolute: "yyyy-mm-dd HH:MM:SS" or "yyyy-mm-dd",
                    format relative is integer 5)
        :param unit: The unit of the relative time: years, months,
@@ -434,7 +434,7 @@ def register_map_object_list(type,  map_list, output_stds,
     """Register a list of AbstractMapDataset objects in the temporal database
        and optional in a space time dataset.
 
-       :param type: The type of the map layer (rast, 3draster, vect)
+       :param type: The type of the map layer (raster, 3draster, vector)
        :param map_list: List of AbstractMapDataset objects
        :param output_stds: The output stds
        :param delete_empty: Set True to delete empty map layer found in the map_list
@@ -452,7 +452,7 @@ def register_map_object_list(type,  map_list, output_stds,
 
     empty_maps = []
     for map_layer in map_list:
-        # Read the raster map data
+        # Read the map data
         map_layer.load()
         # In case of a empty map continue, do not register empty maps
 
@@ -488,7 +488,12 @@ def register_map_object_list(type,  map_list, output_stds,
                 map.delete(dbif)
             mod = copy.deepcopy(g_remove)
             if map.get_name():
-                mod(type='rast', name=map.get_name())
+                if map.get_type() == "raster":
+                    mod(type='raster', name=map.get_name())
+                if map.get_type() == "raster3d":
+                    mod(type='3draster', name=map.get_name())
+                if map.get_type() == "vector":
+                    mod(type='vector', name=map.get_name())
                 mod.run()
 
     if connected:

lib/python/temporal/space_time_datasets.py

@@ -100,7 +100,7 @@ class RasterDataset(AbstractMapDataset):
             >>> rmap.is_time_relative()
             False
 
-            >>> grass.run_command("g.remove", flags="f", type="rast", name=name, quiet=True)
+            >>> grass.run_command("g.remove", flags="f", type="raster", name=name, quiet=True)
             0
             >>> grass.del_temp_region()
 
@@ -746,7 +746,7 @@ class VectorDataset(AbstractMapDataset):
             True
             >>> vmap.is_time_relative()
             False
-            >>> grass.run_command("g.remove", flags="f", type="vect", name=name, quiet=True)
+            >>> grass.run_command("g.remove", flags="f", type="vector", name=name, quiet=True)
             0
             >>> grass.del_temp_region()
 

lib/python/temporal/temporal_algebra.py

@@ -1070,14 +1070,6 @@ class TemporalAlgebraParser(object):
         for chunk in chunklist:
             stringlist = ",".join(chunk)
             
-            # Transform the map type
-            if map_type == "raster":
-                map_type = "rast"
-            if map_type == "raster3d":
-                map_type = "3draster"
-            if map_type == "vector":
-                map_type = "vect"
-
             if self.run:
                 m = copy.deepcopy(self.m_mremove)
                 m.inputs["type"].value = map_type
@@ -2068,7 +2060,7 @@ class TemporalAlgebraParser(object):
                             # Copy the map
                             if map_i.get_type() == 'raster':
                                 m = copy.deepcopy(self.m_copy)
-                                m.inputs["rast"].value = map_i.get_id(),  newident
+                                m.inputs["raster"].value = map_i.get_id(),  newident
                                 m.flags["overwrite"].value = self.overwrite
                                 process_queue.put(m)
                             elif map_i.get_type() == 'raster3d':
@@ -2078,7 +2070,7 @@ class TemporalAlgebraParser(object):
                                 process_queue.put(m)
                             elif map_i.get_type() == 'vector':
                                 m = copy.deepcopy(self.m_copy)
-                                m.inputs["vect"].value = map_i.get_id(),  newident
+                                m.inputs["vector"].value = map_i.get_id(),  newident
                                 m.flags["overwrite"].value = self.overwrite
                                 process_queue.put(m)
                         else:

lib/python/temporal/temporal_raster_algebra.py

@@ -85,7 +85,7 @@ class TemporalRasterAlgebraParser(TemporalRasterBaseAlgebraParser):
         self.overwrite = overwrite
         self.count = 0
         self.stdstype = "strds"
-        self.maptype = "rast"
+        self.maptype = "raster"
         self.mapclass = RasterDataset
         self.basename = basename
         self.expression = expression

lib/python/temporal/temporal_vector_algebra.py

@@ -140,7 +140,7 @@ class TemporalVectorAlgebraParser(TemporalAlgebraParser):
         self.overwrite = overwrite
         self.count = 0
         self.stdstype = "stvds"
-        self.maptype = "vect"
+        self.maptype = "vector"
         self.mapclass = VectorDataset
         self.basename = basename
         self.expression = expression
@@ -420,7 +420,7 @@ class TemporalVectorAlgebraParser(TemporalAlgebraParser):
                             # Change map name to given basename.
                             newident = self.basename + "_" + str(count)
                             m = copy.deepcopy(self.m_rename)
-                            m.inputs["vect"].value = (map_i.get_name(),newident)
+                            m.inputs["vector"].value = (map_i.get_name(),newident)
                             m.flags["overwrite"].value = self.overwrite
                             m.run()
                             map_i.set_id(newident + "@" + mapset)
@@ -451,7 +451,7 @@ class TemporalVectorAlgebraParser(TemporalAlgebraParser):
 
                             # Copy the map
                             m = copy.deepcopy(self.m_copy)
-                            m.inputs["vect"].value = map_i.get_id(),  newident
+                            m.inputs["vector"].value = map_i.get_id(),  newident
                             m.flags["overwrite"].value = self.overwrite
                             m.run()
                         else:

lib/python/temporal/testsuite/test_register_function.py

@@ -43,15 +43,17 @@ class TestRegisterFunctions(grass.gunittest.TestCase):
                        expression="register_map_2 = 2")
 
         self.strds_abs = tgis.open_new_stds(name="register_test_abs", type="strds", temporaltype="absolute",
-                                            title="Test strds", descr="Test strds", semantic="field")
+                                            title="Test strds", descr="Test strds", semantic="field", 
+                                            overwrite=True)
         self.strds_rel = tgis.open_new_stds(name="register_test_rel", type="strds", temporaltype="relative",
-                                            title="Test strds", descr="Test strds", semantic="field")
+                                            title="Test strds", descr="Test strds", semantic="field",
+                                            overwrite=True)
 
     def tearDown(self):
         """Remove maps from temporal database
         """
         self.runModule("t.unregister", maps="register_map_1,register_map_2", quiet=True)
-        self.runModule("g.remove", flags='f', type="rast", name="register_map_1,register_map_2", quiet=True)
+        self.runModule("g.remove", flags='f', type="raster", name="register_map_1,register_map_2", quiet=True)
         self.strds_abs.delete()
         self.strds_rel.delete()
 
@@ -59,7 +61,7 @@ class TestRegisterFunctions(grass.gunittest.TestCase):
         """Test the registration of maps with absolute time in a
            space time raster dataset
         """
-        tgis.register_maps_in_space_time_dataset(type="rast", name=self.strds_abs.get_name(),
+        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)
 
@@ -91,7 +93,7 @@ class TestRegisterFunctions(grass.gunittest.TestCase):
         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(),
+        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())
@@ -114,7 +116,7 @@ class TestRegisterFunctions(grass.gunittest.TestCase):
     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,
+        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)
 
@@ -133,7 +135,7 @@ class TestRegisterFunctions(grass.gunittest.TestCase):
     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,
+        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)
 
@@ -157,7 +159,7 @@ class TestRegisterFunctions(grass.gunittest.TestCase):
         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,
+        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())
@@ -175,7 +177,7 @@ class TestRegisterFunctions(grass.gunittest.TestCase):
            space time raster dataset
         """
 
-        tgis.register_maps_in_space_time_dataset(type="rast", name=self.strds_rel.get_name(),
+        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)
 
@@ -208,7 +210,7 @@ class TestRegisterFunctions(grass.gunittest.TestCase):
         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(),
+        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())
@@ -234,7 +236,7 @@ class TestRegisterFunctions(grass.gunittest.TestCase):
     def test_relative_time_1(self):
         """Test the registration of maps with relative time
         """
-        tgis.register_maps_in_space_time_dataset(type="rast", name=None,
+        tgis.register_maps_in_space_time_dataset(type="raster", name=None,
                  maps="register_map_1,register_map_2",
                  start=0, increment=1, unit="day", interval=True)
 
@@ -255,7 +257,7 @@ class TestRegisterFunctions(grass.gunittest.TestCase):
     def test_relative_time_2(self):
         """Test the registration of maps with relative time
         """
-        tgis.register_maps_in_space_time_dataset(type="rast", name=None,
+        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)
 
@@ -281,7 +283,7 @@ class TestRegisterFunctions(grass.gunittest.TestCase):
         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=None,
+        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())

lib/python/temporal/testsuite/unittests_temporal_algebra.py

@@ -46,15 +46,15 @@ class TestTemporalAlgebra(grass.gunittest.TestCase):
         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="rast", name="A", maps="a1,a2,a3,a4",
+        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="rast", name="B", maps="b1,b2",
+        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="rast", name="C", maps="c1",
+        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="rast", name="D", maps="d1,d2,d3",
+        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="rast", name=None,  maps="singletmap", 
+        tgis.register_maps_in_space_time_dataset(type="raster", name=None,  maps="singletmap", 
                                                 start="2001-01-03", end="2001-01-04", interval=True)
 
     def tearDown(self):

lib/python/temporal/testsuite/unittests_temporal_algebra_grs.py

@@ -48,19 +48,19 @@ class TestTemporalAlgebraGranularity(grass.gunittest.TestCase):
         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="rast", name="A", maps="a1,a2,a3,a4,a5,a6",
+        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="rast", name="B", maps="b1,b2",
+        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="rast", name="C", maps="c1",
+        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="rast", name="D", maps="d1",
+        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="rast", name="D", maps="d2",
+        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="rast", name="D", maps="d3",
+        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="rast", name=None,  maps="singletmap", 
+        tgis.register_maps_in_space_time_dataset(type="raster", name=None,  maps="singletmap", 
                                                 start="2001-01-03", end="2001-01-04", interval=True)
 
     def tearDown(self):
@@ -85,7 +85,7 @@ class TestTemporalAlgebraGranularity(grass.gunittest.TestCase):
 
         ta.count = 0
         ta.stdstype = "strds"
-        ta.maptype = "rast"
+        ta.maptype = "raster"
         ta.mapclass = tgis.RasterDataset
 
         maplist = ta.check_stds("A")

lib/python/temporal/testsuite/unittests_temporal_conditionals.py

@@ -51,17 +51,17 @@ class TestTemporalConditionals(grass.gunittest.TestCase):
         tgis.open_new_stds(name="E", type="strds", temporaltype="absolute",
                                          title="E", descr="E", semantic="field", overwrite=True)
                                          
-        tgis.register_maps_in_space_time_dataset(type="rast", name="A", maps="a1,a2,a3,a4",
+        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="rast", name="B", maps="b1,b2",
+        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="rast", name="C", maps="c1",
+        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="rast", name="D", maps="d1,d2,d3",
+        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="rast", name="E", maps="e1,e2,e3",
+        tgis.register_maps_in_space_time_dataset(type="raster", name="E", maps="e1,e2,e3",
                                                  start="2000-12-31", increment="2 day", interval=True)
-        tgis.register_maps_in_space_time_dataset(type="rast", name=None,  maps="singletmap", 
+        tgis.register_maps_in_space_time_dataset(type="raster", name=None,  maps="singletmap", 
                                                 start="2001-01-03", end="2001-01-04", interval=True)
 
     def tearDown(self):

lib/python/temporal/testsuite/unittests_temporal_raster_algebra.py

@@ -46,15 +46,15 @@ class TestTemporalRasterAlgebra(gunittest.TestCase):
         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="rast", name="A", maps="a1,a2,a3,a4",
+        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="rast", name="B", maps="b1,b2",
+        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="rast", name="C", maps="c1",
+        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="rast", name="D", maps="d1,d2,d3",
+        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="rast", name=None,  maps="singletmap", 
+        tgis.register_maps_in_space_time_dataset(type="raster", name=None,  maps="singletmap", 
                                                 start="2001-01-03", end="2001-01-04", interval=True)
         
     def tearDown(self):

lib/python/temporal/testsuite/unittests_temporal_raster_algebra_grs.py

@@ -47,19 +47,19 @@ class TestTemporalRasterAlgebra(gunittest.TestCase):
         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="rast", name="A", maps="a1,a2,a3,a4,a5,a6",
+        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="rast", name="B", maps="b1,b2",
+        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="rast", name="C", maps="c1",
+        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="rast", name="D", maps="d1",
+        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="rast", name="D", maps="d2",
+        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="rast", name="D", maps="d3",
+        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="rast", name=None,  maps="singletmap", 
+        tgis.register_maps_in_space_time_dataset(type="raster", name=None,  maps="singletmap", 
                                                 start="2001-03-01", end="2001-04-01", interval=True)
         
     def tearDown(self):

lib/python/temporal/testsuite/unittests_temporal_raster_conditionals.py

@@ -45,13 +45,13 @@ class TestTemporalRasterAlgebraConditionals(gunittest.TestCase):
         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="rast", name="A", maps="a1,a2,a3,a4",
+        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="rast", name="B", maps="b1,b2",
+        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="rast", name="C", maps="c1",
+        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="rast", name="D", maps="d1,d2,d3,d4",
+        tgis.register_maps_in_space_time_dataset(type="raster", name="D", maps="d1,d2,d3,d4",
                                                  start="2001-01-03", increment="1 day", interval=True)
         
     def tearDown(self):

lib/python/temporal/testsuite/unittests_temporal_vector_algebra.py

@@ -24,18 +24,18 @@ class TestTemporalVectorAlgebra(gunittest.TestCase):
         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, n=20, seed=1,  output='a1')
-        cls.runModule("v.random", overwrite=True, quiet=True, n=20, seed=1,  output='a2')
-        cls.runModule("v.random", overwrite=True, quiet=True, n=20, seed=1,  output='a3')
-        cls.runModule("v.random", overwrite=True, quiet=True, n=20, seed=1,  output='a4')
-        cls.runModule("v.random", overwrite=True, quiet=True, n=20, seed=2,  output='b1')
-        cls.runModule("v.random", overwrite=True, quiet=True, n=20, seed=2,  output='b2')
-        cls.runModule("v.random", overwrite=True, quiet=True, n=20, seed=3,  output='c1')
-        cls.runModule("v.random", overwrite=True, quiet=True, n=20, seed=4,  output='d1')
-        cls.runModule("v.random", overwrite=True, quiet=True, n=20, seed=4,  output='d2')
-        cls.runModule("v.random", overwrite=True, quiet=True, n=20, seed=4,  output='d3')
-        cls.runModule("v.random", overwrite=True, quiet=True, n=20, seed=5,  output='singletmap')
-        cls.runModule("v.random", overwrite=True, quiet=True, n=20, seed=6,  output='singlemap')        
+        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)
@@ -46,15 +46,15 @@ class TestTemporalVectorAlgebra(gunittest.TestCase):
         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="vect", name="A", maps="a1,a2,a3,a4",
+        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="vect", name="B", maps="b1,b2",
+        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="vect", name="C", maps="c1",
+        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="vect", name="D", maps="d1,d2,d3",
+        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="vect", name=None,  maps="singletmap", 
+        tgis.register_maps_in_space_time_dataset(type="vector", name=None,  maps="singletmap", 
                                                 start="2001-01-03", end="2001-01-04", interval=True)
     
     def tearDown(self):

temporal/t.connect/testsuite/test_distr_tgis_db_raster.py

@@ -31,7 +31,7 @@ class TestRasterExtraction(TestCase):
             
             cls.runModule("t.create",  type="strds",  temporaltype="absolute",  
                                          output="A",  title="A test",  description="A test")
-            cls.runModule("t.register",  flags="i",  type="rast",  input="A",  
+            cls.runModule("t.register",  flags="i",  type="raster",  input="A",  
                                          maps="a1,a2,a3",  
                                          start="2001-01-01", increment="%i months"%i)
 
@@ -56,7 +56,7 @@ class TestRasterExtraction(TestCase):
             
             cls.runModule("t.create",  type="strds",  temporaltype="absolute",  
                                          output="A",  title="A test",  description="A test")
-            cls.runModule("t.register",  flags="i",  type="rast",  input="A",  
+            cls.runModule("t.register",  flags="i",  type="raster",  input="A",  
                                          maps="a1,a2,a3",  
                                          start="2001-01-01", increment="%i months"%i)
 
@@ -219,7 +219,7 @@ class TestRasterExtraction(TestCase):
                                 start_time=2001-01-01 00:00:00
                                 end_time=2001-02-01 00:00:00 """
 
-        info = SimpleModule("t.info", flags="g", type="rast",  input="a1@test1")
+        info = SimpleModule("t.info", flags="g", type="raster",  input="a1@test1")
         self.assertModuleKeyValue(module=info, reference=tinfo_string, precision=2, sep="=")
 
         tinfo_string="""id=a1@test2
@@ -229,7 +229,7 @@ class TestRasterExtraction(TestCase):
                                 start_time=2001-01-01 00:00:00
                                 end_time=2001-03-01 00:00:00 """
 
-        info = SimpleModule("t.info", flags="g", type="rast",  input="a1@test2")
+        info = SimpleModule("t.info", flags="g", type="raster",  input="a1@test2")
         self.assertModuleKeyValue(module=info, reference=tinfo_string, precision=2, sep="=")
 
         tinfo_string="""id=a1@test3
@@ -239,7 +239,7 @@ class TestRasterExtraction(TestCase):
                                 start_time=2001-01-01 00:00:00
                                 end_time=2001-04-01 00:00:00 """
 
-        info = SimpleModule("t.info", flags="g", type="rast",  input="a1@test3")
+        info = SimpleModule("t.info", flags="g", type="raster",  input="a1@test3")
         self.assertModuleKeyValue(module=info, reference=tinfo_string, precision=2, sep="=")
 
         tinfo_string="""id=a1@test4
@@ -249,7 +249,7 @@ class TestRasterExtraction(TestCase):
                                 start_time=2001-01-01 00:00:00
                                 end_time=2001-05-01 00:00:00 """
 
-        info = SimpleModule("t.info", flags="g", type="rast",  input="a1@test4")
+        info = SimpleModule("t.info", flags="g", type="raster",  input="a1@test4")
         self.assertModuleKeyValue(module=info, reference=tinfo_string, precision=2, sep="=")
 
         tinfo_string="""id=a1@test5
@@ -259,7 +259,7 @@ class TestRasterExtraction(TestCase):
                                 start_time=2001-01-01 00:00:00
                                 end_time=2001-06-01 00:00:00 """
 
-        info = SimpleModule("t.info", flags="g", type="rast",  input="a1@test5")
+        info = SimpleModule("t.info", flags="g", type="raster",  input="a1@test5")
         self.assertModuleKeyValue(module=info, reference=tinfo_string, precision=2, sep="=")
 
 if __name__ == '__main__':

temporal/t.connect/testsuite/test_distr_tgis_db_raster3d.py

@@ -28,7 +28,7 @@ class testRaster3dExtraction(TestCase):
             
             cls.runModule("t.create",  type="str3ds",  temporaltype="absolute",  
                                          output="A",  title="A test3d",  description="A test3d")
-            cls.runModule("t.register",  flags="i",  type="rast3d",  input="A",  
+            cls.runModule("t.register",  flags="i",  type="3draster",  input="A",  
                                          maps="a1,a2,a3",  
                                          start="2001-01-01", increment="%i months"%i)
 
@@ -165,7 +165,7 @@ class testRaster3dExtraction(TestCase):
                                 start_time=2001-01-01 00:00:00
                                 end_time=2001-02-01 00:00:00 """
 
-        info = SimpleModule("t.info", flags="g", type="rast3d",  input="a1@test3d1")
+        info = SimpleModule("t.info", flags="g", type="3draster",  input="a1@test3d1")
         self.assertModuleKeyValue(module=info, reference=tinfo_string, precision=2, sep="=")
 
         tinfo_string="""id=a1@test3d2
@@ -175,7 +175,7 @@ class testRaster3dExtraction(TestCase):
                                 start_time=2001-01-01 00:00:00
                                 end_time=2001-03-01 00:00:00 """
 
-        info = SimpleModule("t.info", flags="g", type="rast3d",  input="a1@test3d2")
+        info = SimpleModule("t.info", flags="g", type="3draster",  input="a1@test3d2")
         self.assertModuleKeyValue(module=info, reference=tinfo_string, precision=2, sep="=")
 
         tinfo_string="""id=a1@test3d3
@@ -185,7 +185,7 @@ class testRaster3dExtraction(TestCase):
                                 start_time=2001-01-01 00:00:00
                                 end_time=2001-04-01 00:00:00 """
 
-        info = SimpleModule("t.info", flags="g", type="rast3d",  input="a1@test3d3")
+        info = SimpleModule("t.info", flags="g", type="3draster",  input="a1@test3d3")
         self.assertModuleKeyValue(module=info, reference=tinfo_string, precision=2, sep="=")
 
         tinfo_string="""id=a1@test3d4
@@ -195,7 +195,7 @@ class testRaster3dExtraction(TestCase):
                                 start_time=2001-01-01 00:00:00
                                 end_time=2001-05-01 00:00:00 """
 
-        info = SimpleModule("t.info", flags="g", type="rast3d",  input="a1@test3d4")
+        info = SimpleModule("t.info", flags="g", type="3draster",  input="a1@test3d4")
         self.assertModuleKeyValue(module=info, reference=tinfo_string, precision=2, sep="=")
 
 if __name__ == '__main__':

temporal/t.connect/testsuite/test_distr_tgis_db_vector.py

@@ -14,7 +14,6 @@ from grass.gunittest.case import TestCase
 from grass.gunittest.gmodules import SimpleModule
 import os
 
-
 mapset_count = 0
 class TestRasterExtraction(TestCase):
 
@@ -25,13 +24,13 @@ class TestRasterExtraction(TestCase):
             cls.runModule("g.mapset", flags="c", mapset="testvect%i"%i)
             cls.runModule("g.region",  s=0,  n=80,  w=0,  e=120,  b=0,  t=50,  res=10,  res3=10)
             # Use always the current mapset as temporal database
-            cls.runModule("v.random", output="a1",  n=20)
-            cls.runModule("v.random", output="a2",  n=20)
-            cls.runModule("v.random", output="a3",  n=20)
+            cls.runModule("v.random", output="a1",  npoints=20)
+            cls.runModule("v.random", output="a2",  npoints=20)
+            cls.runModule("v.random", output="a3",  npoints=20)
             
             cls.runModule("t.create",  type="stvds",  temporaltype="absolute",  
                                          output="A",  title="A testvect",  description="A testvect")
-            cls.runModule("t.register",  flags="i",  type="vect",  input="A",  
+            cls.runModule("t.register",  flags="i",  type="vector",  input="A",  
                                          maps="a1,a2,a3",  
                                          start="2001-01-01", increment="%i months"%i)
 
@@ -176,7 +175,7 @@ class TestRasterExtraction(TestCase):
                                 start_time=2001-01-01 00:00:00
                                 end_time=2001-02-01 00:00:00 """
 
-        info = SimpleModule("t.info", flags="g", type="vect",  input="a1@testvect1")
+        info = SimpleModule("t.info", flags="g", type="vector",  input="a1@testvect1")
         self.assertModuleKeyValue(module=info, reference=tinfo_string, precision=2, sep="=")
 
         tinfo_string="""id=a1@testvect2
@@ -186,7 +185,7 @@ class TestRasterExtraction(TestCase):
                                 start_time=2001-01-01 00:00:00
                                 end_time=2001-03-01 00:00:00 """
 
-        info = SimpleModule("t.info", flags="g", type="vect",  input="a1@testvect2")
+        info = SimpleModule("t.info", flags="g", type="vector",  input="a1@testvect2")
         self.assertModuleKeyValue(module=info, reference=tinfo_string, precision=2, sep="=")
 
         tinfo_string="""id=a1@testvect3
@@ -196,7 +195,7 @@ class TestRasterExtraction(TestCase):
                                 start_time=2001-01-01 00:00:00
                                 end_time=2001-04-01 00:00:00 """
 
-        info = SimpleModule("t.info", flags="g", type="vect",  input="a1@testvect3")
+        info = SimpleModule("t.info", flags="g", type="vector",  input="a1@testvect3")
         self.assertModuleKeyValue(module=info, reference=tinfo_string, precision=2, sep="=")
 
         tinfo_string="""id=a1@testvect4
@@ -206,7 +205,7 @@ class TestRasterExtraction(TestCase):
                                 start_time=2001-01-01 00:00:00
                                 end_time=2001-05-01 00:00:00 """
 
-        info = SimpleModule("t.info", flags="g", type="vect",  input="a1@testvect4")
+        info = SimpleModule("t.info", flags="g", type="vector",  input="a1@testvect4")
         self.assertModuleKeyValue(module=info, reference=tinfo_string, precision=2, sep="=")
 
 if __name__ == '__main__':

temporal/t.info/t.info.py

@@ -27,7 +27,7 @@
 #%option G_OPT_STDS_TYPE
 #% guidependency: input
 #% guisection: Required
-#% options: strds, str3ds, stvds, rast, 3draster, vect
+#% options: strds, str3ds, stvds, raster, 3draster, vector
 #%end
 
 #%flag

temporal/t.info/testsuite/test.t.info.sh

@@ -29,18 +29,18 @@ t.create type=str3ds temporaltype=absolute output=precip_abs2 title="A test" des
 t.create type=stvds temporaltype=absolute output=lidar_abs_ds1 title="A test" descr="A test"
 t.create type=stvds temporaltype=absolute output=lidar_abs_ds2 title="A test" descr="A test"
 
-t.register type=rast -i input=precip_abs1 maps=prec_1,prec_2 start="2001-01-01" increment="20 years"
+t.register type=raster -i input=precip_abs1 maps=prec_1,prec_2 start="2001-01-01" increment="20 years"
 t.info type=strds input=precip_abs1
 t.info -g type=strds input=precip_abs1
 
-t.register type=rast -i input=precip_abs2 maps=prec_1,prec_2 start="2001-01-01" increment="20 years"
+t.register type=raster -i input=precip_abs2 maps=prec_1,prec_2 start="2001-01-01" increment="20 years"
 t.info type=strds input=precip_abs2
 t.info -g type=strds input=precip_abs2
 t.info -h type=strds input=precip_abs2
-t.info type=rast input=prec_1
-t.info -g type=rast input=prec_1
-t.info type=rast input=prec_2
-t.info -g type=rast input=prec_2
+t.info type=raster input=prec_1
+t.info -g type=raster input=prec_1
+t.info type=raster input=prec_2
+t.info -g type=raster input=prec_2
 
 
 t.register type=3draster -i input=precip_abs1 maps=prec_1,prec_2 start="2001-01-01" increment="20 years"
@@ -51,29 +51,29 @@ t.register type=3draster -i input=precip_abs2 maps=prec_1,prec_2 start="2001-01-
 t.info type=str3ds input=precip_abs2
 t.info -g type=str3ds input=precip_abs2
 t.info -h type=str3ds input=precip_abs2
-t.info type=rast3 input=prec_1
-t.info -g type=rast3 input=prec_1
-t.info type=rast3 input=prec_2
-t.info -g type=rast3 input=prec_2
+t.info type=3draster input=prec_1
+t.info -g type=3draster input=prec_1
+t.info type=3draster input=prec_2
+t.info -g type=3draster input=prec_2
 
-t.register type=vect --v -i input=lidar_abs_ds1 maps=lidar_abs_1,lidar_abs_2 start="2001-01-01" increment="20 years"
+t.register type=vector --v -i input=lidar_abs_ds1 maps=lidar_abs_1,lidar_abs_2 start="2001-01-01" increment="20 years"
 t.info type=stvds input=lidar_abs_ds1
 t.info -g type=stvds input=lidar_abs_ds1
 
-t.register type=vect --v -i input=lidar_abs_ds2 maps=lidar_abs_1,lidar_abs_2 start="2001-01-01" increment="20 years"
+t.register type=vector --v -i input=lidar_abs_ds2 maps=lidar_abs_1,lidar_abs_2 start="2001-01-01" increment="20 years"
 t.info type=stvds input=lidar_abs_ds2
 t.info -g type=stvds input=lidar_abs_ds2
-t.info type=vect input=lidar_abs_1
-t.info -g type=vect input=lidar_abs_1
-t.info type=vect input=lidar_abs_2
-t.info -g type=vect input=lidar_abs_2
+t.info type=vector input=lidar_abs_1
+t.info -g type=vector input=lidar_abs_1
+t.info type=vector input=lidar_abs_2
+t.info -g type=vector input=lidar_abs_2
 
-t.unregister type=vect maps=lidar_abs_1,lidar_abs_2
+t.unregister type=vector maps=lidar_abs_1,lidar_abs_2
 t.remove type=stvds input=lidar_abs_ds1,lidar_abs_ds2
 
-t.unregister type=rast maps=prec_1,prec_2
+t.unregister type=raster maps=prec_1,prec_2
 t.remove type=strds input=precip_abs1,precip_abs2
 
-t.unregister type=rast3 maps=prec_1,prec_2
+t.unregister type=3draster maps=prec_1,prec_2
 t.remove type=str3ds input=precip_abs1,precip_abs2
 

temporal/t.list/t.list.py

@@ -27,7 +27,7 @@
 #% description: Type of the space time dataset or map, default is strds
 #% guisection: Selection
 #% required: no
-#% options: strds, str3ds, stvds, rast, 3draster, vect
+#% options: strds, str3ds, stvds, raster, 3draster, vector
 #% answer: strds
 #%end
 

temporal/t.rast.accdetect/t.rast.accdetect.py

@@ -418,7 +418,7 @@ def main():
     # Remove empty maps
     if len(empty_maps) > 0:
         for map in empty_maps:
-            grass.run_command("g.remove", flags='f', type="rast",  name=map.get_name(), quiet=True)
+            grass.run_command("g.remove", flags='f', type="raster",  name=map.get_name(), quiet=True)
 
 ############################################################################
 

temporal/t.rast.aggregate/testsuite/test_aggregation_absolute.py

@@ -36,7 +36,7 @@ class TestAggregationAbsolute(TestCase):
                                     output="A",  title="A test",  
                                     description="A test",  overwrite=True)
 
-        cls.runModule("t.register", flags="i",  type="rast",  input="A",  
+        cls.runModule("t.register", flags="i",  type="raster",  input="A",  
                                      maps="a1,a2,a3,a4,a5,a6,a7",
                                      start="2001-01-15 12:05:45", 
                                      increment="14 days",  

temporal/t.rast.aggregate/testsuite/test_aggregation_absolute_parallel.py

@@ -35,7 +35,7 @@ class TestAggregationAbsoluteParallel(TestCase):
                                     output="A",  title="A test",  
                                     description="A test",  overwrite=True)
 
-        cls.runModule("t.register", flags="i",  type="rast",  input="A",  
+        cls.runModule("t.register", flags="i",  type="raster",  input="A",  
                                      maps=name_list,
                                      start="2001-01-01", 
                                      increment="4 hours",  

temporal/t.rast.aggregate/testsuite/test_aggregation_relative.py

@@ -36,7 +36,7 @@ class TestAggregationRelative(TestCase):
                                     output="A",  title="A test",  
                                     description="A test",  overwrite=True)
 
-        cls.runModule("t.register", flags="i",  type="rast",  input="A",  
+        cls.runModule("t.register", flags="i",  type="raster",  input="A",  
                                      maps="a1,a2,a3,a4,a5,a6,a7",
                                      start=0, unit="days", increment=3, 
                                      overwrite=True)

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

@@ -47,15 +47,15 @@ class TestTRastAlgebra(gunittest.TestCase):
         tgis.open_new_stds(name="D", type="strds", temporaltype="absolute",
                                          title="D", descr="D", semantic="field")
 
-        tgis.register_maps_in_space_time_dataset(type="rast", name="A", maps="a1,a2,a3,a4",
+        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="rast", name="B", maps="b1,b2",
+        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="rast", name="C", maps="c1",
+        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="rast", name="D", maps="d1,d2,d3",
+        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="rast", name=None,  maps="singletmap", 
+        tgis.register_maps_in_space_time_dataset(type="raster", name=None,  maps="singletmap", 
                                                 start="2001-01-03", end="2001-01-04", interval=True)
         
     def tearDown(self):

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

@@ -48,19 +48,19 @@ class TestTRastAlgebraGranularity(gunittest.TestCase):
         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="rast", name="A", maps="a1,a2,a3,a4,a5,a6",
+        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="rast", name="B", maps="b1,b2",
+        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="rast", name="C", maps="c1",
+        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="rast", name="D", maps="d1",
+        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="rast", name="D", maps="d2",
+        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="rast", name="D", maps="d3",
+        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="rast", name=None,  maps="singletmap", 
+        tgis.register_maps_in_space_time_dataset(type="raster", name=None,  maps="singletmap", 
                                                 start="2001-03-01", end="2001-04-01", interval=True)
         
     def tearDown(self):

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

@@ -32,9 +32,9 @@ class TestTRastAlgebraGranularityFails(gunittest.TestCase):
         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", 
+        tgis.register_maps_in_space_time_dataset(type="raster", 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", 
+        tgis.register_maps_in_space_time_dataset(type="raster", name="A",  maps="a2", 
                                                 start="2001-03-01", end="2001-05-01", interval=True)
         
     @classmethod

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

@@ -42,7 +42,7 @@ class TestRasterExtraction(TestCase):
 
         self.runModule("t.create",  type="strds",  temporaltype="absolute",  
                                      output="precip_abs1",  title="A test",  description="A test",  overwrite=True)
-        self.runModule("t.register",  flags="i",  type="rast",  input="precip_abs1",  
+        self.runModule("t.register",  flags="i",  type="raster",  input="precip_abs1",  
                                      maps="prec_1,prec_2,prec_3,prec_4,prec_5,prec_6",  
                                      start="2001-01-01", increment="3 months",  overwrite=True)
 

temporal/t.rast.to.rast3/testsuite/test_strds_to_rast3.py

@@ -46,21 +46,21 @@ class TestSTRDSToRast3(TestCase):
         self.runModule("t.create", type="strds",  temporaltype="absolute",  
                        output="precip_i",  title="A test integer",  
                        description="A test integer values")
-        self.runModule("t.register", flags="i",  type="rast",  input="precip_i",  
+        self.runModule("t.register", flags="i",  type="raster",  input="precip_i",  
                        maps="prec_1i,prec_2i,prec_3i,prec_4i,prec_5i,prec_6i",  
                        start="2001-01-01", increment="3 months")
 
         self.runModule("t.create", type="strds",  temporaltype="absolute",  
                        output="precip_f",  title="A test float",  
                        description="A test float values")
-        self.runModule("t.register", flags="i",  type="rast",  input="precip_f",  
+        self.runModule("t.register", flags="i",  type="raster",  input="precip_f",
                        maps="prec_1f,prec_2f,prec_3f,prec_4f,prec_5f,prec_6f",  
                        start="2001-01-01", increment="3 months")
 
         self.runModule("t.create", type="strds",  temporaltype="absolute",  
                        output="precip_d",  title="A test float",  
                        description="A test float values")
-        self.runModule("t.register", flags="i",  type="rast",  input="precip_d",  
+        self.runModule("t.register", flags="i",  type="raster",  input="precip_d",  
                        maps="prec_1d,prec_2d,prec_3d,prec_4d,prec_5d,prec_6d",  
                        start="2001-01-01", increment="3 months")
 

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

@@ -34,7 +34,7 @@ class TestTRast3dAlgebra(gunittest.TestCase):
         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="rast3d", name="A", maps="a1,a2,a3,a4",
+        tgis.register_maps_in_space_time_dataset(type="3draster", name="A", maps="a1,a2,a3,a4",
                                                  start="2001-01-01", increment="1 day", interval=True)
 
     def tearDown(self):

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

@@ -41,7 +41,7 @@ class TestRaster3dExtraction(TestCase):
 
         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",  
+        self.runModule("t.register",  flags="i",  type="3draster",  input="A",  
                                      maps="a1,a2,a3,a4,a5,a6",  
                                      start="2001-01-01", increment="3 months",  overwrite=True)
 

temporal/t.remove/t.remove.py

@@ -132,7 +132,12 @@ def main():
                 # Delete every 100 maps
                 if count%100 == 0:
                     dbif.execute_transaction(map_statement)
-                    remove(type="rast", name=name_list, run_=True)
+                    if type == "strds":
+                        remove(type="raster", name=name_list, run_=True)
+                    if type == "stvds":
+                        remove(type="vector", name=name_list, run_=True)
+                    if type == "str3ds":
+                        remove(type="3draster", name=name_list, run_=True)
                     map_statement = ""
                     name_list = []
 
@@ -140,11 +145,11 @@ def main():
                 dbif.execute_transaction(map_statement)
             if name_list:
                 if type == "strds":
-                    remove(type="rast", name=",".join(name_list), run_=True)
+                    remove(type="raster", name=name_list, run_=True)
                 if type == "stvds":
-                    remove(type="vect", name=",".join(name_list), run_=True)
+                    remove(type="vector", name=name_list, run_=True)
                 if type == "str3ds":
-                    remove(type="3draster", name=",".join(name_list), run_=True)
+                    remove(type="3draster", name=name_list, run_=True)
 
         statement += sp.delete(dbif=dbif, execute=False)
 

temporal/t.sample/testsuite/test.t.sample.sh

@@ -16,15 +16,15 @@ r.mapcalc expr="prec_4 = rand(0, 510)" -s
 r.mapcalc expr="prec_5 = rand(0, 300)" -s
 r.mapcalc expr="prec_6 = rand(0, 650)" -s
 
-v.random -z output=pnts1 n=20 zmin=0 zmax=100 column=height
-v.random -z output=pnts2 n=20 zmin=0 zmax=100 column=height
-
-v.random -z output=pnts3 n=20 zmin=0 zmax=100 column=height
-v.random -z output=pnts4 n=20 zmin=0 zmax=100 column=height
-v.random -z output=pnts5 n=20 zmin=0 zmax=100 column=height
-v.random -z output=pnts6 n=20 zmin=0 zmax=100 column=height
-v.random -z output=pnts7 n=20 zmin=0 zmax=100 column=height
-v.random -z output=pnts8 n=20 zmin=0 zmax=100 column=height
+v.random -z output=pnts1 npoints=20 zmin=0 zmax=100 column=height
+v.random -z output=pnts2 npoints=20 zmin=0 zmax=100 column=height
+
+v.random -z output=pnts3 npoints=20 zmin=0 zmax=100 column=height
+v.random -z output=pnts4 npoints=20 zmin=0 zmax=100 column=height
+v.random -z output=pnts5 npoints=20 zmin=0 zmax=100 column=height
+v.random -z output=pnts6 npoints=20 zmin=0 zmax=100 column=height
+v.random -z output=pnts7 npoints=20 zmin=0 zmax=100 column=height
+v.random -z output=pnts8 npoints=20 zmin=0 zmax=100 column=height
 
 n1=`g.tempfile pid=1 -d` 
 n2=`g.tempfile pid=2 -d`

temporal/t.select/test.t.select.sh

@@ -13,15 +13,15 @@ for i in {1..60}
   do
     if [ "$i" -le 20 ]; then
       echo testpoint1_$i >> ${n1}
-      v.random  -z output=testpoint1_$i n=3 seed=$i
+      v.random  -z output=testpoint1_$i npoints=3 seed=$i
     elif [ "$i" -gt 20 ] && [ "$i" -le 40 ]; then
       echo testpoint2_$i >>  ${n2}
-      v.random  -z output=testpoint2_$i n=3 seed=$i
+      v.random  -z output=testpoint2_$i npoints=3 seed=$i
     else
       echo testpoint3_$i >>  ${n3}
       echo testpoint4_$i >>  ${n4}
-      v.random  -z output=testpoint3_$i n=3 seed=$i
-      v.random  -z output=testpoint4_$i n=3 seed=$i
+      v.random  -z output=testpoint3_$i npoints=3 seed=$i
+      v.random  -z output=testpoint4_$i npoints=3 seed=$i
     fi
   done
 

temporal/t.unregister/testsuite/test_unregister.py

@@ -44,7 +44,7 @@ class TestUnregister(TestCase):
         self.runModule("t.create",  type="strds",  temporaltype="absolute",  
                                     output="A",  title="A test",  
                                     description="A test",  overwrite=True)
-        self.runModule("t.register", flags="i",  type="rast",  input="A",  
+        self.runModule("t.register", flags="i",  type="raster",  input="A",  
                                      maps="a1,a2,a3,a4,a5,a6",
                                      start="2001-01-01", increment="3 months",  
                                      overwrite=True)
@@ -52,14 +52,14 @@ class TestUnregister(TestCase):
         self.runModule("t.create",  type="strds",  temporaltype="absolute",  
                                     output="B",  title="B test",  
                                     description="B test",  overwrite=True)
-        self.runModule("t.register", flags="i",  type="rast",  input="B",  
+        self.runModule("t.register", flags="i",  type="raster",  input="B",  
                                      maps="a1,a2,a3,a4,a5,a6",
                                      start="2001-01-01", increment="3 months",  
                                      overwrite=True)
 
     def tearDown(self):
         """Remove generated data"""
-        self.runModule("g.remove", type="rast",  
+        self.runModule("g.remove", type="raster",  
                                    name="a1,a2,a3,a4,a5,a6")
 
     def test_1(self):
@@ -95,7 +95,7 @@ class TestUnregister(TestCase):
 
 
         # Check if maps a1, a2 and a3 are still present in the temporal database
-        lister = SimpleModule("t.list", type="rast", columns="name", 
+        lister = SimpleModule("t.list", type="raster", columns="name", 
                               where='mapset = "%s" AND (name = "a1" OR name = "a2" OR name = "a3")'%(tgis.get_current_mapset()))
         self.runModule(lister)
         self.assertEqual(a123, lister.outputs.stdout)
@@ -104,7 +104,7 @@ class TestUnregister(TestCase):
         # Unregister maps a1, a2 and a3 from the temporal database
         self.assertModule("t.unregister",  maps="a1,a2,a3")
 
-        lister = SimpleModule("t.list", type="rast", columns="name", 
+        lister = SimpleModule("t.list", type="raster", columns="name", 
                               where='mapset = "%s" AND (name = "a1" OR name = "a2" OR name = "a3")'%(tgis.get_current_mapset()))
         self.runModule(lister)
         self.assertEqual("", lister.outputs.stdout)
@@ -120,7 +120,7 @@ class TestUnregister(TestCase):
         # Remove STRDS A and B and chceck if maps a4, a5 and a6 are still in the temporal database
         self.assertModule("t.remove",  type="strds", inputs="A,B")
 
-        lister = SimpleModule("t.list", type="rast", columns="name", 
+        lister = SimpleModule("t.list", type="raster", columns="name", 
                               where='mapset = "%s" AND (name = "a4" OR name = "a5" OR name = "a6")'%(tgis.get_current_mapset()))
         self.runModule(lister)
         self.assertEqual(a456, lister.outputs.stdout)
@@ -129,7 +129,7 @@ class TestUnregister(TestCase):
         # Unregister maps a4, a5 and a6 from the temporal database
         self.assertModule("t.unregister",  maps="a4,a5,a6")
 
-        lister = SimpleModule("t.list", type="rast", columns="name", 
+        lister = SimpleModule("t.list", type="raster", columns="name", 
                               where='mapset = "%s" AND (name = "a4" OR name = "a5" OR name = "a6")'%(tgis.get_current_mapset()))
         self.runModule(lister)
         self.assertEqual("", lister.outputs.stdout)

temporal/t.vect.algebra/testsuite/test_vector_algebra.py

@@ -25,18 +25,18 @@ class TestTemporalVectorAlgebra(gunittest.TestCase):
         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, n=20, seed=1,  output='a1')
-        cls.runModule("v.random", quiet=True, n=20, seed=1,  output='a2')
-        cls.runModule("v.random", quiet=True, n=20, seed=1,  output='a3')
-        cls.runModule("v.random", quiet=True, n=20, seed=1,  output='a4')
-        cls.runModule("v.random", quiet=True, n=20, seed=2,  output='b1')
-        cls.runModule("v.random", quiet=True, n=20, seed=2,  output='b2')
-        cls.runModule("v.random", quiet=True, n=20, seed=3,  output='c1')
-        cls.runModule("v.random", quiet=True, n=20, seed=4,  output='d1')
-        cls.runModule("v.random", quiet=True, n=20, seed=4,  output='d2')
-        cls.runModule("v.random", quiet=True, n=20, seed=4,  output='d3')
-        cls.runModule("v.random", quiet=True, n=20, seed=5,  output='singletmap')
-        cls.runModule("v.random", quiet=True, n=20, seed=6,  output='singlemap')        
+        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")
@@ -47,15 +47,15 @@ class TestTemporalVectorAlgebra(gunittest.TestCase):
         tgis.open_new_stds(name="D", type="stvds", temporaltype="absolute",
                                          title="D", descr="D", semantic="field")
 
-        tgis.register_maps_in_space_time_dataset(type="vect", name="A", maps="a1,a2,a3,a4",
+        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="vect", name="B", maps="b1,b2",
+        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="vect", name="C", maps="c1",
+        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="vect", name="D", maps="d1,d2,d3",
+        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="vect", name=None,  maps="singletmap", 
+        tgis.register_maps_in_space_time_dataset(type="vector", name=None,  maps="singletmap", 
                                                 start="2001-01-03", end="2001-01-04", interval=True)
     
     def tearDown(self):

temporal/t.vect.db.select/test.t.vect.db.select.sh

@@ -37,8 +37,8 @@ t.vect.db.select input=prec_observer where="cat = 1" separator="  |  "
 t.unregister type=rast maps=prec_1,prec_2,prec_3,prec_4,prec_5,prec_6
 t.remove type=strds input=precip_abs1
 t.remove type=stvds input=prec_observer
-t.unregister type=vect maps=prec_observer:1,prec_observer:2,prec_observer:3,prec_observer:4,prec_observer:5,prec_observer:6
+t.unregister type=vector maps=prec_observer:1,prec_observer:2,prec_observer:3,prec_observer:4,prec_observer:5,prec_observer:6
 
-g.remove -f type=vect name=prec_observer,test_extract
+g.remove -f type=vector name=prec_observer,test_extract
 g.remove -f type=rast name=prec_1,prec_2,prec_3,prec_4,prec_5,prec_6
 

temporal/t.vect.export/test.t.vect.export.sh

@@ -19,7 +19,7 @@ soil_3
 EOF
 
 t.create --o type=stvds temporaltype=absolute output=soil_abs1 title="A test" descr="A test"
-t.register -i type=vect input=soil_abs1 file="${n1}" start='2001-01-01' increment="1 months"
+t.register -i type=vector input=soil_abs1 file="${n1}" start='2001-01-01' increment="1 months"
 
 # The first @test
 t.vect.export format=GML input=soil_abs1 output=stvds_export_gml.tar.bz2 compression=bzip2 workdir=/tmp
@@ -30,7 +30,7 @@ t.vect.export format=pack input=soil_abs1 output=stvds_export_pack.tar.bz2 compr
 t.vect.export format=pack input=soil_abs1 output=stvds_export_pack.tar.gz compression=gzip workdir=/tmp
 t.vect.export format=pack input=soil_abs1 output=stvds_export_pack.tar compression=no workdir=/tmp
 
-t.unregister type=vect file="${n1}"
+t.unregister type=vector file="${n1}"
 t.remove type=stvds input=soil_abs1
 rm stvds_export_gml.tar.bz2
 rm stvds_export_gml.tar.gz

temporal/t.vect.extract/test.t.vect.extract.layer.sh

@@ -37,11 +37,11 @@ t.vect.univar input=test_extract_3 column=prec
 
 
 # @postprocess
-t.unregister type=rast maps=prec_1,prec_2,prec_3,prec_4,prec_5,prec_6
+t.unregister type=raster maps=prec_1,prec_2,prec_3,prec_4,prec_5,prec_6
 t.remove type=strds input=precip_abs1
 t.remove type=stvds input=prec_observer,test_extract_1,test_extract_2,test_extract_3
-t.unregister type=vect maps=prec_observer:1,prec_observer:2,prec_observer:3,prec_observer:4,prec_observer:5,prec_observer:6
+t.unregister type=vector maps=prec_observer:1,prec_observer:2,prec_observer:3,prec_observer:4,prec_observer:5,prec_observer:6
 
-g.remove -f type=vect name=prec_observer
-g.remove -f type=vect pattern=test_*
-g.remove -f type=rast name=prec_1,prec_2,prec_3,prec_4,prec_5,prec_6
+g.remove -f type=vector name=prec_observer
+g.remove -f type=vector pattern=test_*
+g.remove -f type=raster name=prec_1,prec_2,prec_3,prec_4,prec_5,prec_6

temporal/t.vect.extract/test.t.vect.extract.sh

@@ -27,7 +27,7 @@ soil_8
 EOF
 
 t.create --o type=stvds temporaltype=absolute output=soil_abs1 title="A test" descr="A test"
-t.register -i type=vect input=soil_abs1 file="${n1}" start='2001-01-01' increment="1 months"
+t.register -i type=vector input=soil_abs1 file="${n1}" start='2001-01-01' increment="1 months"
 t.info type=stvds input=soil_abs1
 t.vect.list input=soil_abs1
 
@@ -42,7 +42,7 @@ t.info type=stvds input=soil_abs3
 t.vect.list input=soil_abs3 columns=name,start_time,end_time,primitives
 
 # @postprocess
-t.unregister type=vect maps=soil_1,soil_2,soil_3,soil_4,soil_5,soil_6,soil_7,soil_8
+t.unregister type=vector maps=soil_1,soil_2,soil_3,soil_4,soil_5,soil_6,soil_7,soil_8
 t.remove type=stvds input=soil_abs1,soil_abs2,soil_abs3
-g.remove -f type=vect name=soil_1,soil_2,soil_3,soil_4,soil_5,soil_6,soil_7,soil_8
-g.remove -f type=vect name=new_vect_1,new_vect_2,new_vect_3,new_vect_4,new_vect_5,new_vect_6
+g.remove -f type=vector name=soil_1,soil_2,soil_3,soil_4,soil_5,soil_6,soil_7,soil_8
+g.remove -f type=vector name=new_vect_1,new_vect_2,new_vect_3,new_vect_4,new_vect_5,new_vect_6

temporal/t.vect.import/testsuite/test.t.vect.import.sh

@@ -21,7 +21,7 @@ soil_3
 EOF
 
 t.create --o type=stvds temporaltype=absolute output=soil_abs1 title="A test" descr="A test"
-t.register -i type=vect input=soil_abs1 file="${n1}" start='2001-01-01' increment="1 months"
+t.register -i type=vector input=soil_abs1 file="${n1}" start='2001-01-01' increment="1 months"
 
 # The first @test
 t.vect.export format=GML input=soil_abs1 output=stvds_export_gml.tar.bz2 compression=bzip2 workdir=/tmp
@@ -59,8 +59,8 @@ v.info soil_1
 
 # Cleaning up
 rm -rf test
-g.remove -f type=vect name=soil_1,soil_2,soil_3
-t.unregister type=vect file="${n1}"
+g.remove -f type=vector name=soil_1,soil_2,soil_3
+t.unregister type=vector file="${n1}"
 t.remove type=stvds input=soil_abs1,soil_abs2
 rm stvds_export_gml.tar.bz2
 rm stvds_export_gml.tar.gz

temporal/t.vect.list/testsuite/test.t.vect.list.layer.sh

@@ -87,38 +87,38 @@ t.create type=stvds temporaltype=absolute output=soils_abs4 title="A test with i
 t.create type=stvds temporaltype=absolute output=soils_abs5 title="A test with input files" descr="A test with input files"
 
 # The first @test
-t.register type=vect   input=soils_abs1 file="${n1}" start="2001-01-01" increment="1 months"
+t.register type=vector   input=soils_abs1 file="${n1}" start="2001-01-01" increment="1 months"
 t.vect.list    separator=" | " method=comma     input=soils_abs1
 t.vect.list input=soils_abs1
 t.vect.list separator=" | " method=cols      input=soils_abs1
 t.vect.list separator=" | " method=delta     input=soils_abs1
 t.vect.list separator=" | " method=deltagaps input=soils_abs1
 
-t.register type=vect -i input=soils_abs2 file="${n2}"
+t.register type=vector -i input=soils_abs2 file="${n2}"
 t.vect.list    separator=" | " method=comma     input=soils_abs2
 t.vect.list input=soils_abs2
 t.vect.list separator=" | " method=cols      input=soils_abs2
 t.vect.list separator=" | " method=delta     input=soils_abs2
 t.vect.list separator=" | " method=deltagaps input=soils_abs2
 
-t.register type=vect -i input=soils_abs3 file="${n3}"
+t.register type=vector -i input=soils_abs3 file="${n3}"
 t.vect.list    separator=" | " method=comma     input=soils_abs3
 t.vect.list separator=" | " method=delta     input=soils_abs3
 t.vect.list separator=" | " method=deltagaps input=soils_abs3
 
-t.register type=vect -i input=soils_abs4 file="${n4}"
+t.register type=vector -i input=soils_abs4 file="${n4}"
 t.vect.list    separator=" | " method=comma     input=soils_abs4
 t.vect.list separator=" | " method=delta     input=soils_abs4
 t.vect.list separator=" | " method=deltagaps input=soils_abs4
 
-t.register type=vect -i input=soils_abs5 file="${n5}"
+t.register type=vector -i input=soils_abs5 file="${n5}"
 t.vect.list    separator=" | " method=comma     input=soils_abs5
 t.vect.list input=soils_abs5
 t.vect.list separator=" | " method=cols      input=soils_abs5
 t.vect.list separator=" | " method=delta     input=soils_abs5
 t.vect.list separator=" | " method=deltagaps input=soils_abs5
 
-t.unregister type=vect maps=soils:1,soils:2,soils:3,soils:4,soils:5,soils:6
+t.unregister type=vector maps=soils:1,soils:2,soils:3,soils:4,soils:5,soils:6
 t.remove type=stvds input=soils_abs1,soils_abs2,soils_abs3,soils_abs4,soils_abs5
 
-g.remove -f type=vect name=soil_orig,soils
+g.remove -f type=vector name=soil_orig,soils

temporal/t.vect.list/testsuite/test.t.vect.list.sh

@@ -73,37 +73,37 @@ t.create type=stvds temporaltype=absolute output=lidar_abs4 title="A test with i
 t.create type=stvds temporaltype=absolute output=lidar_abs5 title="A test with input files" descr="A test with input files"
 
 # The first @test
-t.register type=vect  input=lidar_abs1 file="${n1}" start="2001-01-01" increment="1 months"
+t.register type=vector  input=lidar_abs1 file="${n1}" start="2001-01-01" increment="1 months"
 t.vect.list    separator=" | " method=comma     input=lidar_abs1
 t.vect.list input=lidar_abs1
 t.vect.list separator=" | " method=cols      input=lidar_abs1
 t.vect.list separator=" | " method=delta     input=lidar_abs1
 t.vect.list separator=" | " method=deltagaps input=lidar_abs1
 
-t.register type=vect -i input=lidar_abs2 file="${n2}"
+t.register type=vector -i input=lidar_abs2 file="${n2}"
 t.vect.list    separator=" | " method=comma     input=lidar_abs2
 t.vect.list input=lidar_abs2
 t.vect.list separator=" | " method=cols      input=lidar_abs2
 t.vect.list separator=" | " method=delta     input=lidar_abs2
 t.vect.list separator=" | " method=deltagaps input=lidar_abs2
 
-t.register type=vect -i input=lidar_abs3 file="${n3}"
+t.register type=vector -i input=lidar_abs3 file="${n3}"
 t.vect.list    separator=" | " method=comma     input=lidar_abs3
 t.vect.list separator=" | " method=delta     input=lidar_abs3
 t.vect.list separator=" | " method=deltagaps input=lidar_abs3
 
-t.register type=vect -i input=lidar_abs4 file="${n4}"
+t.register type=vector -i input=lidar_abs4 file="${n4}"
 t.vect.list    separator=" | " method=comma     input=lidar_abs4
 t.vect.list separator=" | " method=delta     input=lidar_abs4
 t.vect.list separator=" | " method=deltagaps input=lidar_abs4
 
-t.register type=vect -i input=lidar_abs5 file="${n5}"
+t.register type=vector -i input=lidar_abs5 file="${n5}"
 t.vect.list    separator=" | " method=comma     input=lidar_abs5
 t.vect.list input=lidar_abs5
 t.vect.list separator=" | " method=cols      input=lidar_abs5
 t.vect.list separator=" | " method=delta     input=lidar_abs5
 t.vect.list separator=" | " method=deltagaps input=lidar_abs5
 
-#t.unregister type=vect maps=lidar_1,lidar_2,lidar_3,lidar_4,lidar_5,lidar_6
+#t.unregister type=vector maps=lidar_1,lidar_2,lidar_3,lidar_4,lidar_5,lidar_6
 #t.remove type=stvds input=lidar_abs1,lidar_abs2,lidar_abs3,lidar_abs4,lidar_abs5
-#g.remove -f type=vect name=lidar_1,lidar_2,lidar_3,lidar_4,lidar_5,lidar_6
+#g.remove -f type=vector name=lidar_1,lidar_2,lidar_3,lidar_4,lidar_5,lidar_6

temporal/t.vect.observe.strds/testsuite/test.t.vect.observe.strds.layer_bug.sh

@@ -32,9 +32,9 @@ t.vect.list input=prec_observer
 t.vect.db.select input=prec_observer
 
 # @postprocess
-t.unregister type=rast file=${MAP_LIST}
+t.unregister type=raster file=${MAP_LIST}
 t.remove type=strds input=precip_abs1
 t.remove type=stvds input=prec_observer
 
-#g.remove -f type=vect name=prec_observer
-#g.remove -f type=rast pattern="test_prec_*"
+#g.remove -f type=vector name=prec_observer
+#g.remove -f type=raster pattern="test_prec_*"

temporal/t.vect.observe.strds/testsuite/test.t.vect.observe.strds.relative.sh

@@ -26,10 +26,10 @@ t.vect.list input=prec_observer
 t.vect.db.select input=prec_observer
 
 # @postprocess
-t.unregister type=rast maps=prec_1,prec_2,prec_3,prec_4,prec_5,prec_6
+t.unregister type=raster maps=prec_1,prec_2,prec_3,prec_4,prec_5,prec_6
 t.remove type=strds input=precip_abs1
 t.remove type=stvds input=prec_observer
-t.unregister type=vect maps=prec_observer:1,prec_observer:2,prec_observer:3,prec_observer:4,prec_observer:5,prec_observer:6
+t.unregister type=vector maps=prec_observer:1,prec_observer:2,prec_observer:3,prec_observer:4,prec_observer:5,prec_observer:6
 
-#g.remove -f type=vect name=prec_observer,test_extract
-#g.remove -f type=rast name=prec_1,prec_2,prec_3,prec_4,prec_5,prec_6
+#g.remove -f type=vector name=prec_observer,test_extract
+#g.remove -f type=raster name=prec_1,prec_2,prec_3,prec_4,prec_5,prec_6

temporal/t.vect.observe.strds/testsuite/test.t.vect.observe.strds.sh

@@ -19,7 +19,7 @@ r.mapcalc  expr="prec_8 = 500.0"
 r.mapcalc  expr="prec_9 = 600.0"
 
 
-v.random output=prec n=5 seed=1
+v.random output=prec npoints=5 seed=1
 v.random -z output=test_1 column=test n=5 seed=1 
 
 t.create type=strds temporaltype=absolute output=precip_abs1 title="A test" descr="A test"

temporal/t.vect.univar/testsuite/test.t.vect.univar.sh

@@ -15,7 +15,7 @@ v.voronoi input=rpoints1 output=rvoronoi1
 v.voronoi input=rpoints2 output=rvoronoi2
 
 t.create type=stvds temporaltype=absolute output=random_data title="A test" descr="A test"
-t.register type=vect --v -i input=random_data maps=rpoints1,rpoints2,rvoronoi1,rvoronoi2 start="2001-01-15 12:05:45" increment="14 days"
+t.register type=vector --v -i input=random_data maps=rpoints1,rpoints2,rvoronoi1,rvoronoi2 start="2001-01-15 12:05:45" increment="14 days"
 
 # The first @test
 t.vect.univar input=random_data column=height where='height > 50' twhere="start_time > '2000-01-01'" layer=1
@@ -25,7 +25,7 @@ t.vect.univar -e type=centroid input=random_data column=height where='height > 2
 t.vect.univar type=line input=random_data column=height where='height > 20' twhere="start_time > '2000-01-01'" layer=1
 
 # @postprocess
-t.unregister type=vect maps=rpoints1,rpoints2,rvoronoi1,rvoronoi2
+t.unregister type=vector maps=rpoints1,rpoints2,rvoronoi1,rvoronoi2
 t.remove type=stvds input=random_data
-g.remove -f type=vect name=rpoints1,rpoints2,rvoronoi1,rvoronoi2
+g.remove -f type=vector name=rpoints1,rpoints2,rvoronoi1,rvoronoi2
 

temporal/t.vect.what.strds/test.t.vect.what.strds.layer.sh

@@ -41,15 +41,15 @@ soils:6
 EOF
 
 t.create --o type=stvds temporaltype=absolute output=soil_abs title="A test" descr="A test"
-t.register -i type=vect input=soil_abs file="${n1}" start="2001-03-01 00:00:00" increment="1 months"
+t.register -i type=vector input=soil_abs file="${n1}" start="2001-03-01 00:00:00" increment="1 months"
 t.vect.list input=soil_abs columns=name,layer,start_time,end_time
 
 t.create --o type=strds temporaltype=absolute output=sand_frac_abs_1 title="A test" descr="A test"
-t.register -i type=rast input=sand_frac_abs_1 maps=sand_frac start="2001-01-01 00:00:00" increment="12 months"
+t.register -i type=raster input=sand_frac_abs_1 maps=sand_frac start="2001-01-01 00:00:00" increment="12 months"
 t.rast.list input=sand_frac_abs_1 columns=name,start_time,end_time
 
 t.create --o type=strds temporaltype=absolute output=sand_frac_abs_2 title="A test" descr="A test"
-t.register -i type=rast input=sand_frac_abs_2 maps=sand_frac_1,sand_frac_2,sand_frac_3,sand_frac_4,sand_frac_5,sand_frac_6 \
+t.register -i type=raster input=sand_frac_abs_2 maps=sand_frac_1,sand_frac_2,sand_frac_3,sand_frac_4,sand_frac_5,sand_frac_6 \
             start="2001-03-01 00:00:00" increment="1 months"
 t.rast.list input=sand_frac_abs_2 columns=name,start_time,end_time
 
@@ -71,11 +71,11 @@ v.db.select map=soils layer=5
 v.db.select map=soils layer=6
 
 # @postprocess
-t.unregister type=vect maps=soils:1,soils:2,soils:3,soils:4,soils:5,soils:6
+t.unregister type=vector maps=soils:1,soils:2,soils:3,soils:4,soils:5,soils:6
 t.remove type=stvds input=soil_abs
 
-t.unregister type=rast maps=sand_frac,sand_frac_1,sand_frac_2,sand_frac_3,sand_frac_4,sand_frac_5,sand_frac_6
+t.unregister type=raster maps=sand_frac,sand_frac_1,sand_frac_2,sand_frac_3,sand_frac_4,sand_frac_5,sand_frac_6
 t.remove type=strds input=sand_frac_abs_1,sand_frac_abs_2
 
-g.remove -f type=rast name=sand_frac,sand_frac_1,sand_frac_2,sand_frac_3,sand_frac_4,sand_frac_5,sand_frac_6
-g.remove -f type=vect name=soils,soil_orig
+g.remove -f type=raster name=sand_frac,sand_frac_1,sand_frac_2,sand_frac_3,sand_frac_4,sand_frac_5,sand_frac_6
+g.remove -f type=vector name=soils,soil_orig

temporal/t.vect.what.strds/test.t.vect.what.strds.sh

@@ -25,10 +25,10 @@ soil_3|2001-08-01|2001-12-01
 EOF
 
 t.create --o type=stvds temporaltype=absolute output=soil_abs1 title="A test" descr="A test"
-t.register type=vect input=soil_abs1 file="${n1}" 
+t.register type=vector input=soil_abs1 file="${n1}" 
 
 t.create --o type=strds temporaltype=absolute output=precip_abs1 title="A test" descr="A test"
-t.register -i type=rast input=precip_abs1 maps=prec_1,prec_2,prec_3,prec_4,prec_5,prec_6 start="2001-03-01 00:00:00" increment="1 months"
+t.register -i type=raster input=precip_abs1 maps=prec_1,prec_2,prec_3,prec_4,prec_5,prec_6 start="2001-03-01 00:00:00" increment="1 months"
 
 # The @test
 
@@ -48,11 +48,11 @@ v.db.select map=soil_2
 v.db.select map=soil_3
 
 # @postprocess
-t.unregister type=vect maps=soil_1,soil_2,soil_3
+t.unregister type=vector maps=soil_1,soil_2,soil_3
 t.remove type=stvds input=soil_abs1
 
-t.unregister type=rast maps=prec_1,prec_2,prec_3,prec_4,prec_5,prec_6
+t.unregister type=raster maps=prec_1,prec_2,prec_3,prec_4,prec_5,prec_6
 t.remove type=strds input=precip_abs1
 
-g.remove -f type=rast name=prec_1,prec_2,prec_3,prec_4,prec_5,prec_6
-g.remove -f type=vect name=soil_1,soil_2,soil_3
+g.remove -f type=raster name=prec_1,prec_2,prec_3,prec_4,prec_5,prec_6
+g.remove -f type=vector name=soil_1,soil_2,soil_3

temporal/t.vect.what.strds/test.t.vect.what.strds_relative.sh

@@ -12,9 +12,9 @@ r.mapcalc --o expr="prec_4 = 400"
 r.mapcalc --o expr="prec_5 = 500.0"
 r.mapcalc --o expr="prec_6 = 600.0"
 
-v.random --o -z output=soil_1 n=5 zmin=0 zmax=100 column=heigh seed=1
-v.random --o -z output=soil_2 n=5 zmin=0 zmax=100 column=height seed=2
-v.random --o -z output=soil_3 n=5 zmin=0 zmax=100 column=height seed=3
+v.random --o -z output=soil_1 npoints=5 zmin=0 zmax=100 column=heigh seed=1
+v.random --o -z output=soil_2 npoints=5 zmin=0 zmax=100 column=height seed=2
+v.random --o -z output=soil_3 npoints=5 zmin=0 zmax=100 column=height seed=3
 
 n1=`g.tempfile pid=1 -d` 
 
@@ -25,11 +25,11 @@ soil_3|20|30
 EOF
 
 t.create --o type=stvds temporaltype=relative output=soil_rel1 title="A test" descr="A test"
-t.register type=vect input=soil_rel1 file="${n1}" unit=minutes
+t.register type=vector input=soil_rel1 file="${n1}" unit=minutes
 t.info type=stvds input=soil_rel1
 
 t.create --o type=strds temporaltype=relative output=precip_rel1 title="A test" descr="A test"
-t.register type=rast input=precip_rel1 maps=prec_1,prec_2,prec_3,prec_4,prec_5,prec_6 start=0 increment=5 unit=minutes
+t.register type=raster input=precip_rel1 maps=prec_1,prec_2,prec_3,prec_4,prec_5,prec_6 start=0 increment=5 unit=minutes
 
 # The @test
 
@@ -49,11 +49,11 @@ v.db.select map=soil_2
 v.db.select map=soil_3
 
 # @postprocess
-t.unregister type=vect maps=soil_1,soil_2,soil_3
+t.unregister type=vector maps=soil_1,soil_2,soil_3
 t.remove type=stvds input=soil_rel1
 
-t.unregister type=rast maps=prec_1,prec_2,prec_3,prec_4,prec_5,prec_6
+t.unregister type=raster maps=prec_1,prec_2,prec_3,prec_4,prec_5,prec_6
 t.remove type=strds input=precip_rel1
 
-g.remove -f type=rast name=prec_1,prec_2,prec_3,prec_4,prec_5,prec_6
-g.remove -f type=vect name=soil_1,soil_2,soil_3
+g.remove -f type=raster name=prec_1,prec_2,prec_3,prec_4,prec_5,prec_6
+g.remove -f type=vector name=soil_1,soil_2,soil_3