[GRASS-SVN] r62121 - in grass/trunk/lib/python: docs/src temporal
svn_grass at osgeo.org
svn_grass at osgeo.org
Sat Sep 27 18:46:16 PDT 2014
Author: huhabla
Date: 2014-09-27 18:46:15 -0700 (Sat, 27 Sep 2014)
New Revision: 62121
Modified:
grass/trunk/lib/python/docs/src/index.rst
grass/trunk/lib/python/docs/src/temporal_framework.rst
grass/trunk/lib/python/temporal/abstract_dataset.py
grass/trunk/lib/python/temporal/abstract_map_dataset.py
grass/trunk/lib/python/temporal/abstract_space_time_dataset.py
grass/trunk/lib/python/temporal/aggregation.py
grass/trunk/lib/python/temporal/base.py
grass/trunk/lib/python/temporal/c_libraries_interface.py
grass/trunk/lib/python/temporal/core.py
grass/trunk/lib/python/temporal/datetime_math.py
grass/trunk/lib/python/temporal/extract.py
grass/trunk/lib/python/temporal/factory.py
grass/trunk/lib/python/temporal/gui_support.py
grass/trunk/lib/python/temporal/list_stds.py
grass/trunk/lib/python/temporal/mapcalc.py
grass/trunk/lib/python/temporal/metadata.py
grass/trunk/lib/python/temporal/open_stds.py
grass/trunk/lib/python/temporal/register.py
grass/trunk/lib/python/temporal/sampling.py
grass/trunk/lib/python/temporal/space_time_datasets.py
grass/trunk/lib/python/temporal/spatial_extent.py
grass/trunk/lib/python/temporal/spatial_topology_dataset_connector.py
grass/trunk/lib/python/temporal/spatio_temporal_relationships.py
grass/trunk/lib/python/temporal/stds_export.py
grass/trunk/lib/python/temporal/stds_import.py
grass/trunk/lib/python/temporal/temporal_algebra.py
grass/trunk/lib/python/temporal/temporal_extent.py
grass/trunk/lib/python/temporal/temporal_granularity.py
grass/trunk/lib/python/temporal/temporal_raster3d_algebra.py
grass/trunk/lib/python/temporal/temporal_raster_algebra.py
grass/trunk/lib/python/temporal/temporal_raster_base_algebra.py
grass/trunk/lib/python/temporal/temporal_raster_operator.py
grass/trunk/lib/python/temporal/temporal_topology_dataset_connector.py
grass/trunk/lib/python/temporal/temporal_vector_algebra.py
grass/trunk/lib/python/temporal/temporal_vector_operator.py
grass/trunk/lib/python/temporal/unit_tests.py
grass/trunk/lib/python/temporal/univar_statistics.py
Log:
temporal framework: Changed the temporal framework code documentation from doxygen style to sphinx style
Modified: grass/trunk/lib/python/docs/src/index.rst
===================================================================
--- grass/trunk/lib/python/docs/src/index.rst 2014-09-28 01:40:32 UTC (rev 62120)
+++ grass/trunk/lib/python/docs/src/index.rst 2014-09-28 01:46:15 UTC (rev 62121)
@@ -8,7 +8,7 @@
script
pygrass_index
- temporal
+ temporal_framework
exceptions
imaging
gunittest_testing
Modified: grass/trunk/lib/python/docs/src/temporal_framework.rst
===================================================================
--- grass/trunk/lib/python/docs/src/temporal_framework.rst 2014-09-28 01:40:32 UTC (rev 62120)
+++ grass/trunk/lib/python/docs/src/temporal_framework.rst 2014-09-28 01:46:15 UTC (rev 62121)
@@ -28,183 +28,217 @@
as well as function definition. The API can be roughly divided in a low level and high level part. However, several
functions from the low level module are used in module implementation as well.
-
Low level API
-*************
+^^^^^^^^^^^^^
-The low level API implements the core functionality on which the high level API is based on.
+The low level API implements the core functionality of the temporal framework. Core functionality is
+for example the database interface, the temporal database creation and initialization,
+the SQL object serialization, all classes that represent table entries, datetime mathematics and many more.
-**python::temporal::core**
+:mod:`~temporal.core`
+"""""""""""""""""""""
+
The core functionality of the temporal framework:
- - Initialization function :func:`init()`
+ - Initialization function :func:`~temporal.core.init()`
- Definition of global variables
- Several global functions to access TGIS specific variables
- Interfaces to the TGIS C-library and PyGRASS messenger objects
- - Database interface connection class :class:`~temporal.core.SQLDatabaseInterfaceConnection` to sqlite3 and postgresql
- database backends
+ - Database interface connection class :class:`~temporal.core.SQLDatabaseInterfaceConnection`
+ to sqlite3 and postgresql database backends
- Functions to create the temporal database
-**python::temporal::base**
+:mod:`~temporal.base`
+"""""""""""""""""""""
Implements of basic dataset informations and SQL conversion of such information:
- - Definition of the SQL serialize class :class:`~temporal.base.DictSQLSerializer` that converts the content of temporal
+ - Definition of the SQL serialize class :class:`~temporal.base.DictSQLSerializer`
+ that converts the content of temporal
classes into SQL SELECT, INSERT or UPDATE statements
- - Definition of :class:`~temporal.base.SQLDatabaseInterface` that is the base class for all temporal datatype subclasses
+ - Definition of :class:`~temporal.base.SQLDatabaseInterface`
+ that is the base class for all temporal datatype subclasses
- Contains classes for all datasets [#allds]_ that contain
basic informations (id, name, mapset, creator, ...)
-**python::temporal::spatial_extent**
+:mod:`~temporal.spatial_extent`
+"""""""""""""""""""""""""""""""
Implements of 2d and 3d spatial extents of all datasets:
- - Implements class :class:`~temporal.spatial_extent.SpatialExtent` that is the base class for all dataset specific spatial extent classes
+ - Implements class :class:`~temporal.spatial_extent.SpatialExtent`
+ that is the base class for all dataset specific spatial extent classes
It provides spatial topological logic and operations for 2D and 3D extents
- Implements spatial extent classes for all datasets [#allds]_
-**python::temporal::temporal_extent**
+:mod:`~temporal.temporal_extent`
+""""""""""""""""""""""""""""""""
Implements of the temporal extent of all datasets for relative and absolute time:
- - Implements class :class:`~temporal.temporal_extent.TemporalExtent` that is the base class for all dataset specific temporal extent classes
+ - Implements class :class:`~temporal.temporal_extent.TemporalExtent`
+ that is the base class for all dataset specific temporal extent classes
It provides temporal topological logic and operations
- Implements temporal extent classes for relative time and absolute time for
all datasets [#allds]_
-**python::temporal::metadata**
+:mod:`~temporal.metadata`
+"""""""""""""""""""""""""
Implements the metadata base classes and datatype specific derivatives fpr all datasets [#allds]_.
-**python::temporal::spatial_topology_dataset_connector**
+:mod:`~temporal.spatial_topology_dataset_connector`
+"""""""""""""""""""""""""""""""""""""""""""""""""""
Implements the interface to link datasets by spatial topological relations
-**python::temporal::temporal_topology_dataset_connector**
+:mod:`~temporal.temporal_topology_dataset_connector`
+""""""""""""""""""""""""""""""""""""""""""""""""""""
Implements the interface to link datasets by temporal topological relations
-**python::temporal::c_libraries_interface**
+:mod:`~temporal.c_libraries_interface`
+""""""""""""""""""""""""""""""""""""""
The RPC C-library interface for exit safe and fast access to raster, vector and 3D raster informations.
-**python::temporal::temporal_granularity**
+:mod:`~temporal.temporal_granularity`
+"""""""""""""""""""""""""""""""""""""
The computation of the temporal granularity for a list
- of :class:`~temporal.abstract_dataset.AbstractDataset` objects for absolute and relative is implemented here.
+ of :class:`~temporal.abstract_dataset.AbstractDataset`
+ objects for absolute and relative is implemented here.
-**python::temporal::datetime_math**
+:mod:`~temporal.datetime_math`
+""""""""""""""""""""""""""""""
This module contains function to parse, convert and process datetime objects
in the temporal framework.
Spatio-temporal algebra classes for space time raster and vector datasets are defined in:
-- **python::temporal::temporal_algebra**
-- **python::temporal::temporal_vector_algebra**
-- **python::temporal::temporal_vector_operator**
+- :mod:`~temporal.temporal_algebra`
+- :mod:`~temporal.temporal_vector_algebra`
+- :mod:`~temporal.temporal_vector_operator`
High level API
-**************
+^^^^^^^^^^^^^^
-The high level API utilizes the low level API
+The high level API utilizes the low level API. Its classes and functions are usually used to implement
+temporal processing algorithms and temporal GRASS modules.
-**python::temporal::abstract_dataset**
+:mod:`~temporal.abstract_dataset`
+"""""""""""""""""""""""""""""""""
- Implements the base class for all datasets [#allds]_ :class:`~temporal.abstract_dataset.AbstractDataset`.
- Implements the the select, insert and update functionality as well as
convenient functions to access the base, extent and metadata informations
-**python::temporal::abstract_map_dataset**
+:mod:`~temporal.abstract_map_dataset`
+"""""""""""""""""""""""""""""""""""""
- - Implements the base class :class:`~temporal.abstract_map_dataset.AbstractMapDataset` for all map layer specific classes
+ - Implements the base class :class:`~temporal.abstract_map_dataset.AbstractMapDataset`
+ for all map layer specific classes
- Provides the interface to all map layer specific informations in the temporal database
-**python::temporal::abstract_space_time_dataset**
+:mod:`~temporal.abstract_space_time_dataset`
+""""""""""""""""""""""""""""""""""""""""""""
- - Implements the base class :class:`~temporal.abstract_space_time_dataset.AbstractSpaceTimeDataset` for all Space Time Datasets classes
+ - Implements the base class :class:`~temporal.abstract_space_time_dataset.AbstractSpaceTimeDataset`
+ for all Space Time Datasets classes
- Contains the creation and deletion functionality, the map registration and un-registration,
access methods to map layer objects and so on
- Provides the interface to all Space Time Dataset specific informations in the temporal database
-**python::temporal::space_time_datasets**
+:mod:`~temporal.space_time_datasets`
+""""""""""""""""""""""""""""""""""""
- This module contains all classes that represent specific datasets [#allds]_. A module developer uses these
- map layer and Space Time Dataset object representations to perform spatio-temporal tasks.
+ This module contains all classes that represent specific datasets [#allds]_.
+ A module developer uses these map layer and Space Time Dataset object
+ representations to perform spatio-temporal tasks.
+:mod:`~temporal.spatio_temporal_relationships`
+""""""""""""""""""""""""""""""""""""""""""""""
-**python::temporal::spatio_temporal_relationships**
-
The logic to compute spatio-temporal topology for a single list or two lists of :class:`~temporal.abstract_dataset.AbstractDataset` objects
is implemented in this module.
- The class :class:`~temporal.spatio_temporal_relationships.SpatioTemporalTopologyBuilder` provides a convenient
- interface for topology computation.
+ The class :class:`~temporal.spatio_temporal_relationships.SpatioTemporalTopologyBuilder`
+ provides a convenient interface for topology computation.
-**python::temporal::gui_support**
+:mod:`~temporal.gui_support`
+""""""""""""""""""""""""""""
Helper functions to support the listing of space time datasets in the automatically generated GUI.
-Temporal Framework Testsuite
-****************************
-All temporal framework specific unittests and doctests are located here:
-
-- **python::temporal::testsuite**
-
-
Shared Module functionality
-***************************
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
Functionality that is shared between different temporal GRASS modules, such as
-map listing, space time dataset creation, map registration and unregistration,
+map listing, space time dataset creation, map registration and un-registration,
aggregation, extraction, map calculation, statistics as well as import and export of
-space time datasets are defined here:
+space time datasets.
-**python::temporal::aggregation**
+:mod:`~temporal.aggregation`
+""""""""""""""""""""""""""""
Aggregation of Space Time Raster Datasets based on topological relations.
Used in *t.rast.aggregate* and *t.rast.aggregate.ds*
-**python::temporal::extract**
+:mod:`~temporal.extract`
+""""""""""""""""""""""""
- Extraction of subsets from Space Time Datasets including map algebra and vector selection statements.
+ Extraction of subsets from Space Time Datasets including
+ map algebra and vector selection statements.
Used in *t.rast.extract*, *t.rast3d.extract* and *t.vect.extract*.
-**python::temporal::factory**
+:mod:`~temporal.factory`
+""""""""""""""""""""""""
Factory functions to create datasets of all types [#allds]_.
-**python::temporal::open_stds**
+:mod:`~temporal.open_stds`
+""""""""""""""""""""""""""
- Convenient functions to open existing Space Time Datasets or to create new ones. Used in almost all temporal modules.
+ Convenient functions to open existing Space Time Datasets or
+ to create new ones. Used in almost all temporal modules.
-**python::temporal::list_stds**
+:mod:`~temporal.list_stds`
+""""""""""""""""""""""""""
- Convenient functions to list datasets of all types [#allds]_ registered in the temporal database.
+ Convenient functions to list datasets of all types [#allds]_
+ registered in the temporal database.
-**python::temporal::mapcalc**
+:mod:`~temporal.mapcalc`
+""""""""""""""""""""""""
- Simple temporal algebra for Scpae Time Raster and 3d Raster datasets. Used in *t.rast.mapcalc* and *t.rast3d.mapcalc*
+ Simple temporal algebra for Space Time Raster and 3d Raster
+ datasets. Used in *t.rast.mapcalc* and *t.rast3d.mapcalc*
-**python::temporal::register**
+:mod:`~temporal.register`
+"""""""""""""""""""""""""
Convenient functions to register a single or multiple map layer in the temporal database and
SpaceTime Datasets. Used in several modules, most important *t.register*.
-**python::temporal::sampling**
+:mod:`~temporal.sampling`
+"""""""""""""""""""""""""
Sampling functions used in several modules.
-**python::temporal::stds_export**
+:mod:`~temporal.stds_export`
+""""""""""""""""""""""""""""
Functions to export of Space Time Datasets, used in *t.rast.export*, *t.rast3d.export* and *t.vect.export*.
-**python::temporal::stds_import**
+:mod:`~temporal.stds_import`
+""""""""""""""""""""""""""""
Functions to import Space Time Datasets, used in *t.rast.import*, *t.rast3d.import* and *t.vect.import*.
-**python::temporal::univar_statistics**
+:mod:`~temporal.univar_statistics`
+""""""""""""""""""""""""""""""""""
Simple statistical analysis functions for Space Time Datasets, used in *t.rast.univar*, *t.rast3d.univar*
and *t.vect.univar*.
@@ -213,11 +247,20 @@
.. [#allds] : Raster Map Layer, 3d Raster Map Layer, Vector Map Layer, Space time Raster Datasets (STRDS),
Space Time 3d Raster Datasets (STR3DS) and Space Time Vector Datasets (STVDS)
+
+Here the full list of all temporal modules:
+
+.. toctree::
+ :maxdepth: 2
+
+ temporal
+
+
Examples
--------
Howto start example
-*******************
+^^^^^^^^^^^^^^^^^^^
This simple example shows how to open a space time raster dataset
to access its registered maps.
@@ -274,7 +317,7 @@
Creation of a space time dataset
-********************************
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
This example shows howto create a space time dataset. The code is generic and works
for different space time datasets (raster, 3D raster and vector):
@@ -335,7 +378,7 @@
Temporal shifting
-*****************
+^^^^^^^^^^^^^^^^^
.. code-block:: python
Modified: grass/trunk/lib/python/temporal/abstract_dataset.py
===================================================================
--- grass/trunk/lib/python/temporal/abstract_dataset.py 2014-09-28 01:40:32 UTC (rev 62120)
+++ grass/trunk/lib/python/temporal/abstract_dataset.py 2014-09-28 01:46:15 UTC (rev 62121)
@@ -1,17 +1,14 @@
# -*- coding: utf-8 -*-
-"""!@package grass.temporal
+"""
+The abstract_dataset module provides the AbstractDataset class
+that is the base class for all map layer and Space Time Datasets.
- at brief GRASS Python scripting module (temporal GIS functions)
-
-Temporal GIS related functions to be used in temporal GIS Python library package.
-
-
(C) 2011-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.
- at author Soeren Gebbert
+:authors: Soeren Gebbert
"""
import uuid
import copy
@@ -27,7 +24,7 @@
###############################################################################
class AbstractDataset(SpatialTopologyDatasetConnector, TemporalTopologyDatasetConnector):
- """!This is the base class for all datasets
+ """This is the base class for all datasets
(raster, vector, raster3d, strds, stvds, str3ds)"""
__metaclass__ = ABCMeta
@@ -38,42 +35,47 @@
self.msgr = get_tgis_message_interface()
def reset_topology(self):
- """!Reset any information about temporal topology"""
+ """
+ Reset any information about temporal topology"""
+
self.reset_spatial_topology()
self.reset_temporal_topology()
def get_number_of_relations(self):
- """! Return a dictionary in which the keys are the relation names and the value
+ """
+ Return a dictionary in which the keys are the relation names and the value
are the number of relations.
The following relations are available:
- Spatial relations
- - equivalent
- - overlap
- - in
- - contain
- - meet
- - cover
- - covered
+ Spatial relations:
+
+ - equivalent
+ - overlap
+ - in
+ - contain
+ - meet
+ - cover
+ - covered
- Temporal relations
- - equal
- - follows
- - precedes
- - overlaps
- - overlapped
- - during (including starts, finishes)
- - contains (including started, finished)
- - starts
- - started
- - finishes
- - finished
+ Temporal relations:
+
+ - equal
+ - follows
+ - precedes
+ - overlaps
+ - overlapped
+ - during (including starts, finishes)
+ - contains (including started, finished)
+ - starts
+ - started
+ - finishes
+ - finished
To access topological information the spatial, temporal or booth topologies must be build first
using the SpatioTemporalTopologyBuilder.
- @return the dictionary with relations as keys and number as values or None in case the topology wasn't build
+ :return: The dictionary with relations as keys and number as values or None in case the topology wasn't build
"""
if self.is_temporal_topology_build() and not self.is_spatial_topology_build():
return self.get_number_of_temporal_relations()
@@ -86,20 +88,20 @@
return None
def set_topology_build_true(self):
- """!Use this method when the spatio-temporal topology was build"""
+ """Use this method when the spatio-temporal topology was build"""
self.set_spatial_topology_build_true()
self.set_temporal_topology_build_true()
def set_topology_build_false(self):
- """!Use this method when the spatio-temporal topology was not build"""
+ """Use this method when the spatio-temporal topology was not build"""
self.set_spatial_topology_build_false()
self.set_temporal_topology_build_false()
def is_topology_build(self):
- """!Check if the spatial and temporal topology was build
+ """Check if the spatial and temporal topology was build
- @return A dictionary with "spatial" and "temporal" as keys that have boolen values
+ :return: A dictionary with "spatial" and "temporal" as keys that have boolen values
"""
d = {}
d["spatial"] = self.is_spatial_topology_build()
@@ -122,103 +124,105 @@
@abstractmethod
def reset(self, ident):
- """!Reset the internal structure and set the identifier
+ """Reset the internal structure and set the identifier
This method creates the dataset specific internal objects
that store the base information, the spatial and temporal extent
and the metadata. It must be implemented in the dataset
specific subclasses. This is the code for the
vector dataset:
+
+ .. code-block:: python
- self.base = VectorBase(ident=ident)
- self.absolute_time = VectorAbsoluteTime(ident=ident)
- self.relative_time = VectorRelativeTime(ident=ident)
- self.spatial_extent = VectorSpatialExtent(ident=ident)
- self.metadata = VectorMetadata(ident=ident)
+ self.base = VectorBase(ident=ident)
+ self.absolute_time = VectorAbsoluteTime(ident=ident)
+ self.relative_time = VectorRelativeTime(ident=ident)
+ self.spatial_extent = VectorSpatialExtent(ident=ident)
+ self.metadata = VectorMetadata(ident=ident)
- @param ident The identifier of the dataset that "name at mapset" or in case of vector maps "name:layer at mapset"
+ :param ident: The identifier of the dataset that "name at mapset" or in case of vector maps "name:layer at mapset"
"""
@abstractmethod
def is_stds(self):
- """!Return True if this class is a space time dataset
+ """Return True if this class is a space time dataset
- @return True if this class is a space time dataset, False otherwise
+ :return: True if this class is a space time dataset, False otherwise
"""
@abstractmethod
def get_type(self):
- """!Return the type of this class as string
+ """Return the type of this class as string
The type can be "vect", "rast", "rast3d", "stvds", "strds" or "str3ds"
- @return "vect", "rast", "rast3d", "stvds", "strds" or "str3ds"
+ :return: "vect", "rast", "rast3d", "stvds", "strds" or "str3ds"
"""
@abstractmethod
def get_new_instance(self, ident):
- """!Return a new instance with the type of this class
+ """Return a new instance with the type of this class
- @param ident The identifier of the new dataset instance
- @return A new instance with the type of this object
+ :param ident: The identifier of the new dataset instance
+ :return: A new instance with the type of this object
"""
@abstractmethod
def spatial_overlapping(self, dataset):
- """!Return True if the spatial extents overlap
+ """Return True if the spatial extents overlap
- @param dataset The abstract dataset to check spatial overlapping
- @return True if self and the provided dataset spatial overlap
+ :param dataset: The abstract dataset to check spatial overlapping
+ :return: True if self and the provided dataset spatial overlap
"""
@abstractmethod
def spatial_intersection(self, dataset):
- """!Return the spatial intersection as spatial_extent
+ """Return the spatial intersection as spatial_extent
object or None in case no intersection was found.
- @param dataset The abstract dataset to intersect with
- @return The intersection spatial extent
+ :param dataset: The abstract dataset to intersect with
+ :return: The intersection spatial extent
"""
@abstractmethod
def spatial_union(self, dataset):
- """!Return the spatial union as spatial_extent
+ """Return the spatial union as spatial_extent
object or None in case the extents does not overlap or meet.
- @param dataset The abstract dataset to create a union with
- @return The union spatial extent
+ :param dataset: The abstract dataset to create a union with
+ :return: The union spatial extent
"""
@abstractmethod
def spatial_disjoint_union(self, dataset):
- """!Return the spatial union as spatial_extent object.
+ """Return the spatial union as spatial_extent object.
- @param dataset The abstract dataset to create a union with
- @return The union spatial extent
+ :param dataset: The abstract dataset to create a union with
+ :return: The union spatial extent
"""
@abstractmethod
def spatial_relation(self, dataset):
- """!Return the spatial relationship between self and dataset
+ """Return the spatial relationship between self and dataset
- @param dataset The abstract dataset to compute the spatial relation with self
- @return The spatial relationship as string
+ :param dataset: The abstract dataset to compute the spatial relation with self
+ :return: The spatial relationship as string
"""
@abstractmethod
def print_info(self):
- """!Print information about this class in human readable style"""
+ """Print information about this class in human readable style"""
@abstractmethod
def print_shell_info(self):
- """!Print information about this class in shell style"""
+ """Print information about this class in shell style"""
@abstractmethod
def print_self(self):
- """!Print the content of the internal structure to stdout"""
+ """Print the content of the internal structure to stdout"""
def set_id(self, ident):
- """!Set the identifier of the dataset"""
+ """Set the identifier of the dataset"""
self.base.set_id(ident)
self.temporal_extent.set_id(ident)
self.spatial_extent.set_id(ident)
@@ -227,37 +231,37 @@
self.stds_register.set_id(ident)
def get_id(self):
- """!Return the unique identifier of the dataset
- @return The id of the dataset "name(:layer)@mapset" as string
+ """Return the unique identifier of the dataset
+ :return: The id of the dataset "name(:layer)@mapset" as string
"""
return self.base.get_id()
def get_name(self):
- """!Return the name
- @return The name of the dataset as string
+ """Return the name
+ :return: The name of the dataset as string
"""
return self.base.get_name()
def get_mapset(self):
- """!Return the mapset
- @return The mapset in which the dataset was created as string
+ """Return the mapset
+ :return: The mapset in which the dataset was created as string
"""
return self.base.get_mapset()
def get_temporal_extent_as_tuple(self):
- """!Returns a tuple of the valid start and end time
+ """Returns a tuple of the valid start and end time
Start and end time can be either of type datetime or of type integer,
depending on the temporal type.
- @return A tuple of (start_time, end_time)
+ :return: A tuple of (start_time, end_time)
"""
start = self.temporal_extent.get_start_time()
end = self.temporal_extent.get_end_time()
return (start, end)
def get_absolute_time(self):
- """!Returns the start time, the end
+ """Returns the start time, the end
time of the map as tuple
The start time is of type datetime.
@@ -265,7 +269,7 @@
The end time is of type datetime in case of interval time,
or None on case of a time instance.
- @return A tuple of (start_time, end_time)
+ :return: A tuple of (start_time, end_time)
"""
start = self.absolute_time.get_start_time()
@@ -274,7 +278,7 @@
return (start, end)
def get_relative_time(self):
- """!Returns the start time, the end
+ """Returns the start time, the end
time and the temporal unit of the dataset as tuple
The start time is of type integer.
@@ -282,7 +286,7 @@
The end time is of type integer in case of interval time,
or None on case of a time instance.
- @return A tuple of (start_time, end_time, unit)
+ :return: A tuple of (start_time, end_time, unit)
"""
start = self.relative_time.get_start_time()
@@ -292,17 +296,17 @@
return (start, end, unit)
def get_relative_time_unit(self):
- """!Returns the relative time unit
- @return The relative time unit as string, None if not present
+ """Returns the relative time unit
+ :return: The relative time unit as string, None if not present
"""
return self.relative_time.get_unit()
def check_relative_time_unit(self, unit):
- """!Check if unit is of type year(s), month(s), day(s), hour(s),
+ """Check if unit is of type year(s), month(s), day(s), hour(s),
minute(s) or second(s)
- @param unit The unit string
- @return True if success, False otherwise
+ :param unit: The unit string
+ :return: True if success, False otherwise
"""
# Check unit
units = ["year", "years", "month", "months", "day", "days", "hour",
@@ -312,37 +316,37 @@
return True
def get_temporal_type(self):
- """!Return the temporal type of this dataset
+ """Return the temporal type of this dataset
The temporal type can be absolute or relative
- @return The temporal type of the dataset as string
+ :return: The temporal type of the dataset as string
"""
return self.base.get_ttype()
def get_spatial_extent_as_tuple(self):
- """!Return the spatial extent as tuple
+ """Return the spatial extent as tuple
Top and bottom are set to 0 in case of a two dimensional spatial extent.
- @return A the spatial extent as tuple (north, south, east, west, top, bottom)
+ :return: A the spatial extent as tuple (north, south, east, west, top, bottom)
"""
return self.spatial_extent.get_spatial_extent_as_tuple()
def get_spatial_extent(self):
- """!Return the spatial extent
+ """Return the spatial extent
"""
return self.spatial_extent
def select(self, dbif=None):
- """!Select temporal dataset entry from database and fill
+ """Select temporal dataset entry from database and fill
the internal structure
The content of every dataset is stored in the temporal database.
This method must be used to fill this object with the content
from the temporal database.
- @param dbif The database interface to be used
+ :param dbif: The database interface to be used
"""
dbif, connected = init_dbif(dbif)
@@ -358,25 +362,25 @@
dbif.close()
def is_in_db(self, dbif=None):
- """!Check if the dataset is registered in the database
+ """Check if the dataset is registered in the database
- @param dbif The database interface to be used
- @return True if the dataset is registered in the database
+ :param dbif: The database interface to be used
+ :return: True if the dataset is registered in the database
"""
return self.base.is_in_db(dbif)
@abstractmethod
def delete(self):
- """!Delete dataset from database if it exists"""
+ """Delete dataset from database if it exists"""
def insert(self, dbif=None, execute=True):
- """!Insert dataset into database
+ """Insert dataset into database
- @param dbif The database interface to be used
- @param execute If True the SQL statements will be executed.
- If False the prepared SQL statements are returned
- and must be executed by the caller.
- @return The SQL insert statement in case execute=False, or an empty string otherwise
+ :param dbif: The database interface to be used
+ :param execute: If True the SQL statements will be executed.
+ If False the prepared SQL statements are returned
+ and must be executed by the caller.
+ :return: The SQL insert statement in case execute=False, or an empty string otherwise
"""
if get_enable_mapset_check() is True and self.get_mapset() != get_current_mapset():
@@ -405,15 +409,15 @@
return statement
def update(self, dbif=None, execute=True, ident=None):
- """!Update the dataset entry in the database from the internal structure
+ """Update the dataset entry in the database from the internal structure
excluding None variables
- @param dbif The database interface to be used
- @param execute If True the SQL statements will be executed.
- If False the prepared SQL statements are returned
- and must be executed by the caller.
- @param ident The identifier to be updated, useful for renaming
- @return The SQL update statement in case execute=False, or an empty string otherwise
+ :param dbif: The database interface to be used
+ :param execute: If True the SQL statements will be executed.
+ If False the prepared SQL statements are returned
+ and must be executed by the caller.
+ :param ident: The identifier to be updated, useful for renaming
+ :return: The SQL update statement in case execute=False, or an empty string otherwise
"""
if get_enable_mapset_check() is True and self.get_mapset() != get_current_mapset():
@@ -446,15 +450,15 @@
return statement
def update_all(self, dbif=None, execute=True, ident=None):
- """!Update the dataset entry in the database from the internal structure
+ """Update the dataset entry in the database from the internal structure
and include None variables.
- @param dbif The database interface to be used
- @param execute If True the SQL statements will be executed.
- If False the prepared SQL statements are returned
- and must be executed by the caller.
- @param ident The identifier to be updated, useful for renaming
- @return The SQL update statement in case execute=False, or an empty string otherwise
+ :param dbif: The database interface to be used
+ :param execute: If True the SQL statements will be executed.
+ f False the prepared SQL statements are returned
+ and must be executed by the caller.
+ :param ident: The identifier to be updated, useful for renaming
+ :return: The SQL update statement in case execute=False, or an empty string otherwise
"""
if get_enable_mapset_check() is True and self.get_mapset() != get_current_mapset():
@@ -486,9 +490,9 @@
return statement
def is_time_absolute(self):
- """!Return True in case the temporal type is absolute
+ """Return True in case the temporal type is absolute
- @return True if temporal type is absolute, False otherwise
+ :return: True if temporal type is absolute, False otherwise
"""
if "temporal_type" in self.base.D:
return self.base.get_ttype() == "absolute"
@@ -496,9 +500,9 @@
return None
def is_time_relative(self):
- """!Return True in case the temporal type is relative
+ """Return True in case the temporal type is relative
- @return True if temporal type is relative, False otherwise
+ :return: True if temporal type is relative, False otherwise
"""
if "temporal_type" in self.base.D:
return self.base.get_ttype() == "relative"
@@ -506,7 +510,7 @@
return None
def get_temporal_extent(self):
- """!Return the temporal extent of the correct internal type
+ """Return the temporal extent of the correct internal type
"""
if self.is_time_absolute():
return self.absolute_time
@@ -517,55 +521,56 @@
temporal_extent = property(fget=get_temporal_extent)
def temporal_relation(self, dataset):
- """!Return the temporal relation of self and the provided dataset
+ """Return the temporal relation of self and the provided dataset
- @return The temporal relation as string
+ :return: The temporal relation as string
"""
return self.temporal_extent.temporal_relation(dataset.temporal_extent)
def temporal_intersection(self, dataset):
- """!Intersect self with the provided dataset and
+ """Intersect self with the provided dataset and
return a new temporal extent with the new start and end time
- @param dataset The abstract dataset to temporal intersect with
- @return The new temporal extent with start and end time,
- or None in case of no intersection
+ :param dataset: The abstract dataset to temporal intersect with
+ :return: The new temporal extent with start and end time,
+ or None in case of no intersection
"""
return self.temporal_extent.intersect(dataset.temporal_extent)
def temporal_union(self, dataset):
- """!Creates a union with the provided dataset and
+ """Creates a union with the provided dataset and
return a new temporal extent with the new start and end time.
- @param dataset The abstract dataset to create temporal union with
- @return The new temporal extent with start and end time,
- or None in case of no intersection
+ :param dataset: The abstract dataset to create temporal union with
+ :return: The new temporal extent with start and end time,
+ or None in case of no intersection
"""
return self.temporal_extent.union(dataset.temporal_extent)
def temporal_disjoint_union(self, dataset):
- """!Creates a union with the provided dataset and
+ """Creates a union with the provided dataset and
return a new temporal extent with the new start and end time.
- @param dataset The abstract dataset to create temporal union with
- @return The new temporal extent with start and end time
+ :param dataset: The abstract dataset to create temporal union with
+ :return: The new temporal extent with start and end time
"""
return self.temporal_extent.disjoint_union(dataset.temporal_extent)
###############################################################################
class AbstractDatasetComparisonKeyStartTime(object):
- """!This comparison key can be used to sort lists of abstract datasets
+ """This comparison key can be used to sort lists of abstract datasets
by start time
Example:
- # Return all maps in a space time raster dataset as map objects
- map_list = strds.get_registered_maps_as_objects()
+ .. code-block:: python
+
+ # Return all maps in a space time raster dataset as map objects
+ map_list = strds.get_registered_maps_as_objects()
- # Sort the maps in the list by start time
- sorted_map_list = sorted(
- map_list, key=AbstractDatasetComparisonKeyStartTime)
+ # Sort the maps in the list by start time
+ sorted_map_list = sorted(map_list, key=AbstractDatasetComparisonKeyStartTime)
"""
def __init__(self, obj, *args):
self.obj = obj
@@ -603,17 +608,18 @@
###############################################################################
class AbstractDatasetComparisonKeyEndTime(object):
- """!This comparison key can be used to sort lists of abstract datasets
+ """This comparison key can be used to sort lists of abstract datasets
by end time
Example:
- # Return all maps in a space time raster dataset as map objects
- map_list = strds.get_registered_maps_as_objects()
+ .. code-block:: python
+
+ # Return all maps in a space time raster dataset as map objects
+ map_list = strds.get_registered_maps_as_objects()
- # Sort the maps in the list by end time
- sorted_map_list = sorted(
- map_list, key=AbstractDatasetComparisonKeyEndTime)
+ # Sort the maps in the list by end time
+ sorted_map_list = sorted(map_list, key=AbstractDatasetComparisonKeyEndTime)
"""
def __init__(self, obj, *args):
self.obj = obj
Modified: grass/trunk/lib/python/temporal/abstract_map_dataset.py
===================================================================
--- grass/trunk/lib/python/temporal/abstract_map_dataset.py 2014-09-28 01:40:32 UTC (rev 62120)
+++ grass/trunk/lib/python/temporal/abstract_map_dataset.py 2014-09-28 01:46:15 UTC (rev 62121)
@@ -1,22 +1,20 @@
# -*- coding: utf-8 -*-
-"""!@package grass.temporal
+"""
+The abstract_map_dataset module provides the AbstractMapDataset class
+that is the base class for all map layer.
- at brief GRASS Python scripting module (temporal GIS functions)
-
-Temporal GIS related functions to be used in temporal GIS Python library package.
-
(C) 2011-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.
- at author Soeren Gebbert
+:authors: Soeren Gebbert
"""
from abstract_dataset import *
from datetime_math import *
class AbstractMapDataset(AbstractDataset):
- """!This is the base class for all maps (raster, vector, raster3d).
+ """This is the base class for all maps (raster, vector, raster3d).
The temporal extent, the spatial extent and the metadata of maps
are stored in the temporal database. Maps can be registered in the
@@ -24,12 +22,13 @@
This class provides all functionalities that are needed to manage maps
in the temporal database. That are:
+
- insert() to register the map and therefore its spatio-temporal extent
- and metadata in the temporal database
+ and metadata in the temporal database
- update() to update the map spatio-temporal extent and metadata in the
- temporal database
+ temporal database
- unregister() to unregister the map from each space time dataset in
- which this map is registered
+ which this map is registered
- delete() to remove the map from the temporal database
- Methods to set relative and absolute time stamps
- Abstract methods that must be implemented in the map specific
@@ -44,15 +43,15 @@
@abstractmethod
def get_new_stds_instance(self, ident):
- """!Return a new space time dataset instance that store maps with the
+ """Return a new space time dataset instance that store maps with the
type of this map object (rast, rast3d or vect)
- @param ident The identifier of the space time dataset
- @return The new space time dataset instance
+ :param ident The identifier of the space time dataset
+ :return: The new space time dataset instance
"""
def check_resolution_with_current_region(self):
- """!Check if the raster or voxel resolution is
+ """Check if the raster or voxel resolution is
finer than the current resolution
- Return "finer" in case the raster/voxel resolution is finer
@@ -63,7 +62,7 @@
Vector maps have no resolution, since they store the coordinates
directly.
- @return "finer" or "coarser"
+ :return: "finer" or "coarser"
"""
raise ImplementationError(
"This method must be implemented in the subclasses")
@@ -71,20 +70,20 @@
@abstractmethod
def has_grass_timestamp(self):
- """!Check if a grass file based time stamp exists for this map.
- @return True is the grass file based time stamped exists for this
+ """Check if a grass file based time stamp exists for this map.
+ :return: True is the grass file based time stamped exists for this
map
"""
@abstractmethod
def write_timestamp_to_grass(self):
- """!Write the timestamp of this map into the map metadata
+ """Write the timestamp of this map into the map metadata
in the grass file system based spatial database.
"""
@abstractmethod
def read_timestamp_from_grass(self):
- """!Read the timestamp of this map from the map metadata
+ """Read the timestamp of this map from the map metadata
in the grass file system based spatial database and
set the internal time stamp that should be insert/updated
in the temporal database.
@@ -92,29 +91,29 @@
@abstractmethod
def remove_timestamp_from_grass(self):
- """!Remove the timestamp from the grass file
+ """Remove the timestamp from the grass file
system based spatial database
"""
@abstractmethod
def map_exists(self):
- """!Return True in case the map exists in the grass spatial database
+ """Return True in case the map exists in the grass spatial database
- @return True if map exists, False otherwise
+ :return: True if map exists, False otherwise
"""
@abstractmethod
def load(self):
- """!Load the content of this object from the grass
+ """Load the content of this object from the grass
file system based database"""
def _convert_timestamp(self):
- """!Convert the valid time into a grass datetime library
+ """Convert the valid time into a grass datetime library
compatible timestamp string
This methods works for relative and absolute time
- @return the grass timestamp string
+ :return: the grass timestamp string
"""
start = ""
@@ -134,7 +133,7 @@
return start
def get_map_id(self):
- """!Return the map id. The map id is the unique identifier
+ """Return the map id. The map id is the unique identifier
in grass and must not be equal to the
primary key identifier (id) of the map in the database.
Since vector maps may have layer information,
@@ -144,24 +143,23 @@
in the file system but not to identify
map information in the temporal database.
- @return The map id "name at mapset"
+ :return: The map id "name at mapset"
"""
return self.base.get_map_id()
@staticmethod
def build_id(name, mapset, layer=None):
- """!Convenient method to build the unique identifier
+ """Convenient method to build the unique identifier
Existing layer and mapset definitions in the name
string will be reused
- @param name The name of the map
- @param mapset The mapset in which the map is located
- @param layer The layer of the vector map, use None in case no
- layer exists
+ :param name: The name of the map
+ :param mapset: The mapset in which the map is located
+ :param layer: The layer of the vector map, use None in case no
+ layer exists
- @return the id of the map as "name(:layer)@mapset"
- while layer is optional
+ :return: the id of the map as "name(:layer)@mapset" while layer is optional
"""
# Check if the name includes any mapset
@@ -178,14 +176,15 @@
return "%s@%s" % (name, mapset)
def get_layer(self):
- """!Return the layer of the map
- @return the layer of the map or None in case no layer is defined
+ """Return the layer of the map
+
+ :return: the layer of the map or None in case no layer is defined
"""
return self.base.get_layer()
def print_self(self):
- """!Print the content of the internal structure to stdout"""
+ """Print the content of the internal structure to stdout"""
self.base.print_self()
self.temporal_extent.print_self()
self.spatial_extent.print_self()
@@ -193,7 +192,7 @@
self.stds_register.print_self()
def print_info(self):
- """!Print information about this object in human readable style"""
+ """Print information about this object in human readable style"""
if self.get_type() == "raster":
# 1 2 3 4 5 6 7
@@ -231,7 +230,7 @@
print " +----------------------------------------------------------------------------+"
def print_shell_info(self):
- """!Print information about this object in shell style"""
+ """Print information about this object in shell style"""
self.base.print_shell_info()
self.temporal_extent.print_shell_info()
self.spatial_extent.print_shell_info()
@@ -252,7 +251,7 @@
self.print_topology_shell_info()
def insert(self, dbif=None, execute=True):
- """!Insert the map content into the database from the internal
+ """Insert the map content into the database from the internal
structure
This functions assures that the timestamp is written to the
@@ -261,65 +260,65 @@
Hence maps can only be registered in a space time dataset, when
they were inserted in the temporal database beforehand.
- @param dbif The database interface to be used
- @param execute If True the SQL statements will be executed.
- If False the prepared SQL statements are
- returned and must be executed by the caller.
- @return The SQL insert statement in case execute=False, or an
- empty string otherwise
+ :param dbif: The database interface to be used
+ :param execute: If True the SQL statements will be executed.
+ If False the prepared SQL statements are
+ returned and must be executed by the caller.
+ :return: The SQL insert statement in case execute=False, or an
+ empty string otherwise
"""
if get_enable_timestamp_write():
self.write_timestamp_to_grass()
return AbstractDataset.insert(self, dbif=dbif, execute=execute)
def update(self, dbif=None, execute=True):
- """!Update the map content in the database from the internal structure
+ """Update the map content in the database from the internal structure
excluding None variables
This functions assures that the timestamp is written to the
grass file system based database in addition to the temporal
database entry.
- @param dbif The database interface to be used
- @param execute If True the SQL statements will be executed.
- If False the prepared SQL statements are
- returned and must be executed by the caller.
- @return The SQL insert statement in case execute=False, or an
- empty string otherwise
+ :param dbif: The database interface to be used
+ :param execute: If True the SQL statements will be executed.
+ If False the prepared SQL statements are
+ returned and must be executed by the caller.
+ :return: The SQL insert statement in case execute=False, or an
+ empty string otherwise
"""
if get_enable_timestamp_write():
self.write_timestamp_to_grass()
return AbstractDataset.update(self, dbif, execute)
def update_all(self, dbif=None, execute=True):
- """!Update the map content in the database from the internal structure
+ """Update the map content in the database from the internal structure
including None variables
This functions assures that the timestamp is written to the
grass file system based database in addition to the temporal
database entry.
- @param dbif The database interface to be used
- @param execute If True the SQL statements will be executed.
- If False the prepared SQL statements are
- returned and must be executed by the caller.
- @return The SQL insert statement in case execute=False, or an
- empty string otherwise
+ :param dbif: The database interface to be used
+ :param execute: If True the SQL statements will be executed.
+ If False the prepared SQL statements are
+ returned and must be executed by the caller.
+ :return: The SQL insert statement in case execute=False, or an
+ empty string otherwise
"""
if get_enable_timestamp_write():
self.write_timestamp_to_grass()
return AbstractDataset.update_all(self, dbif, execute)
def set_time_to_absolute(self):
- """!Set the temporal type to absolute"""
+ """Set the temporal type to absolute"""
self.base.set_ttype("absolute")
def set_time_to_relative(self):
- """!Set the temporal type to relative"""
+ """Set the temporal type to relative"""
self.base.set_ttype("relative")
def set_absolute_time(self, start_time, end_time=None):
- """!Set the absolute time with start time and end time
+ """Set the absolute time with start time and end time
The end time is optional and must be set to None in case of time
instance.
@@ -327,12 +326,10 @@
This method only modifies this object and does not commit
the modifications to the temporal database.
- @param start_time a datetime object specifying the start time of the
- map
- @param end_time a datetime object specifying the end time of the
- map, None in case or time instance
+ :param start_time: A datetime object specifying the start time of the map
+ :param end_time: A datetime object specifying the end time of the map, None in case or time instance
- @return True for success and False otherwise
+ :return: True for success and False otherwise
"""
if start_time and not isinstance(start_time, datetime):
if self.get_layer() is not None:
@@ -388,7 +385,7 @@
return True
def update_absolute_time(self, start_time, end_time=None, dbif=None):
- """!Update the absolute time
+ """Update the absolute time
The end time is optional and must be set to None in case of time
instance.
@@ -397,11 +394,11 @@
grass file system based database in addition to the temporal
database entry.
- @param start_time a datetime object specifying the start time of
- the map
- @param end_time a datetime object specifying the end time of the
- map, None in case or time instance
- @param dbif The database interface to be used
+ :param start_time: A datetime object specifying the start time of
+ the map
+ :param end_time: A datetime object specifying the end time of the
+ map, None in case or time instance
+ :param dbif: The database interface to be used
"""
if get_enable_mapset_check() is True and self.get_mapset() != get_current_mapset():
@@ -422,7 +419,7 @@
self.write_timestamp_to_grass()
def set_relative_time(self, start_time, end_time, unit):
- """!Set the relative time interval
+ """Set the relative time interval
The end time is optional and must be set to None in case of time
instance.
@@ -430,12 +427,12 @@
This method only modifies this object and does not commit
the modifications to the temporal database.
- @param start_time An integer value
- @param end_time An integer value, None in case or time instance
- @param unit The unit of the relative time. Supported units:
- year(s), month(s), day(s), hour(s), minute(s), second(s)
+ :param start_time: An integer value
+ :param end_time: An integer value, None in case or time instance
+ :param unit: The unit of the relative time. Supported units:
+ year(s), month(s), day(s), hour(s), minute(s), second(s)
- @return True for success and False otherwise
+ :return: True for success and False otherwise
"""
if not self.check_relative_time_unit(unit):
@@ -481,7 +478,7 @@
return True
def update_relative_time(self, start_time, end_time, unit, dbif=None):
- """!Update the relative time interval
+ """Update the relative time interval
The end time is optional and must be set to None in case of time
instance.
@@ -490,10 +487,10 @@
grass file system based database in addition to the temporal
database entry.
- @param start_time An integer value
- @param end_time An integer value, None in case or time instance
- @param unit The relative time unit
- @param dbif The database interface to be used
+ :param start_time: An integer value
+ :param end_time: An integer value, None in case or time instance
+ :param unit: The relative time unit
+ :param dbif: The database interface to be used
"""
if get_enable_mapset_check() is True and self.get_mapset() != get_current_mapset():
self.msgr.fatal(_("Unable to update dataset <%(ds)s> of type %(type)s in the temporal database."
@@ -512,38 +509,38 @@
self.write_timestamp_to_grass()
def set_temporal_extent(self, extent):
- """!Convenient method to set the temporal extent from a temporal extent object
+ """Convenient method to set the temporal extent from a temporal extent object
- @param temporal_extent The temporal extent that should be set for this object
+ :param temporal_extent: The temporal extent that should be set for this object
- @code
- >>> import datetime
- >>> import grass.temporal as tgis
- >>> map = tgis.RasterDataset(None)
- >>> temp_ext = tgis.RasterRelativeTime(start_time=1, end_time=2, unit="years")
- >>> map.set_temporal_extent(temp_ext)
- >>> print map.get_temporal_extent_as_tuple()
- (1, 2)
- >>> map = tgis.VectorDataset(None)
- >>> temp_ext = tgis.VectorAbsoluteTime(start_time=datetime.datetime(2000, 1, 1),
- ... end_time=datetime.datetime(2001, 1, 1))
- >>> map.set_temporal_extent(temp_ext)
- >>> print map.get_temporal_extent_as_tuple()
- (datetime.datetime(2000, 1, 1, 0, 0), datetime.datetime(2001, 1, 1, 0, 0))
+ .. code-block: : python
+
+ >>> import datetime
+ >>> import grass.temporal as tgis
+ >>> map = tgis.RasterDataset(None)
+ >>> temp_ext = tgis.RasterRelativeTime(start_time=1, end_time=2, unit="years")
+ >>> map.set_temporal_extent(temp_ext)
+ >>> print map.get_temporal_extent_as_tuple()
+ (1, 2)
+ >>> map = tgis.VectorDataset(None)
+ >>> temp_ext = tgis.VectorAbsoluteTime(start_time=datetime.datetime(2000, 1, 1),
+ ... end_time=datetime.datetime(2001, 1, 1))
+ >>> map.set_temporal_extent(temp_ext)
+ >>> print map.get_temporal_extent_as_tuple()
+ (datetime.datetime(2000, 1, 1, 0, 0), datetime.datetime(2001, 1, 1, 0, 0))
- >>> map1 = tgis.VectorDataset("A at P")
- >>> check = map1.set_absolute_time(datetime.datetime(2000,5,5), datetime.datetime(2005,6,6))
- >>> print map1.get_temporal_extent_as_tuple()
- (datetime.datetime(2000, 5, 5, 0, 0), datetime.datetime(2005, 6, 6, 0, 0))
- >>> map2 = tgis.RasterDataset("B at P")
- >>> check = map2.set_absolute_time(datetime.datetime(1990,1,1), datetime.datetime(1999,8,1))
- >>> print map2.get_temporal_extent_as_tuple()
- (datetime.datetime(1990, 1, 1, 0, 0), datetime.datetime(1999, 8, 1, 0, 0))
- >>> map2.set_temporal_extent(map1.get_temporal_extent())
- >>> print map2.get_temporal_extent_as_tuple()
- (datetime.datetime(2000, 5, 5, 0, 0), datetime.datetime(2005, 6, 6, 0, 0))
+ >>> map1 = tgis.VectorDataset("A at P")
+ >>> check = map1.set_absolute_time(datetime.datetime(2000,5,5), datetime.datetime(2005,6,6))
+ >>> print map1.get_temporal_extent_as_tuple()
+ (datetime.datetime(2000, 5, 5, 0, 0), datetime.datetime(2005, 6, 6, 0, 0))
+ >>> map2 = tgis.RasterDataset("B at P")
+ >>> check = map2.set_absolute_time(datetime.datetime(1990,1,1), datetime.datetime(1999,8,1))
+ >>> print map2.get_temporal_extent_as_tuple()
+ (datetime.datetime(1990, 1, 1, 0, 0), datetime.datetime(1999, 8, 1, 0, 0))
+ >>> map2.set_temporal_extent(map1.get_temporal_extent())
+ >>> print map2.get_temporal_extent_as_tuple()
+ (datetime.datetime(2000, 5, 5, 0, 0), datetime.datetime(2005, 6, 6, 0, 0))
- @endcode
"""
if issubclass(type(extent), RelativeTemporalExtent):
start = extent.get_start_time()
@@ -559,80 +556,79 @@
self.set_absolute_time(start, end)
def temporal_buffer(self, increment, update=False, dbif=None):
- """!Create a temporal buffer based on an increment
+ """Create a temporal buffer based on an increment
For absolute time the increment must be a string of type "integer
unit"
Unit can be year, years, month, months, day, days, hour, hours,
minute, minutes, day or days.
- @param increment This is the increment, a string in case of absolute
- time or an integer in case of relative time
- @param update Perform an immediate database update to store the
- modified temporal extent, otherwise only this object
- will be modified
+ :param increment: This is the increment, a string in case of absolute
+ time or an integer in case of relative time
+ :param update: Perform an immediate database update to store the
+ modified temporal extent, otherwise only this object
+ will be modified
Usage:
- @code
+ .. code-block: : python
- >>> import grass.temporal as tgis
- >>> maps = []
- >>> for i in range(5):
- ... map = tgis.RasterDataset(None)
- ... if i%2 == 0:
- ... check = map.set_relative_time(i, i + 1, 'years')
- ... else:
- ... check = map.set_relative_time(i, None, 'years')
- ... map.temporal_buffer(3)
- ... maps.append(map)
- >>> for map in maps:
- ... map.temporal_extent.print_info()
- +-------------------- Relative time -----------------------------------------+
- | Start time:................. -3
- | End time:................... 4
- | Relative time unit:......... years
- +-------------------- Relative time -----------------------------------------+
- | Start time:................. -2
- | End time:................... 4
- | Relative time unit:......... years
- +-------------------- Relative time -----------------------------------------+
- | Start time:................. -1
- | End time:................... 6
- | Relative time unit:......... years
- +-------------------- Relative time -----------------------------------------+
- | Start time:................. 0
- | End time:................... 6
- | Relative time unit:......... years
- +-------------------- Relative time -----------------------------------------+
- | Start time:................. 1
- | End time:................... 8
- | Relative time unit:......... years
- >>> maps = []
- >>> for i in range(1,5):
- ... map = tgis.RasterDataset(None)
- ... if i%2 == 0:
- ... check = map.set_absolute_time(datetime(2001,i,1), datetime(2001, i + 1, 1))
- ... else:
- ... check = map.set_absolute_time(datetime(2001,i,1), None)
- ... map.temporal_buffer("7 days")
- ... maps.append(map)
- >>> for map in maps:
- ... map.temporal_extent.print_info()
- +-------------------- Absolute time -----------------------------------------+
- | Start time:................. 2000-12-25 00:00:00
- | End time:................... 2001-01-08 00:00:00
- +-------------------- Absolute time -----------------------------------------+
- | Start time:................. 2001-01-25 00:00:00
- | End time:................... 2001-03-08 00:00:00
- +-------------------- Absolute time -----------------------------------------+
- | Start time:................. 2001-02-22 00:00:00
- | End time:................... 2001-03-08 00:00:00
- +-------------------- Absolute time -----------------------------------------+
- | Start time:................. 2001-03-25 00:00:00
- | End time:................... 2001-05-08 00:00:00
+ >>> import grass.temporal as tgis
+ >>> maps = []
+ >>> for i in range(5):
+ ... map = tgis.RasterDataset(None)
+ ... if i%2 == 0:
+ ... check = map.set_relative_time(i, i + 1, 'years')
+ ... else:
+ ... check = map.set_relative_time(i, None, 'years')
+ ... map.temporal_buffer(3)
+ ... maps.append(map)
+ >>> for map in maps:
+ ... map.temporal_extent.print_info()
+ +-------------------- Relative time -----------------------------------------+
+ | Start time:................. -3
+ | End time:................... 4
+ | Relative time unit:......... years
+ +-------------------- Relative time -----------------------------------------+
+ | Start time:................. -2
+ | End time:................... 4
+ | Relative time unit:......... years
+ +-------------------- Relative time -----------------------------------------+
+ | Start time:................. -1
+ | End time:................... 6
+ | Relative time unit:......... years
+ +-------------------- Relative time -----------------------------------------+
+ | Start time:................. 0
+ | End time:................... 6
+ | Relative time unit:......... years
+ +-------------------- Relative time -----------------------------------------+
+ | Start time:................. 1
+ | End time:................... 8
+ | Relative time unit:......... years
+ >>> maps = []
+ >>> for i in range(1,5):
+ ... map = tgis.RasterDataset(None)
+ ... if i%2 == 0:
+ ... check = map.set_absolute_time(datetime(2001,i,1), datetime(2001, i + 1, 1))
+ ... else:
+ ... check = map.set_absolute_time(datetime(2001,i,1), None)
+ ... map.temporal_buffer("7 days")
+ ... maps.append(map)
+ >>> for map in maps:
+ ... map.temporal_extent.print_info()
+ +-------------------- Absolute time -----------------------------------------+
+ | Start time:................. 2000-12-25 00:00:00
+ | End time:................... 2001-01-08 00:00:00
+ +-------------------- Absolute time -----------------------------------------+
+ | Start time:................. 2001-01-25 00:00:00
+ | End time:................... 2001-03-08 00:00:00
+ +-------------------- Absolute time -----------------------------------------+
+ | Start time:................. 2001-02-22 00:00:00
+ | End time:................... 2001-03-08 00:00:00
+ +-------------------- Absolute time -----------------------------------------+
+ | Start time:................. 2001-03-25 00:00:00
+ | End time:................... 2001-05-08 00:00:00
- @endcode
"""
if self.is_time_absolute():
@@ -662,59 +658,58 @@
self.set_relative_time(new_start, new_end, unit)
def set_spatial_extent_from_values(self, north, south, east, west, top=0, bottom=0):
- """!Set the spatial extent of the map from values
+ """Set the spatial extent of the map from values
This method only modifies this object and does not commit
the modifications to the temporal database.
- @param north The northern edge
- @param south The southern edge
- @param east The eastern edge
- @param west The western edge
- @param top The top edge
- @param bottom The bottom edge
+ :param north: The northern edge
+ :param south: The southern edge
+ :param east: The eastern edge
+ :param west: The western edge
+ :param top: The top edge
+ :param bottom: The bottom edge
"""
self.spatial_extent.set_spatial_extent_from_values(
north, south, east, west, top, bottom)
def set_spatial_extent(self, spatial_extent):
- """!Set the spatial extent of the map
+ """Set the spatial extent of the map
This method only modifies this object and does not commit
the modifications to the temporal database.
- @param spatial_extent An object of type SpatialExtent or its subclasses
+ :param spatial_extent: An object of type SpatialExtent or its subclasses
- @code
- >>> import datetime
- >>> import grass.temporal as tgis
- >>> map = tgis.RasterDataset(None)
- >>> spat_ext = tgis.SpatialExtent(north=10, south=-10, east=20, west=-20, top=5, bottom=-5)
- >>> map.set_spatial_extent(spat_ext)
- >>> print map.get_spatial_extent_as_tuple()
- (10.0, -10.0, 20.0, -20.0, 5.0, -5.0)
+ .. code-block: : python
- @endcode
+ >>> import datetime
+ >>> import grass.temporal as tgis
+ >>> map = tgis.RasterDataset(None)
+ >>> spat_ext = tgis.SpatialExtent(north=10, south=-10, east=20, west=-20, top=5, bottom=-5)
+ >>> map.set_spatial_extent(spat_ext)
+ >>> print map.get_spatial_extent_as_tuple()
+ (10.0, -10.0, 20.0, -20.0, 5.0, -5.0)
+
"""
self.spatial_extent.set_spatial_extent(spatial_extent)
def spatial_buffer(self, size, update=False, dbif=None):
- """!Buffer the spatial extent by a given size in all
+ """Buffer the spatial extent by a given size in all
spatial directions.
- @param size The buffer size, using the unit of the grass region
+ :param size: The buffer size, using the unit of the grass region
- @code
+ .. code-block: : python
- >>> import grass.temporal as tgis
- >>> map = tgis.RasterDataset(None)
- >>> spat_ext = tgis.SpatialExtent(north=10, south=-10, east=20, west=-20, top=5, bottom=-5)
- >>> map.set_spatial_extent(spat_ext)
- >>> map.spatial_buffer(10)
- >>> print map.get_spatial_extent_as_tuple()
- (20.0, -20.0, 30.0, -30.0, 15.0, -15.0)
+ >>> import grass.temporal as tgis
+ >>> map = tgis.RasterDataset(None)
+ >>> spat_ext = tgis.SpatialExtent(north=10, south=-10, east=20, west=-20, top=5, bottom=-5)
+ >>> map.set_spatial_extent(spat_ext)
+ >>> map.spatial_buffer(10)
+ >>> print map.get_spatial_extent_as_tuple()
+ (20.0, -20.0, 30.0, -30.0, 15.0, -15.0)
- @endcode
"""
self.spatial_extent.north += size
self.spatial_extent.south -= size
@@ -727,22 +722,21 @@
self.spatial_extent.update(dbif)
def spatial_buffer_2d(self, size, update=False, dbif=None):
- """!Buffer the spatial extent by a given size in 2d
+ """Buffer the spatial extent by a given size in 2d
spatial directions.
- @param size The buffer size, using the unit of the grass region
+ :param size: The buffer size, using the unit of the grass region
- @code
+ .. code-block: : python
- >>> import grass.temporal as tgis
- >>> map = tgis.RasterDataset(None)
- >>> spat_ext = tgis.SpatialExtent(north=10, south=-10, east=20, west=-20, top=5, bottom=-5)
- >>> map.set_spatial_extent(spat_ext)
- >>> map.spatial_buffer_2d(10)
- >>> print map.get_spatial_extent_as_tuple()
- (20.0, -20.0, 30.0, -30.0, 5.0, -5.0)
+ >>> import grass.temporal as tgis
+ >>> map = tgis.RasterDataset(None)
+ >>> spat_ext = tgis.SpatialExtent(north=10, south=-10, east=20, west=-20, top=5, bottom=-5)
+ >>> map.set_spatial_extent(spat_ext)
+ >>> map.spatial_buffer_2d(10)
+ >>> print map.get_spatial_extent_as_tuple()
+ (20.0, -20.0, 30.0, -30.0, 5.0, -5.0)
- @endcode
"""
self.spatial_extent.north += size
self.spatial_extent.south -= size
@@ -753,7 +747,7 @@
self.spatial_extent.update(dbif)
def check_for_correct_time(self):
- """!Check for correct time"""
+ """Check for correct time"""
if self.is_time_absolute():
start, end= self.get_absolute_time()
else:
@@ -781,24 +775,25 @@
return True
def delete(self, dbif=None, update=True, execute=True):
- """!Delete a map entry from database if it exists
+ """Delete a map entry from database if it exists
Remove dependent entries:
- * Remove the map entry in each space time dataset in which this map
+
+ - Remove the map entry in each space time dataset in which this map
is registered
- * Remove the space time dataset register table
+ - Remove the space time dataset register table
- @param dbif The database interface to be used
- @param update Call for each unregister statement the update from
- registered maps of the space time dataset.
- This can slow down the un-registration process
- significantly.
- @param execute If True the SQL DELETE and DROP table statements will
- be executed.
- If False the prepared SQL statements are
- returned and must be executed by the caller.
+ :param dbif: The database interface to be used
+ :param update: Call for each unregister statement the update from
+ registered maps of the space time dataset.
+ This can slow down the un-registration process
+ significantly.
+ :param execute: If True the SQL DELETE and DROP table statements will
+ be executed.
+ If False the prepared SQL statements are
+ returned and must be executed by the caller.
- @return The SQL statements if execute=False, else an empty string,
+ :return: The SQL statements if execute=False, else an empty string,
None in case of a failure
"""
if get_enable_mapset_check() is True and self.get_mapset() != get_current_mapset():
@@ -840,19 +835,19 @@
return statement
def unregister(self, dbif=None, update=True, execute=True):
- """! Remove the map entry in each space time dataset in which this map
+ """ Remove the map entry in each space time dataset in which this map
is registered
- @param dbif The database interface to be used
- @param update Call for each unregister statement the update from
- registered maps of the space time dataset. This can
- slow down the un-registration process significantly.
- @param execute If True the SQL DELETE and DROP table statements
- will be executed.
- If False the prepared SQL statements are
- returned and must be executed by the caller.
+ :param dbif: The database interface to be used
+ :param update: Call for each unregister statement the update from
+ registered maps of the space time dataset. This can
+ slow down the un-registration process significantly.
+ :param execute: If True the SQL DELETE and DROP table statements
+ will be executed.
+ If False the prepared SQL statements are
+ returned and must be executed by the caller.
- @return The SQL statements if execute=False, else an empty string
+ :return: The SQL statements if execute=False, else an empty string
"""
@@ -900,13 +895,13 @@
return statement
def get_registered_stds(self, dbif=None):
- """!Return all space time dataset ids in which this map is registered
+ """Return all space time dataset ids in which this map is registered
as as a list of strings, or None if this map is not
registered in any space time dataset.
- @param dbif The database interface to be used
- @return A list of ids of all space time datasets in
- which this map is registered
+ :param dbif: The database interface to be used
+ :return: A list of ids of all space time datasets in
+ which this map is registered
"""
dbif, connected = init_dbif(dbif)
@@ -924,16 +919,16 @@
return datasets
def add_stds_to_register(self, stds_id, dbif=None, execute=True):
- """!Add a new space time dataset to the register
+ """Add a new space time dataset to the register
- @param stds_id The id of the space time dataset to be registered
- @param dbif The database interface to be used
- @param execute If True the SQL INSERT table statements
- will be executed.
- If False the prepared SQL statements are
- returned and must be executed by the caller.
+ :param stds_id: The id of the space time dataset to be registered
+ :param dbif: The database interface to be used
+ :param execute: If True the SQL INSERT table statements
+ will be executed.
+ If False the prepared SQL statements are
+ returned and must be executed by the caller.
- @return The SQL statements if execute=False, else an empty string
+ :return: The SQL statements if execute=False, else an empty string
"""
dbif, connected = init_dbif(dbif=dbif)
@@ -970,16 +965,16 @@
def remove_stds_from_register(self, stds_id, dbif=None, execute=True):
- """!Remove a space time dataset from the register
+ """Remove a space time dataset from the register
- @param stds_id The id of the space time dataset to removed from the registered
- @param dbif The database interface to be used
- @param execute If True the SQL INSERT table statements
- will be executed.
- If False the prepared SQL statements are
- returned and must be executed by the caller.
+ :param stds_id: The id of the space time dataset to removed from the registered
+ :param dbif: The database interface to be used
+ :param execute: If True the SQL INSERT table statements
+ will be executed.
+ If False the prepared SQL statements are
+ returned and must be executed by the caller.
- @return The SQL statements if execute=False, else an empty string
+ :return: The SQL statements if execute=False, else an empty string
"""
dbif, connected = init_dbif(dbif)
Modified: grass/trunk/lib/python/temporal/abstract_space_time_dataset.py
===================================================================
--- grass/trunk/lib/python/temporal/abstract_space_time_dataset.py 2014-09-28 01:40:32 UTC (rev 62120)
+++ grass/trunk/lib/python/temporal/abstract_space_time_dataset.py 2014-09-28 01:46:15 UTC (rev 62121)
@@ -1,17 +1,14 @@
# -*- coding: utf-8 -*-
-"""!@package grass.temporal
+"""
+The abstract_space_time_dataset module provides the AbstractSpaceTimeDataset class
+that is the base class for all space time datasets.
- at brief GRASS Python scripting module (temporal GIS functions)
-
-Temporal GIS related functions to be used in temporal GIS Python
-library package.
-
(C) 2011-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.
- at author Soeren Gebbert
+:authors: Soeren Gebbert
"""
import sys
import uuid
@@ -22,9 +19,11 @@
###############################################################################
class AbstractSpaceTimeDataset(AbstractDataset):
- """!Abstract space time dataset class
+ """Abstract space time dataset class
- This class represents a space time dataset. Convenient functions
+ Base class for all space time datasets.
+
+ This class represents an abstract space time dataset. Convenient functions
to select, update, insert or delete objects of this type in the SQL
temporal database exists as well as functions to register or unregister
raster maps.
@@ -42,7 +41,7 @@
self.map_counter = 0
def create_map_register_name(self):
- """!Create the name of the map register table of this space time
+ """Create the name of the map register table of this space time
dataset
A uuid and the map type are used to create the table name
@@ -50,7 +49,7 @@
ATTENTION: It must be assured that the base object has selected its
content from the database.
- @return The name of the map register table
+ :return: The name of the map register table
"""
uuid_rand = str(uuid.uuid4()).replace("-", "")
@@ -60,21 +59,21 @@
@abstractmethod
def get_new_map_instance(self, ident=None):
- """!Return a new instance of a map which is associated
+ """Return a new instance of a map which is associated
with the type of this object
- @param ident The unique identifier of the new object
+ :param ident: The unique identifier of the new object
"""
@abstractmethod
def get_map_register(self):
- """!Return the name of the map register table
- @return The map register table name
+ """Return the name of the map register table
+ :return: The map register table name
"""
@abstractmethod
def set_map_register(self, name):
- """!Set the name of the map register table
+ """Set the name of the map register table
This table stores all map names which are registered
in this space time dataset.
@@ -82,18 +81,18 @@
This method only modifies this object and does not commit
the modifications to the temporal database.
- @param name The name of the register table
+ :param name: The name of the register table
"""
def print_self(self):
- """!Print the content of the internal structure to stdout"""
+ """Print the content of the internal structure to stdout"""
self.base.print_self()
self.temporal_extent.print_self()
self.spatial_extent.print_self()
self.metadata.print_self()
def print_info(self):
- """!Print information about this class in human readable style"""
+ """Print information about this class in human readable style"""
if self.get_type() == "strds":
# 1 2 3 4 5 6 7
@@ -115,21 +114,21 @@
print " +----------------------------------------------------------------------------+"
def print_shell_info(self):
- """!Print information about this class in shell style"""
+ """Print information about this class in shell style"""
self.base.print_shell_info()
self.temporal_extent.print_shell_info()
self.spatial_extent.print_shell_info()
self.metadata.print_shell_info()
def print_history(self):
- """!Print history information about this class in human readable
+ """Print history information about this class in human readable
shell style
"""
self.metadata.print_history()
def set_initial_values(self, temporal_type, semantic_type=None,
title=None, description=None):
- """!Set the initial values of the space time dataset
+ """Set the initial values of the space time dataset
In addition the command creation string is generated
an inserted into the metadata object.
@@ -140,11 +139,11 @@
The insert() function must be called to commit
this content into the temporal database.
- @param temporal_type The temporal type of this space
+ :param temporal_type: The temporal type of this space
time dataset (absolute or relative)
- @param semantic_type The semantic type of this dataset
- @param title The title
- @param description The description of this dataset
+ :param semantic_type: The semantic type of this dataset
+ :param title: The title
+ :param description: The description of this dataset
"""
if temporal_type == "absolute":
@@ -160,16 +159,17 @@
self.metadata.set_command(self.create_command_string())
def set_aggregation_type(self, aggregation_type):
- """!Set the aggregation type of the space time dataset
+ """Set the aggregation type of the space time dataset
- @param aggregation_type The aggregation type of the space time dataset
+ :param aggregation_type The aggregation type of the space time dataset
"""
self.metadata.set_aggregation_type(aggregation_type)
def update_command_string(self, dbif=None):
- """!Append the current command string to any existing command string
+ """Append the current command string to any existing command string
in the metadata class and calls metadata update
- @param dbif The database interface to be used
+
+ :param dbif: The database interface to be used
"""
self.metadata.select(dbif=dbif)
@@ -181,12 +181,12 @@
self.metadata.update(dbif=dbif)
def create_command_string(self):
- """!Create the command string that was used to create this
+ """Create the command string that was used to create this
space time dataset.
The command string should be set with self.metadata.set_command()
- @return The command string
+ :return: The command string
"""
# The grass module
@@ -227,13 +227,13 @@
return str(command)
def get_semantic_type(self):
- """!Return the semantic type of this dataset
- @return The semantic type
+ """Return the semantic type of this dataset
+ :return: The semantic type
"""
return self.base.get_semantic_type()
def get_initial_values(self):
- """!Return the initial values: temporal_type,
+ """Return the initial values: temporal_type,
semantic_type, title, description"""
temporal_type = self.get_temporal_type()
@@ -244,35 +244,33 @@
return temporal_type, semantic_type, title, description
def get_granularity(self):
- """!Return the granularity of the space time dataset
+ """Return the granularity of the space time dataset
Granularity can be of absolute time or relative time.
In case of absolute time a string containing an integer
- value and the time unit (years, months, days, hours, minuts,
- seconds).
+ value and the time unit (years, months, days, hours, minuts, seconds).
In case of relative time an integer value is expected.
- @return The granularity
+ :return: The granularity
"""
return self.temporal_extent.get_granularity()
def set_granularity(self, granularity):
- """!Set the granularity
+ """Set the granularity
The granularity is usually computed by the space time dataset at
runtime.
Granularity can be of absolute time or relative time.
In case of absolute time a string containing an integer
- value and the time unit (years, months, days, hours, minuts,
- seconds).
+ value and the time unit (years, months, days, hours, minuts, seconds).
In case of relative time an integer value is expected.
This method only modifies this object and does not commit
the modifications to the temporal database.
- @param granularity The granularity of the dataset
+ :param granularity: The granularity of the dataset
"""
temporal_type = self.get_temporal_type()
@@ -291,7 +289,7 @@
self.temporal_extent.set_granularity(granularity)
def set_relative_time_unit(self, unit):
- """!Set the relative time unit which may be of type:
+ """Set the relative time unit which may be of type:
years, months, days, hours, minutes or seconds
All maps registered in a (relative time)
@@ -300,7 +298,7 @@
This method only modifies this object and does not commit
the modifications to the temporal database.
- @param unit The relative time unit
+ :param unit: The relative time unit
"""
temporal_type = self.get_temporal_type()
@@ -311,18 +309,18 @@
self.relative_time.set_unit(unit)
def insert(self, dbif=None, execute=True):
- """!Insert the space time dataset content into the database from the internal
+ """Insert the space time dataset content into the database from the internal
structure
The map register table will be created, so that maps
can be registered.
- @param dbif The database interface to be used
- @param execute If True the SQL statements will be executed.
+ :param dbif: The database interface to be used
+ :param execute: If True the SQL statements will be executed.
If False the prepared SQL statements are
returned and must be executed by the caller.
- @return The SQL insert statement in case execute=False, or an
- empty string otherwise
+ :return: The SQL insert statement in case execute=False, or an
+ empty string otherwise
"""
dbif, connected = init_dbif(dbif)
@@ -372,13 +370,13 @@
return statement
def get_map_time(self):
- """!Return the type of the map time, interval, point, mixed or invalid
+ """Return the type of the map time, interval, point, mixed or invalid
"""
return self.temporal_extent.get_map_time()
def count_temporal_types(self, maps=None, dbif=None):
- """!Return the temporal type of the registered maps as dictionary
+ """Return the temporal type of the registered maps as dictionary
The map list must be ordered by start time
@@ -388,8 +386,8 @@
- interval -> start and end time
- invalid -> No valid time point or interval found
- @param maps A sorted (start_time) list of AbstractDataset objects
- @param dbif The database interface to be used
+ :param maps: A sorted (start_time) list of AbstractDataset objects
+ :param dbif: The database interface to be used
"""
if maps is None:
@@ -422,11 +420,11 @@
return tcount
def count_gaps(self, maps=None, dbif=None):
- """!Count the number of gaps between temporal neighbors
+ """Count the number of gaps between temporal neighbors
- @param maps A sorted (start_time) list of AbstractDataset objects
- @param dbif The database interface to be used
- @return The numbers of gaps between temporal neighbors
+ :param maps: A sorted (start_time) list of AbstractDataset objects
+ :param dbif: The database interface to be used
+ :return: The numbers of gaps between temporal neighbors
"""
if maps is None:
@@ -446,16 +444,16 @@
def print_spatio_temporal_relationships(self, maps=None, spatial=None,
dbif=None):
- """!Print the spatio-temporal relationships for each map of the space
+ """Print the spatio-temporal relationships for each map of the space
time dataset or for each map of the optional list of maps
- @param maps a ordered by start_time list of map objects, if None the
+ :param maps: a ordered by start_time list of map objects, if None the
registred maps of the space time dataset are used
- @param spatial This indicates if the spatial topology is created as
+ :param spatial: This indicates if the spatial topology is created as
well: spatial can be None (no spatial topology), "2D"
using west, east, south, north or "3D" using west,
east, south, north, bottom, top
- @param dbif The database interface to be used
+ :param dbif: The database interface to be used
"""
if maps is None:
@@ -466,15 +464,15 @@
spatial=spatial, dbif=dbif)
def count_temporal_relations(self, maps=None, dbif=None):
- """!Count the temporal relations between the registered maps.
+ """Count the temporal relations between the registered maps.
The map list must be ordered by start time.
Temporal relations are counted by analysing the sparse upper right
side temporal relationships matrix.
- @param maps A sorted (start_time) list of AbstractDataset objects
- @param dbif The database interface to be used
- @return A dictionary with counted temporal relationships
+ :param maps: A sorted (start_time) list of AbstractDataset objects
+ :param dbif: The database interface to be used
+ :return: A dictionary with counted temporal relationships
"""
if maps is None:
@@ -484,7 +482,7 @@
return count_temporal_topology_relationships(maps1=maps, dbif=dbif)
def check_temporal_topology(self, maps=None, dbif=None):
- """!Check the temporal topology of all maps of the current space time
+ """Check the temporal topology of all maps of the current space time
dataset or of an optional list of maps
Correct topology means, that time intervals are not overlap or
@@ -494,7 +492,7 @@
The optional map list must be ordered by start time
Allowed and not allowed temporal relationships for correct topology:
- @verbatim
+
- after -> allowed
- precedes -> allowed
- follows -> allowed
@@ -509,12 +507,12 @@
- finishes -> not allowed
- started -> not allowed
- finished -> not allowed
- @endverbatim
- @param maps An optional list of AbstractDataset objects, in case of
+
+ :param maps: An optional list of AbstractDataset objects, in case of
None all maps of the space time dataset are checked
- @param dbif The database interface to be used
- @return True if topology is correct
+ :param dbif: The database interface to be used
+ :return: True if topology is correct
"""
if maps is None:
maps = self.get_registered_maps_as_objects(
@@ -555,7 +553,7 @@
return True
def sample_by_dataset(self, stds, method=None, spatial=False, dbif=None):
- """!Sample this space time dataset with the temporal topology
+ """Sample this space time dataset with the temporal topology
of a second space time dataset
In case spatial is True, the spatial overlap between
@@ -571,17 +569,18 @@
map and its temporal extent (the actual granule) and
the list of samples are stored:
- @code
- list = self.sample_by_dataset(stds=sampler, method=[
- "during","overlap","contains","equal"])
- for entry in list:
- granule = entry["granule"]
- maplist = entry["samples"]
- for map in maplist:
- map.select()
- map.print_info()
- @endcode
+ .. code-block:: python
+ list = self.sample_by_dataset(stds=sampler, method=[
+ "during","overlap","contains","equal"])
+ for entry in list:
+ granule = entry["granule"]
+ maplist = entry["samples"]
+ for map in maplist:
+ map.select()
+ map.print_info()
+
+
A valid temporal topology (no overlapping or inclusion allowed)
is needed to get correct results in case of gaps in the sample
dataset.
@@ -594,83 +593,76 @@
In case more map information are needed, use the select()
method for each listed object.
- @param stds The space time dataset to be used for temporal sampling
- @param method This option specifies what sample method should be
+ :param stds: The space time dataset to be used for temporal sampling
+ :param method: This option specifies what sample method should be
used. In case the registered maps are of temporal
point type, only the start time is used for sampling.
In case of mixed of interval data the user can chose
between:
- - Example @code ["start", "during", "equals"] @endcode
+ - Example ["start", "during", "equals"]
- start: Select maps of which the start time is
- located in the selection granule
- @verbatim
- map : s
- granule: s-----------------e
+ located in the selection granule::
+
+ map : s
+ granule: s-----------------e
- map : s--------------------e
- granule: s-----------------e
+ map : s--------------------e
+ granule: s-----------------e
- map : s--------e
- granule: s-----------------e
- @endverbatim
+ map : s--------e
+ granule: s-----------------e
- contains: Select maps which are temporal
- during the selection granule
- @verbatim
- map : s-----------e
- granule: s-----------------e
- @endverbatim
+ during the selection granule::
+
+ map : s-----------e
+ granule: s-----------------e
- overlap: Select maps which temporal overlap
- the selection granule, this includes overlaps and overlapped
- @verbatim
- map : s-----------e
- granule: s-----------------e
+ the selection granule, this includes overlaps and overlapped::
+
+ map : s-----------e
+ granule: s-----------------e
- map : s-----------e
- granule: s----------e
- @endverbatim
+ map : s-----------e
+ granule: s----------e
- during: Select maps which temporally contains
- the selection granule
- @verbatim
- map : s-----------------e
- granule: s-----------e
- @endverbatim
+ the selection granule::
+
+ map : s-----------------e
+ granule: s-----------e
- equals: Select maps which temporally equal
- to the selection granule
- @verbatim
- map : s-----------e
- granule: s-----------e
- @endverbatim
+ to the selection granule::
+
+ map : s-----------e
+ granule: s-----------e
- follows: Select maps which temporally follow
- the selection granule
- @verbatim
- map : s-----------e
- granule: s-----------e
- @endverbatim
+ the selection granule::
+
+ map : s-----------e
+ granule: s-----------e
- precedes: Select maps which temporally precedes
- the selection granule
- @verbatim
- map : s-----------e
- granule: s-----------e
- @endverbatim
+ the selection granule::
+
+ map : s-----------e
+ granule: s-----------e
All these methods can be combined. Method must be of
type tuple including the identification strings.
- @param spatial If set True additional the 2d spatial overlapping
+ :param spatial: If set True additional the 2d spatial overlapping
is used for selection -> spatio-temporal relation.
The returned map objects will have temporal and
spatial extents
- @param dbif The database interface to be used
+ :param dbif: The database interface to be used
- @return A list of lists of map objects or None in case nothing was
+ :return: A list of lists of map objects or None in case nothing was
found None
"""
@@ -765,7 +757,7 @@
def sample_by_dataset_sql(self, stds, method=None, spatial=False, dbif=None):
- """!Sample this space time dataset with the temporal topology
+ """Sample this space time dataset with the temporal topology
of a second space time dataset using SQL queries.
This function is very slow for huge large space time datasets
@@ -787,17 +779,18 @@
map and its temporal extent (the actual granule) and
the list of samples are stored:
- @code
- list = self.sample_by_dataset(stds=sampler, method=[
- "during","overlap","contain","equal"])
- for entry in list:
- granule = entry["granule"]
- maplist = entry["samples"]
- for map in maplist:
- map.select()
- map.print_info()
- @endcode
+ .. code-block:: python
+
+ list = self.sample_by_dataset(stds=sampler, method=[
+ "during","overlap","contain","equal"])
+ for entry in list:
+ granule = entry["granule"]
+ maplist = entry["samples"]
+ for map in maplist:
+ map.select()
+ map.print_info()
+
A valid temporal topology (no overlapping or inclusion allowed)
is needed to get correct results in case of gaps in the sample
dataset.
@@ -810,82 +803,76 @@
In case more map information are needed, use the select()
method for each listed object.
- @param stds The space time dataset to be used for temporal sampling
- @param method This option specifies what sample method should be
+ :param stds: The space time dataset to be used for temporal sampling
+ :param method: This option specifies what sample method should be
used. In case the registered maps are of temporal
point type, only the start time is used for sampling.
In case of mixed of interval data the user can chose
between:
- - ["start", "during", "equals"]
+
+ - Example ["start", "during", "equals"]
- start: Select maps of which the start time is
- located in the selection granule
- @verbatim
- map : s
- granule: s-----------------e
+ located in the selection granule::
- map : s--------------------e
- granule: s-----------------e
+ map : s
+ granule: s-----------------e
- map : s--------e
- granule: s-----------------e
- @endverbatim
+ map : s--------------------e
+ granule: s-----------------e
+ map : s--------e
+ granule: s-----------------e
+
- contains: Select maps which are temporal
- during the selection granule
- @verbatim
- map : s-----------e
- granule: s-----------------e
- @endverbatim
+ during the selection granule::
+ map : s-----------e
+ granule: s-----------------e
+
- overlap: Select maps which temporal overlap
- the selection granule, this includes overlaps and overlapped
- @verbatim
- map : s-----------e
- granule: s-----------------e
+ the selection granule, this includes overlaps and overlapped::
- map : s-----------e
- granule: s----------e
- @endverbatim
+ map : s-----------e
+ granule: s-----------------e
+ map : s-----------e
+ granule: s----------e
+
- during: Select maps which temporally contains
- the selection granule
- @verbatim
- map : s-----------------e
- granule: s-----------e
- @endverbatim
+ the selection granule::
+ map : s-----------------e
+ granule: s-----------e
+
- equals: Select maps which temporally equal
- to the selection granule
- @verbatim
- map : s-----------e
- granule: s-----------e
- @endverbatim
+ to the selection granule::
+ map : s-----------e
+ granule: s-----------e
+
- follows: Select maps which temporally follow
- the selection granule
- @verbatim
- map : s-----------e
- granule: s-----------e
- @endverbatim
+ the selection granule::
+ map : s-----------e
+ granule: s-----------e
+
- precedes: Select maps which temporally precedes
- the selection granule
- @verbatim
- map : s-----------e
- granule: s-----------e
- @endverbatim
+ the selection granule::
+ map : s-----------e
+ granule: s-----------e
+
All these methods can be combined. Method must be of
type tuple including the identification strings.
- @param spatial If set True additional the 2d spatial overlapping
+ :param spatial: If set True additional the 2d spatial overlapping
is used for selection -> spatio-temporal relation.
The returned map objects will have temporal and
spatial extents
- @param dbif The database interface to be used
+ :param dbif: The database interface to be used
- @return A list of lists of map objects or None in case nothing was
+ :return: A list of lists of map objects or None in case nothing was
found None
"""
@@ -1000,7 +987,7 @@
def get_registered_maps_as_objects_by_granularity(self, gran=None,
dbif=None):
- """!Return all registered maps as ordered (by start_time) object list
+ """Return all registered maps as ordered (by start_time) object list
with "gap" map objects (id==None) for spatio-temporal topological
operations that require the temporal extent only.
@@ -1029,7 +1016,7 @@
In case more map information are needed, use the select()
method for each listed object.
- @param gran The granularity string to be used, if None the
+ :param gran: The granularity string to be used, if None the
granularity of the space time dataset is used.
Absolute time has the format "number unit", relative
time has the format "number".
@@ -1038,9 +1025,9 @@
weeks, month, months, year, years". The unit of the
relative time granule is always the space time dataset
unit and can not be changed.
- @param dbif The database interface to be used
+ :param dbif: The database interface to be used
- @return ordered list of map lists. Each list represents a single
+ :return: ordered list of map lists. Each list represents a single
granule, or None in case nothing found
"""
@@ -1083,7 +1070,7 @@
@staticmethod
def resample_maplist_by_granularity(maps, start, end, gran):
- """!Resample a list of AbstractMapDatasets by a given granularity
+ """Resample a list of AbstractMapDatasets by a given granularity
The provided map list must be sorted by start time.
A valid temporal topology (no overlapping or inclusion allowed)
@@ -1093,6 +1080,7 @@
time are supported.
The temporal topology search order is as follows:
+
1. Maps that are equal to the actual granule are used
2. If no euqal found then maps that contain the actual granule
are used
@@ -1102,6 +1090,7 @@
5. If no overlapped maps are found then maps are used that are
durin the actual granule
+
Each entry in the resulting list is a list of
AbstractMapDatasets objects.
Hence for each granule a list of AbstractMapDatasets can be
@@ -1109,12 +1098,12 @@
Gaps between maps are identified as unregistered maps with id==None.
- @param maps An ordered list (by start time) of AbstractMapDatasets
+ :param maps: An ordered list (by start time) of AbstractMapDatasets
objects. All maps must have the same temporal type
and the same unit in case of relative time.
- @param start The start time of the provided map list
- @param end The end time of the provided map list
- @param gran The granularity string to be used, if None the
+ :param start: The start time of the provided map list
+ :param end: The end time of the provided map list
+ :param gran: The granularity string to be used, if None the
granularity of the space time dataset is used.
Absolute time has the format "number unit", relative
time has the format "number".
@@ -1124,70 +1113,69 @@
relative time granule is always the space time dataset
unit and can not be changed.
- @return ordered list of map lists. Each list represents a single
+ :return: ordered list of map lists. Each list represents a single
granule, or None in case nothing found
Usage:
- @code
+ .. code-block:: python
- >>> import grass.temporal as tgis
- >>> maps = []
- >>> for i in xrange(3):
- ... map = tgis.RasterDataset("map%i at PERMANENT"%i)
- ... check = map.set_relative_time(i + 2, i + 3, "days")
- ... maps.append(map)
- >>> grans = tgis.AbstractSpaceTimeDataset.resample_maplist_by_granularity(maps,0,8,1)
- >>> for map_list in grans:
- ... print map_list[0].get_id(), map_list[0].get_temporal_extent_as_tuple()
- None (0, 1)
- None (1, 2)
- map0 at PERMANENT (2, 3)
- map1 at PERMANENT (3, 4)
- map2 at PERMANENT (4, 5)
- None (5, 6)
- None (6, 7)
- None (7, 8)
+ >>> import grass.temporal as tgis
+ >>> maps = []
+ >>> for i in xrange(3):
+ ... map = tgis.RasterDataset("map%i at PERMANENT"%i)
+ ... check = map.set_relative_time(i + 2, i + 3, "days")
+ ... maps.append(map)
+ >>> grans = tgis.AbstractSpaceTimeDataset.resample_maplist_by_granularity(maps,0,8,1)
+ >>> for map_list in grans:
+ ... print map_list[0].get_id(), map_list[0].get_temporal_extent_as_tuple()
+ None (0, 1)
+ None (1, 2)
+ map0 at PERMANENT (2, 3)
+ map1 at PERMANENT (3, 4)
+ map2 at PERMANENT (4, 5)
+ None (5, 6)
+ None (6, 7)
+ None (7, 8)
- >>> maps = []
- >>> map1 = tgis.RasterDataset("map1 at PERMANENT")
- >>> check = map1.set_relative_time(2, 6, "days")
- >>> maps.append(map1)
- >>> map2 = tgis.RasterDataset("map2 at PERMANENT")
- >>> check = map2.set_relative_time(7, 13, "days")
- >>> maps.append(map2)
- >>> grans = tgis.AbstractSpaceTimeDataset.resample_maplist_by_granularity(maps,0,16,2)
- >>> for map_list in grans:
- ... print map_list[0].get_id(), map_list[0].get_temporal_extent_as_tuple()
- None (0, 2)
- map1 at PERMANENT (2, 4)
- map1 at PERMANENT (4, 6)
- map2 at PERMANENT (6, 8)
- map2 at PERMANENT (8, 10)
- map2 at PERMANENT (10, 12)
- map2 at PERMANENT (12, 14)
- None (14, 16)
+ >>> maps = []
+ >>> map1 = tgis.RasterDataset("map1 at PERMANENT")
+ >>> check = map1.set_relative_time(2, 6, "days")
+ >>> maps.append(map1)
+ >>> map2 = tgis.RasterDataset("map2 at PERMANENT")
+ >>> check = map2.set_relative_time(7, 13, "days")
+ >>> maps.append(map2)
+ >>> grans = tgis.AbstractSpaceTimeDataset.resample_maplist_by_granularity(maps,0,16,2)
+ >>> for map_list in grans:
+ ... print map_list[0].get_id(), map_list[0].get_temporal_extent_as_tuple()
+ None (0, 2)
+ map1 at PERMANENT (2, 4)
+ map1 at PERMANENT (4, 6)
+ map2 at PERMANENT (6, 8)
+ map2 at PERMANENT (8, 10)
+ map2 at PERMANENT (10, 12)
+ map2 at PERMANENT (12, 14)
+ None (14, 16)
- >>> maps = []
- >>> map1 = tgis.RasterDataset("map1 at PERMANENT")
- >>> check = map1.set_relative_time(2, None, "days")
- >>> maps.append(map1)
- >>> map2 = tgis.RasterDataset("map2 at PERMANENT")
- >>> check = map2.set_relative_time(7, None, "days")
- >>> maps.append(map2)
- >>> grans = tgis.AbstractSpaceTimeDataset.resample_maplist_by_granularity(maps,0,16,2)
- >>> for map_list in grans:
- ... print map_list[0].get_id(), map_list[0].get_temporal_extent_as_tuple()
- None (0, 2)
- map1 at PERMANENT (2, 4)
- None (4, 6)
- map2 at PERMANENT (6, 8)
- None (8, 10)
- None (10, 12)
- None (12, 14)
- None (14, 16)
+ >>> maps = []
+ >>> map1 = tgis.RasterDataset("map1 at PERMANENT")
+ >>> check = map1.set_relative_time(2, None, "days")
+ >>> maps.append(map1)
+ >>> map2 = tgis.RasterDataset("map2 at PERMANENT")
+ >>> check = map2.set_relative_time(7, None, "days")
+ >>> maps.append(map2)
+ >>> grans = tgis.AbstractSpaceTimeDataset.resample_maplist_by_granularity(maps,0,16,2)
+ >>> for map_list in grans:
+ ... print map_list[0].get_id(), map_list[0].get_temporal_extent_as_tuple()
+ None (0, 2)
+ map1 at PERMANENT (2, 4)
+ None (4, 6)
+ map2 at PERMANENT (6, 8)
+ None (8, 10)
+ None (10, 12)
+ None (12, 14)
+ None (14, 16)
- @endcode
"""
if not maps:
@@ -1250,7 +1238,7 @@
return None
def get_registered_maps_as_objects_with_gaps(self, where=None, dbif=None):
- """!Return all or a subset of the registered maps as
+ """Return all or a subset of the registered maps as
ordered (by start_time) object list with
"gap" map objects (id==None) for spatio-temporal topological
operations that require the spatio-temporal extent only.
@@ -1263,11 +1251,11 @@
In case more map information are needed, use the select()
method for each listed object.
- @param where The SQL where statement to select a
+ :param where: The SQL where statement to select a
subset of the registered maps without "WHERE"
- @param dbif The database interface to be used
+ :param dbif: The database interface to be used
- @return ordered object list, in case nothing found None is returned
+ :return: ordered object list, in case nothing found None is returned
"""
dbif, connected = init_dbif(dbif)
@@ -1309,7 +1297,7 @@
def get_registered_maps_as_objects_with_temporal_topology(self, where=None,
order="start_time",
dbif=None):
- """!Return all or a subset of the registered maps as ordered object
+ """Return all or a subset of the registered maps as ordered object
list with spatio-temporal topological relationship informations.
The objects are initialized with their id's' and the spatio-temporal
@@ -1318,12 +1306,12 @@
In case more map information are needed, use the select()
method for each listed object.
- @param where The SQL where statement to select a subset of
+ :param where: The SQL where statement to select a subset of
the registered maps without "WHERE"
- @param order The SQL order statement to be used to order the
+ :param order: The SQL order statement to be used to order the
objects in the list without "ORDER BY"
- @param dbif The database interface to be used
- @return The ordered map object list,
+ :param dbif: The database interface to be used
+ :return: The ordered map object list,
In case nothing found None is returned
"""
@@ -1340,7 +1328,7 @@
def get_registered_maps_as_objects(self, where=None, order="start_time",
dbif=None):
- """!Return all or a subset of the registered maps as ordered object
+ """Return all or a subset of the registered maps as ordered object
list for spatio-temporal topological operations that require the
spatio-temporal extent only
@@ -1350,12 +1338,12 @@
In case more map information are needed, use the select()
method for each listed object.
- @param where The SQL where statement to select a subset of
+ :param where: The SQL where statement to select a subset of
the registered maps without "WHERE"
- @param order The SQL order statement to be used to order the
+ :param order: The SQL order statement to be used to order the
objects in the list without "ORDER BY"
- @param dbif The database interface to be used
- @return The ordered map object list,
+ :param dbif: The database interface to be used
+ :return: The ordered map object list,
In case nothing found None is returned
"""
@@ -1414,19 +1402,19 @@
def get_registered_maps(self, columns=None, where=None, order=None,
dbif=None):
- """!Return SQL rows of all registered maps.
+ """Return SQL rows of all registered maps.
In case columns are not specified, each row includes all columns
specified in the datatype specific view.
- @param columns Columns to be selected as SQL compliant string
- @param where The SQL where statement to select a subset
+ :param columns: Columns to be selected as SQL compliant string
+ :param where: The SQL where statement to select a subset
of the registered maps without "WHERE"
- @param order The SQL order statement to be used to order the
+ :param order: The SQL order statement to be used to order the
objects in the list without "ORDER BY"
- @param dbif The database interface to be used
+ :param dbif: The database interface to be used
- @return SQL rows of all registered maps,
+ :return: SQL rows of all registered maps,
In case nothing found None is returned
"""
@@ -1471,72 +1459,72 @@
@staticmethod
def shift_map_list(maps, gran):
- """!Temporally shift each map in the list with the provided granularity
+ """Temporally shift each map in the list with the provided granularity
This method does not perform any temporal database operations.
- @param maps A list of maps with initialized temporal extent
- @param gran The granularity to be used for shifting
- @return The modified map list, None if nothing to shift or wrong
+ :param maps: A list of maps with initialized temporal extent
+ :param gran: The granularity to be used for shifting
+ :return: The modified map list, None if nothing to shift or wrong
granularity
- @code
- >>> import grass.temporal as tgis
- >>> maps = []
- >>> for i in range(5):
- ... map = tgis.RasterDataset(None)
- ... if i%2 == 0:
- ... check = map.set_relative_time(i, i + 1, 'years')
- ... else:
- ... check = map.set_relative_time(i, None, 'years')
- ... maps.append(map)
- >>> for map in maps:
- ... map.temporal_extent.print_info()
- +-------------------- Relative time -----------------------------------------+
- | Start time:................. 0
- | End time:................... 1
- | Relative time unit:......... years
- +-------------------- Relative time -----------------------------------------+
- | Start time:................. 1
- | End time:................... None
- | Relative time unit:......... years
- +-------------------- Relative time -----------------------------------------+
- | Start time:................. 2
- | End time:................... 3
- | Relative time unit:......... years
- +-------------------- Relative time -----------------------------------------+
- | Start time:................. 3
- | End time:................... None
- | Relative time unit:......... years
- +-------------------- Relative time -----------------------------------------+
- | Start time:................. 4
- | End time:................... 5
- | Relative time unit:......... years
- >>> maps = tgis.AbstractSpaceTimeDataset.shift_map_list(maps, 5)
- >>> for map in maps:
- ... map.temporal_extent.print_info()
- +-------------------- Relative time -----------------------------------------+
- | Start time:................. 5
- | End time:................... 6
- | Relative time unit:......... years
- +-------------------- Relative time -----------------------------------------+
- | Start time:................. 6
- | End time:................... None
- | Relative time unit:......... years
- +-------------------- Relative time -----------------------------------------+
- | Start time:................. 7
- | End time:................... 8
- | Relative time unit:......... years
- +-------------------- Relative time -----------------------------------------+
- | Start time:................. 8
- | End time:................... None
- | Relative time unit:......... years
- +-------------------- Relative time -----------------------------------------+
- | Start time:................. 9
- | End time:................... 10
- | Relative time unit:......... years
+ .. code-block:: python
- @endcode
+ >>> import grass.temporal as tgis
+ >>> maps = []
+ >>> for i in range(5):
+ ... map = tgis.RasterDataset(None)
+ ... if i%2 == 0:
+ ... check = map.set_relative_time(i, i + 1, 'years')
+ ... else:
+ ... check = map.set_relative_time(i, None, 'years')
+ ... maps.append(map)
+ >>> for map in maps:
+ ... map.temporal_extent.print_info()
+ +-------------------- Relative time -----------------------------------------+
+ | Start time:................. 0
+ | End time:................... 1
+ | Relative time unit:......... years
+ +-------------------- Relative time -----------------------------------------+
+ | Start time:................. 1
+ | End time:................... None
+ | Relative time unit:......... years
+ +-------------------- Relative time -----------------------------------------+
+ | Start time:................. 2
+ | End time:................... 3
+ | Relative time unit:......... years
+ +-------------------- Relative time -----------------------------------------+
+ | Start time:................. 3
+ | End time:................... None
+ | Relative time unit:......... years
+ +-------------------- Relative time -----------------------------------------+
+ | Start time:................. 4
+ | End time:................... 5
+ | Relative time unit:......... years
+ >>> maps = tgis.AbstractSpaceTimeDataset.shift_map_list(maps, 5)
+ >>> for map in maps:
+ ... map.temporal_extent.print_info()
+ +-------------------- Relative time -----------------------------------------+
+ | Start time:................. 5
+ | End time:................... 6
+ | Relative time unit:......... years
+ +-------------------- Relative time -----------------------------------------+
+ | Start time:................. 6
+ | End time:................... None
+ | Relative time unit:......... years
+ +-------------------- Relative time -----------------------------------------+
+ | Start time:................. 7
+ | End time:................... 8
+ | Relative time unit:......... years
+ +-------------------- Relative time -----------------------------------------+
+ | Start time:................. 8
+ | End time:................... None
+ | Relative time unit:......... years
+ +-------------------- Relative time -----------------------------------------+
+ | Start time:................. 9
+ | End time:................... 10
+ | Relative time unit:......... years
+
"""
if maps is None:
return None
@@ -1561,11 +1549,11 @@
return maps
def shift(self, gran, dbif=None):
- """!Temporally shift each registered map with the provided granularity
+ """Temporally shift each registered map with the provided granularity
- @param gran The granularity to be used for shifting
- @param dbif The database interface to be used
- @return True something to shift, False if nothing to shift or wrong
+ :param gran: The granularity to be used for shifting
+ :param dbif: The database interface to be used
+ :return: True something to shift, False if nothing to shift or wrong
granularity
"""
@@ -1611,7 +1599,7 @@
@staticmethod
def snap_map_list(maps):
- """!For each map in the list snap the end time to the start time of its
+ """For each map in the list snap the end time to the start time of its
temporal nearest neighbor in the future.
Maps with equal time stamps are not snapped.
@@ -1621,70 +1609,69 @@
This method does not perform any temporal database operations.
- @param maps A list of maps with initialized temporal extent
- @return The modified map list, None nothing to shift or wrong
+ :param maps: A list of maps with initialized temporal extent
+ :return: The modified map list, None nothing to shift or wrong
granularity
Usage:
- @code
+ .. code-block:: python
- >>> import grass.temporal as tgis
- >>> maps = []
- >>> for i in range(5):
- ... map = tgis.RasterDataset(None)
- ... if i%2 == 0:
- ... check = map.set_relative_time(i, i + 1, 'years')
- ... else:
- ... check = map.set_relative_time(i, None, 'years')
- ... maps.append(map)
- >>> for map in maps:
- ... map.temporal_extent.print_info()
- +-------------------- Relative time -----------------------------------------+
- | Start time:................. 0
- | End time:................... 1
- | Relative time unit:......... years
- +-------------------- Relative time -----------------------------------------+
- | Start time:................. 1
- | End time:................... None
- | Relative time unit:......... years
- +-------------------- Relative time -----------------------------------------+
- | Start time:................. 2
- | End time:................... 3
- | Relative time unit:......... years
- +-------------------- Relative time -----------------------------------------+
- | Start time:................. 3
- | End time:................... None
- | Relative time unit:......... years
- +-------------------- Relative time -----------------------------------------+
- | Start time:................. 4
- | End time:................... 5
- | Relative time unit:......... years
- >>> maps = tgis.AbstractSpaceTimeDataset.snap_map_list(maps)
- >>> for map in maps:
- ... map.temporal_extent.print_info()
- +-------------------- Relative time -----------------------------------------+
- | Start time:................. 0
- | End time:................... 1
- | Relative time unit:......... years
- +-------------------- Relative time -----------------------------------------+
- | Start time:................. 1
- | End time:................... 2
- | Relative time unit:......... years
- +-------------------- Relative time -----------------------------------------+
- | Start time:................. 2
- | End time:................... 3
- | Relative time unit:......... years
- +-------------------- Relative time -----------------------------------------+
- | Start time:................. 3
- | End time:................... 4
- | Relative time unit:......... years
- +-------------------- Relative time -----------------------------------------+
- | Start time:................. 4
- | End time:................... 5
- | Relative time unit:......... years
+ >>> import grass.temporal as tgis
+ >>> maps = []
+ >>> for i in range(5):
+ ... map = tgis.RasterDataset(None)
+ ... if i%2 == 0:
+ ... check = map.set_relative_time(i, i + 1, 'years')
+ ... else:
+ ... check = map.set_relative_time(i, None, 'years')
+ ... maps.append(map)
+ >>> for map in maps:
+ ... map.temporal_extent.print_info()
+ +-------------------- Relative time -----------------------------------------+
+ | Start time:................. 0
+ | End time:................... 1
+ | Relative time unit:......... years
+ +-------------------- Relative time -----------------------------------------+
+ | Start time:................. 1
+ | End time:................... None
+ | Relative time unit:......... years
+ +-------------------- Relative time -----------------------------------------+
+ | Start time:................. 2
+ | End time:................... 3
+ | Relative time unit:......... years
+ +-------------------- Relative time -----------------------------------------+
+ | Start time:................. 3
+ | End time:................... None
+ | Relative time unit:......... years
+ +-------------------- Relative time -----------------------------------------+
+ | Start time:................. 4
+ | End time:................... 5
+ | Relative time unit:......... years
+ >>> maps = tgis.AbstractSpaceTimeDataset.snap_map_list(maps)
+ >>> for map in maps:
+ ... map.temporal_extent.print_info()
+ +-------------------- Relative time -----------------------------------------+
+ | Start time:................. 0
+ | End time:................... 1
+ | Relative time unit:......... years
+ +-------------------- Relative time -----------------------------------------+
+ | Start time:................. 1
+ | End time:................... 2
+ | Relative time unit:......... years
+ +-------------------- Relative time -----------------------------------------+
+ | Start time:................. 2
+ | End time:................... 3
+ | Relative time unit:......... years
+ +-------------------- Relative time -----------------------------------------+
+ | Start time:................. 3
+ | End time:................... 4
+ | Relative time unit:......... years
+ +-------------------- Relative time -----------------------------------------+
+ | Start time:................. 4
+ | End time:................... 5
+ | Relative time unit:......... years
- @endcode
"""
if maps is None or len(maps) == 0:
return None
@@ -1727,12 +1714,12 @@
return maps
def snap(self, dbif=None):
- """!For each registered map snap the end time to the start time of
+ """For each registered map snap the end time to the start time of
its temporal nearest neighbor in the future
Maps with equal time stamps are not snapped
- @param dbif The database interface to be used
+ :param dbif: The database interface to be used
"""
@@ -1780,15 +1767,15 @@
dbif.close()
def _update_map_timestamps(self, maps, date_list, dbif):
- """!Update the timestamps of maps with the start and end time
+ """Update the timestamps of maps with the start and end time
stored in the date_list.
The number of dates in the list must be equal to the number
of maps.
- @param maps A list of map objects
- @param date_list A list with date tuples (start_time, end_time)
- @param dbif The database interface to be used
+ :param maps: A list of map objects
+ :param date_list: A list with date tuples (start_time, end_time)
+ :param dbif: The database interface to be used
"""
datatsets_to_modify = {}
@@ -1825,15 +1812,15 @@
ds.update_from_registered_maps(dbif)
def rename(self, ident, dbif=None):
- """!Rename the space time dataset
+ """Rename the space time dataset
This method renames the space time dataset, the map register table
and updates the entries in registered maps stds register.
Renaming does not work with Postgresql yet.
- @param ident The new identifier "name at mapset"
- @param dbif The database interface to be used
+ :param ident: The new identifier "name at mapset"
+ :param dbif: The database interface to be used
"""
if get_enable_mapset_check() is True and self.get_mapset() != get_current_mapset():
@@ -1891,18 +1878,18 @@
dbif.close()
def delete(self, dbif=None, execute=True):
- """!Delete a space time dataset from the temporal database
+ """Delete a space time dataset from the temporal database
This method removes the space time dataset from the temporal
database and drops its map register table
- @param dbif The database interface to be used
- @param execute If True the SQL DELETE and DROP table
+ :param dbif: The database interface to be used
+ :param execute: If True the SQL DELETE and DROP table
statements will be executed.
If False the prepared SQL statements are returned
and must be executed by the caller.
- @return The SQL statements if execute == False, else an empty string
+ :return: The SQL statements if execute == False, else an empty string
"""
# First we need to check if maps are registered in this dataset and
# unregister them
@@ -1955,11 +1942,11 @@
return statement
def is_map_registered(self, map_id, dbif=None):
- """!Check if a map is registered in the space time dataset
+ """Check if a map is registered in the space time dataset
- @param map_id The map id
- @param dbif The database interface to be used
- @return True if success, False otherwise
+ :param map_id: The map id
+ :param dbif: The database interface to be used
+ :return: True if success, False otherwise
"""
stds_register_table = self.get_map_register()
@@ -1991,7 +1978,7 @@
return is_registered
def register_map(self, map, dbif=None):
- """!Register a map in the space time dataset.
+ """Register a map in the space time dataset.
This method takes care of the registration of a map
in a space time dataset.
@@ -2001,9 +1988,9 @@
This method raises a FatalError exception in case of a fatal error
- @param map The AbstractMapDataset object that should be registered
- @param dbif The database interface to be used
- @return True if success, False otherwise
+ :param map: The AbstractMapDataset object that should be registered
+ :param dbif: The database interface to be used
+ :return: True if success, False otherwise
"""
if get_enable_mapset_check() is True and self.get_mapset() != get_current_mapset():
@@ -2135,19 +2122,19 @@
return True
def unregister_map(self, map, dbif=None, execute=True):
- """!Unregister a map from the space time dataset.
+ """Unregister a map from the space time dataset.
This method takes care of the un-registration of a map
from a space time dataset.
- @param map The map object to unregister
- @param dbif The database interface to be used
- @param execute If True the SQL DELETE and DROP table
+ :param map: The map object to unregister
+ :param dbif: The database interface to be used
+ :param execute: If True the SQL DELETE and DROP table
statements will be executed.
If False the prepared SQL statements are
returned and must be executed by the caller.
- @return The SQL statements if execute == False, else an empty
+ :return: The SQL statements if execute == False, else an empty
string, None in case of a failure
"""
@@ -2205,7 +2192,7 @@
return statement
def update_from_registered_maps(self, dbif=None):
- """!This methods updates the modification time, the spatial and temporal extent as well as
+ """This methods updates the modification time, the spatial and temporal extent as well as
type specific metadata. It should always been called after maps
are registered or unregistered/deleted from the space time dataset.
@@ -2216,7 +2203,7 @@
will be used. If the end time is earlier than the maximum start
time, it will be replaced by the maximum start time.
- @param dbif The database interface to be used
+ :param dbif: The database interface to be used
"""
if get_enable_mapset_check() is True and self.get_mapset() != get_current_mapset():
Modified: grass/trunk/lib/python/temporal/aggregation.py
===================================================================
--- grass/trunk/lib/python/temporal/aggregation.py 2014-09-28 01:40:32 UTC (rev 62120)
+++ grass/trunk/lib/python/temporal/aggregation.py 2014-09-28 01:46:15 UTC (rev 62121)
@@ -1,26 +1,20 @@
-"""!@package grass.temporal
+"""
+Aggregation methods for space time raster datasets
- at brief GRASS Python scripting module (temporal GIS functions)
-
-Temporal GIS related functions to be used in Python scripts.
-
Usage:
- at code
-import grass.temporal as tgis
+.. code-block:: python
-tgis.aggregate_raster_maps(dataset, mapset, inputs, base, start, end,
- count, method, register_null, dbif)
+ import grass.temporal as tgis
-...
- at endcode
+ tgis.aggregate_raster_maps(dataset, mapset, inputs, base, start, end, count, method, register_null, dbif)
(C) 2012-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.
- at author Soeren Gebbert
+:author: Soeren Gebbert
"""
from space_time_datasets import *
@@ -30,15 +24,15 @@
def collect_map_names(sp, dbif, start, end, sampling):
- """!Gather all maps from dataset using a specific sample method
+ """Gather all maps from dataset using a specific sample method
- @param sp The space time raster dataset to select aps from
- @param dbif The temporal database interface to use
- @param start The start time of the sample interval, may be relative or
+ :param sp: The space time raster dataset to select aps from
+ :param dbif: The temporal database interface to use
+ :param start: The start time of the sample interval, may be relative or
absolute
- @param end The end time of the sample interval, may be relative or
+ :param end: The end time of the sample interval, may be relative or
absolute
- @param sampling The sampling methods to use
+ :param sampling: The sampling methods to use
"""
use_start = False
@@ -104,21 +98,21 @@
def aggregate_raster_maps(inputs, base, start, end, count, method,
register_null, dbif, offset=0):
- """!Aggregate a list of raster input maps with r.series
+ """Aggregate a list of raster input maps with r.series
- @param inputs The names of the raster maps to be aggregated
- @param base The basename of the new created raster maps
- @param start The start time of the sample interval, may be relative or
+ :param inputs: The names of the raster maps to be aggregated
+ :param base: The basename of the new created raster maps
+ :param start: The start time of the sample interval, may be relative or
absolute
- @param end The end time of the sample interval, may be relative or
+ :param end: The end time of the sample interval, may be relative or
absolute
- @param count The number to be attached to the basename of the new
+ :param count: The number to be attached to the basename of the new
created raster map
- @param method The aggreation method to be used by r.series
- @param register_null If true null maps will be registered in the space
+ :param method: The aggreation method to be used by r.series
+ :param register_null: If true null maps will be registered in the space
time raster dataset, if false not
- @param dbif The temporal database interface to use
- @param offset Offset to be added to the map counter to create the map ids
+ :param dbif: The temporal database interface to use
+ :param offset: Offset to be added to the map counter to create the map ids
"""
msgr = get_tgis_message_interface()
@@ -184,28 +178,28 @@
def aggregate_by_topology(granularity_list, granularity, map_list, topo_list, basename, time_suffix,
offset=0, method="average", nprocs=1, spatial=None, dbif=None,
overwrite=False):
- """!Aggregate a list of raster input maps with r.series
+ """Aggregate a list of raster input maps with r.series
- @param granularity_list A list of AbstractMapDataset objects.
+ :param granularity_list: A list of AbstractMapDataset objects.
The temporal extents of the objects are used
to build the spatio-temporal topology with the map list objects
- @param granularity The granularity of the granularity list
- @param map_list A list of RasterDataset objects that contain the raster
+ :param granularity: The granularity of the granularity list
+ :param map_list: A list of RasterDataset objects that contain the raster
maps that should be aggregated
- @param topo_list A list of strings of topological relations that are
+ :param topo_list: A list of strings of topological relations that are
used to select the raster maps for aggregation
- @param basename The basename of the new generated raster maps
- @param time_suffix Use the granularity truncated start time of the
+ :param basename: The basename of the new generated raster maps
+ :param time_suffix: Use the granularity truncated start time of the
actual granule to create the suffix for the basename
- @param offset Use a numerical offset for suffix generation (overwritten by time_suffix)
- @param method The aggregation method of r.series (average,min,max, ...)
- @param nprocs The number of processes used for parallel computation
- @param spatial This indicates if the spatial topology is created as well:
+ :param offset: Use a numerical offset for suffix generation (overwritten by time_suffix)
+ :param method: The aggregation method of r.series (average,min,max, ...)
+ :param nprocs: The number of processes used for parallel computation
+ :param spatial: This indicates if the spatial topology is created as well:
spatial can be None (no spatial topology), "2D" using west, east,
south, north or "3D" using west, east, south, north, bottom, top
- @param dbif The database interface to be used
- @param overwrite Overwrite existing raster maps
- @return A list of RasterDataset objects that contain the new map names and
+ :param dbif: The database interface to be used
+ :param overwrite: Overwrite existing raster maps
+ :return: A list of RasterDataset objects that contain the new map names and
the temporal extent for map registration
"""
import grass.pygrass.modules as pymod
Modified: grass/trunk/lib/python/temporal/base.py
===================================================================
--- grass/trunk/lib/python/temporal/base.py 2014-09-28 01:40:32 UTC (rev 62120)
+++ grass/trunk/lib/python/temporal/base.py 2014-09-28 01:46:15 UTC (rev 62121)
@@ -1,35 +1,28 @@
-"""!@package grass.temporal
-
- at brief GRASS Python scripting module (temporal GIS functions)
-
-Temporal GIS base classes to be used in other
-Python temporal gis packages.
-
+"""
This packages includes all base classes to store basic information
like id, name, mapset creation and modification time as well as sql
serialization and de-serialization and the sql database interface.
Usage:
- at code
+.. code-block:: python
->>> import grass.temporal as tgis
->>> tgis.init()
->>> rbase = tgis.RasterBase(ident="soil at PERMANENT")
->>> vbase = tgis.VectorBase(ident="soil:1 at PERMANENT")
->>> r3base = tgis.Raster3DBase(ident="soil at PERMANENT")
->>> strdsbase = tgis.STRDSBase(ident="soil at PERMANENT")
->>> stvdsbase = tgis.STVDSBase(ident="soil at PERMANENT")
->>> str3dsbase = tgis.STR3DSBase(ident="soil at PERMANENT")
+ >>> import grass.temporal as tgis
+ >>> tgis.init()
+ >>> rbase = tgis.RasterBase(ident="soil at PERMANENT")
+ >>> vbase = tgis.VectorBase(ident="soil:1 at PERMANENT")
+ >>> r3base = tgis.Raster3DBase(ident="soil at PERMANENT")
+ >>> strdsbase = tgis.STRDSBase(ident="soil at PERMANENT")
+ >>> stvdsbase = tgis.STVDSBase(ident="soil at PERMANENT")
+ >>> str3dsbase = tgis.STR3DSBase(ident="soil at PERMANENT")
- at endcode
(C) 2011-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.
- at author Soeren Gebbert
+:author: Soeren Gebbert
"""
from datetime import datetime, date, time, timedelta
@@ -43,36 +36,36 @@
self.dbmi_paramstyle = get_tgis_dbmi_paramstyle()
def serialize(self, type, table, where=None):
- """!Convert the internal dictionary into a string of semicolon
+ """Convert the internal dictionary into a string of semicolon
separated SQL statements The keys are the column names and
the values are the row entries
Usage:
- \code
- >>> init()
- >>> t = DictSQLSerializer()
- >>> t.D["id"] = "soil at PERMANENT"
- >>> t.D["name"] = "soil"
- >>> t.D["mapset"] = "PERMANENT"
- >>> t.D["creator"] = "soeren"
- >>> t.D["creation_time"] = datetime(2001,1,1)
- >>> t.D["modification_time"] = datetime(2001,1,1)
- >>> t.serialize(type="SELECT", table="raster_base")
- ('SELECT name , creator , creation_time , modification_time , mapset , id FROM raster_base ;\\n', ())
- >>> t.serialize(type="INSERT", table="raster_base")
- ('INSERT INTO raster_base ( name ,creator ,creation_time ,modification_time ,mapset ,id ) VALUES (? ,? ,? ,? ,? ,?) ;\\n', ('soil', 'soeren', datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2001, 1, 1, 0, 0), 'PERMANENT', 'soil at PERMANENT'))
- >>> t.serialize(type="UPDATE", table="raster_base")
- ('UPDATE raster_base SET name = ? ,creator = ? ,creation_time = ? ,modification_time = ? ,mapset = ? ,id = ? ;\\n', ('soil', 'soeren', datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2001, 1, 1, 0, 0), 'PERMANENT', 'soil at PERMANENT'))
- >>> t.serialize(type="UPDATE ALL", table="raster_base")
- ('UPDATE raster_base SET name = ? ,creator = ? ,creation_time = ? ,modification_time = ? ,mapset = ? ,id = ? ;\\n', ('soil', 'soeren', datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2001, 1, 1, 0, 0), 'PERMANENT', 'soil at PERMANENT'))
+ .. code-block:: python
+
+ >>> init()
+ >>> t = DictSQLSerializer()
+ >>> t.D["id"] = "soil at PERMANENT"
+ >>> t.D["name"] = "soil"
+ >>> t.D["mapset"] = "PERMANENT"
+ >>> t.D["creator"] = "soeren"
+ >>> t.D["creation_time"] = datetime(2001,1,1)
+ >>> t.D["modification_time"] = datetime(2001,1,1)
+ >>> t.serialize(type="SELECT", table="raster_base")
+ ('SELECT name , creator , creation_time , modification_time , mapset , id FROM raster_base ;\\n', ())
+ >>> t.serialize(type="INSERT", table="raster_base")
+ ('INSERT INTO raster_base ( name ,creator ,creation_time ,modification_time ,mapset ,id ) VALUES (? ,? ,? ,? ,? ,?) ;\\n', ('soil', 'soeren', datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2001, 1, 1, 0, 0), 'PERMANENT', 'soil at PERMANENT'))
+ >>> t.serialize(type="UPDATE", table="raster_base")
+ ('UPDATE raster_base SET name = ? ,creator = ? ,creation_time = ? ,modification_time = ? ,mapset = ? ,id = ? ;\\n', ('soil', 'soeren', datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2001, 1, 1, 0, 0), 'PERMANENT', 'soil at PERMANENT'))
+ >>> t.serialize(type="UPDATE ALL", table="raster_base")
+ ('UPDATE raster_base SET name = ? ,creator = ? ,creation_time = ? ,modification_time = ? ,mapset = ? ,id = ? ;\\n', ('soil', 'soeren', datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2001, 1, 1, 0, 0), 'PERMANENT', 'soil at PERMANENT'))
- @param type must be SELECT. INSERT, UPDATE
- @param table The name of the table to select, insert or update
- @param where The optional where statement
- @return a tuple containing the SQL string and the arguments
+ :param type: must be SELECT. INSERT, UPDATE
+ :param table: The name of the table to select, insert or update
+ :param where: The optional where statement
+ :return: a tuple containing the SQL string and the arguments
- \endcode
"""
@@ -177,33 +170,34 @@
return sql, tuple(args)
def deserialize(self, row):
- """!Convert the content of the dbmi dictionary like row into the
+ """Convert the content of the dbmi dictionary like row into the
internal dictionary
- @param row The dictionary like row to store in the internal dict
+ :param row: The dictionary like row to store in the internal dict
"""
self.D = {}
for key in row.keys():
self.D[key] = row[key]
def clear(self):
- """!Initialize the internal storage"""
+ """Initialize the internal storage"""
self.D = {}
def print_self(self):
- """!Print the content of the internal dictionary to stdout
+ """Print the content of the internal dictionary to stdout
"""
print self.D
###############################################################################
class SQLDatabaseInterface(DictSQLSerializer):
- """!This class represents the SQL database interface
+ """This class represents the SQL database interface
Functions to insert, select and update the internal
structure of this class in the temporal database are implemented.
This is the base class for raster, raster3d, vector and
space time datasets data management classes:
+
- Identification information (base)
- Spatial extent
- Temporal extent
@@ -211,43 +205,42 @@
Usage:
- \code
+ .. code-block:: python
- >>> init()
- >>> t = SQLDatabaseInterface("raster", "soil at PERMANENT")
- >>> t.mapset = get_current_mapset()
- >>> t.D["name"] = "soil"
- >>> t.D["mapset"] = "PERMANENT"
- >>> t.D["creator"] = "soeren"
- >>> t.D["creation_time"] = datetime(2001,1,1)
- >>> t.get_delete_statement()
- "DELETE FROM raster WHERE id = 'soil at PERMANENT';\\n"
- >>> t.get_is_in_db_statement()
- "SELECT id FROM raster WHERE id = 'soil at PERMANENT';\\n"
- >>> t.get_select_statement()
- ("SELECT creation_time , mapset , name , creator FROM raster WHERE id = 'soil at PERMANENT';\\n", ())
- >>> t.get_select_statement_mogrified()
- "SELECT creation_time , mapset , name , creator FROM raster WHERE id = 'soil at PERMANENT';\\n"
- >>> t.get_insert_statement()
- ('INSERT INTO raster ( creation_time ,mapset ,name ,creator ) VALUES (? ,? ,? ,?) ;\\n', (datetime.datetime(2001, 1, 1, 0, 0), 'PERMANENT', 'soil', 'soeren'))
- >>> t.get_insert_statement_mogrified()
- "INSERT INTO raster ( creation_time ,mapset ,name ,creator ) VALUES ('2001-01-01 00:00:00' ,'PERMANENT' ,'soil' ,'soeren') ;\\n"
- >>> t.get_update_statement()
- ("UPDATE raster SET creation_time = ? ,mapset = ? ,name = ? ,creator = ? WHERE id = 'soil at PERMANENT';\\n", (datetime.datetime(2001, 1, 1, 0, 0), 'PERMANENT', 'soil', 'soeren'))
- >>> t.get_update_statement_mogrified()
- "UPDATE raster SET creation_time = '2001-01-01 00:00:00' ,mapset = 'PERMANENT' ,name = 'soil' ,creator = 'soeren' WHERE id = 'soil at PERMANENT';\\n"
- >>> t.get_update_all_statement()
- ("UPDATE raster SET creation_time = ? ,mapset = ? ,name = ? ,creator = ? WHERE id = 'soil at PERMANENT';\\n", (datetime.datetime(2001, 1, 1, 0, 0), 'PERMANENT', 'soil', 'soeren'))
- >>> t.get_update_all_statement_mogrified()
- "UPDATE raster SET creation_time = '2001-01-01 00:00:00' ,mapset = 'PERMANENT' ,name = 'soil' ,creator = 'soeren' WHERE id = 'soil at PERMANENT';\\n"
+ >>> init()
+ >>> t = SQLDatabaseInterface("raster", "soil at PERMANENT")
+ >>> t.mapset = get_current_mapset()
+ >>> t.D["name"] = "soil"
+ >>> t.D["mapset"] = "PERMANENT"
+ >>> t.D["creator"] = "soeren"
+ >>> t.D["creation_time"] = datetime(2001,1,1)
+ >>> t.get_delete_statement()
+ "DELETE FROM raster WHERE id = 'soil at PERMANENT';\\n"
+ >>> t.get_is_in_db_statement()
+ "SELECT id FROM raster WHERE id = 'soil at PERMANENT';\\n"
+ >>> t.get_select_statement()
+ ("SELECT creation_time , mapset , name , creator FROM raster WHERE id = 'soil at PERMANENT';\\n", ())
+ >>> t.get_select_statement_mogrified()
+ "SELECT creation_time , mapset , name , creator FROM raster WHERE id = 'soil at PERMANENT';\\n"
+ >>> t.get_insert_statement()
+ ('INSERT INTO raster ( creation_time ,mapset ,name ,creator ) VALUES (? ,? ,? ,?) ;\\n', (datetime.datetime(2001, 1, 1, 0, 0), 'PERMANENT', 'soil', 'soeren'))
+ >>> t.get_insert_statement_mogrified()
+ "INSERT INTO raster ( creation_time ,mapset ,name ,creator ) VALUES ('2001-01-01 00:00:00' ,'PERMANENT' ,'soil' ,'soeren') ;\\n"
+ >>> t.get_update_statement()
+ ("UPDATE raster SET creation_time = ? ,mapset = ? ,name = ? ,creator = ? WHERE id = 'soil at PERMANENT';\\n", (datetime.datetime(2001, 1, 1, 0, 0), 'PERMANENT', 'soil', 'soeren'))
+ >>> t.get_update_statement_mogrified()
+ "UPDATE raster SET creation_time = '2001-01-01 00:00:00' ,mapset = 'PERMANENT' ,name = 'soil' ,creator = 'soeren' WHERE id = 'soil at PERMANENT';\\n"
+ >>> t.get_update_all_statement()
+ ("UPDATE raster SET creation_time = ? ,mapset = ? ,name = ? ,creator = ? WHERE id = 'soil at PERMANENT';\\n", (datetime.datetime(2001, 1, 1, 0, 0), 'PERMANENT', 'soil', 'soeren'))
+ >>> t.get_update_all_statement_mogrified()
+ "UPDATE raster SET creation_time = '2001-01-01 00:00:00' ,mapset = 'PERMANENT' ,name = 'soil' ,creator = 'soeren' WHERE id = 'soil at PERMANENT';\\n"
- \endcode
"""
def __init__(self, table=None, ident=None):
- """!Constructor of this class
+ """Constructor of this class
- @param table The name of the table
- @param ident The identifier (primary key) of this
+ :param table: The name of the table
+ :param ident: The identifier (primary key) of this
object in the database table
"""
DictSQLSerializer.__init__(self)
@@ -262,23 +255,23 @@
self.mapset = None
def get_table_name(self):
- """!Return the name of the table in which the internal
+ """Return the name of the table in which the internal
data are inserted, updated or selected
- @return The name of the table
+ :return: The name of the table
"""
return self.table
def get_delete_statement(self):
- """!Return the delete string
- @return The DELETE string
+ """Return the delete string
+ :return: The DELETE string
"""
return "DELETE FROM " + self.get_table_name() + \
" WHERE id = \'" + str(self.ident) + "\';\n"
def delete(self, dbif=None):
- """!Delete the entry of this object from the temporal database
+ """Delete the entry of this object from the temporal database
- @param dbif The database interface to be used,
+ :param dbif: The database interface to be used,
if None a temporary connection will be established
"""
sql = self.get_delete_statement()
@@ -293,19 +286,19 @@
dbif.close()
def get_is_in_db_statement(self):
- """!Return the selection string that checks if this object is registered in the
+ """Return the selection string that checks if this object is registered in the
temporal database
- @return The SELECT string
+ :return: The SELECT string
"""
return "SELECT id FROM " + self.get_table_name() + \
" WHERE id = \'" + str(self.ident) + "\';\n"
def is_in_db(self, dbif=None):
- """!Check if this object is present in the temporal database
+ """Check if this object is present in the temporal database
- @param dbif The database interface to be used,
+ :param dbif: The database interface to be used,
if None a temporary connection will be established
- @return True if this object is present in the temporal database, False otherwise
+ :return: True if this object is present in the temporal database, False otherwise
"""
sql = self.get_is_in_db_statement()
@@ -327,19 +320,19 @@
return True
def get_select_statement(self):
- """!Return the sql statement and the argument list in
+ """Return the sql statement and the argument list in
database specific style
- @return The SELECT string
+ :return: The SELECT string
"""
return self.serialize("SELECT", self.get_table_name(),
"WHERE id = \'" + str(self.ident) + "\'")
def get_select_statement_mogrified(self, dbif=None):
- """!Return the select statement as mogrified string
+ """Return the select statement as mogrified string
- @param dbif The database interface to be used,
+ :param dbif: The database interface to be used,
if None a temporary connection will be established
- @return The SELECT string
+ :return: The SELECT string
"""
if not dbif:
dbif = SQLDatabaseInterfaceConnection()
@@ -347,10 +340,10 @@
return dbif.mogrify_sql_statement(self.get_select_statement(), mapset=self.mapset)
def select(self, dbif=None):
- """!Select the content from the temporal database and store it
+ """Select the content from the temporal database and store it
in the internal dictionary structure
- @param dbif The database interface to be used,
+ :param dbif: The database interface to be used,
if None a temporary connection will be established
"""
sql, args = self.get_select_statement()
@@ -386,17 +379,17 @@
return True
def get_insert_statement(self):
- """!Return the sql statement and the argument
+ """Return the sql statement and the argument
list in database specific style
- @return The INSERT string"""
+ :return: The INSERT string"""
return self.serialize("INSERT", self.get_table_name())
def get_insert_statement_mogrified(self, dbif=None):
- """!Return the insert statement as mogrified string
+ """Return the insert statement as mogrified string
- @param dbif The database interface to be used,
+ :param dbif: The database interface to be used,
if None a temporary connection will be established
- @return The INSERT string
+ :return: The INSERT string
"""
if not dbif:
dbif = SQLDatabaseInterfaceConnection()
@@ -404,10 +397,10 @@
return dbif.mogrify_sql_statement(self.get_insert_statement(), mapset=self.mapset)
def insert(self, dbif=None):
- """!Serialize the content of this object and store it in the temporal
+ """Serialize the content of this object and store it in the temporal
database using the internal identifier
- @param dbif The database interface to be used,
+ :param dbif: The database interface to be used,
if None a temporary connection will be established
"""
sql, args = self.get_insert_statement()
@@ -423,11 +416,11 @@
dbif.close()
def get_update_statement(self, ident=None):
- """!Return the sql statement and the argument list
+ """Return the sql statement and the argument list
in database specific style
- @param ident The identifier to be updated, useful for renaming
- @return The UPDATE string
+ :param ident: The identifier to be updated, useful for renaming
+ :return: The UPDATE string
"""
if ident:
@@ -438,12 +431,12 @@
"WHERE id = \'" + str(self.ident) + "\'")
def get_update_statement_mogrified(self, dbif=None, ident=None):
- """!Return the update statement as mogrified string
+ """Return the update statement as mogrified string
- @param dbif The database interface to be used,
+ :param dbif: The database interface to be used,
if None a temporary connection will be established
- @param ident The identifier to be updated, useful for renaming
- @return The UPDATE string
+ :param ident: The identifier to be updated, useful for renaming
+ :return: The UPDATE string
"""
if not dbif:
dbif = SQLDatabaseInterfaceConnection()
@@ -451,14 +444,14 @@
return dbif.mogrify_sql_statement(self.get_update_statement(ident), mapset=self.mapset)
def update(self, dbif=None, ident=None):
- """!Serialize the content of this object and update it in the temporal
+ """Serialize the content of this object and update it in the temporal
database using the internal identifier
Only object entries which are exists (not None) are updated
- @param dbif The database interface to be used,
+ :param dbif: The database interface to be used,
if None a temporary connection will be established
- @param ident The identifier to be updated, useful for renaming
+ :param ident: The identifier to be updated, useful for renaming
"""
if self.ident is None:
self.msgr.fatal(_("Missing identifer"))
@@ -476,11 +469,11 @@
dbif.close()
def get_update_all_statement(self, ident=None):
- """!Return the sql statement and the argument
+ """Return the sql statement and the argument
list in database specific style
- @param ident The identifier to be updated, useful for renaming
- @return The UPDATE string
+ :param ident: The identifier to be updated, useful for renaming
+ :return: The UPDATE string
"""
if ident:
return self.serialize("UPDATE ALL", self.get_table_name(),
@@ -490,12 +483,12 @@
"WHERE id = \'" + str(self.ident) + "\'")
def get_update_all_statement_mogrified(self, dbif=None, ident=None):
- """!Return the update all statement as mogrified string
+ """Return the update all statement as mogrified string
- @param dbif The database interface to be used,
+ :param dbif: The database interface to be used,
if None a temporary connection will be established
- @param ident The identifier to be updated, useful for renaming
- @return The UPDATE string
+ :param ident: The identifier to be updated, useful for renaming
+ :return: The UPDATE string
"""
if not dbif:
dbif = SQLDatabaseInterfaceConnection()
@@ -503,12 +496,12 @@
return dbif.mogrify_sql_statement(self.get_update_all_statement(ident), mapset=self.mapset)
def update_all(self, dbif=None, ident=None):
- """!Serialize the content of this object, including None objects,
+ """Serialize the content of this object, including None objects,
and update it in the temporal database using the internal identifier
- @param dbif The database interface to be used,
+ :param dbif: The database interface to be used,
if None a temporary connection will be established
- @param ident The identifier to be updated, useful for renaming
+ :param ident: The identifier to be updated, useful for renaming
"""
if self.ident is None:
self.msgr.fatal(_("Missing identifer"))
@@ -528,61 +521,61 @@
###############################################################################
class DatasetBase(SQLDatabaseInterface):
- """!This is the base class for all maps and spacetime datasets storing
+ """This is the base class for all maps and spacetime datasets storing
basic identification information
Usage:
- \code
+ .. code-block:: python
- >>> init()
- >>> t = DatasetBase("raster", "soil at PERMANENT", creator="soeren", ctime=datetime(2001,1,1), ttype="absolute")
- >>> t.id
- 'soil at PERMANENT'
- >>> t.name
- 'soil'
- >>> t.mapset
- 'PERMANENT'
- >>> t.creator
- 'soeren'
- >>> t.ctime
- datetime.datetime(2001, 1, 1, 0, 0)
- >>> t.ttype
- 'absolute'
- >>> t.print_info()
- +-------------------- Basic information -------------------------------------+
- | Id: ........................ soil at PERMANENT
- | Name: ...................... soil
- | Mapset: .................... PERMANENT
- | Creator: ................... soeren
- | Temporal type: ............. absolute
- | Creation time: ............. 2001-01-01 00:00:00
- >>> t.print_shell_info()
- id=soil at PERMANENT
- name=soil
- mapset=PERMANENT
- creator=soeren
- temporal_type=absolute
- creation_time=2001-01-01 00:00:00
+ >>> init()
+ >>> t = DatasetBase("raster", "soil at PERMANENT", creator="soeren", ctime=datetime(2001,1,1), ttype="absolute")
+ >>> t.id
+ 'soil at PERMANENT'
+ >>> t.name
+ 'soil'
+ >>> t.mapset
+ 'PERMANENT'
+ >>> t.creator
+ 'soeren'
+ >>> t.ctime
+ datetime.datetime(2001, 1, 1, 0, 0)
+ >>> t.ttype
+ 'absolute'
+ >>> t.print_info()
+ +-------------------- Basic information -------------------------------------+
+ | Id: ........................ soil at PERMANENT
+ | Name: ...................... soil
+ | Mapset: .................... PERMANENT
+ | Creator: ................... soeren
+ | Temporal type: ............. absolute
+ | Creation time: ............. 2001-01-01 00:00:00
+ >>> t.print_shell_info()
+ id=soil at PERMANENT
+ name=soil
+ mapset=PERMANENT
+ creator=soeren
+ temporal_type=absolute
+ creation_time=2001-01-01 00:00:00
- \endcode
"""
def __init__(self, table=None, ident=None, name=None, mapset=None,
creator=None, ctime=None,ttype=None):
- """!Constructor
+ """Constructor
- @param table The name of the temporal database table
+ :param table: The name of the temporal database table
that should be used to store the values
- @param ident The unique identifier must be a combination of
+ :param ident: The unique identifier must be a combination of
the dataset name, layer name and the mapset
"name at mapset" or "name:layer at mapset"
used as as primary key in the temporal database
- @param name The name of the map or dataset
- @param mapset The name of the mapset
- @param creator The name of the creator
- @param ctime The creation datetime object
- @param ttype The temporal type
+ :param name: The name of the map or dataset
+ :param mapset: The name of the mapset
+ :param creator: The name of the creator
+ :param ctime: The creation datetime object
+ :param ttype: The temporal type
+
- "absolute" Identifier for absolute time
- "relative" Identifier for relative time
"""
@@ -602,9 +595,9 @@
self.set_ttype(ttype)
def set_id(self, ident):
- """!Convenient method to set the unique identifier (primary key)
+ """Convenient method to set the unique identifier (primary key)
- @param ident The unique identifier must be a combination
+ :param ident: The unique identifier must be a combination
of the dataset name, layer name and the mapset
"name at mapset" or "name:layer at mapset"
"""
@@ -625,40 +618,40 @@
def set_name(self, name):
- """!Set the name of the dataset
+ """Set the name of the dataset
- @param name The name of the dataset
+ :param name: The name of the dataset
"""
self.D["name"] = name
def set_mapset(self, mapset):
- """!Set the mapset of the dataset
+ """Set the mapset of the dataset
- @param mapset The name of the mapset in which this dataset is stored
+ :param mapset: The name of the mapset in which this dataset is stored
"""
self.D["mapset"] = mapset
def set_layer(self, layer):
- """!Convenient method to set the layer of the map (part of primary key)
+ """Convenient method to set the layer of the map (part of primary key)
Layer are supported for vector maps
- @param layer The layer of the map
+ :param layer: The layer of the map
"""
self.D["layer"] = layer
def set_creator(self, creator):
- """!Set the creator of the dataset
+ """Set the creator of the dataset
- @param creator The name of the creator
+ :param creator: The name of the creator
"""
self.D["creator"] = creator
def set_ctime(self, ctime=None):
- """!Set the creation time of the dataset,
+ """Set the creation time of the dataset,
if nothing set the current time is used
- @param ctime The current time of type datetime
+ :param ctime: The current time of type datetime
"""
if ctime is None:
self.D["creation_time"] = datetime.today()
@@ -666,10 +659,10 @@
self.D["creation_time"] = ctime
def set_ttype(self, ttype):
- """!Set the temporal type of the dataset: absolute or relative,
+ """Set the temporal type of the dataset: absolute or relative,
if nothing set absolute time will assumed
- @param ttype The temporal type of the dataset "absolute or relative"
+ :param ttype: The temporal type of the dataset "absolute or relative"
"""
if ttype is None or (ttype != "absolute" and ttype != "relative"):
self.D["temporal_type"] = "absolute"
@@ -677,9 +670,9 @@
self.D["temporal_type"] = ttype
def get_id(self):
- """!Convenient method to get the unique identifier (primary key)
+ """Convenient method to get the unique identifier (primary key)
- @return None if not found
+ :return: None if not found
"""
if "id" in self.D:
return self.D["id"]
@@ -687,10 +680,10 @@
return None
def get_map_id(self):
- """!Convenient method to get the unique map identifier
+ """Convenient method to get the unique map identifier
without layer information
- @return the name of the vector map as "name at mapset"
+ :return: the name of the vector map as "name at mapset"
or None in case the id was not set
"""
if self.id:
@@ -704,11 +697,11 @@
return None
def get_layer(self):
- """!Convenient method to get the layer of the map (part of primary key)
+ """Convenient method to get the layer of the map (part of primary key)
Layer are currently supported for vector maps
- @return None if not found
+ :return: None if not found
"""
if "layer" in self.D:
return self.D["layer"]
@@ -716,40 +709,40 @@
return None
def get_name(self):
- """!Get the name of the dataset
- @return None if not found"""
+ """Get the name of the dataset
+ :return: None if not found"""
if "name" in self.D:
return self.D["name"]
else:
return None
def get_mapset(self):
- """!Get the name of mapset of this dataset
- @return None if not found"""
+ """Get the name of mapset of this dataset
+ :return: None if not found"""
if "mapset" in self.D:
return self.D["mapset"]
else:
return None
def get_creator(self):
- """!Get the creator of the dataset
- @return None if not found"""
+ """Get the creator of the dataset
+ :return: None if not found"""
if "creator" in self.D:
return self.D["creator"]
else:
return None
def get_ctime(self):
- """!Get the creation time of the dataset, datatype is datetime
- @return None if not found"""
+ """Get the creation time of the dataset, datatype is datetime
+ :return: None if not found"""
if "creation_time" in self.D:
return self.D["creation_time"]
else:
return None
def get_ttype(self):
- """!Get the temporal type of the map
- @return None if not found"""
+ """Get the temporal type of the map
+ :return: None if not found"""
if "temporal_type" in self.D:
return self.D["temporal_type"]
else:
@@ -765,7 +758,7 @@
creator = property(fget=get_creator, fset=set_creator)
def print_info(self):
- """!Print information about this class in human readable style"""
+ """Print information about this class in human readable style"""
# 0123456789012345678901234567890
print " +-------------------- Basic information -------------------------------------+"
print " | Id: ........................ " + str(self.get_id())
@@ -778,7 +771,7 @@
print " | Creation time: ............. " + str(self.get_ctime())
def print_shell_info(self):
- """!Print information about this class in shell style"""
+ """Print information about this class in shell style"""
print "id=" + str(self.get_id())
print "name=" + str(self.get_name())
print "mapset=" + str(self.get_mapset())
@@ -792,7 +785,7 @@
class RasterBase(DatasetBase):
- """!Time stamped raster map base information class"""
+ """Time stamped raster map base information class"""
def __init__(self, ident=None, name=None, mapset=None, creator=None,
creation_time=None, temporal_type=None):
DatasetBase.__init__(self, "raster_base", ident, name, mapset,
@@ -800,7 +793,7 @@
class Raster3DBase(DatasetBase):
- """!Time stamped 3D raster map base information class"""
+ """Time stamped 3D raster map base information class"""
def __init__(self, ident=None, name=None, mapset=None, creator=None,
creation_time=None, temporal_type=None,):
DatasetBase.__init__(self, "raster3d_base", ident, name,
@@ -809,7 +802,7 @@
class VectorBase(DatasetBase):
- """!Time stamped vector map base information class"""
+ """Time stamped vector map base information class"""
def __init__(self, ident=None, name=None, mapset=None, layer=None,
creator=None, creation_time=None, temporal_type=None):
DatasetBase.__init__(self, "vector_base", ident, name, mapset,
@@ -831,40 +824,39 @@
class STDSBase(DatasetBase):
- """!Base class for space time datasets
+ """Base class for space time datasets
This class adds the semantic type member variable to the dataset
base class.
Usage:
- \code
+ .. code-block:: python
- >>> init()
- >>> t = STDSBase("stds", "soil at PERMANENT", semantic_type="average", creator="soeren", ctime=datetime(2001,1,1), ttype="absolute", mtime=datetime(2001,1,1))
- >>> t.semantic_type
- 'average'
- >>> t.print_info()
- +-------------------- Basic information -------------------------------------+
- | Id: ........................ soil at PERMANENT
- | Name: ...................... soil
- | Mapset: .................... PERMANENT
- | Creator: ................... soeren
- | Temporal type: ............. absolute
- | Creation time: ............. 2001-01-01 00:00:00
- | Modification time:.......... 2001-01-01 00:00:00
- | Semantic type:.............. average
- >>> t.print_shell_info()
- id=soil at PERMANENT
- name=soil
- mapset=PERMANENT
- creator=soeren
- temporal_type=absolute
- creation_time=2001-01-01 00:00:00
- modification_time=2001-01-01 00:00:00
- semantic_type=average
+ >>> init()
+ >>> t = STDSBase("stds", "soil at PERMANENT", semantic_type="average", creator="soeren", ctime=datetime(2001,1,1), ttype="absolute", mtime=datetime(2001,1,1))
+ >>> t.semantic_type
+ 'average'
+ >>> t.print_info()
+ +-------------------- Basic information -------------------------------------+
+ | Id: ........................ soil at PERMANENT
+ | Name: ...................... soil
+ | Mapset: .................... PERMANENT
+ | Creator: ................... soeren
+ | Temporal type: ............. absolute
+ | Creation time: ............. 2001-01-01 00:00:00
+ | Modification time:.......... 2001-01-01 00:00:00
+ | Semantic type:.............. average
+ >>> t.print_shell_info()
+ id=soil at PERMANENT
+ name=soil
+ mapset=PERMANENT
+ creator=soeren
+ temporal_type=absolute
+ creation_time=2001-01-01 00:00:00
+ modification_time=2001-01-01 00:00:00
+ semantic_type=average
- \endcode
"""
def __init__(self, table=None, ident=None, name=None, mapset=None,
semantic_type=None, creator=None, ctime=None,
@@ -876,27 +868,27 @@
self.set_mtime(mtime)
def set_semantic_type(self, semantic_type):
- """!Set the semantic type of the space time dataset"""
+ """Set the semantic type of the space time dataset"""
self.D["semantic_type"] = semantic_type
def set_mtime(self, mtime=None):
- """!Set the modification time of the space time dataset, if nothing set the current time is used"""
+ """Set the modification time of the space time dataset, if nothing set the current time is used"""
if mtime == None:
self.D["modification_time"] = datetime.now()
else:
self.D["modification_time"] = mtime
def get_semantic_type(self):
- """!Get the semantic type of the space time dataset
- @return None if not found"""
+ """Get the semantic type of the space time dataset
+ :return: None if not found"""
if "semantic_type" in self.D:
return self.D["semantic_type"]
else:
return None
def get_mtime(self):
- """!Get the modification time of the space time dataset, datatype is datetime
- @return None if not found"""
+ """Get the modification time of the space time dataset, datatype is datetime
+ :return: None if not found"""
if self.D.has_key("modification_time"):
return self.D["modification_time"]
else:
@@ -905,7 +897,7 @@
semantic_type = property(fget=get_semantic_type, fset=set_semantic_type)
def print_info(self):
- """!Print information about this class in human readable style"""
+ """Print information about this class in human readable style"""
DatasetBase.print_info(self)
# 0123456789012345678901234567890
print " | Modification time:.......... " + str(self.get_mtime())
@@ -913,7 +905,7 @@
self.get_semantic_type())
def print_shell_info(self):
- """!Print information about this class in shell style"""
+ """Print information about this class in shell style"""
DatasetBase.print_shell_info(self)
print "modification_time=" + str(self.get_mtime())
print "semantic_type=" + str(self.get_semantic_type())
@@ -922,7 +914,7 @@
class STRDSBase(STDSBase):
- """!Space time raster dataset base information class"""
+ """Space time raster dataset base information class"""
def __init__(self, ident=None, name=None, mapset=None,
semantic_type=None, creator=None, ctime=None,
ttype=None):
@@ -932,7 +924,7 @@
class STR3DSBase(STDSBase):
- """!Space time 3D raster dataset base information class"""
+ """Space time 3D raster dataset base information class"""
def __init__(self, ident=None, name=None, mapset=None,
semantic_type=None, creator=None, ctime=None,
ttype=None):
@@ -942,7 +934,7 @@
class STVDSBase(STDSBase):
- """!Space time vector dataset base information class"""
+ """Space time vector dataset base information class"""
def __init__(self, ident=None, name=None, mapset=None,
semantic_type=None, creator=None, ctime=None,
ttype=None):
@@ -953,33 +945,32 @@
###############################################################################
class AbstractSTDSRegister(SQLDatabaseInterface):
- """!This is the base class for all maps to store the space time datasets
+ """This is the base class for all maps to store the space time datasets
as comma separated string in which they are registered
Usage:
- \code
+ .. code-block:: python
- >>> init()
- >>> t = AbstractSTDSRegister("raster", "soil at PERMANENT", "A at P,B at P,C at P")
- >>> t.id
- 'soil at PERMANENT'
- >>> t.registered_stds
- 'A at P,B at P,C at P'
+ >>> init()
+ >>> t = AbstractSTDSRegister("raster", "soil at PERMANENT", "A at P,B at P,C at P")
+ >>> t.id
+ 'soil at PERMANENT'
+ >>> t.registered_stds
+ 'A at P,B at P,C at P'
- \endcode
"""
def __init__(self, table=None, ident=None, registered_stds=None):
- """!Constructor
+ """Constructor
- @param table The name of the temporal database table
+ :param table: The name of the temporal database table
that should be used to store the values
- @param ident The unique identifier must be a combination of
+ :param ident: The unique identifier must be a combination of
the dataset name, layer name and the mapset
"name at mapset" or "name:layer at mapset"
used as as primary key in the temporal database
- @param stds A comma separted list of space time dataset ids
+ :param stds: A comma separted list of space time dataset ids
"""
SQLDatabaseInterface.__init__(self, table, ident)
@@ -988,9 +979,9 @@
self.set_registered_stds(registered_stds)
def set_id(self, ident):
- """!Convenient method to set the unique identifier (primary key)
+ """Convenient method to set the unique identifier (primary key)
- @param ident The unique identifier must be a combination
+ :param ident: The unique identifier must be a combination
of the dataset name, layer name and the mapset
"name at mapset" or "name:layer at mapset"
"""
@@ -998,17 +989,17 @@
self.D["id"] = ident
def set_registered_stds(self, registered_stds):
- """!Get the comma separated list of space time datasets ids
+ """Get the comma separated list of space time datasets ids
in which this map is registered
- @param registered_stds A comma separated list of space time dataset ids
+ :param registered_stds A comma separated list of space time dataset ids
in which this map is registered
"""
self.D["registered_stds"] = registered_stds
def get_id(self):
- """!Convenient method to get the unique identifier (primary key)
+ """Convenient method to get the unique identifier (primary key)
- @return None if not found
+ :return: None if not found
"""
if "id" in self.D:
return self.D["id"]
@@ -1016,9 +1007,9 @@
return None
def get_registered_stds(self):
- """!Get the comma separated list of space time datasets ids
+ """Get the comma separated list of space time datasets ids
in which this map is registered
- @return None if not found"""
+ :return: None if not found"""
if "registered_stds" in self.D:
return self.D["registered_stds"]
else:
@@ -1031,17 +1022,17 @@
###############################################################################
class RasterSTDSRegister(AbstractSTDSRegister):
- """!Time stamped raster map base information class"""
+ """Time stamped raster map base information class"""
def __init__(self, ident=None, registered_stds=None):
AbstractSTDSRegister.__init__(self, "raster_stds_register", ident, registered_stds)
class Raster3DSTDSRegister(AbstractSTDSRegister):
- """!Time stamped 3D raster map base information class"""
+ """Time stamped 3D raster map base information class"""
def __init__(self, ident=None, registered_stds=None):
AbstractSTDSRegister.__init__(self, "raster3d_stds_register", ident, registered_stds)
class VectorSTDSRegister(AbstractSTDSRegister):
- """!Time stamped vector map base information class"""
+ """Time stamped vector map base information class"""
def __init__(self, ident=None, registered_stds=None):
AbstractSTDSRegister.__init__(self, "vector_stds_register", ident, registered_stds)
Modified: grass/trunk/lib/python/temporal/c_libraries_interface.py
===================================================================
--- grass/trunk/lib/python/temporal/c_libraries_interface.py 2014-09-28 01:40:32 UTC (rev 62120)
+++ grass/trunk/lib/python/temporal/c_libraries_interface.py 2014-09-28 01:46:15 UTC (rev 62121)
@@ -1,18 +1,14 @@
# -*- coding: utf-8 -*-
-"""@package grass.pygrass.massages
-
- at brief Temporal Framework GRASS C-library interface
-
+"""
Fast and exit-safe interface to GRASS C-library functions
using ctypes and multiprocessing
-
(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.
- at author Soeren Gebbert
+:authors: Soeren Gebbert
"""
import sys
@@ -761,118 +757,118 @@
Usage:
- @code
- >>> import grass.script as gscript
- >>> import grass.temporal as tgis
- >>> gscript.use_temp_region()
- >>> gscript.run_command("g.region", n=80.0, s=0.0, e=120.0, w=0.0,
- ... t=1.0, b=0.0, res=10.0, res3=10.0)
- 0
- >>> tgis.init()
- >>> gscript.run_command("r.mapcalc", expression="test = 1", overwrite=True, quiet=True)
- 0
- >>> gscript.run_command("r3.mapcalc", expression="test = 1", overwrite=True, quiet=True)
- 0
- >>> gscript.run_command("v.random", output="test", n=10, overwrite=True, quiet=True)
- 0
- >>> gscript.run_command("r.timestamp", map="test", date='12 Mar 1995 10:34:40', overwrite=True, quiet=True)
- 0
- >>> gscript.run_command("r3.timestamp", map="test", date='12 Mar 1995 10:34:40', overwrite=True, quiet=True)
- 0
- >>> gscript.run_command("v.timestamp", map="test", date='12 Mar 1995 10:34:40', overwrite=True, quiet=True)
- 0
+ .. code-block:: python
+
+ >>> import grass.script as gscript
+ >>> import grass.temporal as tgis
+ >>> gscript.use_temp_region()
+ >>> gscript.run_command("g.region", n=80.0, s=0.0, e=120.0, w=0.0,
+ ... t=1.0, b=0.0, res=10.0, res3=10.0)
+ 0
+ >>> tgis.init()
+ >>> gscript.run_command("r.mapcalc", expression="test = 1", overwrite=True, quiet=True)
+ 0
+ >>> gscript.run_command("r3.mapcalc", expression="test = 1", overwrite=True, quiet=True)
+ 0
+ >>> gscript.run_command("v.random", output="test", n=10, overwrite=True, quiet=True)
+ 0
+ >>> gscript.run_command("r.timestamp", map="test", date='12 Mar 1995 10:34:40', overwrite=True, quiet=True)
+ 0
+ >>> gscript.run_command("r3.timestamp", map="test", date='12 Mar 1995 10:34:40', overwrite=True, quiet=True)
+ 0
+ >>> gscript.run_command("v.timestamp", map="test", date='12 Mar 1995 10:34:40', overwrite=True, quiet=True)
+ 0
- # Check mapsets
- >>> ciface = tgis.CLibrariesInterface()
- >>> mapsets = ciface.available_mapsets()
- >>> mapsets[0] == tgis.get_current_mapset()
- True
-
- # Raster map
- >>> ciface = tgis.CLibrariesInterface()
- >>> check = ciface.raster_map_exists("test", tgis.get_current_mapset())
- >>> print check
- True
- >>> ciface.read_raster_info("test", tgis.get_current_mapset())
- {'rows': 12, 'north': 80.0, 'min': 1, 'datatype': 'CELL', 'max': 1, 'ewres': 10.0, 'cols': 8, 'west': 0.0, 'east': 120.0, 'nsres': 10.0, 'south': 0.0}
- >>> check = ciface.has_raster_timestamp("test", tgis.get_current_mapset())
- >>> print check
- True
- >>> if check:
- ... res = ciface.read_raster_timestamp("test", tgis.get_current_mapset())
- ... if res[0]:
- ... print str(res[1][0]), str(res[1][0])
- ... ciface.remove_raster_timestamp("test", tgis.get_current_mapset())
- 1995-03-12 10:34:40 1995-03-12 10:34:40
- 1
- >>> ciface.has_raster_timestamp("test", tgis.get_current_mapset())
- False
- >>> ciface.write_raster_timestamp("test", tgis.get_current_mapset(), "13 Jan 1999 14:30:05")
- 1
- >>> ciface.has_raster_timestamp("test", tgis.get_current_mapset())
- True
+ # Check mapsets
+ >>> ciface = tgis.CLibrariesInterface()
+ >>> mapsets = ciface.available_mapsets()
+ >>> mapsets[0] == tgis.get_current_mapset()
+ True
+
+ # Raster map
+ >>> ciface = tgis.CLibrariesInterface()
+ >>> check = ciface.raster_map_exists("test", tgis.get_current_mapset())
+ >>> print check
+ True
+ >>> ciface.read_raster_info("test", tgis.get_current_mapset())
+ {'rows': 12, 'north': 80.0, 'min': 1, 'datatype': 'CELL', 'max': 1, 'ewres': 10.0, 'cols': 8, 'west': 0.0, 'east': 120.0, 'nsres': 10.0, 'south': 0.0}
+ >>> check = ciface.has_raster_timestamp("test", tgis.get_current_mapset())
+ >>> print check
+ True
+ >>> if check:
+ ... res = ciface.read_raster_timestamp("test", tgis.get_current_mapset())
+ ... if res[0]:
+ ... print str(res[1][0]), str(res[1][0])
+ ... ciface.remove_raster_timestamp("test", tgis.get_current_mapset())
+ 1995-03-12 10:34:40 1995-03-12 10:34:40
+ 1
+ >>> ciface.has_raster_timestamp("test", tgis.get_current_mapset())
+ False
+ >>> ciface.write_raster_timestamp("test", tgis.get_current_mapset(), "13 Jan 1999 14:30:05")
+ 1
+ >>> ciface.has_raster_timestamp("test", tgis.get_current_mapset())
+ True
- # 3D raster map
- >>> check = ciface.raster3d_map_exists("test", tgis.get_current_mapset())
- >>> print check
- True
- >>> ciface.read_raster3d_info("test", tgis.get_current_mapset())
- {'tbres': 1.0, 'rows': 12, 'north': 80.0, 'bottom': 0.0, 'datatype': 'DCELL', 'max': 1.0, 'top': 1.0, 'min': 1.0, 'cols': 8, 'depths': 1, 'west': 0.0, 'ewres': 10.0, 'east': 120.0, 'nsres': 10.0, 'south': 0.0}
- >>> check = ciface.has_raster3d_timestamp("test", tgis.get_current_mapset())
- >>> print check
- True
- >>> if check:
- ... res = ciface.read_raster3d_timestamp("test", tgis.get_current_mapset())
- ... if res[0]:
- ... print str(res[1][0]), str(res[1][0])
- ... ciface.remove_raster3d_timestamp("test", tgis.get_current_mapset())
- 1995-03-12 10:34:40 1995-03-12 10:34:40
- 1
- >>> ciface.has_raster3d_timestamp("test", tgis.get_current_mapset())
- False
- >>> ciface.write_raster3d_timestamp("test", tgis.get_current_mapset(), "13 Jan 1999 14:30:05")
- 1
- >>> ciface.has_raster3d_timestamp("test", tgis.get_current_mapset())
- True
+ # 3D raster map
+ >>> check = ciface.raster3d_map_exists("test", tgis.get_current_mapset())
+ >>> print check
+ True
+ >>> ciface.read_raster3d_info("test", tgis.get_current_mapset())
+ {'tbres': 1.0, 'rows': 12, 'north': 80.0, 'bottom': 0.0, 'datatype': 'DCELL', 'max': 1.0, 'top': 1.0, 'min': 1.0, 'cols': 8, 'depths': 1, 'west': 0.0, 'ewres': 10.0, 'east': 120.0, 'nsres': 10.0, 'south': 0.0}
+ >>> check = ciface.has_raster3d_timestamp("test", tgis.get_current_mapset())
+ >>> print check
+ True
+ >>> if check:
+ ... res = ciface.read_raster3d_timestamp("test", tgis.get_current_mapset())
+ ... if res[0]:
+ ... print str(res[1][0]), str(res[1][0])
+ ... ciface.remove_raster3d_timestamp("test", tgis.get_current_mapset())
+ 1995-03-12 10:34:40 1995-03-12 10:34:40
+ 1
+ >>> ciface.has_raster3d_timestamp("test", tgis.get_current_mapset())
+ False
+ >>> ciface.write_raster3d_timestamp("test", tgis.get_current_mapset(), "13 Jan 1999 14:30:05")
+ 1
+ >>> ciface.has_raster3d_timestamp("test", tgis.get_current_mapset())
+ True
- # Vector map
- >>> check = ciface.vector_map_exists("test", tgis.get_current_mapset())
- >>> print check
- True
- >>> kvp = ciface.read_vector_info("test", tgis.get_current_mapset())
- >>> print kvp['points']
- 10
- >>> check = ciface.has_vector_timestamp("test", tgis.get_current_mapset(), None)
- >>> print check
- True
- >>> if check:
- ... res = ciface.read_vector_timestamp("test", tgis.get_current_mapset())
- ... if res[0]:
- ... print str(res[1][0]), str(res[1][0])
- ... ciface.remove_vector_timestamp("test", tgis.get_current_mapset())
- 1995-03-12 10:34:40 1995-03-12 10:34:40
- 1
- >>> ciface.has_vector_timestamp("test", tgis.get_current_mapset())
- False
- >>> ciface.write_vector_timestamp("test", tgis.get_current_mapset(), "13 Jan 1999 14:30:05")
- 1
- >>> ciface.has_vector_timestamp("test", tgis.get_current_mapset())
- True
-
- >>> ciface.get_driver_name()
- 'sqlite'
- >>> ciface.get_database_name().split("/")[-1]
- 'sqlite.db'
-
- >>> mapset = ciface.get_mapset()
- >>> location = ciface.get_location()
- >>> gisdbase = ciface.get_gisdbase()
+ # Vector map
+ >>> check = ciface.vector_map_exists("test", tgis.get_current_mapset())
+ >>> print check
+ True
+ >>> kvp = ciface.read_vector_info("test", tgis.get_current_mapset())
+ >>> print kvp['points']
+ 10
+ >>> check = ciface.has_vector_timestamp("test", tgis.get_current_mapset(), None)
+ >>> print check
+ True
+ >>> if check:
+ ... res = ciface.read_vector_timestamp("test", tgis.get_current_mapset())
+ ... if res[0]:
+ ... print str(res[1][0]), str(res[1][0])
+ ... ciface.remove_vector_timestamp("test", tgis.get_current_mapset())
+ 1995-03-12 10:34:40 1995-03-12 10:34:40
+ 1
+ >>> ciface.has_vector_timestamp("test", tgis.get_current_mapset())
+ False
+ >>> ciface.write_vector_timestamp("test", tgis.get_current_mapset(), "13 Jan 1999 14:30:05")
+ 1
+ >>> ciface.has_vector_timestamp("test", tgis.get_current_mapset())
+ True
+
+ >>> ciface.get_driver_name()
+ 'sqlite'
+ >>> ciface.get_database_name().split("/")[-1]
+ 'sqlite.db'
+
+ >>> mapset = ciface.get_mapset()
+ >>> location = ciface.get_location()
+ >>> gisdbase = ciface.get_gisdbase()
- >>> gscript.del_temp_region()
+ >>> gscript.del_temp_region()
- @endcode
"""
def __init__(self):
self.client_conn = None
@@ -1131,7 +1127,7 @@
:param name: The name of the map
:param mapset: The mapset of the map
- :param layer The layer of the vector map
+ :param layer: The layer of the vector map
:returns: The return value of G_remove_vector_timestamp
"""
self._check_restart_server()
Modified: grass/trunk/lib/python/temporal/core.py
===================================================================
--- grass/trunk/lib/python/temporal/core.py 2014-09-28 01:40:32 UTC (rev 62120)
+++ grass/trunk/lib/python/temporal/core.py 2014-09-28 01:46:15 UTC (rev 62121)
@@ -1,28 +1,24 @@
-"""package grass.temporal
-
-GRASS Python scripting module (temporal GIS functions)
-
-Temporal GIS core functions to be used in library modules and scripts.
-
+"""
This module provides the functionality to create the temporal
SQL database and to establish a connection to the database.
Usage:
+.. code-block:: python
->>> import grass.temporal as tgis
->>> # Create the temporal database
->>> tgis.init()
->>> # Establish a database connection
->>> dbif, connected = tgis.init_dbif(None)
->>> dbif.connect()
->>> # Execute a SQL statement
->>> dbif.execute_transaction("SELECT datetime(0, 'unixepoch', 'localtime');")
->>> # Mogrify an SQL statement
->>> dbif.mogrify_sql_statement(["SELECT name from raster_base where name = ?",
-... ("precipitation",)])
-"SELECT name from raster_base where name = 'precipitation'"
->>> dbif.close()
+ >>> import grass.temporal as tgis
+ >>> # Create the temporal database
+ >>> tgis.init()
+ >>> # Establish a database connection
+ >>> dbif, connected = tgis.init_dbif(None)
+ >>> dbif.connect()
+ >>> # Execute a SQL statement
+ >>> dbif.execute_transaction("SELECT datetime(0, 'unixepoch', 'localtime');")
+ >>> # Mogrify an SQL statement
+ >>> dbif.mogrify_sql_statement(["SELECT name from raster_base where name = ?",
+ ... ("precipitation",)])
+ "SELECT name from raster_base where name = 'precipitation'"
+ >>> dbif.close()
(C) 2011-2014 by the GRASS Development Team
@@ -273,28 +269,28 @@
:param raise_exp: True to raise a FatalError exception instead of calling
sys.exit(1) when using the tgis messenger interface
+ .. code-block:: python
+
+ >>> import grass.temporal as tgis
+ >>> tgis.init()
+ >>> ignore = tgis.set_raise_on_error(False)
+ >>> msgr = tgis.get_tgis_message_interface()
+ >>> tgis.get_raise_on_error()
+ False
+ >>> msgr.fatal("Ohh no no no!")
+ Traceback (most recent call last):
+ File "__init__.py", line 239, in fatal
+ sys.exit(1)
+ SystemExit: 1
- >>> import grass.temporal as tgis
- >>> tgis.init()
- >>> ignore = tgis.set_raise_on_error(False)
- >>> msgr = tgis.get_tgis_message_interface()
- >>> tgis.get_raise_on_error()
- False
- >>> msgr.fatal("Ohh no no no!")
- Traceback (most recent call last):
- File "__init__.py", line 239, in fatal
- sys.exit(1)
- SystemExit: 1
+ >>> tgis.set_raise_on_error(True)
+ False
+ >>> msgr.fatal("Ohh no no no!")
+ Traceback (most recent call last):
+ File "__init__.py", line 241, in fatal
+ raise FatalError(message)
+ FatalError: Ohh no no no!
- >>> tgis.set_raise_on_error(True)
- False
- >>> msgr.fatal("Ohh no no no!")
- Traceback (most recent call last):
- File "__init__.py", line 241, in fatal
- raise FatalError(message)
- FatalError: Ohh no no no!
-
-
:returns: current status
"""
global raise_on_error
@@ -434,6 +430,7 @@
subprocesses are spawned.
Re-run this function in case the following GRASS variables change while the process runs:
+
- MAPSET
- LOCATION_NAME
- GISDBASE
@@ -441,10 +438,12 @@
- TGIS_DISABLE_TIMESTAMP_WRITE
Re-run this function if the following t.connect variables change while the process runs:
+
- temporal GIS driver (set by t.connect driver=)
- temporal GIS database (set by t.connect database=)
The following environmental variables are checked:
+
- GRASS_TGIS_PROFILE (True, False, 1, 0)
- GRASS_TGIS_RAISE_ON_ERROR (True, False, 1, 0)
@@ -453,7 +452,6 @@
:param raise_fatal_error: Set this True to assure that the init() function
does not kill a persistent process like the GUI.
-
If set True a grass.pygrass.messages.FatalError
exception will be raised in case a fatal error occurs
in the init process, otherwise sys.exit(1) will be called.
@@ -757,9 +755,9 @@
"""!Create the temporal gis metadata table which stores all metadata
information about the temporal database.
- @param content The dictionary that stores the key:value metadata
+ :param content: The dictionary that stores the key:value metadata
that should be stored in the metadata table
- @param dbif The database interface to be used
+ :param dbif: The database interface to be used
"""
dbif, connected = init_dbif(dbif)
statement = "CREATE TABLE tgis_metadata (key VARCHAR NOT NULL, value VARCHAR);\n";
@@ -937,6 +935,7 @@
and provides access to the chisen backend modules.
The following DBMS are supported:
+
- sqlite via the sqlite3 standard library
- postgresql via psycopg2
@@ -1014,7 +1013,6 @@
There may be several temporal databases in a location, hence
close all temporal databases that have been opened. Use a dictionary
to manage different connections.
-
"""
self.connection.commit()
self.cursor.close()
@@ -1036,12 +1034,14 @@
Usage:
-
- >>> init()
- >>> dbif = SQLDatabaseInterfaceConnection()
- >>> dbif.mogrify_sql_statement(["SELECT ctime FROM raster_base WHERE id = ?",
- ... ["soil at PERMANENT",]])
- "SELECT ctime FROM raster_base WHERE id = 'soil at PERMANENT'"
+ .. code-block:: python
+
+ >>> init()
+ >>> dbif = SQLDatabaseInterfaceConnection()
+ >>> dbif.mogrify_sql_statement(["SELECT ctime FROM raster_base WHERE id = ?",
+ ... ["soil at PERMANENT",]])
+ "SELECT ctime FROM raster_base WHERE id = 'soil at PERMANENT'"
+
"""
sql = content[0]
args = content[1]
@@ -1216,16 +1216,17 @@
Usage code sample:
+ .. code-block:: python
+
+ dbif, connect = tgis.init_dbif(None)
- dbif, connect = tgis.init_dbif(None)
+ sql = dbif.mogrify_sql_statement(["SELECT * FROM raster_base WHERE ? = ?"],
+ ["id", "soil at PERMANENT"])
+ dbif.execute_transaction(sql)
- sql = dbif.mogrify_sql_statement(["SELECT * FROM raster_base WHERE ? = ?"],
- ["id", "soil at PERMANENT"])
- dbif.execute_transaction(sql)
+ if connect:
+ dbif.close()
- if connect:
- dbif.close()
-
"""
if dbif is None:
dbif = SQLDatabaseInterfaceConnection()
Modified: grass/trunk/lib/python/temporal/datetime_math.py
===================================================================
--- grass/trunk/lib/python/temporal/datetime_math.py 2014-09-28 01:40:32 UTC (rev 62120)
+++ grass/trunk/lib/python/temporal/datetime_math.py 2014-09-28 01:46:15 UTC (rev 62121)
@@ -1,15 +1,12 @@
-"""!@package grass.temporal
+"""
+Functions for mathematical datetime operations
- at brief GRASS Python scripting module (temporal GIS functions)
-
-Temporal GIS datetime math functions to be used in library functions and modules.
-
(C) 2011-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.
- at author Soeren Gebbert
+:authors: Soeren Gebbert
"""
from datetime import datetime, date, time, timedelta
from core import *
@@ -27,7 +24,7 @@
###############################################################################
def relative_time_to_time_delta(value):
- """!Convert the double value representing days
+ """Convert the double value representing days
into a timedelta object.
"""
@@ -41,7 +38,7 @@
def time_delta_to_relative_time(delta):
- """!Convert the time delta into a
+ """Convert the time delta into a
double value, representing days.
"""
@@ -51,7 +48,7 @@
def relative_time_to_time_delta_seconds(value):
- """!Convert the double value representing seconds
+ """Convert the double value representing seconds
into a timedelta object.
"""
@@ -64,7 +61,7 @@
def time_delta_to_relative_time_seconds(delta):
- """!Convert the time delta into a
+ """Convert the time delta into a
double value, representing seconds.
"""
@@ -74,159 +71,157 @@
def decrement_datetime_by_string(mydate, increment, mult=1):
- """!Return a new datetime object decremented with the provided
+ """Return a new datetime object decremented with the provided
relative dates specified as string.
Additional a multiplier can be specified to multiply the increment
before adding to the provided datetime object.
Usage:
- @code
+ .. code-block:: python
- >>> dt = datetime(2001, 1, 1, 0, 0, 0)
- >>> string = "31 days"
- >>> decrement_datetime_by_string(dt, string)
- datetime.datetime(2000, 12, 1, 0, 0)
+ >>> dt = datetime(2001, 1, 1, 0, 0, 0)
+ >>> string = "31 days"
+ >>> decrement_datetime_by_string(dt, string)
+ datetime.datetime(2000, 12, 1, 0, 0)
- >>> dt = datetime(2001, 1, 1, 0, 0, 0)
- >>> string = "1 month"
- >>> decrement_datetime_by_string(dt, string)
- datetime.datetime(2000, 12, 1, 0, 0)
+ >>> dt = datetime(2001, 1, 1, 0, 0, 0)
+ >>> string = "1 month"
+ >>> decrement_datetime_by_string(dt, string)
+ datetime.datetime(2000, 12, 1, 0, 0)
- >>> dt = datetime(2001, 1, 1, 0, 0, 0)
- >>> string = "2 month"
- >>> decrement_datetime_by_string(dt, string)
- datetime.datetime(2000, 11, 1, 0, 0)
+ >>> dt = datetime(2001, 1, 1, 0, 0, 0)
+ >>> string = "2 month"
+ >>> decrement_datetime_by_string(dt, string)
+ datetime.datetime(2000, 11, 1, 0, 0)
- >>> dt = datetime(2001, 1, 1, 0, 0, 0)
- >>> string = "24 months"
- >>> decrement_datetime_by_string(dt, string)
- datetime.datetime(1999, 1, 1, 0, 0)
+ >>> dt = datetime(2001, 1, 1, 0, 0, 0)
+ >>> string = "24 months"
+ >>> decrement_datetime_by_string(dt, string)
+ datetime.datetime(1999, 1, 1, 0, 0)
- >>> dt = datetime(2001, 1, 1, 0, 0, 0)
- >>> string = "48 months"
- >>> decrement_datetime_by_string(dt, string)
- datetime.datetime(1997, 1, 1, 0, 0)
+ >>> dt = datetime(2001, 1, 1, 0, 0, 0)
+ >>> string = "48 months"
+ >>> decrement_datetime_by_string(dt, string)
+ datetime.datetime(1997, 1, 1, 0, 0)
- >>> dt = datetime(2001, 6, 1, 0, 0, 0)
- >>> string = "5 months"
- >>> decrement_datetime_by_string(dt, string)
- datetime.datetime(2001, 1, 1, 0, 0)
+ >>> dt = datetime(2001, 6, 1, 0, 0, 0)
+ >>> string = "5 months"
+ >>> decrement_datetime_by_string(dt, string)
+ datetime.datetime(2001, 1, 1, 0, 0)
- >>> dt = datetime(2001, 6, 1, 0, 0, 0)
- >>> string = "7 months"
- >>> decrement_datetime_by_string(dt, string)
- datetime.datetime(2000, 11, 1, 0, 0)
+ >>> dt = datetime(2001, 6, 1, 0, 0, 0)
+ >>> string = "7 months"
+ >>> decrement_datetime_by_string(dt, string)
+ datetime.datetime(2000, 11, 1, 0, 0)
- >>> dt = datetime(2001, 1, 1, 0, 0, 0)
- >>> string = "1 year"
- >>> decrement_datetime_by_string(dt, string)
- datetime.datetime(2000, 1, 1, 0, 0)
+ >>> dt = datetime(2001, 1, 1, 0, 0, 0)
+ >>> string = "1 year"
+ >>> decrement_datetime_by_string(dt, string)
+ datetime.datetime(2000, 1, 1, 0, 0)
- @endcode
- @param mydate A datetime object to incremented
- @param increment A string providing increment information:
+ :param mydate: A datetime object to incremented
+ :param increment: A string providing increment information:
The string may include comma separated values of type seconds,
minutes, hours, days, weeks, months and years
Example: Increment the datetime 2001-01-01 00:00:00
with "60 seconds, 4 minutes, 12 hours, 10 days, 1 weeks, 5 months, 1 years"
will result in the datetime 2003-02-18 12:05:00
- @param mult A multiplier, default is 1
- @return The new datetime object or none in case of an error
+ :param mult: A multiplier, default is 1
+ :return: The new datetime object or none in case of an error
"""
return modify_datetime_by_string(mydate, increment, mult, sign=int(-1))
###############################################################################
def increment_datetime_by_string(mydate, increment, mult=1):
- """!Return a new datetime object incremented with the provided
+ """Return a new datetime object incremented with the provided
relative dates specified as string.
Additional a multiplier can be specified to multiply the increment
before adding to the provided datetime object.
Usage:
- @code
+ .. code-block:: python
- >>> dt = datetime(2001, 9, 1, 0, 0, 0)
- >>> string = "60 seconds, 4 minutes, 12 hours, 10 days, 1 weeks, 5 months, 1 years"
- >>> increment_datetime_by_string(dt, string)
- datetime.datetime(2003, 2, 18, 12, 5)
+ >>> dt = datetime(2001, 9, 1, 0, 0, 0)
+ >>> string = "60 seconds, 4 minutes, 12 hours, 10 days, 1 weeks, 5 months, 1 years"
+ >>> increment_datetime_by_string(dt, string)
+ datetime.datetime(2003, 2, 18, 12, 5)
- >>> dt = datetime(2001, 11, 1, 0, 0, 0)
- >>> string = "1 months"
- >>> increment_datetime_by_string(dt, string)
- datetime.datetime(2001, 12, 1, 0, 0)
+ >>> dt = datetime(2001, 11, 1, 0, 0, 0)
+ >>> string = "1 months"
+ >>> increment_datetime_by_string(dt, string)
+ datetime.datetime(2001, 12, 1, 0, 0)
- >>> dt = datetime(2001, 11, 1, 0, 0, 0)
- >>> string = "13 months"
- >>> increment_datetime_by_string(dt, string)
- datetime.datetime(2002, 12, 1, 0, 0)
+ >>> dt = datetime(2001, 11, 1, 0, 0, 0)
+ >>> string = "13 months"
+ >>> increment_datetime_by_string(dt, string)
+ datetime.datetime(2002, 12, 1, 0, 0)
- >>> dt = datetime(2001, 1, 1, 0, 0, 0)
- >>> string = "72 months"
- >>> increment_datetime_by_string(dt, string)
- datetime.datetime(2007, 1, 1, 0, 0)
+ >>> dt = datetime(2001, 1, 1, 0, 0, 0)
+ >>> string = "72 months"
+ >>> increment_datetime_by_string(dt, string)
+ datetime.datetime(2007, 1, 1, 0, 0)
- >>> dt = datetime(2001, 1, 1, 0, 0, 0)
- >>> string = "72 months"
- >>> increment_datetime_by_string(dt, string)
- datetime.datetime(2007, 1, 1, 0, 0)
+ >>> dt = datetime(2001, 1, 1, 0, 0, 0)
+ >>> string = "72 months"
+ >>> increment_datetime_by_string(dt, string)
+ datetime.datetime(2007, 1, 1, 0, 0)
- >>> dt = datetime(2001, 1, 1, 0, 0, 0)
- >>> string = "5 minutes"
- >>> increment_datetime_by_string(dt, string)
- datetime.datetime(2001, 1, 1, 0, 5)
+ >>> dt = datetime(2001, 1, 1, 0, 0, 0)
+ >>> string = "5 minutes"
+ >>> increment_datetime_by_string(dt, string)
+ datetime.datetime(2001, 1, 1, 0, 5)
- >>> dt = datetime(2001, 1, 1, 0, 0, 0)
- >>> string = "49 hours"
- >>> increment_datetime_by_string(dt, string)
- datetime.datetime(2001, 1, 3, 1, 0)
+ >>> dt = datetime(2001, 1, 1, 0, 0, 0)
+ >>> string = "49 hours"
+ >>> increment_datetime_by_string(dt, string)
+ datetime.datetime(2001, 1, 3, 1, 0)
- >>> dt = datetime(2001, 1, 1, 0, 0, 0)
- >>> string = "3600 seconds"
- >>> increment_datetime_by_string(dt, string)
- datetime.datetime(2001, 1, 1, 1, 0)
+ >>> dt = datetime(2001, 1, 1, 0, 0, 0)
+ >>> string = "3600 seconds"
+ >>> increment_datetime_by_string(dt, string)
+ datetime.datetime(2001, 1, 1, 1, 0)
- >>> dt = datetime(2001, 1, 1, 0, 0, 0)
- >>> string = "30 days"
- >>> increment_datetime_by_string(dt, string)
- datetime.datetime(2001, 1, 31, 0, 0)
+ >>> dt = datetime(2001, 1, 1, 0, 0, 0)
+ >>> string = "30 days"
+ >>> increment_datetime_by_string(dt, string)
+ datetime.datetime(2001, 1, 31, 0, 0)
- @endcode
- @param mydate A datetime object to incremented
- @param increment A string providing increment information:
+ :param mydate: A datetime object to incremented
+ :param increment: A string providing increment information:
The string may include comma separated values of type seconds,
minutes, hours, days, weeks, months and years
Example: Increment the datetime 2001-01-01 00:00:00
with "60 seconds, 4 minutes, 12 hours, 10 days, 1 weeks, 5 months, 1 years"
will result in the datetime 2003-02-18 12:05:00
- @param mult A multiplier, default is 1
- @return The new datetime object or none in case of an error
+ :param mult: A multiplier, default is 1
+ :return: The new datetime object or none in case of an error
"""
return modify_datetime_by_string(mydate, increment, mult, sign=int(1))
###############################################################################
def modify_datetime_by_string(mydate, increment, mult=1, sign=1):
- """!Return a new datetime object incremented with the provided
+ """Return a new datetime object incremented with the provided
relative dates specified as string.
Additional a multiplier can be specified to multiply the increment
before adding to the provided datetime object.
- @param mydate A datetime object to incremented
- @param increment A string providing increment information:
+ :param mydate: A datetime object to incremented
+ :param increment: A string providing increment information:
The string may include comma separated values of type seconds,
minutes, hours, days, weeks, months and years
Example: Increment the datetime 2001-01-01 00:00:00
with "60 seconds, 4 minutes, 12 hours, 10 days, 1 weeks, 5 months, 1 years"
will result in the datetime 2003-02-18 12:05:00
- @param mult A multiplier, default is 1
- @param sign Choose 1 for positive sign (incrementing) or -1 for negative
+ :param mult: A multiplier, default is 1
+ :param sign: Choose 1 for positive sign (incrementing) or -1 for negative
sign (decrementing).
- @return The new datetime object or none in case of an error
+ :return: The new datetime object or none in case of an error
"""
sign = int(sign)
if sign != 1 and sign != -1:
@@ -279,7 +274,7 @@
def modify_datetime(mydate, years=0, months=0, weeks=0, days=0, hours=0,
minutes=0, seconds=0):
- """!Return a new datetime object incremented with the provided
+ """Return a new datetime object incremented with the provided
relative dates and times"""
tdelta_seconds = timedelta(seconds=seconds)
@@ -354,7 +349,7 @@
def adjust_datetime_to_granularity(mydate, granularity):
- """!Modify the datetime object to fit the given granularity
+ """Modify the datetime object to fit the given granularity
- Years will start at the first of Januar
- Months will start at the first day of the month
@@ -364,43 +359,42 @@
Usage:
- @code
+ .. code-block:: python
- >>> dt = datetime(2001, 8, 8, 12,30,30)
- >>> adjust_datetime_to_granularity(dt, "5 seconds")
- datetime.datetime(2001, 8, 8, 12, 30, 30)
+ >>> dt = datetime(2001, 8, 8, 12,30,30)
+ >>> adjust_datetime_to_granularity(dt, "5 seconds")
+ datetime.datetime(2001, 8, 8, 12, 30, 30)
- >>> adjust_datetime_to_granularity(dt, "20 minutes")
- datetime.datetime(2001, 8, 8, 12, 30)
+ >>> adjust_datetime_to_granularity(dt, "20 minutes")
+ datetime.datetime(2001, 8, 8, 12, 30)
- >>> adjust_datetime_to_granularity(dt, "20 minutes")
- datetime.datetime(2001, 8, 8, 12, 30)
+ >>> adjust_datetime_to_granularity(dt, "20 minutes")
+ datetime.datetime(2001, 8, 8, 12, 30)
- >>> adjust_datetime_to_granularity(dt, "3 hours")
- datetime.datetime(2001, 8, 8, 12, 0)
+ >>> adjust_datetime_to_granularity(dt, "3 hours")
+ datetime.datetime(2001, 8, 8, 12, 0)
- >>> adjust_datetime_to_granularity(dt, "5 days")
- datetime.datetime(2001, 8, 8, 0, 0)
+ >>> adjust_datetime_to_granularity(dt, "5 days")
+ datetime.datetime(2001, 8, 8, 0, 0)
- >>> adjust_datetime_to_granularity(dt, "2 weeks")
- datetime.datetime(2001, 8, 6, 0, 0)
+ >>> adjust_datetime_to_granularity(dt, "2 weeks")
+ datetime.datetime(2001, 8, 6, 0, 0)
- >>> adjust_datetime_to_granularity(dt, "6 months")
- datetime.datetime(2001, 8, 1, 0, 0)
+ >>> adjust_datetime_to_granularity(dt, "6 months")
+ datetime.datetime(2001, 8, 1, 0, 0)
- >>> adjust_datetime_to_granularity(dt, "2 years")
- datetime.datetime(2001, 1, 1, 0, 0)
+ >>> adjust_datetime_to_granularity(dt, "2 years")
+ datetime.datetime(2001, 1, 1, 0, 0)
- >>> adjust_datetime_to_granularity(dt, "2 years, 3 months, 5 days, 3 hours, 3 minutes, 2 seconds")
- datetime.datetime(2001, 8, 8, 12, 30, 30)
+ >>> adjust_datetime_to_granularity(dt, "2 years, 3 months, 5 days, 3 hours, 3 minutes, 2 seconds")
+ datetime.datetime(2001, 8, 8, 12, 30, 30)
- >>> adjust_datetime_to_granularity(dt, "3 months, 5 days, 3 minutes")
- datetime.datetime(2001, 8, 8, 12, 30)
+ >>> adjust_datetime_to_granularity(dt, "3 months, 5 days, 3 minutes")
+ datetime.datetime(2001, 8, 8, 12, 30)
- >>> adjust_datetime_to_granularity(dt, "3 weeks, 5 days")
- datetime.datetime(2001, 8, 8, 0, 0)
+ >>> adjust_datetime_to_granularity(dt, "3 weeks, 5 days")
+ datetime.datetime(2001, 8, 8, 0, 0)
- @endcode
"""
if granularity:
@@ -486,136 +480,135 @@
def compute_datetime_delta(start, end):
- """!Return a dictionary with the accumulated delta in year, month, day,
+ """Return a dictionary with the accumulated delta in year, month, day,
hour, minute and second
Usage:
- @code
+ .. code-block:: python
- >>> start = datetime(2001, 1, 1, 00,00,00)
- >>> end = datetime(2001, 1, 1, 00,00,00)
- >>> compute_datetime_delta(start, end)
- {'hour': 0, 'month': 0, 'second': 0, 'max_days': 0, 'year': 0, 'day': 0, 'minute': 0}
+ >>> start = datetime(2001, 1, 1, 00,00,00)
+ >>> end = datetime(2001, 1, 1, 00,00,00)
+ >>> compute_datetime_delta(start, end)
+ {'hour': 0, 'month': 0, 'second': 0, 'max_days': 0, 'year': 0, 'day': 0, 'minute': 0}
- >>> start = datetime(2001, 1, 1, 00,00,14)
- >>> end = datetime(2001, 1, 1, 00,00,44)
- >>> compute_datetime_delta(start, end)
- {'hour': 0, 'month': 0, 'second': 30, 'max_days': 0, 'year': 0, 'day': 0, 'minute': 0}
+ >>> start = datetime(2001, 1, 1, 00,00,14)
+ >>> end = datetime(2001, 1, 1, 00,00,44)
+ >>> compute_datetime_delta(start, end)
+ {'hour': 0, 'month': 0, 'second': 30, 'max_days': 0, 'year': 0, 'day': 0, 'minute': 0}
- >>> start = datetime(2001, 1, 1, 00,00,44)
- >>> end = datetime(2001, 1, 1, 00,01,14)
- >>> compute_datetime_delta(start, end)
- {'hour': 0, 'month': 0, 'second': 30, 'max_days': 0, 'year': 0, 'day': 0, 'minute': 1}
+ >>> start = datetime(2001, 1, 1, 00,00,44)
+ >>> end = datetime(2001, 1, 1, 00,01,14)
+ >>> compute_datetime_delta(start, end)
+ {'hour': 0, 'month': 0, 'second': 30, 'max_days': 0, 'year': 0, 'day': 0, 'minute': 1}
- >>> start = datetime(2001, 1, 1, 00,00,30)
- >>> end = datetime(2001, 1, 1, 00,05,30)
- >>> compute_datetime_delta(start, end)
- {'hour': 0, 'month': 0, 'second': 300, 'max_days': 0, 'year': 0, 'day': 0, 'minute': 5}
+ >>> start = datetime(2001, 1, 1, 00,00,30)
+ >>> end = datetime(2001, 1, 1, 00,05,30)
+ >>> compute_datetime_delta(start, end)
+ {'hour': 0, 'month': 0, 'second': 300, 'max_days': 0, 'year': 0, 'day': 0, 'minute': 5}
- >>> start = datetime(2001, 1, 1, 00,00,00)
- >>> end = datetime(2001, 1, 1, 00,01,00)
- >>> compute_datetime_delta(start, end)
- {'hour': 0, 'month': 0, 'second': 0, 'max_days': 0, 'year': 0, 'day': 0, 'minute': 1}
+ >>> start = datetime(2001, 1, 1, 00,00,00)
+ >>> end = datetime(2001, 1, 1, 00,01,00)
+ >>> compute_datetime_delta(start, end)
+ {'hour': 0, 'month': 0, 'second': 0, 'max_days': 0, 'year': 0, 'day': 0, 'minute': 1}
- >>> start = datetime(2011,10,31, 00,45,00)
- >>> end = datetime(2011,10,31, 01,45,00)
- >>> compute_datetime_delta(start, end)
- {'hour': 1, 'second': 0, 'max_days': 0, 'year': 0, 'day': 0, 'minute': 60}
+ >>> start = datetime(2011,10,31, 00,45,00)
+ >>> end = datetime(2011,10,31, 01,45,00)
+ >>> compute_datetime_delta(start, end)
+ {'hour': 1, 'second': 0, 'max_days': 0, 'year': 0, 'day': 0, 'minute': 60}
- >>> start = datetime(2011,10,31, 00,45,00)
- >>> end = datetime(2011,10,31, 01,15,00)
- >>> compute_datetime_delta(start, end)
- {'hour': 1, 'second': 0, 'max_days': 0, 'year': 0, 'day': 0, 'minute': 30}
+ >>> start = datetime(2011,10,31, 00,45,00)
+ >>> end = datetime(2011,10,31, 01,15,00)
+ >>> compute_datetime_delta(start, end)
+ {'hour': 1, 'second': 0, 'max_days': 0, 'year': 0, 'day': 0, 'minute': 30}
- >>> start = datetime(2011,10,31, 00,45,00)
- >>> end = datetime(2011,10,31, 12,15,00)
- >>> compute_datetime_delta(start, end)
- {'hour': 12, 'second': 0, 'max_days': 0, 'year': 0, 'day': 0, 'minute': 690}
+ >>> start = datetime(2011,10,31, 00,45,00)
+ >>> end = datetime(2011,10,31, 12,15,00)
+ >>> compute_datetime_delta(start, end)
+ {'hour': 12, 'second': 0, 'max_days': 0, 'year': 0, 'day': 0, 'minute': 690}
- >>> start = datetime(2011,10,31, 00,00,00)
- >>> end = datetime(2011,10,31, 01,00,00)
- >>> compute_datetime_delta(start, end)
- {'hour': 1, 'second': 0, 'max_days': 0, 'year': 0, 'day': 0, 'minute': 0}
+ >>> start = datetime(2011,10,31, 00,00,00)
+ >>> end = datetime(2011,10,31, 01,00,00)
+ >>> compute_datetime_delta(start, end)
+ {'hour': 1, 'second': 0, 'max_days': 0, 'year': 0, 'day': 0, 'minute': 0}
- >>> start = datetime(2011,10,31, 00,00,00)
- >>> end = datetime(2011,11,01, 01,00,00)
- >>> compute_datetime_delta(start, end)
- {'hour': 25, 'second': 0, 'max_days': 1, 'year': 0, 'day': 1, 'minute': 0}
+ >>> start = datetime(2011,10,31, 00,00,00)
+ >>> end = datetime(2011,11,01, 01,00,00)
+ >>> compute_datetime_delta(start, end)
+ {'hour': 25, 'second': 0, 'max_days': 1, 'year': 0, 'day': 1, 'minute': 0}
- >>> start = datetime(2011,10,31, 12,00,00)
- >>> end = datetime(2011,11,01, 06,00,00)
- >>> compute_datetime_delta(start, end)
- {'hour': 18, 'second': 0, 'max_days': 0, 'year': 0, 'day': 0, 'minute': 0}
+ >>> start = datetime(2011,10,31, 12,00,00)
+ >>> end = datetime(2011,11,01, 06,00,00)
+ >>> compute_datetime_delta(start, end)
+ {'hour': 18, 'second': 0, 'max_days': 0, 'year': 0, 'day': 0, 'minute': 0}
- >>> start = datetime(2011,11,01, 00,00,00)
- >>> end = datetime(2011,12,01, 01,00,00)
- >>> compute_datetime_delta(start, end)
- {'hour': 721, 'month': 1, 'second': 0, 'max_days': 30, 'year': 0, 'day': 0, 'minute': 0}
+ >>> start = datetime(2011,11,01, 00,00,00)
+ >>> end = datetime(2011,12,01, 01,00,00)
+ >>> compute_datetime_delta(start, end)
+ {'hour': 721, 'month': 1, 'second': 0, 'max_days': 30, 'year': 0, 'day': 0, 'minute': 0}
- >>> start = datetime(2011,11,01, 00,00,00)
- >>> end = datetime(2011,11,05, 00,00,00)
- >>> compute_datetime_delta(start, end)
- {'hour': 0, 'second': 0, 'max_days': 4, 'year': 0, 'day': 4, 'minute': 0}
+ >>> start = datetime(2011,11,01, 00,00,00)
+ >>> end = datetime(2011,11,05, 00,00,00)
+ >>> compute_datetime_delta(start, end)
+ {'hour': 0, 'second': 0, 'max_days': 4, 'year': 0, 'day': 4, 'minute': 0}
- >>> start = datetime(2011,10,06, 00,00,00)
- >>> end = datetime(2011,11,05, 00,00,00)
- >>> compute_datetime_delta(start, end)
- {'hour': 0, 'second': 0, 'max_days': 30, 'year': 0, 'day': 30, 'minute': 0}
+ >>> start = datetime(2011,10,06, 00,00,00)
+ >>> end = datetime(2011,11,05, 00,00,00)
+ >>> compute_datetime_delta(start, end)
+ {'hour': 0, 'second': 0, 'max_days': 30, 'year': 0, 'day': 30, 'minute': 0}
- >>> start = datetime(2011,12,02, 00,00,00)
- >>> end = datetime(2012,01,01, 00,00,00)
- >>> compute_datetime_delta(start, end)
- {'hour': 0, 'second': 0, 'max_days': 30, 'year': 1, 'day': 30, 'minute': 0}
+ >>> start = datetime(2011,12,02, 00,00,00)
+ >>> end = datetime(2012,01,01, 00,00,00)
+ >>> compute_datetime_delta(start, end)
+ {'hour': 0, 'second': 0, 'max_days': 30, 'year': 1, 'day': 30, 'minute': 0}
- >>> start = datetime(2011,01,01, 00,00,00)
- >>> end = datetime(2011,02,01, 00,00,00)
- >>> compute_datetime_delta(start, end)
- {'hour': 0, 'month': 1, 'second': 0, 'max_days': 31, 'year': 0, 'day': 0, 'minute': 0}
+ >>> start = datetime(2011,01,01, 00,00,00)
+ >>> end = datetime(2011,02,01, 00,00,00)
+ >>> compute_datetime_delta(start, end)
+ {'hour': 0, 'month': 1, 'second': 0, 'max_days': 31, 'year': 0, 'day': 0, 'minute': 0}
- >>> start = datetime(2011,12,01, 00,00,00)
- >>> end = datetime(2012,01,01, 00,00,00)
- >>> compute_datetime_delta(start, end)
- {'hour': 0, 'month': 1, 'second': 0, 'max_days': 31, 'year': 1, 'day': 0, 'minute': 0}
+ >>> start = datetime(2011,12,01, 00,00,00)
+ >>> end = datetime(2012,01,01, 00,00,00)
+ >>> compute_datetime_delta(start, end)
+ {'hour': 0, 'month': 1, 'second': 0, 'max_days': 31, 'year': 1, 'day': 0, 'minute': 0}
- >>> start = datetime(2011,12,01, 00,00,00)
- >>> end = datetime(2012,06,01, 00,00,00)
- >>> compute_datetime_delta(start, end)
- {'hour': 0, 'month': 6, 'second': 0, 'max_days': 183, 'year': 1, 'day': 0, 'minute': 0}
+ >>> start = datetime(2011,12,01, 00,00,00)
+ >>> end = datetime(2012,06,01, 00,00,00)
+ >>> compute_datetime_delta(start, end)
+ {'hour': 0, 'month': 6, 'second': 0, 'max_days': 183, 'year': 1, 'day': 0, 'minute': 0}
- >>> start = datetime(2011,06,01, 00,00,00)
- >>> end = datetime(2021,06,01, 00,00,00)
- >>> compute_datetime_delta(start, end)
- {'hour': 0, 'month': 120, 'second': 0, 'max_days': 3653, 'year': 10, 'day': 0, 'minute': 0}
+ >>> start = datetime(2011,06,01, 00,00,00)
+ >>> end = datetime(2021,06,01, 00,00,00)
+ >>> compute_datetime_delta(start, end)
+ {'hour': 0, 'month': 120, 'second': 0, 'max_days': 3653, 'year': 10, 'day': 0, 'minute': 0}
- >>> start = datetime(2011,06,01, 00,00,00)
- >>> end = datetime(2012,06,01, 12,00,00)
- >>> compute_datetime_delta(start, end)
- {'hour': 8796, 'month': 12, 'second': 0, 'max_days': 366, 'year': 1, 'day': 0, 'minute': 0}
+ >>> start = datetime(2011,06,01, 00,00,00)
+ >>> end = datetime(2012,06,01, 12,00,00)
+ >>> compute_datetime_delta(start, end)
+ {'hour': 8796, 'month': 12, 'second': 0, 'max_days': 366, 'year': 1, 'day': 0, 'minute': 0}
- >>> start = datetime(2011,06,01, 00,00,00)
- >>> end = datetime(2012,06,01, 12,30,00)
- >>> compute_datetime_delta(start, end)
- {'hour': 8796, 'month': 12, 'second': 0, 'max_days': 366, 'year': 1, 'day': 0, 'minute': 527790}
+ >>> start = datetime(2011,06,01, 00,00,00)
+ >>> end = datetime(2012,06,01, 12,30,00)
+ >>> compute_datetime_delta(start, end)
+ {'hour': 8796, 'month': 12, 'second': 0, 'max_days': 366, 'year': 1, 'day': 0, 'minute': 527790}
- >>> start = datetime(2011,06,01, 00,00,00)
- >>> end = datetime(2012,06,01, 12,00,05)
- >>> compute_datetime_delta(start, end)
- {'hour': 8796, 'month': 12, 'second': 31665605, 'max_days': 366, 'year': 1, 'day': 0, 'minute': 0}
+ >>> start = datetime(2011,06,01, 00,00,00)
+ >>> end = datetime(2012,06,01, 12,00,05)
+ >>> compute_datetime_delta(start, end)
+ {'hour': 8796, 'month': 12, 'second': 31665605, 'max_days': 366, 'year': 1, 'day': 0, 'minute': 0}
- >>> start = datetime(2011,06,01, 00,00,00)
- >>> end = datetime(2012,06,01, 00,30,00)
- >>> compute_datetime_delta(start, end)
- {'hour': 0, 'month': 12, 'second': 0, 'max_days': 366, 'year': 1, 'day': 0, 'minute': 527070}
+ >>> start = datetime(2011,06,01, 00,00,00)
+ >>> end = datetime(2012,06,01, 00,30,00)
+ >>> compute_datetime_delta(start, end)
+ {'hour': 0, 'month': 12, 'second': 0, 'max_days': 366, 'year': 1, 'day': 0, 'minute': 527070}
- >>> start = datetime(2011,06,01, 00,00,00)
- >>> end = datetime(2012,06,01, 00,00,05)
- >>> compute_datetime_delta(start, end)
- {'hour': 0, 'month': 12, 'second': 31622405, 'max_days': 366, 'year': 1, 'day': 0, 'minute': 0}
+ >>> start = datetime(2011,06,01, 00,00,00)
+ >>> end = datetime(2012,06,01, 00,00,05)
+ >>> compute_datetime_delta(start, end)
+ {'hour': 0, 'month': 12, 'second': 31622405, 'max_days': 366, 'year': 1, 'day': 0, 'minute': 0}
- @endcode
- @return A dictionary with year, month, day, hour, minute and second as keys()
+ :return: A dictionary with year, month, day, hour, minute and second as keys()
"""
comp = {}
@@ -702,16 +695,17 @@
def check_datetime_string(time_string):
- """!Check if a string can be converted into a datetime object
+ """Check if a string can be converted into a datetime object
Supported ISO string formats are:
+
- YYYY-mm-dd
- YYYY-mm-dd HH:MM:SS
Time zones are not supported
- @param time_string The time string to be checked for conversion
- @return datetime object or an error message string in case of an error
+ :param time_string: The time string to be checked for conversion
+ :return: datetime: object or an error message string in case of an error
"""
global has_dateutil
@@ -754,9 +748,10 @@
def string_to_datetime(time_string):
- """!Convert a string into a datetime object
+ """Convert a string into a datetime object
In case datutil is not installed the supported ISO string formats are:
+
- YYYY-mm-dd
- YYYY-mm-dd HH:MM:SS
- Time zones are not supported
@@ -764,8 +759,8 @@
If dateutil is installed, all string formats of the dateutil module
are supported, as well as time zones
- @param time_string The time string to convert
- @return datetime object or None in case the string
+ :param time_string: The time string to convert
+ :return: datetime: object or None in case the string
could not be converted
"""
@@ -784,26 +779,25 @@
def datetime_to_grass_datetime_string(dt):
- """!Convert a python datetime object into a GRASS datetime string
+ """Convert a python datetime object into a GRASS datetime string
- @code
+ .. code-block:: python
- >>> import grass.temporal as tgis
- >>> import dateutil.parser as parser
- >>> dt = parser.parse("2011-01-01 10:00:00 +01:30")
- >>> tgis.datetime_to_grass_datetime_string(dt)
- '01 jan 2011 10:00:00 +0090'
- >>> dt = parser.parse("2011-01-01 10:00:00 +02:30")
- >>> tgis.datetime_to_grass_datetime_string(dt)
- '01 jan 2011 10:00:00 +0150'
- >>> dt = parser.parse("2011-01-01 10:00:00 +12:00")
- >>> tgis.datetime_to_grass_datetime_string(dt)
- '01 jan 2011 10:00:00 +0720'
- >>> dt = parser.parse("2011-01-01 10:00:00 -01:30")
- >>> tgis.datetime_to_grass_datetime_string(dt)
- '01 jan 2011 10:00:00 -0090'
+ >>> import grass.temporal as tgis
+ >>> import dateutil.parser as parser
+ >>> dt = parser.parse("2011-01-01 10:00:00 +01:30")
+ >>> tgis.datetime_to_grass_datetime_string(dt)
+ '01 jan 2011 10:00:00 +0090'
+ >>> dt = parser.parse("2011-01-01 10:00:00 +02:30")
+ >>> tgis.datetime_to_grass_datetime_string(dt)
+ '01 jan 2011 10:00:00 +0150'
+ >>> dt = parser.parse("2011-01-01 10:00:00 +12:00")
+ >>> tgis.datetime_to_grass_datetime_string(dt)
+ '01 jan 2011 10:00:00 +0720'
+ >>> dt = parser.parse("2011-01-01 10:00:00 -01:30")
+ >>> tgis.datetime_to_grass_datetime_string(dt)
+ '01 jan 2011 10:00:00 -0090'
- @endcode
"""
# GRASS datetime month names
month_names = ["", "jan", "feb", "mar", "apr", "may", "jun",
@@ -843,14 +837,14 @@
def create_suffix_from_datetime(start_time, granularity):
- """!Create a datetime string based on a datetime object and a provided
+ """Create a datetime string based on a datetime object and a provided
granularity that can be used as suffix for map names.
dateteime=2001-01-01 00:00:00, granularity="1 month" returns "2001_01"
- @param start_time The datetime object
- @param granularity The granularity for example "1 month" or "100 seconds"
- @return A string
+ :param start_time: The datetime object
+ :param granularity: The granularity for example "1 month" or "100 seconds"
+ :return: A string
"""
global suffix_units
return start_time.strftime(suffix_units[granularity.split(' ')[1]])
Modified: grass/trunk/lib/python/temporal/extract.py
===================================================================
--- grass/trunk/lib/python/temporal/extract.py 2014-09-28 01:40:32 UTC (rev 62120)
+++ grass/trunk/lib/python/temporal/extract.py 2014-09-28 01:46:15 UTC (rev 62121)
@@ -1,15 +1,12 @@
-"""!@package grass.temporal
+"""
+Extract functions for space time raster, 3d raster and vector datasets
- at brief GRASS Python scripting module (temporal GIS functions)
-
-Temporal GIS related functions to be used in Python scripts.
-
(C) 2012-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.
- at author Soeren Gebbert
+:authors: Soeren Gebbert
"""
from grass.script.utils import get_num_suffix
@@ -24,28 +21,28 @@
def extract_dataset(input, output, type, where, expression, base, nprocs=1,
register_null=False, layer=1,
vtype="point,line,boundary,centroid,area,face"):
- """!Extract a subset of a space time raster, raster3d or vector dataset
+ """Extract a subset of a space time raster, raster3d or vector dataset
A mapcalc expression can be provided to process the temporal extracted
maps.
Mapcalc expressions are supported for raster and raster3d maps.
- @param input The name of the input space time raster/raster3d dataset
- @param output The name of the extracted new space time raster/raster3d
+ :param input: The name of the input space time raster/raster3d dataset
+ :param output: The name of the extracted new space time raster/raster3d
dataset
- @param type The type of the dataset: "raster", "raster3d" or vector
- @param where The temporal SQL WHERE statement for subset extraction
- @param expression The r(3).mapcalc expression or the v.extract where
+ :param type: The type of the dataset: "raster", "raster3d" or vector
+ :param where: The temporal SQL WHERE statement for subset extraction
+ :param expression: The r(3).mapcalc expression or the v.extract where
statement
- @param base The base name of the new created maps in case a mapclac
+ :param base: The base name of the new created maps in case a mapclac
expression is provided
- @param nprocs The number of parallel processes to be used for mapcalc
+ :param nprocs: The number of parallel processes to be used for mapcalc
processing
- @param register_null Set this number True to register empty maps
+ :param register_null: Set this number True to register empty maps
(only raster and raster3d maps)
- @param layer The vector layer number to be used when no timestamped
+ :param layer: The vector layer number to be used when no timestamped
layer is present, default is 1
- @param vtype The feature type to be extracted for vector maps, default
+ :param vtype: The feature type to be extracted for vector maps, default
is point,line,boundary,centroid,area and face
"""
Modified: grass/trunk/lib/python/temporal/factory.py
===================================================================
--- grass/trunk/lib/python/temporal/factory.py 2014-09-28 01:40:32 UTC (rev 62120)
+++ grass/trunk/lib/python/temporal/factory.py 2014-09-28 01:46:15 UTC (rev 62121)
@@ -1,25 +1,21 @@
-"""!@package grass.temporal
+"""
+Object factory
- at brief GRASS Python scripting module (temporal GIS functions)
-
-Temporal GIS related functions to be used in Python scripts.
-
Usage:
- at code
-import grass.temporal as tgis
+.. code-block:: python
-tgis.register_maps_in_space_time_dataset(type, name, maps)
+ import grass.temporal as tgis
-...
- at endcode
+ tgis.register_maps_in_space_time_dataset(type, name, maps)
+
(C) 2012-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.
- at author Soeren Gebbert
+:authors: Soeren Gebbert
"""
from space_time_datasets import *
@@ -28,11 +24,11 @@
def dataset_factory(type, id):
- """!A factory functions to create space time or map datasets
+ """A factory functions to create space time or map datasets
- @param type the dataset type: rast or raster, rast3d,
+ :param type: the dataset type: rast or raster, rast3d,
vect or vector, strds, str3ds, stvds
- @param id The id of the dataset ("name at mapset")
+ :param id: The id of the dataset ("name at mapset")
"""
if type == "strds":
sp = SpaceTimeRasterDataset(id)
Modified: grass/trunk/lib/python/temporal/gui_support.py
===================================================================
--- grass/trunk/lib/python/temporal/gui_support.py 2014-09-28 01:40:32 UTC (rev 62120)
+++ grass/trunk/lib/python/temporal/gui_support.py 2014-09-28 01:46:15 UTC (rev 62121)
@@ -1,16 +1,13 @@
-"""!@package grass.temporal
+"""
+GUI support functions
- at brief GRASS Python scripting module (temporal GIS functions)
-Temporal GIS related functions to be used in Python scripts.
-
-
(C) 2008-2011 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.
- at author Soeren Gebbert
+:authors: Soeren Gebbert
"""
from space_time_datasets import *
@@ -20,21 +17,22 @@
###############################################################################
def tlist_grouped(type, group_type = False, dbif=None):
- """!List of temporal elements grouped by mapsets.
+ """List of temporal elements grouped by mapsets.
Returns a dictionary where the keys are mapset
names and the values are lists of space time datasets in that
mapset. Example:
- @code
- >>> tgis.tlist_grouped('strds')['PERMANENT']
- ['precipitation', 'temperature']
- @endcode
+ .. code-block:: python
- @param type element type (strds, str3ds, stvds)
- @param group_type TBD
+ >>> tgis.tlist_grouped('strds')['PERMANENT']
+ ['precipitation', 'temperature']
- @return directory of mapsets/elements
+
+ :param type: element type (strds, str3ds, stvds)
+ :param group_type: TBD
+
+ :return: directory of mapsets/elements
"""
result = {}
dbif, connected = init_dbif(dbif)
@@ -80,11 +78,11 @@
###############################################################################
def tlist(type, dbif=None):
- """!Return a list of space time datasets of absolute and relative time
+ """Return a list of space time datasets of absolute and relative time
- @param type element type (strds, str3ds, stvds)
+ :param type: element type (strds, str3ds, stvds)
- @return a list of space time dataset ids
+ :return: a list of space time dataset ids
"""
id = None
sp = dataset_factory(type, id)
Modified: grass/trunk/lib/python/temporal/list_stds.py
===================================================================
--- grass/trunk/lib/python/temporal/list_stds.py 2014-09-28 01:40:32 UTC (rev 62120)
+++ grass/trunk/lib/python/temporal/list_stds.py 2014-09-28 01:46:15 UTC (rev 62121)
@@ -1,25 +1,21 @@
-"""!@package grass.temporal
+"""
+Functions to create space time dataset lists
- at brief GRASS Python scripting module (temporal GIS functions)
+Usage:
-Temporal GIS related functions to be used in Python scripts.
+.. code-block:: python
-Usage:
+ import grass.temporal as tgis
- at code
-import grass.temporal as tgis
+ tgis.register_maps_in_space_time_dataset(type, name, maps)
-tgis.register_maps_in_space_time_dataset(type, name, maps)
-...
- at endcode
-
(C) 2012-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.
- at author Soeren Gebbert
+:authors: Soeren Gebbert
"""
from space_time_datasets import *
@@ -29,40 +25,43 @@
###############################################################################
def get_dataset_list(type, temporal_type, columns=None, where=None, order=None):
- """! Return a list of time stamped maps or space time datasets of a specific temporal type
+ """ Return a list of time stamped maps or space time datasets of a specific temporal type
that are registred in the temporal database
This method returns a dictionary, the keys are the available mapsets,
the values are the rows from the SQL database query.
- @param type The type of the datasets (strds, str3ds, stvds, rast, rast3d, vect)
- @param temporal_type The temporal type of the datasets (absolute, relative)
- @param columns A comma separated list of columns that will be selected
- @param where A where statement for selected listing without "WHERE"
- @param order A comma separated list of columns to order the
+ :param type: The type of the datasets (strds, str3ds, stvds, rast, rast3d, vect)
+ :param temporal_type: The temporal type of the datasets (absolute, relative)
+ :param columns: A comma separated list of columns that will be selected
+ :param where: A where statement for selected listing without "WHERE"
+ :param order: A comma separated list of columns to order the
datasets by category
- @return A dictionary with the rows of the SQL query for each available mapset
+ :return: A dictionary with the rows of the SQL query for each available mapset
- >>> import grass.temporal as tgis
- >>> tgis.init()
- >>> name = "list_stds_test"
- >>> sp = tgis.open_new_stds(name=name, type="strds",
- ... temporaltype="absolute", title="title", descr="descr", semantic="mean", dbif=None, overwrite=True)
- >>> mapset = tgis.get_current_mapset()
- >>> stds_list = tgis.get_dataset_list("strds", "absolute", columns="name")
- >>> rows = stds_list[mapset]
- >>> for row in rows:
- ... if row["name"] == name:
- ... print True
- True
- >>> stds_list = tgis.get_dataset_list("strds", "absolute", columns="name,mapset", where="mapset = '%s'"%(mapset))
- >>> rows = stds_list[mapset]
- >>> for row in rows:
- ... if row["name"] == name and row["mapset"] == mapset:
- ... print True
- True
- >>> check = sp.delete()
+ .. code-block:: python
+
+ >>> import grass.temporal as tgis
+ >>> tgis.init()
+ >>> name = "list_stds_test"
+ >>> sp = tgis.open_new_stds(name=name, type="strds",
+ ... temporaltype="absolute", title="title", descr="descr", semantic="mean", dbif=None, overwrite=True)
+ >>> mapset = tgis.get_current_mapset()
+ >>> stds_list = tgis.get_dataset_list("strds", "absolute", columns="name")
+ >>> rows = stds_list[mapset]
+ >>> for row in rows:
+ ... if row["name"] == name:
+ ... print True
+ True
+ >>> stds_list = tgis.get_dataset_list("strds", "absolute", columns="name,mapset", where="mapset = '%s'"%(mapset))
+ >>> rows = stds_list[mapset]
+ >>> for row in rows:
+ ... if row["name"] == name and row["mapset"] == mapset:
+ ... print True
+ True
+ >>> check = sp.delete()
+
"""
id = None
sp = dataset_factory(type, id)
@@ -106,29 +105,31 @@
###############################################################################
def list_maps_of_stds(type, input, columns, order, where, separator, method, no_header=False, gran=None):
- """! List the maps of a space time dataset using diffetent methods
+ """ List the maps of a space time dataset using diffetent methods
- @param type The type of the maps raster, raster3d or vector
- @param input Name of a space time raster dataset
- @param columns A comma separated list of columns to be printed to stdout
- @param order A comma separated list of columns to order the
+ :param type: The type of the maps raster, raster3d or vector
+ :param input: Name of a space time raster dataset
+ :param columns: A comma separated list of columns to be printed to stdout
+ :param order: A comma separated list of columns to order the
maps by category
- @param where A where statement for selected listing without "WHERE"
+ :param where: A where statement for selected listing without "WHERE"
e.g: start_time < "2001-01-01" and end_time > "2001-01-01"
- @param separator The field separator character between the columns
- @param method String identifier to select a method out of cols,
+ :param separator: The field separator character between the columns
+ :param method: String identifier to select a method out of cols,
comma,delta or deltagaps
+
- "cols" Print preselected columns specified by columns
- "comma" Print the map ids ("name at mapset") as comma separated string
- "delta" Print the map ids ("name at mapset") with start time,
- end time, relative length of intervals and the relative
- distance to the begin
+ end time, relative length of intervals and the relative
+ distance to the begin
- "deltagaps" Same as "delta" with additional listing of gaps.
- Gaps can be simply identified as the id is "None"
+ Gaps can be simply identified as the id is "None"
- "gran" List map using the granularity of the space time dataset,
- columns are identical to deltagaps
- @param no_header Supress the printing of column names
- @param gran The user defined granule to be used if method=gran is set, in case gran=None the
+ columns are identical to deltagaps
+
+ :param no_header: Supress the printing of column names
+ :param gran: The user defined granule to be used if method=gran is set, in case gran=None the
granule of the space time dataset is used
"""
Modified: grass/trunk/lib/python/temporal/mapcalc.py
===================================================================
--- grass/trunk/lib/python/temporal/mapcalc.py 2014-09-28 01:40:32 UTC (rev 62120)
+++ grass/trunk/lib/python/temporal/mapcalc.py 2014-09-28 01:46:15 UTC (rev 62121)
@@ -1,15 +1,12 @@
-"""!@package grass.temporal
+"""
+Raster and 3d raster mapcalculation functions
- at brief GRASS Python scripting module (temporal GIS functions)
-
-Temporal GIS related functions to be used in Python scripts.
-
(C) 2012-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.
- at author Soeren Gebbert
+:authors: Soeren Gebbert
"""
from space_time_datasets import *
@@ -22,7 +19,7 @@
def dataset_mapcalculator(inputs, output, type, expression, base, method,
nprocs=1, register_null=False, spatial=False):
- """!Perform map-calculations of maps from different space time
+ """Perform map-calculations of maps from different space time
raster/raster3d datasets, using a specific sampling method
to select temporal related maps.
@@ -31,6 +28,7 @@
the r.mapcalc operators:
Supported operators for relative and absolute time are:
+
- td() - the time delta of the current interval in days
and fractions of days or the unit in case of relative time
- start_time() - The start time of the interval from the begin of
@@ -41,6 +39,7 @@
unit in case of relative time
Supported operators for absolute time:
+
- start_doy() - Day of year (doy) from the start time [1 - 366]
- start_dow() - Day of week (dow) from the start time [1 - 7],
the start of the week is monday == 1
@@ -63,17 +62,17 @@
- end_minute() - The minute of the end time [0 - 59]
- end_second() - The minute of the end time [0 - 59]
- @param inputs The names of the input space time raster/raster3d datasets
- @param output The name of the extracted new space time raster(3d) dataset
- @param type The type of the dataset: "raster" or "raster3d"
- @param expression The r(3).mapcalc expression
- @param base The base name of the new created maps in case a
+ :param inputs: The names of the input space time raster/raster3d datasets
+ :param output: The name of the extracted new space time raster(3d) dataset
+ :param type: The type of the dataset: "raster" or "raster3d"
+ :param expression: The r(3).mapcalc expression
+ :param base: The base name of the new created maps in case a
mapclac expression is provided
- @param method The method to be used for temporal sampling
- @param nprocs The number of parallel processes to be used for
+ :param method: The method to be used for temporal sampling
+ :param nprocs: The number of parallel processes to be used for
mapcalc processing
- @param register_null Set this number True to register empty maps
- @param spatial Check spatial overlap
+ :param register_null: Set this number True to register empty maps
+ :param spatial: Check spatial overlap
"""
# We need a database interface for fast computation
@@ -363,37 +362,38 @@
the temporal operators with numerical values.
Supported operators for relative and absolute time are:
- * td() - the time delta of the current interval in days
+
+ - td() - the time delta of the current interval in days
and fractions of days or the unit in case of relative time
- * start_time() - The start time of the interval from the begin of the
+ - start_time() - The start time of the interval from the begin of the
time series in days and fractions of days or the unit
in case of relative time
- * end_time() - The end time of the current interval from the begin of
+ - end_time() - The end time of the current interval from the begin of
the time series in days and fractions of days or the
unit in case of relative time
Supported operators for absolute time:
- * start_doy() - Day of year (doy) from the start time [1 - 366]
- * start_dow() - Day of week (dow) from the start time [1 - 7],
+
+ - start_doy() - Day of year (doy) from the start time [1 - 366]
+ - start_dow() - Day of week (dow) from the start time [1 - 7],
the start of the week is monday == 1
- * start_year() - The year of the start time [0 - 9999]
- * start_month() - The month of the start time [1 - 12]
- * start_week() - Week of year of the start time [1 - 54]
- * start_day() - Day of month from the start time [1 - 31]
- * start_hour() - The hour of the start time [0 - 23]
- * start_minute() - The minute of the start time [0 - 59]
- * start_second() - The second of the start time [0 - 59]
-
- * end_doy() - Day of year (doy) from the end time [1 - 366]
- * end_dow() - Day of week (dow) from the end time [1 - 7],
+ - start_year() - The year of the start time [0 - 9999]
+ - start_month() - The month of the start time [1 - 12]
+ - start_week() - Week of year of the start time [1 - 54]
+ - start_day() - Day of month from the start time [1 - 31]
+ - start_hour() - The hour of the start time [0 - 23]
+ - start_minute() - The minute of the start time [0 - 59]
+ - start_second() - The second of the start time [0 - 59]
+ - end_doy() - Day of year (doy) from the end time [1 - 366]
+ - end_dow() - Day of week (dow) from the end time [1 - 7],
the start of the week is monday == 1
- * end_year() - The year of the end time [0 - 9999]
- * end_month() - The month of the end time [1 - 12]
- * end_week() - Week of year of the end time [1 - 54]
- * end_day() - Day of month from the end time [1 - 31]
- * end_hour() - The hour of the end time [0 - 23]
- * end_minute() - The minute of the end time [0 - 59]
- * end_second() - The minute of the end time [0 - 59]
+ - end_year() - The year of the end time [0 - 9999]
+ - end_month() - The month of the end time [1 - 12]
+ - end_week() - Week of year of the end time [1 - 54]
+ - end_day() - Day of month from the end time [1 - 31]
+ - end_hour() - The hour of the end time [0 - 23]
+ - end_minute() - The minute of the end time [0 - 59]
+ - end_second() - The minute of the end time [0 - 59]
The modified expression is returned.
@@ -414,16 +414,16 @@
def _parse_start_operators(expr, is_time_absolute, current):
"""
Supported operators for absolute time:
- * start_doy() - Day of year (doy) from the start time [1 - 366]
- * start_dow() - Day of week (dow) from the start time [1 - 7],
+ - start_doy() - Day of year (doy) from the start time [1 - 366]
+ - start_dow() - Day of week (dow) from the start time [1 - 7],
the start of the week is monday == 1
- * start_year() - The year of the start time [0 - 9999]
- * start_month() - The month of the start time [1 - 12]
- * start_week() - Week of year of the start time [1 - 54]
- * start_day() - Day of month from the start time [1 - 31]
- * start_hour() - The hour of the start time [0 - 23]
- * start_minute() - The minute of the start time [0 - 59]
- * start_second() - The second of the start time [0 - 59]
+ - start_year() - The year of the start time [0 - 9999]
+ - start_month() - The month of the start time [1 - 12]
+ - start_week() - Week of year of the start time [1 - 54]
+ - start_day() - Day of month from the start time [1 - 31]
+ - start_hour() - The hour of the start time [0 - 23]
+ - start_minute() - The minute of the start time [0 - 59]
+ - start_second() - The second of the start time [0 - 59]
"""
start, end = current.get_absolute_time()
@@ -505,7 +505,7 @@
- end_minute() - The minute of the end time [0 - 59]
- end_second() - The minute of the end time [0 - 59]
- In case of time instances the end_* expression will be replaced by
+ In case of time instances the end* expression will be replaced by
null()
"""
Modified: grass/trunk/lib/python/temporal/metadata.py
===================================================================
--- grass/trunk/lib/python/temporal/metadata.py 2014-09-28 01:40:32 UTC (rev 62120)
+++ grass/trunk/lib/python/temporal/metadata.py 2014-09-28 01:46:15 UTC (rev 62121)
@@ -1,30 +1,25 @@
-"""!@package grass.temporal
+"""
+Metadata classes for map layer and space time datasets
- at brief GRASS Python scripting module (temporal GIS functions)
-
-Temporal GIS related metadata functions to be used in Python scripts and tgis packages.
-
Usage:
- at code
+.. code-block:: python
->>> import grass.temporal as tgis
->>> tgis.init()
->>> meta = tgis.RasterMetadata()
->>> meta = tgis.Raster3DMetadata()
->>> meta = tgis.VectorMetadata()
->>> meta = tgis.STRDSMetadata()
->>> meta = tgis.STR3DSMetadata()
->>> meta = tgis.STVDSMetadata()
+ >>> import grass.temporal as tgis
+ >>> tgis.init()
+ >>> meta = tgis.RasterMetadata()
+ >>> meta = tgis.Raster3DMetadata()
+ >>> meta = tgis.VectorMetadata()
+ >>> meta = tgis.STRDSMetadata()
+ >>> meta = tgis.STR3DSMetadata()
+ >>> meta = tgis.STVDSMetadata()
- at endcode
-
(C) 2012-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.
- at author Soeren Gebbert
+:authors: Soeren Gebbert
"""
from base import *
@@ -32,52 +27,51 @@
class RasterMetadataBase(SQLDatabaseInterface):
- """!This is the metadata base class for time stamped raster and raster3d maps
+ """This is the metadata base class for time stamped raster and raster3d maps
Usage:
- @code
+ .. code-block:: python
- >>> init()
- >>> meta = RasterMetadataBase(table="metadata", ident="soil at PERMANENT",
- ... datatype="CELL", cols=100, rows=100, number_of_cells=10000, nsres=0.1,
- ... ewres=0.1, min=0, max=100)
- >>> meta.datatype
- 'CELL'
- >>> meta.cols
- 100
- >>> meta.rows
- 100
- >>> meta.number_of_cells
- 10000
- >>> meta.nsres
- 0.1
- >>> meta.ewres
- 0.1
- >>> meta.min
- 0.0
- >>> meta.max
- 100.0
- >>> meta.print_info()
- | Datatype:................... CELL
- | Number of columns:.......... 100
- | Number of rows:............. 100
- | Number of cells:............ 10000
- | North-South resolution:..... 0.1
- | East-west resolution:....... 0.1
- | Minimum value:.............. 0.0
- | Maximum value:.............. 100.0
- >>> meta.print_shell_info()
- datatype=CELL
- cols=100
- rows=100
- number_of_cells=10000
- nsres=0.1
- ewres=0.1
- min=0.0
- max=100.0
+ >>> init()
+ >>> meta = RasterMetadataBase(table="metadata", ident="soil at PERMANENT",
+ ... datatype="CELL", cols=100, rows=100, number_of_cells=10000, nsres=0.1,
+ ... ewres=0.1, min=0, max=100)
+ >>> meta.datatype
+ 'CELL'
+ >>> meta.cols
+ 100
+ >>> meta.rows
+ 100
+ >>> meta.number_of_cells
+ 10000
+ >>> meta.nsres
+ 0.1
+ >>> meta.ewres
+ 0.1
+ >>> meta.min
+ 0.0
+ >>> meta.max
+ 100.0
+ >>> meta.print_info()
+ | Datatype:................... CELL
+ | Number of columns:.......... 100
+ | Number of rows:............. 100
+ | Number of cells:............ 10000
+ | North-South resolution:..... 0.1
+ | East-west resolution:....... 0.1
+ | Minimum value:.............. 0.0
+ | Maximum value:.............. 100.0
+ >>> meta.print_shell_info()
+ datatype=CELL
+ cols=100
+ rows=100
+ number_of_cells=10000
+ nsres=0.1
+ ewres=0.1
+ min=0.0
+ max=100.0
- @endcode
"""
def __init__(self, table=None, ident=None, datatype=None, cols=None,
rows=None, number_of_cells=None, nsres=None, ewres=None,
@@ -96,66 +90,66 @@
self.set_max(max)
def set_id(self, ident):
- """!Convenient method to set the unique identifier (primary key)"""
+ """Convenient method to set the unique identifier (primary key)"""
self.ident = ident
self.D["id"] = ident
def set_datatype(self, datatype):
- """!Set the datatype"""
+ """Set the datatype"""
self.D["datatype"] = datatype
def set_cols(self, cols):
- """!Set the number of cols"""
+ """Set the number of cols"""
if cols is not None:
self.D["cols"] = int(cols)
else:
self.D["cols"] = None
def set_rows(self, rows):
- """!Set the number of rows"""
+ """Set the number of rows"""
if rows is not None:
self.D["rows"] = int(rows)
else:
self.D["rows"] = None
def set_number_of_cells(self, number_of_cells):
- """!Set the number of cells"""
+ """Set the number of cells"""
if number_of_cells is not None:
self.D["number_of_cells"] = int(number_of_cells)
else:
self.D["number_of_cells"] = None
def set_nsres(self, nsres):
- """!Set the north-south resolution"""
+ """Set the north-south resolution"""
if nsres is not None:
self.D["nsres"] = float(nsres)
else:
self.D["nsres"] = None
def set_ewres(self, ewres):
- """!Set the east-west resolution"""
+ """Set the east-west resolution"""
if ewres is not None:
self.D["ewres"] = float(ewres)
else:
self.D["ewres"] = None
def set_min(self, min):
- """!Set the minimum raster value"""
+ """Set the minimum raster value"""
if min is not None:
self.D["min"] = float(min)
else:
self.D["min"] = None
def set_max(self, max):
- """!Set the maximum raster value"""
+ """Set the maximum raster value"""
if max is not None:
self.D["max"] = float(max)
else:
self.D["max"] = None
def get_id(self):
- """!Convenient method to get the unique identifier (primary key)
- @return None if not found
+ """Convenient method to get the unique identifier (primary key)
+ :return: None if not found
"""
if "id" in self.D:
return self.D["id"]
@@ -163,64 +157,64 @@
return None
def get_datatype(self):
- """!Get the map type
- @return None if not found"""
+ """Get the map type
+ :return: None if not found"""
if "datatype" in self.D:
return self.D["datatype"]
else:
return None
def get_cols(self):
- """!Get number of cols
- @return None if not found"""
+ """Get number of cols
+ :return: None if not found"""
if "cols" in self.D:
return self.D["cols"]
else:
return None
def get_rows(self):
- """!Get number of rows
- @return None if not found"""
+ """Get number of rows
+ :return: None if not found"""
if "rows" in self.D:
return self.D["rows"]
else:
return None
def get_number_of_cells(self):
- """!Get number of cells
- @return None if not found"""
+ """Get number of cells
+ :return: None if not found"""
if "number_of_cells" in self.D:
return self.D["number_of_cells"]
else:
return None
def get_nsres(self):
- """!Get the north-south resolution
- @return None if not found"""
+ """Get the north-south resolution
+ :return: None if not found"""
if "nsres" in self.D:
return self.D["nsres"]
else:
return None
def get_ewres(self):
- """!Get east-west resolution
- @return None if not found"""
+ """Get east-west resolution
+ :return: None if not found"""
if "ewres" in self.D:
return self.D["ewres"]
else:
return None
def get_min(self):
- """!Get the minimum cell value
- @return None if not found"""
+ """Get the minimum cell value
+ :return: None if not found"""
if "min" in self.D:
return self.D["min"]
else:
return None
def get_max(self):
- """!Get the maximum cell value
- @return None if not found"""
+ """Get the maximum cell value
+ :return: None if not found"""
if "max" in self.D:
return self.D["max"]
else:
@@ -237,7 +231,7 @@
max = property(fget=get_max, fset=set_max)
def print_info(self):
- """!Print information about this class in human readable style"""
+ """Print information about this class in human readable style"""
# 0123456789012345678901234567890
print " | Datatype:................... " + str(self.get_datatype())
print " | Number of columns:.......... " + str(self.get_cols())
@@ -250,7 +244,7 @@
print " | Maximum value:.............. " + str(self.get_max())
def print_shell_info(self):
- """!Print information about this class in shell style"""
+ """Print information about this class in shell style"""
print "datatype=" + str(self.get_datatype())
print "cols=" + str(self.get_cols())
print "rows=" + str(self.get_rows())
@@ -264,7 +258,7 @@
class RasterMetadata(RasterMetadataBase):
- """!This is the raster metadata class
+ """This is the raster metadata class
This class is the interface to the raster_metadata table in the
temporal database that stores the metadata of all registered raster maps.
@@ -275,49 +269,48 @@
Usage:
- @code
+ .. code-block:: python
- >>> init()
- >>> meta = RasterMetadata(ident="soil at PERMANENT",
- ... datatype="CELL", cols=100, rows=100, number_of_cells=10000, nsres=0.1,
- ... ewres=0.1, min=0, max=100)
- >>> meta.datatype
- 'CELL'
- >>> meta.cols
- 100
- >>> meta.rows
- 100
- >>> meta.number_of_cells
- 10000
- >>> meta.nsres
- 0.1
- >>> meta.ewres
- 0.1
- >>> meta.min
- 0.0
- >>> meta.max
- 100.0
- >>> meta.print_info()
- +-------------------- Metadata information ----------------------------------+
- | Datatype:................... CELL
- | Number of columns:.......... 100
- | Number of rows:............. 100
- | Number of cells:............ 10000
- | North-South resolution:..... 0.1
- | East-west resolution:....... 0.1
- | Minimum value:.............. 0.0
- | Maximum value:.............. 100.0
- >>> meta.print_shell_info()
- datatype=CELL
- cols=100
- rows=100
- number_of_cells=10000
- nsres=0.1
- ewres=0.1
- min=0.0
- max=100.0
+ >>> init()
+ >>> meta = RasterMetadata(ident="soil at PERMANENT",
+ ... datatype="CELL", cols=100, rows=100, number_of_cells=10000, nsres=0.1,
+ ... ewres=0.1, min=0, max=100)
+ >>> meta.datatype
+ 'CELL'
+ >>> meta.cols
+ 100
+ >>> meta.rows
+ 100
+ >>> meta.number_of_cells
+ 10000
+ >>> meta.nsres
+ 0.1
+ >>> meta.ewres
+ 0.1
+ >>> meta.min
+ 0.0
+ >>> meta.max
+ 100.0
+ >>> meta.print_info()
+ +-------------------- Metadata information ----------------------------------+
+ | Datatype:................... CELL
+ | Number of columns:.......... 100
+ | Number of rows:............. 100
+ | Number of cells:............ 10000
+ | North-South resolution:..... 0.1
+ | East-west resolution:....... 0.1
+ | Minimum value:.............. 0.0
+ | Maximum value:.............. 100.0
+ >>> meta.print_shell_info()
+ datatype=CELL
+ cols=100
+ rows=100
+ number_of_cells=10000
+ nsres=0.1
+ ewres=0.1
+ min=0.0
+ max=100.0
- @endcode
"""
def __init__(self, ident=None, datatype=None,
cols=None, rows=None, number_of_cells=None, nsres=None,
@@ -328,20 +321,20 @@
ewres, min, max)
def print_info(self):
- """!Print information about this class in human readable style"""
+ """Print information about this class in human readable style"""
print " +-------------------- Metadata information ----------------------------------+"
# 0123456789012345678901234567890
RasterMetadataBase.print_info(self)
def print_shell_info(self):
- """!Print information about this class in shell style"""
+ """Print information about this class in shell style"""
RasterMetadataBase.print_shell_info(self)
###############################################################################
class Raster3DMetadata(RasterMetadataBase):
- """!This is the raster3d metadata class
+ """This is the raster3d metadata class
This class is the interface to the raster3d_metadata table in the
temporal database that stores the metadata of all registered
@@ -353,58 +346,57 @@
Usage:
- @code
+ .. code-block:: python
- >>> init()
- >>> meta = Raster3DMetadata(ident="soil at PERMANENT",
- ... datatype="FCELL", cols=100, rows=100, depths=100,
- ... number_of_cells=1000000, nsres=0.1, ewres=0.1, tbres=0.1,
- ... min=0, max=100)
- >>> meta.datatype
- 'FCELL'
- >>> meta.cols
- 100
- >>> meta.rows
- 100
- >>> meta.depths
- 100
- >>> meta.number_of_cells
- 1000000
- >>> meta.nsres
- 0.1
- >>> meta.ewres
- 0.1
- >>> meta.tbres
- 0.1
- >>> meta.min
- 0.0
- >>> meta.max
- 100.0
- >>> meta.print_info()
- +-------------------- Metadata information ----------------------------------+
- | Datatype:................... FCELL
- | Number of columns:.......... 100
- | Number of rows:............. 100
- | Number of cells:............ 1000000
- | North-South resolution:..... 0.1
- | East-west resolution:....... 0.1
- | Minimum value:.............. 0.0
- | Maximum value:.............. 100.0
- | Number of depths:........... 100
- | Top-Bottom resolution:...... 0.1
- >>> meta.print_shell_info()
- datatype=FCELL
- cols=100
- rows=100
- number_of_cells=1000000
- nsres=0.1
- ewres=0.1
- min=0.0
- max=100.0
- depths=100
- tbres=0.1
+ >>> init()
+ >>> meta = Raster3DMetadata(ident="soil at PERMANENT",
+ ... datatype="FCELL", cols=100, rows=100, depths=100,
+ ... number_of_cells=1000000, nsres=0.1, ewres=0.1, tbres=0.1,
+ ... min=0, max=100)
+ >>> meta.datatype
+ 'FCELL'
+ >>> meta.cols
+ 100
+ >>> meta.rows
+ 100
+ >>> meta.depths
+ 100
+ >>> meta.number_of_cells
+ 1000000
+ >>> meta.nsres
+ 0.1
+ >>> meta.ewres
+ 0.1
+ >>> meta.tbres
+ 0.1
+ >>> meta.min
+ 0.0
+ >>> meta.max
+ 100.0
+ >>> meta.print_info()
+ +-------------------- Metadata information ----------------------------------+
+ | Datatype:................... FCELL
+ | Number of columns:.......... 100
+ | Number of rows:............. 100
+ | Number of cells:............ 1000000
+ | North-South resolution:..... 0.1
+ | East-west resolution:....... 0.1
+ | Minimum value:.............. 0.0
+ | Maximum value:.............. 100.0
+ | Number of depths:........... 100
+ | Top-Bottom resolution:...... 0.1
+ >>> meta.print_shell_info()
+ datatype=FCELL
+ cols=100
+ rows=100
+ number_of_cells=1000000
+ nsres=0.1
+ ewres=0.1
+ min=0.0
+ max=100.0
+ depths=100
+ tbres=0.1
- @endcode
"""
def __init__(self, ident=None, datatype=None,
cols=None, rows=None, depths=None, number_of_cells=None,
@@ -418,30 +410,30 @@
self.set_depths(depths)
def set_depths(self, depths):
- """!Set the number of depths"""
+ """Set the number of depths"""
if depths is not None:
self.D["depths"] = int(depths)
else:
self.D["depths"] = None
def set_tbres(self, tbres):
- """!Set the top-bottom resolution"""
+ """Set the top-bottom resolution"""
if tbres is not None:
self.D["tbres"] = float(tbres)
else:
self.D["tbres"] = None
def get_depths(self):
- """!Get number of depths
- @return None if not found"""
+ """Get number of depths
+ :return: None if not found"""
if "depths" in self.D:
return self.D["depths"]
else:
return None
def get_tbres(self):
- """!Get top-bottom resolution
- @return None if not found"""
+ """Get top-bottom resolution
+ :return: None if not found"""
if "tbres" in self.D:
return self.D["tbres"]
else:
@@ -451,7 +443,7 @@
tbres = property(fget=get_tbres, fset=set_tbres)
def print_info(self):
- """!Print information about this class in human readable style"""
+ """Print information about this class in human readable style"""
print " +-------------------- Metadata information ----------------------------------+"
# 0123456789012345678901234567890
RasterMetadataBase.print_info(self)
@@ -460,7 +452,7 @@
print " | Top-Bottom resolution:...... " + str(self.get_tbres())
def print_shell_info(self):
- """!Print information about this class in shell style"""
+ """Print information about this class in shell style"""
RasterMetadataBase.print_shell_info(self)
print "depths=" + str(self.get_depths())
print "tbres=" + str(self.get_tbres())
@@ -469,7 +461,7 @@
class VectorMetadata(SQLDatabaseInterface):
- """!This is the vector metadata class
+ """This is the vector metadata class
This class is the interface to the vector_metadata table in the
temporal database that stores the metadata of all registered
@@ -477,73 +469,72 @@
Usage:
- @code
+ .. code-block:: python
- >>> init()
- >>> meta = VectorMetadata(ident="lidar at PERMANENT", is_3d=True,
- ... number_of_points=1, number_of_lines=2, number_of_boundaries=3,
- ... number_of_centroids=4, number_of_faces=5, number_of_kernels=6,
- ... number_of_primitives=7, number_of_nodes=8, number_of_areas=9,
- ... number_of_islands=10, number_of_holes=11, number_of_volumes=12)
- >>> meta.id
- 'lidar at PERMANENT'
- >>> meta.is_3d
- True
- >>> meta.number_of_points
- 1
- >>> meta.number_of_lines
- 2
- >>> meta.number_of_boundaries
- 3
- >>> meta.number_of_centroids
- 4
- >>> meta.number_of_faces
- 5
- >>> meta.number_of_kernels
- 6
- >>> meta.number_of_primitives
- 7
- >>> meta.number_of_nodes
- 8
- >>> meta.number_of_areas
- 9
- >>> meta.number_of_islands
- 10
- >>> meta.number_of_holes
- 11
- >>> meta.number_of_volumes
- 12
- >>> meta.print_info()
- +-------------------- Metadata information ----------------------------------+
- | Is map 3d .................. True
- | Number of points ........... 1
- | Number of lines ............ 2
- | Number of boundaries ....... 3
- | Number of centroids ........ 4
- | Number of faces ............ 5
- | Number of kernels .......... 6
- | Number of primitives ....... 7
- | Number of nodes ............ 8
- | Number of areas ............ 9
- | Number of islands .......... 10
- | Number of holes ............ 11
- | Number of volumes .......... 12
- >>> meta.print_shell_info()
- is_3d=True
- points=1
- lines=2
- boundaries=3
- centroids=4
- faces=5
- kernels=6
- primitives=7
- nodes=8
- areas=9
- islands=10
- holes=11
- volumes=12
+ >>> init()
+ >>> meta = VectorMetadata(ident="lidar at PERMANENT", is_3d=True,
+ ... number_of_points=1, number_of_lines=2, number_of_boundaries=3,
+ ... number_of_centroids=4, number_of_faces=5, number_of_kernels=6,
+ ... number_of_primitives=7, number_of_nodes=8, number_of_areas=9,
+ ... number_of_islands=10, number_of_holes=11, number_of_volumes=12)
+ >>> meta.id
+ 'lidar at PERMANENT'
+ >>> meta.is_3d
+ True
+ >>> meta.number_of_points
+ 1
+ >>> meta.number_of_lines
+ 2
+ >>> meta.number_of_boundaries
+ 3
+ >>> meta.number_of_centroids
+ 4
+ >>> meta.number_of_faces
+ 5
+ >>> meta.number_of_kernels
+ 6
+ >>> meta.number_of_primitives
+ 7
+ >>> meta.number_of_nodes
+ 8
+ >>> meta.number_of_areas
+ 9
+ >>> meta.number_of_islands
+ 10
+ >>> meta.number_of_holes
+ 11
+ >>> meta.number_of_volumes
+ 12
+ >>> meta.print_info()
+ +-------------------- Metadata information ----------------------------------+
+ | Is map 3d .................. True
+ | Number of points ........... 1
+ | Number of lines ............ 2
+ | Number of boundaries ....... 3
+ | Number of centroids ........ 4
+ | Number of faces ............ 5
+ | Number of kernels .......... 6
+ | Number of primitives ....... 7
+ | Number of nodes ............ 8
+ | Number of areas ............ 9
+ | Number of islands .......... 10
+ | Number of holes ............ 11
+ | Number of volumes .......... 12
+ >>> meta.print_shell_info()
+ is_3d=True
+ points=1
+ lines=2
+ boundaries=3
+ centroids=4
+ faces=5
+ kernels=6
+ primitives=7
+ nodes=8
+ areas=9
+ islands=10
+ holes=11
+ volumes=12
- @endcode
"""
def __init__(
self, ident=None, is_3d=False,
@@ -570,65 +561,65 @@
self.set_number_of_volumes(number_of_volumes)
def set_id(self, ident):
- """!Convenient method to set the unique identifier (primary key)"""
+ """Convenient method to set the unique identifier (primary key)"""
self.ident = ident
self.D["id"] = ident
def set_3d_info(self, is_3d):
- """!Set True if the vector map is three dimensional"""
+ """Set True if the vector map is three dimensional"""
self.D["is_3d"] = is_3d
def set_number_of_points(self, number_of_points):
- """!Set the number of points of the vector map"""
+ """Set the number of points of the vector map"""
self.D["points"] = number_of_points
def set_number_of_lines(self, number_of_lines):
- """!Set the number of lines of the vector map"""
+ """Set the number of lines of the vector map"""
self.D["lines"] = number_of_lines
def set_number_of_boundaries(self, number_of_boundaries):
- """!Set the number of boundaries of the vector map"""
+ """Set the number of boundaries of the vector map"""
self.D["boundaries"] = number_of_boundaries
def set_number_of_centroids(self, number_of_centroids):
- """!Set the number of centroids of the vector map"""
+ """Set the number of centroids of the vector map"""
self.D["centroids"] = number_of_centroids
def set_number_of_faces(self, number_of_faces):
- """!Set the number of faces of the vector map"""
+ """Set the number of faces of the vector map"""
self.D["faces"] = number_of_faces
def set_number_of_kernels(self, number_of_kernels):
- """!Set the number of kernels of the vector map"""
+ """Set the number of kernels of the vector map"""
self.D["kernels"] = number_of_kernels
def set_number_of_primitives(self, number_of_primitives):
- """!Set the number of primitives of the vector map"""
+ """Set the number of primitives of the vector map"""
self.D["primitives"] = number_of_primitives
def set_number_of_nodes(self, number_of_nodes):
- """!Set the number of nodes of the vector map"""
+ """Set the number of nodes of the vector map"""
self.D["nodes"] = number_of_nodes
def set_number_of_areas(self, number_of_areas):
- """!Set the number of areas of the vector map"""
+ """Set the number of areas of the vector map"""
self.D["areas"] = number_of_areas
def set_number_of_islands(self, number_of_islands):
- """!Set the number of islands of the vector map"""
+ """Set the number of islands of the vector map"""
self.D["islands"] = number_of_islands
def set_number_of_holes(self, number_of_holes):
- """!Set the number of holes of the vector map"""
+ """Set the number of holes of the vector map"""
self.D["holes"] = number_of_holes
def set_number_of_volumes(self, number_of_volumes):
- """!Set the number of volumes of the vector map"""
+ """Set the number of volumes of the vector map"""
self.D["volumes"] = number_of_volumes
def get_id(self):
- """!Convenient method to get the unique identifier (primary key)
- @return None if not found
+ """Convenient method to get the unique identifier (primary key)
+ :return: None if not found
"""
if "id" in self.D:
return self.D["id"]
@@ -636,7 +627,7 @@
return None
def get_3d_info(self):
- """!Return True if the map is three dimensional,
+ """Return True if the map is three dimensional,
False if not and None if not info was found"""
if "is_3d" in self.D:
return self.D["is_3d"]
@@ -644,96 +635,96 @@
return None
def get_number_of_points(self):
- """!Get the number of points of the vector map
- @return None if not found"""
+ """Get the number of points of the vector map
+ :return: None if not found"""
if "points" in self.D:
return self.D["points"]
else:
return None
def get_number_of_lines(self):
- """!Get the number of lines of the vector map
- @return None if not found"""
+ """Get the number of lines of the vector map
+ :return: None if not found"""
if "lines" in self.D:
return self.D["lines"]
else:
return None
def get_number_of_boundaries(self):
- """!Get the number of boundaries of the vector map
- @return None if not found"""
+ """Get the number of boundaries of the vector map
+ :return: None if not found"""
if "boundaries" in self.D:
return self.D["boundaries"]
else:
return None
def get_number_of_centroids(self):
- """!Get the number of centroids of the vector map
- @return None if not found"""
+ """Get the number of centroids of the vector map
+ :return: None if not found"""
if "centroids" in self.D:
return self.D["centroids"]
else:
return None
def get_number_of_faces(self):
- """!Get the number of faces of the vector map
- @return None if not found"""
+ """Get the number of faces of the vector map
+ :return: None if not found"""
if "faces" in self.D:
return self.D["faces"]
else:
return None
def get_number_of_kernels(self):
- """!Get the number of kernels of the vector map
- @return None if not found"""
+ """Get the number of kernels of the vector map
+ :return: None if not found"""
if "kernels" in self.D:
return self.D["kernels"]
else:
return None
def get_number_of_primitives(self):
- """!Get the number of primitives of the vector map
- @return None if not found"""
+ """Get the number of primitives of the vector map
+ :return: None if not found"""
if "primitives" in self.D:
return self.D["primitives"]
else:
return None
def get_number_of_nodes(self):
- """!Get the number of nodes of the vector map
- @return None if not found"""
+ """Get the number of nodes of the vector map
+ :return: None if not found"""
if "nodes" in self.D:
return self.D["nodes"]
else:
return None
def get_number_of_areas(self):
- """!Get the number of areas of the vector map
- @return None if not found"""
+ """Get the number of areas of the vector map
+ :return: None if not found"""
if "areas" in self.D:
return self.D["areas"]
else:
return None
def get_number_of_islands(self):
- """!Get the number of islands of the vector map
- @return None if not found"""
+ """Get the number of islands of the vector map
+ :return: None if not found"""
if "islands" in self.D:
return self.D["islands"]
else:
return None
def get_number_of_holes(self):
- """!Get the number of holes of the vector map
- @return None if not found"""
+ """Get the number of holes of the vector map
+ :return: None if not found"""
if "holes" in self.D:
return self.D["holes"]
else:
return None
def get_number_of_volumes(self):
- """!Get the number of volumes of the vector map
- @return None if not found"""
+ """Get the number of volumes of the vector map
+ :return: None if not found"""
if "volumes" in self.D:
return self.D["volumes"]
else:
@@ -768,7 +759,7 @@
fset=set_number_of_volumes)
def print_info(self):
- """!Print information about this class in human readable style"""
+ """Print information about this class in human readable style"""
# 0123456789012345678901234567890
print " +-------------------- Metadata information ----------------------------------+"
print " | Is map 3d .................. " + str(self.get_3d_info())
@@ -786,7 +777,7 @@
print " | Number of volumes .......... " + str(self.get_number_of_volumes())
def print_shell_info(self):
- """!Print information about this class in shell style"""
+ """Print information about this class in shell style"""
print "is_3d=" + str(self.get_3d_info())
print "points=" + str(self.get_number_of_points())
print "lines=" + str(self.get_number_of_lines())
@@ -805,36 +796,35 @@
class STDSMetadataBase(SQLDatabaseInterface):
- """!This is the space time dataset metadata base class for
+ """This is the space time dataset metadata base class for
strds, stvds and str3ds datasets
setting/getting the id, the title and the description
Usage:
- @code
+ .. code-block:: python
- >>> init()
- >>> meta = STDSMetadataBase(ident="soils at PERMANENT",
- ... title="Soils", description="Soils 1950 - 2010")
- >>> meta.id
- 'soils at PERMANENT'
- >>> meta.title
- 'Soils'
- >>> meta.description
- 'Soils 1950 - 2010'
- >>> meta.number_of_maps
- >>> meta.print_info()
- | Number of registered maps:.. None
- |
- | Title:
- | Soils
- | Description:
- | Soils 1950 - 2010
- | Command history:
- >>> meta.print_shell_info()
- number_of_maps=None
+ >>> init()
+ >>> meta = STDSMetadataBase(ident="soils at PERMANENT",
+ ... title="Soils", description="Soils 1950 - 2010")
+ >>> meta.id
+ 'soils at PERMANENT'
+ >>> meta.title
+ 'Soils'
+ >>> meta.description
+ 'Soils 1950 - 2010'
+ >>> meta.number_of_maps
+ >>> meta.print_info()
+ | Number of registered maps:.. None
+ |
+ | Title:
+ | Soils
+ | Description:
+ | Soils 1950 - 2010
+ | Command history:
+ >>> meta.print_shell_info()
+ number_of_maps=None
- @endcode
"""
def __init__(self, table=None, ident=None, title=None, description=None, command=None):
@@ -848,25 +838,25 @@
self.D["number_of_maps"] = None
def set_id(self, ident):
- """!Convenient method to set the unique identifier (primary key)"""
+ """Convenient method to set the unique identifier (primary key)"""
self.ident = ident
self.D["id"] = ident
def set_title(self, title):
- """!Set the title"""
+ """Set the title"""
self.D["title"] = title
def set_description(self, description):
- """!Set the number of cols"""
+ """Set the number of cols"""
self.D["description"] = description
def set_command(self, command):
- """!Set the number of cols"""
+ """Set the number of cols"""
self.D["command"] = command
def get_id(self):
- """!Convenient method to get the unique identifier (primary key)
- @return None if not found
+ """Convenient method to get the unique identifier (primary key)
+ :return: None if not found
"""
if "id" in self.D:
return self.D["id"]
@@ -874,34 +864,34 @@
return None
def get_title(self):
- """!Get the title
- @return None if not found"""
+ """Get the title
+ :return: None if not found"""
if "title" in self.D:
return self.D["title"]
else:
return None
def get_description(self):
- """!Get description
- @return None if not found"""
+ """Get description
+ :return: None if not found"""
if "description" in self.D:
return self.D["description"]
else:
return None
def get_command(self):
- """!Get command
- @return None if not found"""
+ """Get command
+ :return: None if not found"""
if "command" in self.D:
return self.D["command"]
else:
return None
def get_number_of_maps(self):
- """!Get the number of registered maps,
+ """Get the number of registered maps,
this value is set in the database
automatically via SQL, so no setter exists
- @return None if not found"""
+ :return: None if not found"""
if "number_of_maps" in self.D:
return self.D["number_of_maps"]
else:
@@ -913,7 +903,7 @@
number_of_maps = property(fget=get_number_of_maps)
def print_info(self):
- """!Print information about this class in human readable style"""
+ """Print information about this class in human readable style"""
# 0123456789012345678901234567890
print " | Number of registered maps:.. " + str(
self.get_number_of_maps())
@@ -929,7 +919,7 @@
print " | " + str(token)
def print_history(self):
- """!Print history information about this class in human readable
+ """Print history information about this class in human readable
shell style
"""
# 0123456789012345678901234567890
@@ -960,72 +950,71 @@
print token
def print_shell_info(self):
- """!Print information about this class in shell style"""
+ """Print information about this class in shell style"""
print "number_of_maps=" + str(self.get_number_of_maps())
###############################################################################
class STDSRasterMetadataBase(STDSMetadataBase):
- """!This is the space time dataset metadata base
+ """This is the space time dataset metadata base
class for strds and str3ds datasets
Most of the metadata values are set by SQL scripts in the database when
new maps are added. Therefor only some set- an many
get-functions are available.
-
Usage:
- @code
- >>> init()
- >>> meta = STDSRasterMetadataBase(ident="soils at PERMANENT",
- ... title="Soils", description="Soils 1950 - 2010")
- >>> meta.id
- 'soils at PERMANENT'
- >>> meta.title
- 'Soils'
- >>> meta.description
- 'Soils 1950 - 2010'
- >>> meta.number_of_maps
- >>> meta.min_max
- >>> meta.max_max
- >>> meta.min_min
- >>> meta.max_min
- >>> meta.nsres_min
- >>> meta.nsres_max
- >>> meta.ewres_min
- >>> meta.ewres_max
- >>> meta.print_info()
- | North-South resolution min:. None
- | North-South resolution max:. None
- | East-west resolution min:... None
- | East-west resolution max:... None
- | Minimum value min:.......... None
- | Minimum value max:.......... None
- | Maximum value min:.......... None
- | Maximum value max:.......... None
- | Aggregation type:........... None
- | Number of registered maps:.. None
- |
- | Title:
- | Soils
- | Description:
- | Soils 1950 - 2010
- | Command history:
- >>> meta.print_shell_info()
- aggregation_type=None
- number_of_maps=None
- nsres_min=None
- nsres_max=None
- ewres_min=None
- ewres_max=None
- min_min=None
- min_max=None
- max_min=None
- max_max=None
+ .. code-block:: python
+
+ >>> init()
+ >>> meta = STDSRasterMetadataBase(ident="soils at PERMANENT",
+ ... title="Soils", description="Soils 1950 - 2010")
+ >>> meta.id
+ 'soils at PERMANENT'
+ >>> meta.title
+ 'Soils'
+ >>> meta.description
+ 'Soils 1950 - 2010'
+ >>> meta.number_of_maps
+ >>> meta.min_max
+ >>> meta.max_max
+ >>> meta.min_min
+ >>> meta.max_min
+ >>> meta.nsres_min
+ >>> meta.nsres_max
+ >>> meta.ewres_min
+ >>> meta.ewres_max
+ >>> meta.print_info()
+ | North-South resolution min:. None
+ | North-South resolution max:. None
+ | East-west resolution min:... None
+ | East-west resolution max:... None
+ | Minimum value min:.......... None
+ | Minimum value max:.......... None
+ | Maximum value min:.......... None
+ | Maximum value max:.......... None
+ | Aggregation type:........... None
+ | Number of registered maps:.. None
+ |
+ | Title:
+ | Soils
+ | Description:
+ | Soils 1950 - 2010
+ | Command history:
+ >>> meta.print_shell_info()
+ aggregation_type=None
+ number_of_maps=None
+ nsres_min=None
+ nsres_max=None
+ ewres_min=None
+ ewres_max=None
+ min_min=None
+ min_max=None
+ max_min=None
+ max_max=None
- @endcode
"""
def __init__(self, table=None, ident=None, title=None, description=None, aggregation_type=None):
@@ -1043,12 +1032,12 @@
self.D["aggregation_type"] = aggregation_type
def set_aggregation_type(self, aggregation_type):
- """!Set the aggregation type of the dataset (mean, min, max, ...)"""
+ """Set the aggregation type of the dataset (mean, min, max, ...)"""
self.D["aggregation_type"] = aggregation_type
def get_aggregation_type(self):
- """!Get the aggregation type of the dataset (mean, min, max, ...)
- @return None if not found
+ """Get the aggregation type of the dataset (mean, min, max, ...)
+ :return: None if not found
"""
if "aggregation_type" in self.D:
return self.D["aggregation_type"]
@@ -1056,80 +1045,80 @@
return None
def get_max_min(self):
- """!Get the minimal maximum of all registered maps,
+ """Get the minimal maximum of all registered maps,
this value is set in the database
automatically via SQL, so no setter exists
- @return None if not found"""
+ :return: None if not found"""
if "max_min" in self.D:
return self.D["max_min"]
else:
return None
def get_min_min(self):
- """!Get the minimal minimum of all registered maps,
+ """Get the minimal minimum of all registered maps,
this value is set in the database
automatically via SQL, so no setter exists
- @return None if not found"""
+ :return: None if not found"""
if "min_min" in self.D:
return self.D["min_min"]
else:
return None
def get_max_max(self):
- """!Get the maximal maximum of all registered maps,
+ """Get the maximal maximum of all registered maps,
this value is set in the database
automatically via SQL, so no setter exists
- @return None if not found"""
+ :return: None if not found"""
if "max_max" in self.D:
return self.D["max_max"]
else:
return None
def get_min_max(self):
- """!Get the maximal minimum of all registered maps,
+ """Get the maximal minimum of all registered maps,
this value is set in the database
automatically via SQL, so no setter exists
- @return None if not found"""
+ :return: None if not found"""
if "min_max" in self.D:
return self.D["min_max"]
else:
return None
def get_nsres_min(self):
- """!Get the minimal north-south resolution of all registered maps,
+ """Get the minimal north-south resolution of all registered maps,
this value is set in the database
automatically via SQL, so no setter exists
- @return None if not found"""
+ :return: None if not found"""
if "nsres_min" in self.D:
return self.D["nsres_min"]
else:
return None
def get_nsres_max(self):
- """!Get the maximal north-south resolution of all registered maps,
+ """Get the maximal north-south resolution of all registered maps,
this value is set in the database
automatically via SQL, so no setter exists
- @return None if not found"""
+ :return: None if not found"""
if "nsres_max" in self.D:
return self.D["nsres_max"]
else:
return None
def get_ewres_min(self):
- """!Get the minimal east-west resolution of all registered maps,
+ """Get the minimal east-west resolution of all registered maps,
this value is set in the database
automatically via SQL, so no setter exists
- @return None if not found"""
+ :return: None if not found"""
if "ewres_min" in self.D:
return self.D["ewres_min"]
else:
return None
def get_ewres_max(self):
- """!Get the maximal east-west resolution of all registered maps,
+ """Get the maximal east-west resolution of all registered maps,
this value is set in the database
automatically via SQL, so no setter exists
- @return None if not found"""
+ :return: None if not found"""
if "ewres_max" in self.D:
return self.D["ewres_max"]
else:
@@ -1147,7 +1136,7 @@
fget=get_aggregation_type)
def print_info(self):
- """!Print information about this class in human readable style"""
+ """Print information about this class in human readable style"""
# 0123456789012345678901234567890
print " | North-South resolution min:. " + str(self.get_nsres_min())
print " | North-South resolution max:. " + str(self.get_nsres_max())
@@ -1161,7 +1150,7 @@
STDSMetadataBase.print_info(self)
def print_shell_info(self):
- """!Print information about this class in shell style"""
+ """Print information about this class in shell style"""
print "aggregation_type=" + str(self.get_aggregation_type())
STDSMetadataBase.print_shell_info(self)
print "nsres_min=" + str(self.get_nsres_min())
@@ -1177,7 +1166,7 @@
###############################################################################
class STRDSMetadata(STDSRasterMetadataBase):
- """!This is the raster metadata class
+ """This is the raster metadata class
This class is the interface to the strds_metadata table in the
temporal database that stores the metadata of all registered
@@ -1189,60 +1178,59 @@
Usage:
- @code
+ .. code-block:: python
- >>> init()
- >>> meta = STRDSMetadata(ident="soils at PERMANENT",
- ... title="Soils", description="Soils 1950 - 2010")
- >>> meta.id
- 'soils at PERMANENT'
- >>> meta.title
- 'Soils'
- >>> meta.description
- 'Soils 1950 - 2010'
- >>> meta.number_of_maps
- >>> meta.min_max
- >>> meta.max_max
- >>> meta.min_min
- >>> meta.max_min
- >>> meta.nsres_min
- >>> meta.nsres_max
- >>> meta.ewres_min
- >>> meta.ewres_max
- >>> meta.raster_register
- >>> meta.print_info()
- +-------------------- Metadata information ----------------------------------+
- | Raster register table:...... None
- | North-South resolution min:. None
- | North-South resolution max:. None
- | East-west resolution min:... None
- | East-west resolution max:... None
- | Minimum value min:.......... None
- | Minimum value max:.......... None
- | Maximum value min:.......... None
- | Maximum value max:.......... None
- | Aggregation type:........... None
- | Number of registered maps:.. None
- |
- | Title:
- | Soils
- | Description:
- | Soils 1950 - 2010
- | Command history:
- >>> meta.print_shell_info()
- aggregation_type=None
- number_of_maps=None
- nsres_min=None
- nsres_max=None
- ewres_min=None
- ewres_max=None
- min_min=None
- min_max=None
- max_min=None
- max_max=None
- raster_register=None
+ >>> init()
+ >>> meta = STRDSMetadata(ident="soils at PERMANENT",
+ ... title="Soils", description="Soils 1950 - 2010")
+ >>> meta.id
+ 'soils at PERMANENT'
+ >>> meta.title
+ 'Soils'
+ >>> meta.description
+ 'Soils 1950 - 2010'
+ >>> meta.number_of_maps
+ >>> meta.min_max
+ >>> meta.max_max
+ >>> meta.min_min
+ >>> meta.max_min
+ >>> meta.nsres_min
+ >>> meta.nsres_max
+ >>> meta.ewres_min
+ >>> meta.ewres_max
+ >>> meta.raster_register
+ >>> meta.print_info()
+ +-------------------- Metadata information ----------------------------------+
+ | Raster register table:...... None
+ | North-South resolution min:. None
+ | North-South resolution max:. None
+ | East-west resolution min:... None
+ | East-west resolution max:... None
+ | Minimum value min:.......... None
+ | Minimum value max:.......... None
+ | Maximum value min:.......... None
+ | Maximum value max:.......... None
+ | Aggregation type:........... None
+ | Number of registered maps:.. None
+ |
+ | Title:
+ | Soils
+ | Description:
+ | Soils 1950 - 2010
+ | Command history:
+ >>> meta.print_shell_info()
+ aggregation_type=None
+ number_of_maps=None
+ nsres_min=None
+ nsres_max=None
+ ewres_min=None
+ ewres_max=None
+ min_min=None
+ min_max=None
+ max_min=None
+ max_max=None
+ raster_register=None
- @endcode
"""
def __init__(self, ident=None, raster_register=None, title=None, description=None):
@@ -1252,12 +1240,12 @@
self.set_raster_register(raster_register)
def set_raster_register(self, raster_register):
- """!Set the raster map register table name"""
+ """Set the raster map register table name"""
self.D["raster_register"] = raster_register
def get_raster_register(self):
- """!Get the raster map register table name
- @return None if not found"""
+ """Get the raster map register table name
+ :return: None if not found"""
if "raster_register" in self.D:
return self.D["raster_register"]
else:
@@ -1267,7 +1255,7 @@
fset=set_raster_register)
def print_info(self):
- """!Print information about this class in human readable style"""
+ """Print information about this class in human readable style"""
print " +-------------------- Metadata information ----------------------------------+"
# 0123456789012345678901234567890
print " | Raster register table:...... " + str(
@@ -1275,7 +1263,7 @@
STDSRasterMetadataBase.print_info(self)
def print_shell_info(self):
- """!Print information about this class in shell style"""
+ """Print information about this class in shell style"""
STDSRasterMetadataBase.print_shell_info(self)
print "raster_register=" + str(self.get_raster_register())
@@ -1283,7 +1271,7 @@
class STR3DSMetadata(STDSRasterMetadataBase):
- """!This is the space time 3D raster metadata class
+ """This is the space time 3D raster metadata class
This class is the interface to the str3ds_metadata table in the
temporal database that stores the metadata of all registered
@@ -1295,66 +1283,65 @@
Usage:
- @code
+ .. code-block:: python
- >>> init()
- >>> meta = STR3DSMetadata(ident="soils at PERMANENT",
- ... title="Soils", description="Soils 1950 - 2010")
- >>> meta.id
- 'soils at PERMANENT'
- >>> meta.title
- 'Soils'
- >>> meta.description
- 'Soils 1950 - 2010'
- >>> meta.number_of_maps
- >>> meta.min_max
- >>> meta.max_max
- >>> meta.min_min
- >>> meta.max_min
- >>> meta.nsres_min
- >>> meta.nsres_max
- >>> meta.ewres_min
- >>> meta.ewres_max
- >>> meta.tbres_min
- >>> meta.tbres_max
- >>> meta.raster3d_register
- >>> meta.print_info()
- +-------------------- Metadata information ----------------------------------+
- | 3D raster register table:... None
- | Top-bottom resolution min:.. None
- | Top-bottom resolution max:.. None
- | North-South resolution min:. None
- | North-South resolution max:. None
- | East-west resolution min:... None
- | East-west resolution max:... None
- | Minimum value min:.......... None
- | Minimum value max:.......... None
- | Maximum value min:.......... None
- | Maximum value max:.......... None
- | Aggregation type:........... None
- | Number of registered maps:.. None
- |
- | Title:
- | Soils
- | Description:
- | Soils 1950 - 2010
- | Command history:
- >>> meta.print_shell_info()
- aggregation_type=None
- number_of_maps=None
- nsres_min=None
- nsres_max=None
- ewres_min=None
- ewres_max=None
- min_min=None
- min_max=None
- max_min=None
- max_max=None
- tbres_min=None
- tbres_max=None
- raster3d_register=None
+ >>> init()
+ >>> meta = STR3DSMetadata(ident="soils at PERMANENT",
+ ... title="Soils", description="Soils 1950 - 2010")
+ >>> meta.id
+ 'soils at PERMANENT'
+ >>> meta.title
+ 'Soils'
+ >>> meta.description
+ 'Soils 1950 - 2010'
+ >>> meta.number_of_maps
+ >>> meta.min_max
+ >>> meta.max_max
+ >>> meta.min_min
+ >>> meta.max_min
+ >>> meta.nsres_min
+ >>> meta.nsres_max
+ >>> meta.ewres_min
+ >>> meta.ewres_max
+ >>> meta.tbres_min
+ >>> meta.tbres_max
+ >>> meta.raster3d_register
+ >>> meta.print_info()
+ +-------------------- Metadata information ----------------------------------+
+ | 3D raster register table:... None
+ | Top-bottom resolution min:.. None
+ | Top-bottom resolution max:.. None
+ | North-South resolution min:. None
+ | North-South resolution max:. None
+ | East-west resolution min:... None
+ | East-west resolution max:... None
+ | Minimum value min:.......... None
+ | Minimum value max:.......... None
+ | Maximum value min:.......... None
+ | Maximum value max:.......... None
+ | Aggregation type:........... None
+ | Number of registered maps:.. None
+ |
+ | Title:
+ | Soils
+ | Description:
+ | Soils 1950 - 2010
+ | Command history:
+ >>> meta.print_shell_info()
+ aggregation_type=None
+ number_of_maps=None
+ nsres_min=None
+ nsres_max=None
+ ewres_min=None
+ ewres_max=None
+ min_min=None
+ min_max=None
+ max_min=None
+ max_max=None
+ tbres_min=None
+ tbres_max=None
+ raster3d_register=None
- @endcode
"""
def __init__(self, ident=None, raster3d_register=None, title=None, description=None):
@@ -1366,32 +1353,32 @@
self.D["tbres_max"] = None
def set_raster3d_register(self, raster3d_register):
- """!Set the raster map register table name"""
+ """Set the raster map register table name"""
self.D["raster3d_register"] = raster3d_register
def get_raster3d_register(self):
- """!Get the raster3d map register table name
- @return None if not found"""
+ """Get the raster3d map register table name
+ :return: None if not found"""
if "raster3d_register" in self.D:
return self.D["raster3d_register"]
else:
return None
def get_tbres_min(self):
- """!Get the minimal top-bottom resolution of all registered maps,
+ """Get the minimal top-bottom resolution of all registered maps,
this value is set in the database
automatically via SQL, so no setter exists
- @return None if not found"""
+ :return: None if not found"""
if "tbres_min" in self.D:
return self.D["tbres_min"]
else:
return None
def get_tbres_max(self):
- """!Get the maximal top-bottom resolution of all registered maps,
+ """Get the maximal top-bottom resolution of all registered maps,
this value is set in the database
automatically via SQL, so no setter exists
- @return None if not found"""
+ :return: None if not found"""
if "tbres_max" in self.D:
return self.D["tbres_max"]
else:
@@ -1403,7 +1390,7 @@
tbres_max = property(fget=get_tbres_max)
def print_info(self):
- """!Print information about this class in human readable style"""
+ """Print information about this class in human readable style"""
print " +-------------------- Metadata information ----------------------------------+"
# 0123456789012345678901234567890
# 0123456789012345678901234567890
@@ -1414,7 +1401,7 @@
STDSRasterMetadataBase.print_info(self)
def print_shell_info(self):
- """!Print information about this class in shell style"""
+ """Print information about this class in shell style"""
STDSRasterMetadataBase.print_shell_info(self)
print "tbres_min=" + str(self.get_tbres_min())
print "tbres_max=" + str(self.get_tbres_max())
@@ -1423,7 +1410,7 @@
###############################################################################
class STVDSMetadata(STDSMetadataBase):
- """!This is the space time vector dataset metadata class
+ """This is the space time vector dataset metadata class
This class is the interface to the stvds_metadata table in the
temporal database that stores the metadata of all registered
@@ -1435,69 +1422,68 @@
Usage:
- @code
+ .. code-block:: python
- >>> init()
- >>> meta = STVDSMetadata(ident="lidars at PERMANENT",
- ... title="LIDARS", description="LIDARS 2008 - 2010")
- >>> meta.id
- 'lidars at PERMANENT'
- >>> meta.title
- 'LIDARS'
- >>> meta.description
- 'LIDARS 2008 - 2010'
- >>> meta.number_of_maps
- >>> meta.number_of_points
- >>> meta.number_of_lines
- >>> meta.number_of_boundaries
- >>> meta.number_of_centroids
- >>> meta.number_of_faces
- >>> meta.number_of_kernels
- >>> meta.number_of_primitives
- >>> meta.number_of_nodes
- >>> meta.number_of_areas
- >>> meta.number_of_islands
- >>> meta.number_of_holes
- >>> meta.number_of_volumes
- >>> meta.print_info()
- +-------------------- Metadata information ----------------------------------+
- | Vector register table:...... None
- | Number of points ........... None
- | Number of lines ............ None
- | Number of boundaries ....... None
- | Number of centroids ........ None
- | Number of faces ............ None
- | Number of kernels .......... None
- | Number of primitives ....... None
- | Number of nodes ............ None
- | Number of areas ............ None
- | Number of islands .......... None
- | Number of holes ............ None
- | Number of volumes .......... None
- | Number of registered maps:.. None
- |
- | Title:
- | LIDARS
- | Description:
- | LIDARS 2008 - 2010
- | Command history:
- >>> meta.print_shell_info()
- number_of_maps=None
- vector_register=None
- points=None
- lines=None
- boundaries=None
- centroids=None
- faces=None
- kernels=None
- primitives=None
- nodes=None
- areas=None
- islands=None
- holes=None
- volumes=None
+ >>> init()
+ >>> meta = STVDSMetadata(ident="lidars at PERMANENT",
+ ... title="LIDARS", description="LIDARS 2008 - 2010")
+ >>> meta.id
+ 'lidars at PERMANENT'
+ >>> meta.title
+ 'LIDARS'
+ >>> meta.description
+ 'LIDARS 2008 - 2010'
+ >>> meta.number_of_maps
+ >>> meta.number_of_points
+ >>> meta.number_of_lines
+ >>> meta.number_of_boundaries
+ >>> meta.number_of_centroids
+ >>> meta.number_of_faces
+ >>> meta.number_of_kernels
+ >>> meta.number_of_primitives
+ >>> meta.number_of_nodes
+ >>> meta.number_of_areas
+ >>> meta.number_of_islands
+ >>> meta.number_of_holes
+ >>> meta.number_of_volumes
+ >>> meta.print_info()
+ +-------------------- Metadata information ----------------------------------+
+ | Vector register table:...... None
+ | Number of points ........... None
+ | Number of lines ............ None
+ | Number of boundaries ....... None
+ | Number of centroids ........ None
+ | Number of faces ............ None
+ | Number of kernels .......... None
+ | Number of primitives ....... None
+ | Number of nodes ............ None
+ | Number of areas ............ None
+ | Number of islands .......... None
+ | Number of holes ............ None
+ | Number of volumes .......... None
+ | Number of registered maps:.. None
+ |
+ | Title:
+ | LIDARS
+ | Description:
+ | LIDARS 2008 - 2010
+ | Command history:
+ >>> meta.print_shell_info()
+ number_of_maps=None
+ vector_register=None
+ points=None
+ lines=None
+ boundaries=None
+ centroids=None
+ faces=None
+ kernels=None
+ primitives=None
+ nodes=None
+ areas=None
+ islands=None
+ holes=None
+ volumes=None
- @endcode
"""
def __init__(
self, ident=None, vector_register=None, title=None, description=None):
@@ -1520,132 +1506,132 @@
self.D["volumes"] = None
def set_vector_register(self, vector_register):
- """!Set the vector map register table name"""
+ """Set the vector map register table name"""
self.D["vector_register"] = vector_register
def get_vector_register(self):
- """!Get the vector map register table name
- @return None if not found"""
+ """Get the vector map register table name
+ :return: None if not found"""
if "vector_register" in self.D:
return self.D["vector_register"]
else:
return None
def get_number_of_points(self):
- """!Get the number of points of all registered maps,
+ """Get the number of points of all registered maps,
this value is set in the database
automatically via SQL, so no setter exists
- @return None if not found"""
+ :return: None if not found"""
if "points" in self.D:
return self.D["points"]
else:
return None
def get_number_of_lines(self):
- """!Get the number of lines of all registered maps,
+ """Get the number of lines of all registered maps,
this value is set in the database
automatically via SQL, so no setter exists
- @return None if not found"""
+ :return: None if not found"""
if "lines" in self.D:
return self.D["lines"]
else:
return None
def get_number_of_boundaries(self):
- """!Get the number of boundaries of all registered maps,
+ """Get the number of boundaries of all registered maps,
this value is set in the database
automatically via SQL, so no setter exists
- @return None if not found"""
+ :return: None if not found"""
if "boundaries" in self.D:
return self.D["boundaries"]
else:
return None
def get_number_of_centroids(self):
- """!Get the number of centroids of all registered maps,
+ """Get the number of centroids of all registered maps,
this value is set in the database
automatically via SQL, so no setter exists
- @return None if not found"""
+ :return: None if not found"""
if "centroids" in self.D:
return self.D["centroids"]
else:
return None
def get_number_of_faces(self):
- """!Get the number of faces of all registered maps,
+ """Get the number of faces of all registered maps,
this value is set in the database
automatically via SQL, so no setter exists
- @return None if not found"""
+ :return: None if not found"""
if "faces" in self.D:
return self.D["faces"]
else:
return None
def get_number_of_kernels(self):
- """!Get the number of kernels of all registered maps,
+ """Get the number of kernels of all registered maps,
this value is set in the database
automatically via SQL, so no setter exists
- @return None if not found"""
+ :return: None if not found"""
if "kernels" in self.D:
return self.D["kernels"]
else:
return None
def get_number_of_primitives(self):
- """!Get the number of primitives of all registered maps,
+ """Get the number of primitives of all registered maps,
this value is set in the database
automatically via SQL, so no setter exists
- @return None if not found"""
+ :return: None if not found"""
if "primitives" in self.D:
return self.D["primitives"]
else:
return None
def get_number_of_nodes(self):
- """!Get the number of nodes of all registered maps,
+ """Get the number of nodes of all registered maps,
this value is set in the database
automatically via SQL, so no setter exists
- @return None if not found"""
+ :return: None if not found"""
if "nodes" in self.D:
return self.D["nodes"]
else:
return None
def get_number_of_areas(self):
- """!Get the number of areas of all registered maps,
+ """Get the number of areas of all registered maps,
this value is set in the database
automatically via SQL, so no setter exists
- @return None if not found"""
+ :return: None if not found"""
if "areas" in self.D:
return self.D["areas"]
else:
return None
def get_number_of_islands(self):
- """!Get the number of islands of all registered maps,
+ """Get the number of islands of all registered maps,
this value is set in the database
automatically via SQL, so no setter exists
- @return None if not found"""
+ :return: None if not found"""
if "islands" in self.D:
return self.D["islands"]
else:
return None
def get_number_of_holes(self):
- """!Get the number of holes of all registered maps,
+ """Get the number of holes of all registered maps,
this value is set in the database
automatically via SQL, so no setter exists
- @return None if not found"""
+ :return: None if not found"""
if "holes" in self.D:
return self.D["holes"]
else:
return None
def get_number_of_volumes(self):
- """!Get the number of volumes of all registered maps,
+ """Get the number of volumes of all registered maps,
this value is set in the database
automatically via SQL, so no setter exists
- @return None if not found"""
+ :return: None if not found"""
if "volumes" in self.D:
return self.D["volumes"]
else:
@@ -1668,7 +1654,7 @@
number_of_volumes = property(fget=get_number_of_volumes)
def print_info(self):
- """!Print information about this class in human readable style"""
+ """Print information about this class in human readable style"""
print " +-------------------- Metadata information ----------------------------------+"
# 0123456789012345678901234567890
print " | Vector register table:...... " + str(
@@ -1688,7 +1674,7 @@
STDSMetadataBase.print_info(self)
def print_shell_info(self):
- """!Print information about this class in shell style"""
+ """Print information about this class in shell style"""
STDSMetadataBase.print_shell_info(self)
print "vector_register=" + str(self.get_vector_register())
print "points=" + str(self.get_number_of_points())
Modified: grass/trunk/lib/python/temporal/open_stds.py
===================================================================
--- grass/trunk/lib/python/temporal/open_stds.py 2014-09-28 01:40:32 UTC (rev 62120)
+++ grass/trunk/lib/python/temporal/open_stds.py 2014-09-28 01:46:15 UTC (rev 62121)
@@ -1,25 +1,21 @@
-"""!@package grass.temporal
+"""
+Functions to open or create space time datasets
- at brief GRASS Python scripting module (temporal GIS functions)
-
-Temporal GIS related functions to be used in Python scripts.
-
Usage:
- at code
-import grass.temporal as tgis
+.. code-block:: python
-tgis.register_maps_in_space_time_dataset(type, name, maps)
+ import grass.temporal as tgis
-...
- at endcode
+ tgis.register_maps_in_space_time_dataset(type, name, maps)
+
(C) 2012-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.
- at author Soeren Gebbert
+:authors: Soeren Gebbert
"""
from factory import *
@@ -27,18 +23,18 @@
###############################################################################
def open_old_stds(name, type, dbif=None):
- """!This function opens an existing space time dataset and return the
+ """This function opens an existing space time dataset and return the
created and intialized object of the specified type.
This function will call exit() or raise a grass.pygrass.messages.FatalError in case the type is wrong,
or the space time dataset was not found.
- @param name The name of the space time dataset, if the name does not
+ :param name: The name of the space time dataset, if the name does not
contain the mapset (name at mapset) then the current mapset
will be used to identifiy the space time dataset
- @param type The type of the space time dataset (strd, str3ds, stvds,
+ :param type: The type of the space time dataset (strd, str3ds, stvds,
raster, vector, raster3d)
- @param dbif The optional database interface to be used
+ :param dbif: The optional database interface to be used
"""
mapset = get_current_mapset()
@@ -77,18 +73,18 @@
###############################################################################
def check_new_stds(name, type, dbif=None, overwrite=False):
- """!Check if a new space time dataset of a specific type can be created
+ """Check if a new space time dataset of a specific type can be created
- @param name The name of the new space time dataset
- @param type The type of the new space time dataset (strd, str3ds, stvds,
+ :param name: The name of the new space time dataset
+ :param type: The type of the new space time dataset (strd, str3ds, stvds,
raster, vector, raster3d)
- @param dbif The temporal database interface to be used
- @param overwrite Flag to allow overwriting
+ :param dbif: The temporal database interface to be used
+ :param overwrite: Flag to allow overwriting
- @return A space time dataset object that must be filled with
+ :return: A space time dataset object that must be filled with
content before insertion in the temporal database
- This function will raise a ScriptError in case of an error.
+ This function will raise a FatalError in case of an error.
"""
#Get the current mapset to create the id of the space time dataset
@@ -131,19 +127,19 @@
def open_new_stds(name, type, temporaltype, title, descr, semantic,
dbif=None, overwrite=False):
- """!Create a new space time dataset of a specific type
+ """Create a new space time dataset of a specific type
- @param name The name of the new space time dataset
- @param type The type of the new space time dataset (strd, str3ds, stvds,
+ :param name: The name of the new space time dataset
+ :param type: The type of the new space time dataset (strd, str3ds, stvds,
raster, vector, raster3d)
- @param temporaltype The temporal type (relative or absolute)
- @param title The title
- @param descr The dataset description
- @param semantic Semantical information
- @param dbif The temporal database interface to be used
- @param overwrite Flag to allow overwriting
+ :param temporaltype: The temporal type (relative or absolute)
+ :param title: The title
+ :param descr: The dataset description
+ :param semantic: Semantical information
+ :param dbif: The temporal database interface to be used
+ :param overwrite: Flag to allow overwriting
- @return The new created space time dataset
+ :return: The new created space time dataset
This function will raise a FatalError in case of an error.
"""
@@ -177,18 +173,18 @@
def check_new_map_dataset(name, layer=None, type="raster",
overwrite=False, dbif=None):
- """!Check if a new map dataset of a specific type can be created in
+ """Check if a new map dataset of a specific type can be created in
the temporal database
- @param name The name of the new map dataset
- @param layer The layer of the new map dataset
- @param type The type of the new map dataset (raster, vector, raster3d)
- @param dbif The temporal database interface to be used
- @param overwrite Flag to allow overwriting
+ :param name: The name of the new map dataset
+ :param layer: The layer of the new map dataset
+ :param type: The type of the new map dataset (raster, vector, raster3d)
+ :param dbif: The temporal database interface to be used
+ :param overwrite: Flag to allow overwriting
- @return A map dataset object
+ :return: A map dataset object
- This function will raise a ScriptError in case of an error.
+ This function will raise a FatalError in case of an error.
"""
mapset = get_current_mapset()
msgr = get_tgis_message_interface()
@@ -215,18 +211,17 @@
def open_new_map_dataset(name, layer=None, type="raster",
temporal_extent=None, overwrite=False,
dbif=None):
- """!Create a new map dataset object of a specific type that can be
+ """Create a new map dataset object of a specific type that can be
registered in the temporal database
- @param name The name of the new map dataset
- @param layer The layer of the new map dataset
- @param type The type of the new map dataset (raster, vector, raster3d)
- @param dbif The temporal database interface to be used
- @param overwrite Flag to allow overwriting
+ :param name: The name of the new map dataset
+ :param layer: The layer of the new map dataset
+ :param type: The type of the new map dataset (raster, vector, raster3d)
+ :param dbif: The temporal database interface to be used
+ :param overwrite: Flag to allow overwriting
- @return A map dataset object
+ :return: A map dataset object
- This function will raise a ScriptError in case of an error.
"""
mapset = get_current_mapset()
Modified: grass/trunk/lib/python/temporal/register.py
===================================================================
--- grass/trunk/lib/python/temporal/register.py 2014-09-28 01:40:32 UTC (rev 62120)
+++ grass/trunk/lib/python/temporal/register.py 2014-09-28 01:46:15 UTC (rev 62121)
@@ -1,25 +1,20 @@
-"""!@package grass.temporal
+"""
+Functions to register map layer in space time datasets and the temporal database
- at brief GRASS Python scripting module (temporal GIS functions)
-
-Temporal GIS related functions to be used in Python scripts.
-
Usage:
- at code
-import grass.temporal as tgis
+.. code-block:: python
-tgis.register_maps_in_space_time_dataset(type, name, maps)
+ import grass.temporal as tgis
-...
- at endcode
+ tgis.register_maps_in_space_time_dataset(type, name, maps)
(C) 2012-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.
- at author Soeren Gebbert
+:authors: Soeren Gebbert
"""
from open_stds import *
@@ -32,7 +27,7 @@
type, name, maps=None, file=None, start=None,
end=None, unit=None, increment=None, dbif=None,
interval=False, fs="|", update_cmd_list=True):
- """!Use this method to register maps in space time datasets.
+ """Use this method to register maps in space time datasets.
Additionally a start time string and an increment string can be
specified to assign a time interval automatically to the maps.
@@ -40,28 +35,28 @@
It takes care of the correct update of the space time datasets from all
registered maps.
- @param type The type of the maps rast, rast3d or vect
- @param name The name of the space time dataset. Maps will be registered in the
+ :param type: The type of the maps rast, rast3d or vect
+ :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
+ :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 raster 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 raster 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,
+ :param unit: The unit of the relative time: years, months, days,
hours, minutes, seconds
- @param increment Time increment between maps for time stamp creation
+ :param increment: Time increment between maps for time stamp creation
(format absolute: NNN seconds, minutes, hours, days,
weeks, months, years; format relative: 1.0)
- @param dbif The database interface to be used
- @param interval If True, time intervals are created in case the start
+ :param dbif: The database interface to be used
+ :param interval: If True, time intervals are created in case the start
time and an increment is provided
- @param fs Field separator used in input file
- @param update_cmd_list If is True, the command that was invoking this process
+ :param fs: Field separator used in input file
+ :param update_cmd:_list If is True, the command that was invoking this process
will be written to the process history
"""
start_time_in_file = False
@@ -346,24 +341,24 @@
def assign_valid_time_to_map(ttype, map, start, end, unit, increment=None,
mult=1, interval=False):
- """!Assign the valid time to a map dataset
+ """Assign the valid time to a map dataset
- @param ttype The temporal type which should be assigned
+ :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 map: A map dataset object derived from abstract_map_dataset
+ :param start: The start date and time of the first raster 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 raster 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,
+ :param unit: The unit of the relative time: years, months,
days, hours, minutes, seconds
- @param increment Time increment between maps for time stamp creation
+ :param increment: Time increment between maps for time stamp creation
(format absolute: NNN seconds, minutes, hours, days,
weeks, months, years; format relative is integer 1)
- @param mult A multiplier for the increment
- @param interval If True, time intervals are created in case the start
+ :param mult: A multiplier for the increment
+ :param interval: If True, time intervals are created in case the start
time and an increment is provided
"""
@@ -437,12 +432,12 @@
"""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, rast3d, vect)
- @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
- @param unit The temporal unit of the space time dataset
- @param dbif The database interface to be used
+ :param type: The type of the map layer (rast, rast3d, vect)
+ :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
+ :param unit: The temporal unit of the space time dataset
+ :param dbif: The database interface to be used
"""
import grass.pygrass.modules as pymod
Modified: grass/trunk/lib/python/temporal/sampling.py
===================================================================
--- grass/trunk/lib/python/temporal/sampling.py 2014-09-28 01:40:32 UTC (rev 62120)
+++ grass/trunk/lib/python/temporal/sampling.py 2014-09-28 01:46:15 UTC (rev 62121)
@@ -1,25 +1,20 @@
-"""!@package grass.temporal
+"""
+Sampling functions for space time datasets
- at brief GRASS Python scripting module (temporal GIS functions)
-
-Temporal GIS related functions to be used in Python scripts.
-
Usage:
- at code
-import grass.temporal as tgis
+.. code-block:: python
-tgis.register_maps_in_space_time_dataset(type, name, maps)
+ import grass.temporal as tgis
-...
- at endcode
+ tgis.register_maps_in_space_time_dataset(type, name, maps)
(C) 2012-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.
- at author Soeren Gebbert
+:authors: Soeren Gebbert
"""
from factory import *
@@ -27,7 +22,7 @@
def sample_stds_by_stds_topology(intype, sampletype, inputs, sampler, header,
separator, method, spatial=False,
print_only=True):
- """!Sample the input space time datasets with a sample
+ """Sample the input space time datasets with a sample
space time dataset, return the created map matrix and optionally
print the result to stdout
@@ -39,21 +34,21 @@
Attention: Do not use the comma as separator for printing
- @param intype Type of the input space time dataset (strds, stvds or str3ds)
- @param sampletype Type of the sample space time datasets (strds, stvds or str3ds)
- @param inputs Name or comma separated names of space time datasets or a list of map names
- @param sampler Name of a space time dataset used for temporal sampling
- @param header Set True to print column names
- @param separator The field separator character between the columns
- @param method The method to be used for temporal sampling
+ :param intype: Type of the input space time dataset (strds, stvds or str3ds)
+ :param sampletype: Type of the sample space time datasets (strds, stvds or str3ds)
+ :param inputs: Name or comma separated names of space time datasets or a list of map names
+ :param sampler: Name of a space time dataset used for temporal sampling
+ :param header: Set True to print column names
+ :param separator: The field separator character between the columns
+ :param method: The method to be used for temporal sampling
(start,during,contain,overlap,equal) as comma separated string
or as a list of methods
- @param spatial Perform spatial overlapping check
- @param print_only If set True (default) then the result of the sampling will be
+ :param spatial: Perform spatial overlapping check
+ :param print_only: If set True (default) then the result of the sampling will be
printed to stdout, if set to False the resulting map matrix
will be returned.
- @return The map matrix or None if nothing found
+ :return: The map matrix or None if nothing found
"""
mapset = get_current_mapset()
msgr = get_tgis_message_interface()
Modified: grass/trunk/lib/python/temporal/space_time_datasets.py
===================================================================
--- grass/trunk/lib/python/temporal/space_time_datasets.py 2014-09-28 01:40:32 UTC (rev 62120)
+++ grass/trunk/lib/python/temporal/space_time_datasets.py 2014-09-28 01:46:15 UTC (rev 62121)
@@ -1,15 +1,12 @@
-"""!@package grass.temporal
+"""
+Map layer and space time dataset classes
- at brief GRASS Python scripting module (temporal GIS functions)
-
-Temporal GIS related functions to be used in Python scripts.
-
(C) 2012-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.
- at author Soeren Gebbert
+:authors: Soeren Gebbert
"""
import getpass
import logging
@@ -19,104 +16,103 @@
###############################################################################
class RasterDataset(AbstractMapDataset):
- """!Raster dataset class
+ """Raster dataset class
- This class provides functions to select, update, insert or delete raster
- map information and valid time stamps into the SQL temporal database.
+ This class provides functions to select, update, insert or delete raster
+ map information and valid time stamps into the SQL temporal database.
- Usage:
+ Usage:
- @code
+ .. code-block:: python
- >>> import grass.script as grass
- >>> init()
- >>> grass.use_temp_region()
- >>> grass.run_command("g.region", n=80.0, s=0.0, e=120.0, w=0.0,
- ... t=1.0, b=0.0, res=10.0)
- 0
- >>> grass.run_command("r.mapcalc", overwrite=True, quiet=True,
- ... expression="strds_map_test_case = 1")
- 0
- >>> grass.run_command("r.timestamp", map="strds_map_test_case",
- ... date="15 jan 1999", quiet=True)
- 0
- >>> mapset = get_current_mapset()
- >>> name = "strds_map_test_case"
- >>> identifier = "%s@%s" % (name, mapset)
- >>> rmap = RasterDataset(identifier)
- >>> rmap.map_exists()
- True
- >>> rmap.read_timestamp_from_grass()
- True
- >>> rmap.get_temporal_extent_as_tuple()
- (datetime.datetime(1999, 1, 15, 0, 0), None)
- >>> rmap.load()
- True
- >>> rmap.spatial_extent.print_info()
- +-------------------- Spatial extent ----------------------------------------+
- | North:...................... 80.0
- | South:...................... 0.0
- | East:.. .................... 120.0
- | West:....................... 0.0
- | Top:........................ 0.0
- | Bottom:..................... 0.0
- >>> rmap.absolute_time.print_info()
- +-------------------- Absolute time -----------------------------------------+
- | Start time:................. 1999-01-15 00:00:00
- | End time:................... None
- >>> rmap.metadata.print_info()
- +-------------------- Metadata information ----------------------------------+
- | Datatype:................... CELL
- | Number of columns:.......... 8
- | Number of rows:............. 12
- | Number of cells:............ 96
- | North-South resolution:..... 10.0
- | East-west resolution:....... 10.0
- | Minimum value:.............. 1.0
- | Maximum value:.............. 1.0
+ >>> import grass.script as grass
+ >>> init()
+ >>> grass.use_temp_region()
+ >>> grass.run_command("g.region", n=80.0, s=0.0, e=120.0, w=0.0,
+ ... t=1.0, b=0.0, res=10.0)
+ 0
+ >>> grass.run_command("r.mapcalc", overwrite=True, quiet=True,
+ ... expression="strds_map_test_case = 1")
+ 0
+ >>> grass.run_command("r.timestamp", map="strds_map_test_case",
+ ... date="15 jan 1999", quiet=True)
+ 0
+ >>> mapset = get_current_mapset()
+ >>> name = "strds_map_test_case"
+ >>> identifier = "%s@%s" % (name, mapset)
+ >>> rmap = RasterDataset(identifier)
+ >>> rmap.map_exists()
+ True
+ >>> rmap.read_timestamp_from_grass()
+ True
+ >>> rmap.get_temporal_extent_as_tuple()
+ (datetime.datetime(1999, 1, 15, 0, 0), None)
+ >>> rmap.load()
+ True
+ >>> rmap.spatial_extent.print_info()
+ +-------------------- Spatial extent ----------------------------------------+
+ | North:...................... 80.0
+ | South:...................... 0.0
+ | East:.. .................... 120.0
+ | West:....................... 0.0
+ | Top:........................ 0.0
+ | Bottom:..................... 0.0
+ >>> rmap.absolute_time.print_info()
+ +-------------------- Absolute time -----------------------------------------+
+ | Start time:................. 1999-01-15 00:00:00
+ | End time:................... None
+ >>> rmap.metadata.print_info()
+ +-------------------- Metadata information ----------------------------------+
+ | Datatype:................... CELL
+ | Number of columns:.......... 8
+ | Number of rows:............. 12
+ | Number of cells:............ 96
+ | North-South resolution:..... 10.0
+ | East-west resolution:....... 10.0
+ | Minimum value:.............. 1.0
+ | Maximum value:.............. 1.0
- >>> newmap = rmap.get_new_instance("new at PERMANENT")
- >>> isinstance(newmap, RasterDataset)
- True
- >>> newstrds = rmap.get_new_stds_instance("new at PERMANENT")
- >>> isinstance(newstrds, SpaceTimeRasterDataset)
- True
- >>> rmap.get_type()
- 'raster'
- >>> rmap.set_absolute_time(start_time=datetime(2001,1,1),
- ... end_time=datetime(2012,1,1))
- True
- >>> rmap.get_absolute_time()
- (datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2012, 1, 1, 0, 0))
- >>> rmap.get_temporal_extent_as_tuple()
- (datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2012, 1, 1, 0, 0))
- >>> rmap.get_name()
- 'strds_map_test_case'
- >>> rmap.get_mapset() == mapset
- True
- >>> rmap.get_temporal_type()
- 'absolute'
- >>> rmap.get_spatial_extent_as_tuple()
- (80.0, 0.0, 120.0, 0.0, 0.0, 0.0)
- >>> rmap.is_time_absolute()
- True
- >>> rmap.is_time_relative()
- False
+ >>> newmap = rmap.get_new_instance("new at PERMANENT")
+ >>> isinstance(newmap, RasterDataset)
+ True
+ >>> newstrds = rmap.get_new_stds_instance("new at PERMANENT")
+ >>> isinstance(newstrds, SpaceTimeRasterDataset)
+ True
+ >>> rmap.get_type()
+ 'raster'
+ >>> rmap.set_absolute_time(start_time=datetime(2001,1,1),
+ ... end_time=datetime(2012,1,1))
+ True
+ >>> rmap.get_absolute_time()
+ (datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2012, 1, 1, 0, 0))
+ >>> rmap.get_temporal_extent_as_tuple()
+ (datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2012, 1, 1, 0, 0))
+ >>> rmap.get_name()
+ 'strds_map_test_case'
+ >>> rmap.get_mapset() == mapset
+ True
+ >>> rmap.get_temporal_type()
+ 'absolute'
+ >>> rmap.get_spatial_extent_as_tuple()
+ (80.0, 0.0, 120.0, 0.0, 0.0, 0.0)
+ >>> rmap.is_time_absolute()
+ True
+ >>> rmap.is_time_relative()
+ False
- >>> grass.run_command("g.remove", flags="f", type="rast", pattern=name, quiet=True)
- 0
- >>> grass.del_temp_region()
+ >>> grass.run_command("g.remove", flags="f", type="rast", pattern=name, quiet=True)
+ 0
+ >>> grass.del_temp_region()
- @endcode
"""
def __init__(self, ident):
AbstractMapDataset.__init__(self)
self.reset(ident)
def is_stds(self):
- """!Return True if this class is a space time dataset
+ """Return True if this class is a space time dataset
- @return True if this class is a space time dataset, False otherwise
+ :return: True if this class is a space time dataset, False otherwise
"""
return False
@@ -124,50 +120,50 @@
return 'raster'
def get_new_instance(self, ident):
- """!Return a new instance with the type of this class"""
+ """Return a new instance with the type of this class"""
return RasterDataset(ident)
def get_new_stds_instance(self, ident):
- """!Return a new space time dataset instance in which maps
+ """Return a new space time dataset instance in which maps
are stored with the type of this class"""
return SpaceTimeRasterDataset(ident)
def spatial_overlapping(self, dataset):
- """!Return True if the spatial extents 2d overlap"""
+ """Return True if the spatial extents 2d overlap"""
return self.spatial_extent.overlapping_2d(dataset.spatial_extent)
def spatial_relation(self, dataset):
- """!Return the two dimensional spatial relation"""
+ """Return the two dimensional spatial relation"""
return self.spatial_extent.spatial_relation_2d(dataset.spatial_extent)
def spatial_intersection(self, dataset):
- """!Return the two dimensional intersection as spatial_extent
+ """Return the two dimensional intersection as spatial_extent
object or None in case no intersection was found.
- @param dataset The abstract dataset to intersect with
- @return The intersection spatial extent or None
+ :param dataset: The abstract dataset to intersect with
+ :return: The intersection spatial extent or None
"""
return self.spatial_extent.intersect_2d(dataset.spatial_extent)
def spatial_union(self, dataset):
- """!Return the two dimensional union as spatial_extent
+ """Return the two dimensional union as spatial_extent
object or None in case the extents does not overlap or meet.
- @param dataset The abstract dataset to create a union with
- @return The union spatial extent or None
+ :param dataset :The abstract dataset to create a union with
+ :return: The union spatial extent or None
"""
return self.spatial_extent.union_2d(dataset.spatial_extent)
def spatial_disjoint_union(self, dataset):
- """!Return the two dimensional union as spatial_extent object.
+ """Return the two dimensional union as spatial_extent object.
- @param dataset The abstract dataset to create a union with
- @return The union spatial extent
+ :param dataset: The abstract dataset to create a union with
+ :return: The union spatial extent
"""
return self.spatial_extent.disjoint_union_2d(dataset.spatial_extent)
def get_np_array(self):
- """!Return this raster map as memmap numpy style array to access the raster
+ """Return this raster map as memmap numpy style array to access the raster
values in numpy style without loading the whole map in the RAM.
In case this raster map does exists in the grass spatial database,
@@ -189,7 +185,7 @@
return a
def reset(self, ident):
- """!Reset the internal structure and set the identifier"""
+ """Reset the internal structure and set the identifier"""
self.base = RasterBase(ident=ident)
self.absolute_time = RasterAbsoluteTime(ident=ident)
self.relative_time = RasterRelativeTime(ident=ident)
@@ -198,20 +194,20 @@
self.stds_register = RasterSTDSRegister(ident=ident)
def has_grass_timestamp(self):
- """!Check if a grass file bsased time stamp exists for this map.
+ """Check if a grass file bsased time stamp exists for this map.
- @return True if success, False on error
+ :return: True if success, False on error
"""
return self.ciface.has_raster_timestamp(self.get_name(),
self.get_mapset())
def read_timestamp_from_grass(self):
- """!Read the timestamp of this map from the map metadata
+ """Read the timestamp of this map from the map metadata
in the grass file system based spatial database and
set the internal time stamp that should be insert/updated
in the temporal database.
- @return True if success, False on error
+ :return: True if success, False on error
"""
if not self.has_grass_timestamp():
@@ -233,12 +229,12 @@
return True
def write_timestamp_to_grass(self):
- """!Write the timestamp of this map into the map metadata in
+ """Write the timestamp of this map into the map metadata in
the grass file system based spatial database.
Internally the libgis API functions are used for writing
- @return True if success, False on error
+ :return: True if success, False on error
"""
check = self.ciface.write_raster_timestamp(self.get_name(),
self.get_mapset(),
@@ -261,12 +257,12 @@
return True
def remove_timestamp_from_grass(self):
- """!Remove the timestamp from the grass file system based
+ """Remove the timestamp from the grass file system based
spatial database
Internally the libgis API functions are used for removal
- @return True if success, False on error
+ :return: True if success, False on error
"""
check = self.ciface.remove_raster_timestamp(self.get_name(),
self.get_mapset())
@@ -279,20 +275,20 @@
return True
def map_exists(self):
- """!Return True in case the map exists in the grass spatial database
+ """Return True in case the map exists in the grass spatial database
- @return True if map exists, False otherwise
+ :return: True if map exists, False otherwise
"""
return self.ciface.raster_map_exists(self.get_name(),
self.get_mapset())
def load(self):
- """!Load all info from an existing raster map into the internal structure
+ """Load all info from an existing raster map into the internal structure
This method checks first if the map exists, in case it exists
the metadata of the map is put into this object and True is returned.
- @return True is the map exists and the metadata was filled successfully
+ :return: True is the map exists and the metadata was filled successfully
and getting the data was successfull, False otherwise
"""
@@ -335,103 +331,104 @@
###############################################################################
class Raster3DDataset(AbstractMapDataset):
- """!Raster3d dataset class
+ """Raster3d dataset class
- This class provides functions to select, update, insert or delete raster3d
- map information and valid time stamps into the SQL temporal database.
+ This class provides functions to select, update, insert or delete raster3d
+ map information and valid time stamps into the SQL temporal database.
- Usage:
+ Usage:
- @code
+ .. code-block:: python
- >>> import grass.script as grass
- >>> init()
- >>> grass.use_temp_region()
- >>> grass.run_command("g.region", n=80.0, s=0.0, e=120.0, w=0.0,
- ... t=100.0, b=0.0, res=10.0, res3=10.0)
- 0
- >>> grass.run_command("r3.mapcalc", overwrite=True, quiet=True,
- ... expression="str3ds_map_test_case = 1")
- 0
- >>> grass.run_command("r3.timestamp", map="str3ds_map_test_case",
- ... date="15 jan 1999", quiet=True)
- 0
- >>> mapset = get_current_mapset()
- >>> name = "str3ds_map_test_case"
- >>> identifier = "%s@%s" % (name, mapset)
- >>> r3map = Raster3DDataset(identifier)
- >>> r3map.map_exists()
- True
- >>> r3map.read_timestamp_from_grass()
- True
- >>> r3map.get_temporal_extent_as_tuple()
- (datetime.datetime(1999, 1, 15, 0, 0), None)
- >>> r3map.load()
- True
- >>> r3map.spatial_extent.print_info()
- +-------------------- Spatial extent ----------------------------------------+
- | North:...................... 80.0
- | South:...................... 0.0
- | East:.. .................... 120.0
- | West:....................... 0.0
- | Top:........................ 100.0
- | Bottom:..................... 0.0
- >>> r3map.absolute_time.print_info()
- +-------------------- Absolute time -----------------------------------------+
- | Start time:................. 1999-01-15 00:00:00
- | End time:................... None
- >>> r3map.metadata.print_info()
- +-------------------- Metadata information ----------------------------------+
- | Datatype:................... DCELL
- | Number of columns:.......... 8
- | Number of rows:............. 12
- | Number of cells:............ 960
- | North-South resolution:..... 10.0
- | East-west resolution:....... 10.0
- | Minimum value:.............. 1.0
- | Maximum value:.............. 1.0
- | Number of depths:........... 10
- | Top-Bottom resolution:...... 10.0
+ >>> import grass.script as grass
+ >>> init()
+ >>> grass.use_temp_region()
+ >>> grass.run_command("g.region", n=80.0, s=0.0, e=120.0, w=0.0,
+ ... t=100.0, b=0.0, res=10.0, res3=10.0)
+ 0
+ >>> grass.run_command("r3.mapcalc", overwrite=True, quiet=True,
+ ... expression="str3ds_map_test_case = 1")
+ 0
+ >>> grass.run_command("r3.timestamp", map="str3ds_map_test_case",
+ ... date="15 jan 1999", quiet=True)
+ 0
+ >>> mapset = get_current_mapset()
+ >>> name = "str3ds_map_test_case"
+ >>> identifier = "%s@%s" % (name, mapset)
+ >>> r3map = Raster3DDataset(identifier)
+ >>> r3map.map_exists()
+ True
+ >>> r3map.read_timestamp_from_grass()
+ True
+ >>> r3map.get_temporal_extent_as_tuple()
+ (datetime.datetime(1999, 1, 15, 0, 0), None)
+ >>> r3map.load()
+ True
+ >>> r3map.spatial_extent.print_info()
+ +-------------------- Spatial extent ----------------------------------------+
+ | North:...................... 80.0
+ | South:...................... 0.0
+ | East:.. .................... 120.0
+ | West:....................... 0.0
+ | Top:........................ 100.0
+ | Bottom:..................... 0.0
+ >>> r3map.absolute_time.print_info()
+ +-------------------- Absolute time -----------------------------------------+
+ | Start time:................. 1999-01-15 00:00:00
+ | End time:................... None
+ >>> r3map.metadata.print_info()
+ +-------------------- Metadata information ----------------------------------+
+ | Datatype:................... DCELL
+ | Number of columns:.......... 8
+ | Number of rows:............. 12
+ | Number of cells:............ 960
+ | North-South resolution:..... 10.0
+ | East-west resolution:....... 10.0
+ | Minimum value:.............. 1.0
+ | Maximum value:.............. 1.0
+ | Number of depths:........... 10
+ | Top-Bottom resolution:...... 10.0
- >>> newmap = r3map.get_new_instance("new at PERMANENT")
- >>> isinstance(newmap, Raster3DDataset)
- True
- >>> newstr3ds = r3map.get_new_stds_instance("new at PERMANENT")
- >>> isinstance(newstr3ds, SpaceTimeRaster3DDataset)
- True
- >>> r3map.get_type()
- 'raster3d'
- >>> r3map.set_absolute_time(start_time=datetime(2001,1,1),
- ... end_time=datetime(2012,1,1))
- True
- >>> r3map.get_absolute_time()
- (datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2012, 1, 1, 0, 0))
- >>> r3map.get_temporal_extent_as_tuple()
- (datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2012, 1, 1, 0, 0))
- >>> r3map.get_name()
- 'str3ds_map_test_case'
- >>> r3map.get_mapset() == mapset
- True
- >>> r3map.get_temporal_type()
- 'absolute'
- >>> r3map.get_spatial_extent_as_tuple()
- (80.0, 0.0, 120.0, 0.0, 100.0, 0.0)
- >>> r3map.is_time_absolute()
- True
- >>> r3map.is_time_relative()
- False
- >>> grass.run_command("g.remove", flags="f", type="rast3d", pattern=name, quiet=True)
- 0
- >>> grass.del_temp_region()
+ >>> newmap = r3map.get_new_instance("new at PERMANENT")
+ >>> isinstance(newmap, Raster3DDataset)
+ True
+ >>> newstr3ds = r3map.get_new_stds_instance("new at PERMANENT")
+ >>> isinstance(newstr3ds, SpaceTimeRaster3DDataset)
+ True
+ >>> r3map.get_type()
+ 'raster3d'
+ >>> r3map.set_absolute_time(start_time=datetime(2001,1,1),
+ ... end_time=datetime(2012,1,1))
+ True
+ >>> r3map.get_absolute_time()
+ (datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2012, 1, 1, 0, 0))
+ >>> r3map.get_temporal_extent_as_tuple()
+ (datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2012, 1, 1, 0, 0))
+ >>> r3map.get_name()
+ 'str3ds_map_test_case'
+ >>> r3map.get_mapset() == mapset
+ True
+ >>> r3map.get_temporal_type()
+ 'absolute'
+ >>> r3map.get_spatial_extent_as_tuple()
+ (80.0, 0.0, 120.0, 0.0, 100.0, 0.0)
+ >>> r3map.is_time_absolute()
+ True
+ >>> r3map.is_time_relative()
+ False
+ >>> grass.run_command("g.remove", flags="f", type="rast3d", pattern=name, quiet=True)
+ 0
+ >>> grass.del_temp_region()
+
"""
def __init__(self, ident):
AbstractMapDataset.__init__(self)
self.reset(ident)
def is_stds(self):
- """!Return True if this class is a space time dataset
+ """Return True if this class is a space time dataset
- @return True if this class is a space time dataset, False otherwise
+ :return: True if this class is a space time dataset, False otherwise
"""
return False
@@ -439,34 +436,34 @@
return "raster3d"
def get_new_instance(self, ident):
- """!Return a new instance with the type of this class"""
+ """Return a new instance with the type of this class"""
return Raster3DDataset(ident)
def get_new_stds_instance(self, ident):
- """!Return a new space time dataset instance in which maps
+ """Return a new space time dataset instance in which maps
are stored with the type of this class"""
return SpaceTimeRaster3DDataset(ident)
def spatial_overlapping(self, dataset):
- """!Return True if the spatial extents overlap"""
+ """Return True if the spatial extents overlap"""
if self.get_type() == dataset.get_type() or dataset.get_type() == "str3ds":
return self.spatial_extent.overlapping(dataset.spatial_extent)
else:
return self.spatial_extent.overlapping_2d(dataset.spatial_extent)
def spatial_relation(self, dataset):
- """!Return the two or three dimensional spatial relation"""
+ """Return the two or three dimensional spatial relation"""
if self.get_type() == dataset.get_type() or dataset.get_type() == "str3ds":
return self.spatial_extent.spatial_relation(dataset.spatial_extent)
else:
return self.spatial_extent.spatial_relation_2d(dataset.spatial_extent)
def spatial_intersection(self, dataset):
- """!Return the three or two dimensional intersection as spatial_extent
+ """Return the three or two dimensional intersection as spatial_extent
object or None in case no intersection was found.
- @param dataset The abstract dataset to intersect with
- @return The intersection spatial extent or None
+ :param dataset: The abstract dataset to intersect with
+ :return: The intersection spatial extent or None
"""
if self.get_type() == dataset.get_type() or dataset.get_type() == "str3ds":
return self.spatial_extent.intersect(dataset.spatial_extent)
@@ -474,11 +471,11 @@
return self.spatial_extent.intersect_2d(dataset.spatial_extent)
def spatial_union(self, dataset):
- """!Return the three or two dimensional union as spatial_extent
+ """Return the three or two dimensional union as spatial_extent
object or None in case the extents does not overlap or meet.
- @param dataset The abstract dataset to create a union with
- @return The union spatial extent or None
+ :param dataset: The abstract dataset to create a union with
+ :return: The union spatial extent or None
"""
if self.get_type() == dataset.get_type() or dataset.get_type() == "str3ds":
return self.spatial_extent.union(dataset.spatial_extent)
@@ -486,10 +483,10 @@
return self.spatial_extent.union_2d(dataset.spatial_extent)
def spatial_disjoint_union(self, dataset):
- """!Return the three or two dimensional union as spatial_extent object.
+ """Return the three or two dimensional union as spatial_extent object.
- @param dataset The abstract dataset to create a union with
- @return The union spatial extent
+ :param dataset: The abstract dataset to create a union with
+ :return: The union spatial extent
"""
if self.get_type() == dataset.get_type() or dataset.get_type() == "str3ds":
return self.spatial_extent.disjoint_union(dataset.spatial_extent)
@@ -497,7 +494,7 @@
return self.spatial_extent.disjoint_union_2d(dataset.spatial_extent)
def get_np_array(self):
- """!Return this 3D raster map as memmap numpy style array to access the 3D raster
+ """Return this 3D raster map as memmap numpy style array to access the 3D raster
values in numpy style without loading the whole map in the RAM.
In case this 3D raster map does exists in the grass spatial database,
@@ -519,7 +516,7 @@
return a
def reset(self, ident):
- """!Reset the internal structure and set the identifier"""
+ """Reset the internal structure and set the identifier"""
self.base = Raster3DBase(ident=ident)
self.absolute_time = Raster3DAbsoluteTime(ident=ident)
self.relative_time = Raster3DRelativeTime(ident=ident)
@@ -528,20 +525,20 @@
self.stds_register = Raster3DSTDSRegister(ident=ident)
def has_grass_timestamp(self):
- """!Check if a grass file bsased time stamp exists for this map.
+ """Check if a grass file bsased time stamp exists for this map.
- @return True if success, False on error
+ :return: True if success, False on error
"""
return self.ciface.has_raster3d_timestamp(self.get_name(),
self.get_mapset())
def read_timestamp_from_grass(self):
- """!Read the timestamp of this map from the map metadata
+ """Read the timestamp of this map from the map metadata
in the grass file system based spatial database and
set the internal time stamp that should be insert/updated
in the temporal database.
- @return True if success, False on error
+ :return: True if success, False on error
"""
if not self.has_grass_timestamp():
@@ -563,12 +560,12 @@
return True
def write_timestamp_to_grass(self):
- """!Write the timestamp of this map into the map metadata
+ """Write the timestamp of this map into the map metadata
in the grass file system based spatial database.
Internally the libgis API functions are used for writing
- @return True if success, False on error
+ :return: True if success, False on error
"""
check = self.ciface.write_raster3d_timestamp(self.get_name(),
self.get_mapset(),
@@ -591,9 +588,9 @@
return True
def remove_timestamp_from_grass(self):
- """!Remove the timestamp from the grass file system based spatial database
+ """Remove the timestamp from the grass file system based spatial database
- @return True if success, False on error
+ :return: True if success, False on error
"""
check = self.ciface.remove_raster3d_timestamp(self.get_name(),
self.get_mapset())
@@ -606,21 +603,21 @@
return True
def map_exists(self):
- """!Return True in case the map exists in the grass spatial database
+ """Return True in case the map exists in the grass spatial database
- @return True if map exists, False otherwise
+ :return: True if map exists, False otherwise
"""
return self.ciface.raster3d_map_exists(self.get_name(),
self.get_mapset())
def load(self):
- """!Load all info from an existing 3d raster map into the internal structure
+ """Load all info from an existing 3d raster map into the internal structure
This method checks first if the map exists, in case it exists
the metadata of the map is put into this object and True is returned.
- @return True is the map exists and the metadata was filled successfully
- and getting the data was successfull, False otherwise
+ :return: True is the map exists and the metadata was filled successfully
+ and getting the data was successfull, False otherwise
"""
if self.map_exists() is not True:
@@ -664,97 +661,96 @@
###############################################################################
class VectorDataset(AbstractMapDataset):
- """!Vector dataset class
+ """Vector dataset class
- This class provides functions to select, update, insert or delete vector
- map information and valid time stamps into the SQL temporal database.
+ This class provides functions to select, update, insert or delete vector
+ map information and valid time stamps into the SQL temporal database.
- Usage:
+ Usage:
- @code
+ .. code-block:: python
- >>> import grass.script as grass
- >>> init()
- >>> grass.use_temp_region()
- >>> grass.run_command("g.region", n=80.0, s=0.0, e=120.0, w=0.0,
- ... t=1.0, b=0.0, res=10.0)
- 0
- >>> grass.run_command("v.random", overwrite=True, output="stvds_map_test_case",
- ... n=100, zmin=0, zmax=100, flags="z", column="elevation", quiet=True)
- 0
- >>> grass.run_command("v.timestamp", map="stvds_map_test_case",
- ... date="15 jan 1999", quiet=True)
- 0
- >>> mapset = get_current_mapset()
- >>> name = "stvds_map_test_case"
- >>> identifier = "%s@%s" % (name, mapset)
- >>> vmap = VectorDataset(identifier)
- >>> vmap.map_exists()
- True
- >>> vmap.read_timestamp_from_grass()
- True
- >>> vmap.get_temporal_extent_as_tuple()
- (datetime.datetime(1999, 1, 15, 0, 0), None)
- >>> vmap.load()
- True
- >>> vmap.absolute_time.print_info()
- +-------------------- Absolute time -----------------------------------------+
- | Start time:................. 1999-01-15 00:00:00
- | End time:................... None
- >>> vmap.metadata.print_info()
- +-------------------- Metadata information ----------------------------------+
- | Is map 3d .................. True
- | Number of points ........... 100
- | Number of lines ............ 0
- | Number of boundaries ....... 0
- | Number of centroids ........ 0
- | Number of faces ............ 0
- | Number of kernels .......... 0
- | Number of primitives ....... 100
- | Number of nodes ............ 0
- | Number of areas ............ 0
- | Number of islands .......... 0
- | Number of holes ............ 0
- | Number of volumes .......... 0
- >>> newmap = vmap.get_new_instance("new at PERMANENT")
- >>> isinstance(newmap, VectorDataset)
- True
- >>> newstvds = vmap.get_new_stds_instance("new at PERMANENT")
- >>> isinstance(newstvds, SpaceTimeVectorDataset)
- True
- >>> vmap.get_type()
- 'vector'
- >>> vmap.set_absolute_time(start_time=datetime(2001,1,1),
- ... end_time=datetime(2012,1,1))
- True
- >>> vmap.get_absolute_time()
- (datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2012, 1, 1, 0, 0))
- >>> vmap.get_temporal_extent_as_tuple()
- (datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2012, 1, 1, 0, 0))
- >>> vmap.get_name()
- 'stvds_map_test_case'
- >>> vmap.get_mapset() == mapset
- True
- >>> vmap.get_temporal_type()
- 'absolute'
- >>> vmap.is_time_absolute()
- True
- >>> vmap.is_time_relative()
- False
- >>> grass.run_command("g.remove", flags="f", type="vect", pattern=name, quiet=True)
- 0
- >>> grass.del_temp_region()
+ >>> import grass.script as grass
+ >>> init()
+ >>> grass.use_temp_region()
+ >>> grass.run_command("g.region", n=80.0, s=0.0, e=120.0, w=0.0,
+ ... t=1.0, b=0.0, res=10.0)
+ 0
+ >>> grass.run_command("v.random", overwrite=True, output="stvds_map_test_case",
+ ... n=100, zmin=0, zmax=100, flags="z", column="elevation", quiet=True)
+ 0
+ >>> grass.run_command("v.timestamp", map="stvds_map_test_case",
+ ... date="15 jan 1999", quiet=True)
+ 0
+ >>> mapset = get_current_mapset()
+ >>> name = "stvds_map_test_case"
+ >>> identifier = "%s@%s" % (name, mapset)
+ >>> vmap = VectorDataset(identifier)
+ >>> vmap.map_exists()
+ True
+ >>> vmap.read_timestamp_from_grass()
+ True
+ >>> vmap.get_temporal_extent_as_tuple()
+ (datetime.datetime(1999, 1, 15, 0, 0), None)
+ >>> vmap.load()
+ True
+ >>> vmap.absolute_time.print_info()
+ +-------------------- Absolute time -----------------------------------------+
+ | Start time:................. 1999-01-15 00:00:00
+ | End time:................... None
+ >>> vmap.metadata.print_info()
+ +-------------------- Metadata information ----------------------------------+
+ | Is map 3d .................. True
+ | Number of points ........... 100
+ | Number of lines ............ 0
+ | Number of boundaries ....... 0
+ | Number of centroids ........ 0
+ | Number of faces ............ 0
+ | Number of kernels .......... 0
+ | Number of primitives ....... 100
+ | Number of nodes ............ 0
+ | Number of areas ............ 0
+ | Number of islands .......... 0
+ | Number of holes ............ 0
+ | Number of volumes .......... 0
+ >>> newmap = vmap.get_new_instance("new at PERMANENT")
+ >>> isinstance(newmap, VectorDataset)
+ True
+ >>> newstvds = vmap.get_new_stds_instance("new at PERMANENT")
+ >>> isinstance(newstvds, SpaceTimeVectorDataset)
+ True
+ >>> vmap.get_type()
+ 'vector'
+ >>> vmap.set_absolute_time(start_time=datetime(2001,1,1),
+ ... end_time=datetime(2012,1,1))
+ True
+ >>> vmap.get_absolute_time()
+ (datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2012, 1, 1, 0, 0))
+ >>> vmap.get_temporal_extent_as_tuple()
+ (datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2012, 1, 1, 0, 0))
+ >>> vmap.get_name()
+ 'stvds_map_test_case'
+ >>> vmap.get_mapset() == mapset
+ True
+ >>> vmap.get_temporal_type()
+ 'absolute'
+ >>> vmap.is_time_absolute()
+ True
+ >>> vmap.is_time_relative()
+ False
+ >>> grass.run_command("g.remove", flags="f", type="vect", pattern=name, quiet=True)
+ 0
+ >>> grass.del_temp_region()
- @endcode
"""
def __init__(self, ident):
AbstractMapDataset.__init__(self)
self.reset(ident)
def is_stds(self):
- """!Return True if this class is a space time dataset
+ """Return True if this class is a space time dataset
- @return True if this class is a space time dataset, False otherwise
+ :return: True if this class is a space time dataset, False otherwise
"""
return False
@@ -762,56 +758,56 @@
return "vector"
def get_new_instance(self, ident):
- """!Return a new instance with the type of this class"""
+ """Return a new instance with the type of this class"""
return VectorDataset(ident)
def get_new_stds_instance(self, ident):
- """!Return a new space time dataset instance in which maps
+ """Return a new space time dataset instance in which maps
are stored with the type of this class"""
return SpaceTimeVectorDataset(ident)
def get_layer(self):
- """!Return the layer"""
+ """Return the layer"""
return self.base.get_layer()
def spatial_overlapping(self, dataset):
- """!Return True if the spatial extents 2d overlap"""
+ """Return True if the spatial extents 2d overlap"""
return self.spatial_extent.overlapping_2d(dataset.spatial_extent)
def spatial_relation(self, dataset):
- """!Return the two dimensional spatial relation"""
+ """Return the two dimensional spatial relation"""
return self.spatial_extent.spatial_relation_2d(dataset.spatial_extent)
def spatial_intersection(self, dataset):
- """!Return the two dimensional intersection as spatial_extent
+ """Return the two dimensional intersection as spatial_extent
object or None in case no intersection was found.
- @param dataset The abstract dataset to intersect with
- @return The intersection spatial extent or None
+ :param dataset: The abstract dataset to intersect with
+ :return: The intersection spatial extent or None
"""
return self.spatial_extent.intersect_2d(dataset.spatial_extent)
def spatial_union(self, dataset):
- """!Return the two dimensional union as spatial_extent
+ """Return the two dimensional union as spatial_extent
object or None in case the extents does not overlap or meet.
- @param dataset The abstract dataset to create a union with
- @return The union spatial extent or None
+ :param dataset: The abstract dataset to create a union with
+ :return: The union spatial extent or None
"""
return self.spatial_extent.union_2d(dataset.spatial_extent)
def spatial_disjoint_union(self, dataset):
- """!Return the two dimensional union as spatial_extent object.
+ """Return the two dimensional union as spatial_extent object.
- @param dataset The abstract dataset to create a union with
- @return The union spatial extent
+ :param dataset: The abstract dataset to create a union with
+ :return: The union spatial extent
"""
return self.spatial_extent.disjoint_union_2d(dataset.spatial_extent)
def reset(self, ident):
- """!Reset the internal structure and set the identifier"""
+ """Reset the internal structure and set the identifier"""
self.base = VectorBase(ident=ident)
self.absolute_time = VectorAbsoluteTime(ident=ident)
self.relative_time = VectorRelativeTime(ident=ident)
@@ -820,7 +816,7 @@
self.stds_register = VectorSTDSRegister(ident=ident)
def has_grass_timestamp(self):
- """!Check if a grass file bsased time stamp exists for this map.
+ """Check if a grass file bsased time stamp exists for this map.
"""
return self.ciface.has_vector_timestamp(self.get_name(),
self.get_mapset(),
@@ -828,7 +824,7 @@
def read_timestamp_from_grass(self):
- """!Read the timestamp of this map from the map metadata
+ """Read the timestamp of this map from the map metadata
in the grass file system based spatial database and
set the internal time stamp that should be insert/updated
in the temporal database.
@@ -853,7 +849,7 @@
return True
def write_timestamp_to_grass(self):
- """!Write the timestamp of this map into the map metadata in
+ """Write the timestamp of this map into the map metadata in
the grass file system based spatial database.
Internally the libgis API functions are used for writing
@@ -876,7 +872,7 @@
return True
def remove_timestamp_from_grass(self):
- """!Remove the timestamp from the grass file system based spatial
+ """Remove the timestamp from the grass file system based spatial
database
Internally the libgis API functions are used for removal
@@ -892,9 +888,9 @@
return True
def map_exists(self):
- """!Return True in case the map exists in the grass spatial database
+ """Return True in case the map exists in the grass spatial database
- @return True if map exists, False otherwise
+ :return: True if map exists, False otherwise
"""
return self.ciface.vector_map_exists(self.get_name(),
self.get_mapset())
@@ -902,12 +898,12 @@
def load(self):
- """!Load all info from an existing vector map into the internal structure
+ """Load all info from an existing vector map into the internal structure
This method checks first if the map exists, in case it exists
the metadata of the map is put into this object and True is returned.
- @return True is the map exists and the metadata was filled successfully
+ :return: True is the map exists and the metadata was filled successfully
and getting the data was successfull, False otherwise
"""
@@ -951,15 +947,15 @@
###############################################################################
class SpaceTimeRasterDataset(AbstractSpaceTimeDataset):
- """!Space time raster dataset class
+ """Space time raster dataset class
"""
def __init__(self, ident):
AbstractSpaceTimeDataset.__init__(self, ident)
def is_stds(self):
- """!Return True if this class is a space time dataset
+ """Return True if this class is a space time dataset
- @return True if this class is a space time dataset, False otherwise
+ :return: True if this class is a space time dataset, False otherwise
"""
return True
@@ -967,59 +963,59 @@
return "strds"
def get_new_instance(self, ident):
- """!Return a new instance with the type of this class"""
+ """Return a new instance with the type of this class"""
return SpaceTimeRasterDataset(ident)
def get_new_map_instance(self, ident):
- """!Return a new instance of a map dataset which is associated "
+ """Return a new instance of a map dataset which is associated "
"with the type of this class"""
return RasterDataset(ident)
def get_map_register(self):
- """!Return the name of the map register table"""
+ """Return the name of the map register table"""
return self.metadata.get_raster_register()
def set_map_register(self, name):
- """!Set the name of the map register table"""
+ """Set the name of the map register table"""
self.metadata.set_raster_register(name)
def spatial_overlapping(self, dataset):
- """!Return True if the spatial extents 2d overlap"""
+ """Return True if the spatial extents 2d overlap"""
return self.spatial_extent.overlapping_2d(dataset.spatial_extent)
def spatial_relation(self, dataset):
- """!Return the two dimensional spatial relation"""
+ """Return the two dimensional spatial relation"""
return self.spatial_extent.spatial_relation_2d(dataset.spatial_extent)
def spatial_intersection(self, dataset):
- """!Return the two dimensional intersection as spatial_extent
+ """Return the two dimensional intersection as spatial_extent
object or None in case no intersection was found.
- @param dataset The abstract dataset to intersect with
- @return The intersection spatial extent or None
+ :param dataset: The abstract dataset to intersect with
+ :return: The intersection spatial extent or None
"""
return self.spatial_extent.intersect_2d(dataset.spatial_extent)
def spatial_union(self, dataset):
- """!Return the two dimensional union as spatial_extent
+ """Return the two dimensional union as spatial_extent
object or None in case the extents does not overlap or meet.
- @param dataset The abstract dataset to create a union with
- @return The union spatial extent or None
+ :param dataset: The abstract dataset to create a union with
+ :return: The union spatial extent or None
"""
return self.spatial_extent.union_2d(dataset.spatial_extent)
def spatial_disjoint_union(self, dataset):
- """!Return the two dimensional union as spatial_extent object.
+ """Return the two dimensional union as spatial_extent object.
- @param dataset The abstract dataset to create a union with
- @return The union spatial extent
+ :param dataset: The abstract dataset to create a union with
+ :return: The union spatial extent
"""
return self.spatial_extent.disjoint_union_2d(dataset.spatial_extent)
def reset(self, ident):
- """!Reset the internal structure and set the identifier"""
+ """Reset the internal structure and set the identifier"""
self.base = STRDSBase(ident=ident)
self.base.set_creator(str(getpass.getuser()))
self.absolute_time = STRDSAbsoluteTime(ident=ident)
@@ -1030,16 +1026,16 @@
###############################################################################
class SpaceTimeRaster3DDataset(AbstractSpaceTimeDataset):
- """!Space time raster3d dataset class
+ """Space time raster3d dataset class
"""
def __init__(self, ident):
AbstractSpaceTimeDataset.__init__(self, ident)
def is_stds(self):
- """!Return True if this class is a space time dataset
+ """Return True if this class is a space time dataset
- @return True if this class is a space time dataset, False otherwise
+ :return: True if this class is a space time dataset, False otherwise
"""
return True
@@ -1047,24 +1043,24 @@
return "str3ds"
def get_new_instance(self, ident):
- """!Return a new instance with the type of this class"""
+ """Return a new instance with the type of this class"""
return SpaceTimeRaster3DDataset(ident)
def get_new_map_instance(self, ident):
- """!Return a new instance of a map dataset which is associated
+ """Return a new instance of a map dataset which is associated
with the type of this class"""
return Raster3DDataset(ident)
def get_map_register(self):
- """!Return the name of the map register table"""
+ """Return the name of the map register table"""
return self.metadata.get_raster3d_register()
def set_map_register(self, name):
- """!Set the name of the map register table"""
+ """Set the name of the map register table"""
self.metadata.set_raster3d_register(name)
def spatial_overlapping(self, dataset):
- """!Return True if the spatial extents overlap"""
+ """Return True if the spatial extents overlap"""
if self.get_type() == dataset.get_type() or dataset.get_type() == "str3ds":
return self.spatial_extent.overlapping(dataset.spatial_extent)
@@ -1072,7 +1068,7 @@
return self.spatial_extent.overlapping_2d(dataset.spatial_extent)
def spatial_relation(self, dataset):
- """!Return the two or three dimensional spatial relation"""
+ """Return the two or three dimensional spatial relation"""
if self.get_type() == dataset.get_type() or \
dataset.get_type() == "str3ds":
@@ -1081,11 +1077,11 @@
return self.spatial_extent.spatial_relation_2d(dataset.spatial_extent)
def spatial_intersection(self, dataset):
- """!Return the three or two dimensional intersection as spatial_extent
+ """Return the three or two dimensional intersection as spatial_extent
object or None in case no intersection was found.
- @param dataset The abstract dataset to intersect with
- @return The intersection spatial extent or None
+ :param dataset: The abstract dataset to intersect with
+ :return: The intersection spatial extent or None
"""
if self.get_type() == dataset.get_type() or dataset.get_type() == "raster3d":
return self.spatial_extent.intersect(dataset.spatial_extent)
@@ -1093,11 +1089,11 @@
return self.spatial_extent.intersect_2d(dataset.spatial_extent)
def spatial_union(self, dataset):
- """!Return the three or two dimensional union as spatial_extent
+ """Return the three or two dimensional union as spatial_extent
object or None in case the extents does not overlap or meet.
- @param dataset The abstract dataset to create a union with
- @return The union spatial extent or None
+ :param dataset: The abstract dataset to create a union with
+ :return: The union spatial extent or None
"""
if self.get_type() == dataset.get_type() or dataset.get_type() == "raster3d":
return self.spatial_extent.union(dataset.spatial_extent)
@@ -1105,10 +1101,10 @@
return self.spatial_extent.union_2d(dataset.spatial_extent)
def spatial_disjoint_union(self, dataset):
- """!Return the three or two dimensional union as spatial_extent object.
+ """Return the three or two dimensional union as spatial_extent object.
- @param dataset The abstract dataset to create a union with
- @return The union spatial extent
+ :param dataset: The abstract dataset to create a union with
+ :return: The union spatial extent
"""
if self.get_type() == dataset.get_type() or dataset.get_type() == "raster3d":
return self.spatial_extent.disjoint_union(dataset.spatial_extent)
@@ -1117,7 +1113,7 @@
def reset(self, ident):
- """!Reset the internal structure and set the identifier"""
+ """Reset the internal structure and set the identifier"""
self.base = STR3DSBase(ident=ident)
self.base.set_creator(str(getpass.getuser()))
self.absolute_time = STR3DSAbsoluteTime(ident=ident)
@@ -1129,16 +1125,16 @@
class SpaceTimeVectorDataset(AbstractSpaceTimeDataset):
- """!Space time vector dataset class
+ """Space time vector dataset class
"""
def __init__(self, ident):
AbstractSpaceTimeDataset.__init__(self, ident)
def is_stds(self):
- """!Return True if this class is a space time dataset
+ """Return True if this class is a space time dataset
- @return True if this class is a space time dataset, False otherwise
+ :return: True if this class is a space time dataset, False otherwise
"""
return True
@@ -1146,59 +1142,59 @@
return "stvds"
def get_new_instance(self, ident):
- """!Return a new instance with the type of this class"""
+ """Return a new instance with the type of this class"""
return SpaceTimeVectorDataset(ident)
def get_new_map_instance(self, ident):
- """!Return a new instance of a map dataset which is associated
+ """Return a new instance of a map dataset which is associated
with the type of this class"""
return VectorDataset(ident)
def get_map_register(self):
- """!Return the name of the map register table"""
+ """Return the name of the map register table"""
return self.metadata.get_vector_register()
def set_map_register(self, name):
- """!Set the name of the map register table"""
+ """Set the name of the map register table"""
self.metadata.set_vector_register(name)
def spatial_overlapping(self, dataset):
- """!Return True if the spatial extents 2d overlap"""
+ """Return True if the spatial extents 2d overlap"""
return self.spatial_extent.overlapping_2d(dataset.spatial_extent)
def spatial_relation(self, dataset):
- """!Return the two dimensional spatial relation"""
+ """Return the two dimensional spatial relation"""
return self.spatial_extent.spatial_relation_2d(dataset.spatial_extent)
def spatial_intersection(self, dataset):
- """!Return the two dimensional intersection as spatial_extent
+ """Return the two dimensional intersection as spatial_extent
object or None in case no intersection was found.
- @param dataset The abstract dataset to intersect with
- @return The intersection spatial extent or None
+ :param dataset: The abstract dataset to intersect with
+ :return: The intersection spatial extent or None
"""
return self.spatial_extent.intersect_2d(dataset.spatial_extent)
def spatial_union(self, dataset):
- """!Return the two dimensional union as spatial_extent
+ """Return the two dimensional union as spatial_extent
object or None in case the extents does not overlap or meet.
- @param dataset The abstract dataset to create a union with
- @return The union spatial extent or None
+ :param dataset: The abstract dataset to create a union with
+ :return: The union spatial extent or None
"""
return self.spatial_extent.union_2d(dataset.spatial_extent)
def spatial_disjoint_union(self, dataset):
- """!Return the two dimensional union as spatial_extent object.
+ """Return the two dimensional union as spatial_extent object.
- @param dataset The abstract dataset to create a union with
- @return The union spatial extent
+ :param dataset: The abstract dataset to create a union with
+ :return: The union spatial extent
"""
return self.spatial_extent.disjoint_union_2d(dataset.spatial_extent)
def reset(self, ident):
- """!Reset the internal structure and set the identifier"""
+ """Reset the internal structure and set the identifier"""
self.base = STVDSBase(ident=ident)
self.base.set_creator(str(getpass.getuser()))
self.absolute_time = STVDSAbsoluteTime(ident=ident)
Modified: grass/trunk/lib/python/temporal/spatial_extent.py
===================================================================
--- grass/trunk/lib/python/temporal/spatial_extent.py 2014-09-28 01:40:32 UTC (rev 62120)
+++ grass/trunk/lib/python/temporal/spatial_extent.py 2014-09-28 01:46:15 UTC (rev 62121)
@@ -1,91 +1,85 @@
-"""!@package grass.temporal
+"""
+Spatial extents classes for map layer and space time datasets
- at brief GRASS Python scripting module (temporal GIS functions)
-
-Temporal GIS related spatial extent functions to be used in Python scripts and tgis packages.
-
Usage:
- at code
+.. code-block:: python
->>> import grass.temporal as tgis
->>> tgis.init()
->>> extent = tgis.RasterSpatialExtent(
-... ident="raster at PERMANENT", north=90, south=90, east=180, west=180,
-... top=100, bottom=-20)
->>> extent = tgis.Raster3DSpatialExtent(
-... ident="raster3d at PERMANENT", north=90, south=90, east=180, west=180,
-... top=100, bottom=-20)
->>> extent = tgis.VectorSpatialExtent(
-... ident="vector at PERMANENT", north=90, south=90, east=180, west=180,
-... top=100, bottom=-20)
->>> extent = tgis.STRDSSpatialExtent(
-... ident="strds at PERMANENT", north=90, south=90, east=180, west=180,
-... top=100, bottom=-20)
->>> extent = tgis.STR3DSSpatialExtent(
-... ident="str3ds at PERMANENT", north=90, south=90, east=180, west=180,
-... top=100, bottom=-20)
->>> extent = tgis.STVDSSpatialExtent(
-... ident="stvds at PERMANENT", north=90, south=90, east=180, west=180,
-... top=100, bottom=-20)
+ >>> import grass.temporal as tgis
+ >>> tgis.init()
+ >>> extent = tgis.RasterSpatialExtent(
+ ... ident="raster at PERMANENT", north=90, south=90, east=180, west=180,
+ ... top=100, bottom=-20)
+ >>> extent = tgis.Raster3DSpatialExtent(
+ ... ident="raster3d at PERMANENT", north=90, south=90, east=180, west=180,
+ ... top=100, bottom=-20)
+ >>> extent = tgis.VectorSpatialExtent(
+ ... ident="vector at PERMANENT", north=90, south=90, east=180, west=180,
+ ... top=100, bottom=-20)
+ >>> extent = tgis.STRDSSpatialExtent(
+ ... ident="strds at PERMANENT", north=90, south=90, east=180, west=180,
+ ... top=100, bottom=-20)
+ >>> extent = tgis.STR3DSSpatialExtent(
+ ... ident="str3ds at PERMANENT", north=90, south=90, east=180, west=180,
+ ... top=100, bottom=-20)
+ >>> extent = tgis.STVDSSpatialExtent(
+ ... ident="stvds at PERMANENT", north=90, south=90, east=180, west=180,
+ ... top=100, bottom=-20)
- at endcode
-
(C) 2012-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.
- at author Soeren Gebbert
+:authors: Soeren Gebbert
"""
from base import *
class SpatialExtent(SQLDatabaseInterface):
- """!This is the spatial extent base class for all maps and space time datasets
+ """This is the spatial extent base class for all maps and space time datasets
This class implements a three dimensional axis aligned bounding box
and functions to compute topological relationships
Usage:
- @code
+ .. code-block:: python
- >>> init()
- >>> extent = SpatialExtent(table="raster_spatial_extent",
- ... ident="soil at PERMANENT", north=90, south=90, east=180, west=180,
- ... top=100, bottom=-20)
- >>> extent.id
- 'soil at PERMANENT'
- >>> extent.north
- 90.0
- >>> extent.south
- 90.0
- >>> extent.east
- 180.0
- >>> extent.west
- 180.0
- >>> extent.top
- 100.0
- >>> extent.bottom
- -20.0
- >>> extent.print_info()
- +-------------------- Spatial extent ----------------------------------------+
- | North:...................... 90.0
- | South:...................... 90.0
- | East:.. .................... 180.0
- | West:....................... 180.0
- | Top:........................ 100.0
- | Bottom:..................... -20.0
- >>> extent.print_shell_info()
- north=90.0
- south=90.0
- east=180.0
- west=180.0
- top=100.0
- bottom=-20.0
+ >>> init()
+ >>> extent = SpatialExtent(table="raster_spatial_extent",
+ ... ident="soil at PERMANENT", north=90, south=90, east=180, west=180,
+ ... top=100, bottom=-20)
+ >>> extent.id
+ 'soil at PERMANENT'
+ >>> extent.north
+ 90.0
+ >>> extent.south
+ 90.0
+ >>> extent.east
+ 180.0
+ >>> extent.west
+ 180.0
+ >>> extent.top
+ 100.0
+ >>> extent.bottom
+ -20.0
+ >>> extent.print_info()
+ +-------------------- Spatial extent ----------------------------------------+
+ | North:...................... 90.0
+ | South:...................... 90.0
+ | East:.. .................... 180.0
+ | West:....................... 180.0
+ | Top:........................ 100.0
+ | Bottom:..................... -20.0
+ >>> extent.print_shell_info()
+ north=90.0
+ south=90.0
+ east=180.0
+ west=180.0
+ top=100.0
+ bottom=-20.0
- @endcode
"""
def __init__(self, table=None, ident=None, north=None, south=None,
east=None, west=None, top=None, bottom=None, proj="XY"):
@@ -96,7 +90,7 @@
self.set_projection(proj)
def overlapping_2d(self, extent):
- """!Return True if this (A) and the provided spatial extent (B) overlaps
+ """Return True if this (A) and the provided spatial extent (B) overlaps
in two dimensional space.
Code is lend from wind_overlap.c in lib/gis
@@ -108,17 +102,15 @@
- covered
- equivalent
- @code
+ .. code-block:: python
- >>> A = SpatialExtent(north=80, south=20, east=60, west=10)
- >>> B = SpatialExtent(north=80, south=20, east=60, west=10)
- >>> A.overlapping_2d(B)
- True
+ >>> A = SpatialExtent(north=80, south=20, east=60, west=10)
+ >>> B = SpatialExtent(north=80, south=20, east=60, west=10)
+ >>> A.overlapping_2d(B)
+ True
- @endcode
-
- @param extent The spatial extent to check overlapping with
- @return True or False
+ :param extent: The spatial extent to check overlapping with
+ :return: True or False
"""
if self.get_projection() != extent.get_projection():
@@ -156,7 +148,7 @@
return True
def overlapping(self, extent):
- """!Return True if this (A) and the provided spatial
+ """Return True if this (A) and the provided spatial
extent (B) overlaps in three dimensional space.
Overlapping includes the spatial relations:
@@ -167,19 +159,17 @@
- covered
- equivalent
- Usage:
+ Usage:
- @code
+ .. code-block:: python
- >>> A = SpatialExtent(north=80, south=20, east=60, west=10, bottom=-50, top=50)
- >>> B = SpatialExtent(north=80, south=20, east=60, west=10, bottom=-50, top=50)
- >>> A.overlapping(B)
- True
+ >>> A = SpatialExtent(north=80, south=20, east=60, west=10, bottom=-50, top=50)
+ >>> B = SpatialExtent(north=80, south=20, east=60, west=10, bottom=-50, top=50)
+ >>> A.overlapping(B)
+ True
- @endcode
-
- @param extent The spatial extent to check overlapping with
- @return True or False
+ :param extent: The spatial extent to check overlapping with
+ :return: True or False
"""
if not self.overlapping_2d(extent):
@@ -197,11 +187,11 @@
return True
def intersect_2d(self, extent):
- """!Return the two dimensional intersection as spatial_extent
+ """Return the two dimensional intersection as spatial_extent
object or None in case no intersection was found.
- @param extent The spatial extent to intersect with
- @return The intersection spatial extent
+ :param extent: The spatial extent to intersect with
+ :return: The intersection spatial extent
"""
if not self.overlapping_2d(extent):
@@ -247,76 +237,74 @@
return new
def intersect(self, extent):
- """!Return the three dimensional intersection as spatial_extent
+ """Return the three dimensional intersection as spatial_extent
object or None in case no intersection was found.
Usage:
- @code
+ .. code-block:: python
- >>> A = SpatialExtent(north=80, south=20, east=60, west=10,
- ... bottom=-50, top=50)
- >>> B = SpatialExtent(north=80, south=20, east=60, west=10,
- ... bottom=-50, top=50)
- >>> C = A.intersect(B)
- >>> C.print_info()
- +-------------------- Spatial extent ----------------------------------------+
- | North:...................... 80.0
- | South:...................... 20.0
- | East:.. .................... 60.0
- | West:....................... 10.0
- | Top:........................ 50.0
- | Bottom:..................... -50.0
- >>> B = SpatialExtent(north=40, south=30, east=60, west=10,
- ... bottom=-50, top=50)
- >>> C = A.intersect(B)
- >>> C.print_info()
- +-------------------- Spatial extent ----------------------------------------+
- | North:...................... 40.0
- | South:...................... 30.0
- | East:.. .................... 60.0
- | West:....................... 10.0
- | Top:........................ 50.0
- | Bottom:..................... -50.0
- >>> B = SpatialExtent(north=40, south=30, east=60, west=30,
- ... bottom=-50, top=50)
- >>> C = A.intersect(B)
- >>> C.print_info()
- +-------------------- Spatial extent ----------------------------------------+
- | North:...................... 40.0
- | South:...................... 30.0
- | East:.. .................... 60.0
- | West:....................... 30.0
- | Top:........................ 50.0
- | Bottom:..................... -50.0
- >>> B = SpatialExtent(north=40, south=30, east=60, west=30,
- ... bottom=-30, top=50)
- >>> C = A.intersect(B)
- >>> C.print_info()
- +-------------------- Spatial extent ----------------------------------------+
- | North:...................... 40.0
- | South:...................... 30.0
- | East:.. .................... 60.0
- | West:....................... 30.0
- | Top:........................ 50.0
- | Bottom:..................... -30.0
- >>> B = SpatialExtent(north=40, south=30, east=60, west=30,
- ... bottom=-30, top=30)
- >>> C = A.intersect(B)
- >>> C.print_info()
- +-------------------- Spatial extent ----------------------------------------+
- | North:...................... 40.0
- | South:...................... 30.0
- | East:.. .................... 60.0
- | West:....................... 30.0
- | Top:........................ 30.0
- | Bottom:..................... -30.0
+ >>> A = SpatialExtent(north=80, south=20, east=60, west=10,
+ ... bottom=-50, top=50)
+ >>> B = SpatialExtent(north=80, south=20, east=60, west=10,
+ ... bottom=-50, top=50)
+ >>> C = A.intersect(B)
+ >>> C.print_info()
+ +-------------------- Spatial extent ----------------------------------------+
+ | North:...................... 80.0
+ | South:...................... 20.0
+ | East:.. .................... 60.0
+ | West:....................... 10.0
+ | Top:........................ 50.0
+ | Bottom:..................... -50.0
+ >>> B = SpatialExtent(north=40, south=30, east=60, west=10,
+ ... bottom=-50, top=50)
+ >>> C = A.intersect(B)
+ >>> C.print_info()
+ +-------------------- Spatial extent ----------------------------------------+
+ | North:...................... 40.0
+ | South:...................... 30.0
+ | East:.. .................... 60.0
+ | West:....................... 10.0
+ | Top:........................ 50.0
+ | Bottom:..................... -50.0
+ >>> B = SpatialExtent(north=40, south=30, east=60, west=30,
+ ... bottom=-50, top=50)
+ >>> C = A.intersect(B)
+ >>> C.print_info()
+ +-------------------- Spatial extent ----------------------------------------+
+ | North:...................... 40.0
+ | South:...................... 30.0
+ | East:.. .................... 60.0
+ | West:....................... 30.0
+ | Top:........................ 50.0
+ | Bottom:..................... -50.0
+ >>> B = SpatialExtent(north=40, south=30, east=60, west=30,
+ ... bottom=-30, top=50)
+ >>> C = A.intersect(B)
+ >>> C.print_info()
+ +-------------------- Spatial extent ----------------------------------------+
+ | North:...................... 40.0
+ | South:...................... 30.0
+ | East:.. .................... 60.0
+ | West:....................... 30.0
+ | Top:........................ 50.0
+ | Bottom:..................... -30.0
+ >>> B = SpatialExtent(north=40, south=30, east=60, west=30,
+ ... bottom=-30, top=30)
+ >>> C = A.intersect(B)
+ >>> C.print_info()
+ +-------------------- Spatial extent ----------------------------------------+
+ | North:...................... 40.0
+ | South:...................... 30.0
+ | East:.. .................... 60.0
+ | West:....................... 30.0
+ | Top:........................ 30.0
+ | Bottom:..................... -30.0
- @endcode
-
- @param extent The spatial extent to intersect with
- @return The intersection spatial extent
+ :param extent: The spatial extent to intersect with
+ :return: The intersection spatial extent
"""
if not self.overlapping(extent):
@@ -344,11 +332,11 @@
return new
def union_2d(self, extent):
- """!Return the two dimensional union as spatial_extent
+ """Return the two dimensional union as spatial_extent
object or None in case the extents does not overlap or meet.
- @param extent The spatial extent to create a union with
- @return The union spatial extent
+ :param extent: The spatial extent to create a union with
+ :return: The union spatial extent
"""
if not self.overlapping_2d(extent) and not self.meet_2d(extent):
return None
@@ -356,10 +344,10 @@
return self.disjoint_union_2d(extent)
def disjoint_union_2d(self, extent):
- """!Return the two dimensional union as spatial_extent.
+ """Return the two dimensional union as spatial_extent.
- @param extent The spatial extent to create a union with
- @return The union spatial extent
+ :param extent: The spatial extent to create a union with
+ :return: The union spatial extent
"""
eN = extent.get_north()
eS = extent.get_south()
@@ -401,11 +389,11 @@
return new
def union(self, extent):
- """!Return the three dimensional union as spatial_extent
+ """Return the three dimensional union as spatial_extent
object or None in case the extents does not overlap or meet.
- @param extent The spatial extent to create a union with
- @return The union spatial extent
+ :param extent: The spatial extent to create a union with
+ :return: The union spatial extent
"""
if not self.overlapping(extent) and not self.meet(extent):
return None
@@ -413,87 +401,86 @@
return self.disjoint_union(extent)
def disjoint_union(self, extent):
- """!Return the three dimensional union as spatial_extent .
+ """Return the three dimensional union as spatial_extent .
Usage:
- @code
+ .. code-block:: python
- >>> A = SpatialExtent(north=80, south=20, east=60, west=10,
- ... bottom=-50, top=50)
- >>> B = SpatialExtent(north=80, south=20, east=60, west=10,
- ... bottom=-50, top=50)
- >>> C = A.disjoint_union(B)
- >>> C.print_info()
- +-------------------- Spatial extent ----------------------------------------+
- | North:...................... 80.0
- | South:...................... 20.0
- | East:.. .................... 60.0
- | West:....................... 10.0
- | Top:........................ 50.0
- | Bottom:..................... -50.0
- >>> B = SpatialExtent(north=40, south=30, east=60, west=10,
- ... bottom=-50, top=50)
- >>> C = A.disjoint_union(B)
- >>> C.print_info()
- +-------------------- Spatial extent ----------------------------------------+
- | North:...................... 80.0
- | South:...................... 20.0
- | East:.. .................... 60.0
- | West:....................... 10.0
- | Top:........................ 50.0
- | Bottom:..................... -50.0
- >>> B = SpatialExtent(north=40, south=30, east=60, west=30,
- ... bottom=-50, top=50)
- >>> C = A.disjoint_union(B)
- >>> C.print_info()
- +-------------------- Spatial extent ----------------------------------------+
- | North:...................... 80.0
- | South:...................... 20.0
- | East:.. .................... 60.0
- | West:....................... 10.0
- | Top:........................ 50.0
- | Bottom:..................... -50.0
- >>> B = SpatialExtent(north=40, south=30, east=60, west=30,
- ... bottom=-30, top=50)
- >>> C = A.disjoint_union(B)
- >>> C.print_info()
- +-------------------- Spatial extent ----------------------------------------+
- | North:...................... 80.0
- | South:...................... 20.0
- | East:.. .................... 60.0
- | West:....................... 10.0
- | Top:........................ 50.0
- | Bottom:..................... -50.0
- >>> B = SpatialExtent(north=40, south=30, east=60, west=30,
- ... bottom=-30, top=30)
- >>> C = A.disjoint_union(B)
- >>> C.print_info()
- +-------------------- Spatial extent ----------------------------------------+
- | North:...................... 80.0
- | South:...................... 20.0
- | East:.. .................... 60.0
- | West:....................... 10.0
- | Top:........................ 50.0
- | Bottom:..................... -50.0
- >>> A = SpatialExtent(north=80, south=20, east=60, west=10,
- ... bottom=-50, top=50)
- >>> B = SpatialExtent(north=90, south=80, east=70, west=20,
- ... bottom=-30, top=60)
- >>> C = A.disjoint_union(B)
- >>> C.print_info()
- +-------------------- Spatial extent ----------------------------------------+
- | North:...................... 90.0
- | South:...................... 20.0
- | East:.. .................... 70.0
- | West:....................... 10.0
- | Top:........................ 60.0
- | Bottom:..................... -50.0
+ >>> A = SpatialExtent(north=80, south=20, east=60, west=10,
+ ... bottom=-50, top=50)
+ >>> B = SpatialExtent(north=80, south=20, east=60, west=10,
+ ... bottom=-50, top=50)
+ >>> C = A.disjoint_union(B)
+ >>> C.print_info()
+ +-------------------- Spatial extent ----------------------------------------+
+ | North:...................... 80.0
+ | South:...................... 20.0
+ | East:.. .................... 60.0
+ | West:....................... 10.0
+ | Top:........................ 50.0
+ | Bottom:..................... -50.0
+ >>> B = SpatialExtent(north=40, south=30, east=60, west=10,
+ ... bottom=-50, top=50)
+ >>> C = A.disjoint_union(B)
+ >>> C.print_info()
+ +-------------------- Spatial extent ----------------------------------------+
+ | North:...................... 80.0
+ | South:...................... 20.0
+ | East:.. .................... 60.0
+ | West:....................... 10.0
+ | Top:........................ 50.0
+ | Bottom:..................... -50.0
+ >>> B = SpatialExtent(north=40, south=30, east=60, west=30,
+ ... bottom=-50, top=50)
+ >>> C = A.disjoint_union(B)
+ >>> C.print_info()
+ +-------------------- Spatial extent ----------------------------------------+
+ | North:...................... 80.0
+ | South:...................... 20.0
+ | East:.. .................... 60.0
+ | West:....................... 10.0
+ | Top:........................ 50.0
+ | Bottom:..................... -50.0
+ >>> B = SpatialExtent(north=40, south=30, east=60, west=30,
+ ... bottom=-30, top=50)
+ >>> C = A.disjoint_union(B)
+ >>> C.print_info()
+ +-------------------- Spatial extent ----------------------------------------+
+ | North:...................... 80.0
+ | South:...................... 20.0
+ | East:.. .................... 60.0
+ | West:....................... 10.0
+ | Top:........................ 50.0
+ | Bottom:..................... -50.0
+ >>> B = SpatialExtent(north=40, south=30, east=60, west=30,
+ ... bottom=-30, top=30)
+ >>> C = A.disjoint_union(B)
+ >>> C.print_info()
+ +-------------------- Spatial extent ----------------------------------------+
+ | North:...................... 80.0
+ | South:...................... 20.0
+ | East:.. .................... 60.0
+ | West:....................... 10.0
+ | Top:........................ 50.0
+ | Bottom:..................... -50.0
+ >>> A = SpatialExtent(north=80, south=20, east=60, west=10,
+ ... bottom=-50, top=50)
+ >>> B = SpatialExtent(north=90, south=80, east=70, west=20,
+ ... bottom=-30, top=60)
+ >>> C = A.disjoint_union(B)
+ >>> C.print_info()
+ +-------------------- Spatial extent ----------------------------------------+
+ | North:...................... 90.0
+ | South:...................... 20.0
+ | East:.. .................... 70.0
+ | West:....................... 10.0
+ | Top:........................ 60.0
+ | Bottom:..................... -50.0
- @endcode
- @param extent The spatial extent to create a disjoint union with
- @return The union spatial extent
+ :param extent: The spatial extent to create a disjoint union with
+ :return: The union spatial extent
"""
new = self.disjoint_union_2d(extent)
@@ -518,19 +505,19 @@
return new
def is_in_2d(self, extent):
- """!Return True if this extent (A) is located in the provided spatial
+ """Return True if this extent (A) is located in the provided spatial
extent (B) in two dimensions.
+
+ ::
+
+ _____
+ |A _ |
+ | |_| |
+ |_____|B
- @verbatim
- _____
- |A _ |
- | |_| |
- |_____|B
- @endverbatim
-
- @param extent The spatial extent
- @return True or False
+ :param extent: The spatial extent
+ :return: True or False
"""
if self.get_projection() != extent.get_projection():
self.msgr.error(_("Projections are different. Unable to compute "
@@ -569,26 +556,24 @@
return True
def is_in(self, extent):
- """!Return True if this extent (A) is located in the provided spatial
+ """Return True if this extent (A) is located in the provided spatial
extent (B) in three dimensions.
Usage:
- @code
+ .. code-block:: python
- >>> A = SpatialExtent(north=79, south=21, east=59, west=11,
- ... bottom=-49, top=49)
- >>> B = SpatialExtent(north=80, south=20, east=60, west=10,
- ... bottom=-50, top=50)
- >>> A.is_in(B)
- True
- >>> B.is_in(A)
- False
+ >>> A = SpatialExtent(north=79, south=21, east=59, west=11,
+ ... bottom=-49, top=49)
+ >>> B = SpatialExtent(north=80, south=20, east=60, west=10,
+ ... bottom=-50, top=50)
+ >>> A.is_in(B)
+ True
+ >>> B.is_in(A)
+ False
- @endcode
-
- @param extent The spatial extent
- @return True or False
+ :param extent: The spatial extent
+ :return: True or False
"""
if not self.is_in_2d(extent):
return False
@@ -607,70 +592,64 @@
return True
def contain_2d(self, extent):
- """!Return True if this extent (A) contains the provided spatial
+ """Return True if this extent (A) contains the provided spatial
extent (B) in two dimensions.
Usage:
- @code
+ .. code-block:: python
- >>> A = SpatialExtent(north=80, south=20, east=60, west=10)
- >>> B = SpatialExtent(north=79, south=21, east=59, west=11)
- >>> A.contain_2d(B)
- True
- >>> B.contain_2d(A)
- False
+ >>> A = SpatialExtent(north=80, south=20, east=60, west=10)
+ >>> B = SpatialExtent(north=79, south=21, east=59, west=11)
+ >>> A.contain_2d(B)
+ True
+ >>> B.contain_2d(A)
+ False
- @endcode
-
- @param extent The spatial extent
- @return True or False
+ :param extent: The spatial extent
+ :return: True or False
"""
return extent.is_in_2d(self)
def contain(self, extent):
- """!Return True if this extent (A) contains the provided spatial
+ """Return True if this extent (A) contains the provided spatial
extent (B) in three dimensions.
Usage:
- @code
+ .. code-block:: python
- >>> A = SpatialExtent(north=80, south=20, east=60, west=10,
- ... bottom=-50, top=50)
- >>> B = SpatialExtent(north=79, south=21, east=59, west=11,
- ... bottom=-49, top=49)
- >>> A.contain(B)
- True
- >>> B.contain(A)
- False
+ >>> A = SpatialExtent(north=80, south=20, east=60, west=10,
+ ... bottom=-50, top=50)
+ >>> B = SpatialExtent(north=79, south=21, east=59, west=11,
+ ... bottom=-49, top=49)
+ >>> A.contain(B)
+ True
+ >>> B.contain(A)
+ False
- @endcode
-
- @param extent The spatial extent
- @return True or False
+ :param extent: The spatial extent
+ :return: True or False
"""
return extent.is_in(self)
def equivalent_2d(self, extent):
- """!Return True if this extent (A) is equal to the provided spatial
+ """Return True if this extent (A) is equal to the provided spatial
extent (B) in two dimensions.
Usage:
- @code
+ .. code-block:: python
- >>> A = SpatialExtent(north=80, south=20, east=60, west=10)
- >>> B = SpatialExtent(north=80, south=20, east=60, west=10)
- >>> A.equivalent_2d(B)
- True
- >>> B.equivalent_2d(A)
- True
+ >>> A = SpatialExtent(north=80, south=20, east=60, west=10)
+ >>> B = SpatialExtent(north=80, south=20, east=60, west=10)
+ >>> A.equivalent_2d(B)
+ True
+ >>> B.equivalent_2d(A)
+ True
- @endcode
-
- @param extent The spatial extent
- @return True or False
+ :param extent: The spatial extent
+ :return: True or False
"""
if self.get_projection() != extent.get_projection():
self.msgr.error(_("Projections are different. Unable to compute "
@@ -709,26 +688,24 @@
return True
def equivalent(self, extent):
- """!Return True if this extent (A) is equal to the provided spatial
+ """Return True if this extent (A) is equal to the provided spatial
extent (B) in three dimensions.
Usage:
- @code
+ .. code-block:: python
- >>> A = SpatialExtent(north=80, south=20, east=60, west=10,
- ... bottom=-50, top=50)
- >>> B = SpatialExtent(north=80, south=20, east=60, west=10,
- ... bottom=-50, top=50)
- >>> A.equivalent(B)
- True
- >>> B.equivalent(A)
- True
+ >>> A = SpatialExtent(north=80, south=20, east=60, west=10,
+ ... bottom=-50, top=50)
+ >>> B = SpatialExtent(north=80, south=20, east=60, west=10,
+ ... bottom=-50, top=50)
+ >>> A.equivalent(B)
+ True
+ >>> B.equivalent(A)
+ True
- @endcode
-
- @param extent The spatial extent
- @return True or False
+ :param extent: The spatial extent
+ :return: True or False
"""
if not self.equivalent_2d(extent):
@@ -748,26 +725,26 @@
return True
def cover_2d(self, extent):
- """!Return True if this extent (A) covers the provided spatial
+ """Return True if this extent (A) covers the provided spatial
extent (B) in two dimensions.
- @verbatim
- _____ _____ _____ _____
- |A __| |__ A| |A | B| |B | A|
- | |B | | B| | | |__| |__| |
- |__|__| |__|__| |_____| |_____|
+ ::
+
+ _____ _____ _____ _____
+ |A __| |__ A| |A | B| |B | A|
+ | |B | | B| | | |__| |__| |
+ |__|__| |__|__| |_____| |_____|
- _____ _____ _____ _____
- |A|B| | |A __| |A _ | |__ A|
- | |_| | | |__|B | |B| | B|__| |
- |_____| |_____| |_|_|_| |_____|
+ _____ _____ _____ _____
+ |A|B| | |A __| |A _ | |__ A|
+ | |_| | | |__|B | |B| | B|__| |
+ |_____| |_____| |_|_|_| |_____|
- _____ _____ _____ _____
- |A|B | |_____|A |A|B|A| |_____|A
- | | | |B | | | | | |_____|B
- |_|___| |_____| |_|_|_| |_____|A
+ _____ _____ _____ _____
+ |A|B | |_____|A |A|B|A| |_____|A
+ | | | |B | | | | | |_____|B
+ |_|___| |_____| |_|_|_| |_____|A
- @endverbatim
The following cases are excluded:
@@ -775,8 +752,8 @@
- in
- equivalent
- @param extent The spatial extent
- @return True or False
+ :param extent: The spatial extent
+ :return: True or False
"""
if self.get_projection() != extent.get_projection():
@@ -838,7 +815,7 @@
return True
def cover(self, extent):
- """!Return True if this extent covers the provided spatial
+ """Return True if this extent covers the provided spatial
extent in three dimensions.
The following cases are excluded:
@@ -847,8 +824,8 @@
- in
- equivalent
- @param extent The spatial extent
- @return True or False
+ :param extent: The spatial extent
+ :return: True or False
"""
if self.get_projection() != extent.get_projection():
self.msgr.error(_("Projections are different. Unable to compute "
@@ -928,7 +905,7 @@
return True
def covered_2d(self, extent):
- """!Return True if this extent is covered by the provided spatial
+ """Return True if this extent is covered by the provided spatial
extent in two dimensions.
The following cases are excluded:
@@ -937,14 +914,14 @@
- in
- equivalent
- @param extent The spatial extent
- @return True or False
+ :param extent: The spatial extent
+ :return: True or False
"""
return extent.cover_2d(self)
def covered(self, extent):
- """!Return True if this extent is covered by the provided spatial
+ """Return True if this extent is covered by the provided spatial
extent in three dimensions.
The following cases are excluded:
@@ -953,25 +930,25 @@
- in
- equivalent
- @param extent The spatial extent
- @return True or False
+ :param extent: The spatial extent
+ :return: True or False
"""
return extent.cover(self)
def overlap_2d(self, extent):
- """!Return True if this extent (A) overlaps with the provided spatial
+ """Return True if this extent (A) overlaps with the provided spatial
extent (B) in two dimensions.
Code is lend from wind_overlap.c in lib/gis
- @verbatim
- _____
- |A __|__
- | | | B|
- |__|__| |
- |_____|
+ ::
+
+ _____
+ |A __|__
+ | | | B|
+ |__|__| |
+ |_____|
- @endverbatim
The following cases are excluded:
@@ -981,8 +958,8 @@
- covered
- equivalent
- @param extent The spatial extent
- @return True or False
+ :param extent: The spatial extent
+ :return: True or False
"""
if self.contain_2d(extent):
@@ -1030,7 +1007,7 @@
return True
def overlap(self, extent):
- """!Return True if this extent overlaps with the provided spatial
+ """Return True if this extent overlaps with the provided spatial
extent in three dimensions.
The following cases are excluded:
@@ -1041,8 +1018,8 @@
- covered
- equivalent
- @param extent The spatial extent
- @return True or False
+ :param extent: The spatial extent
+ :return: True or False
"""
if self.is_in(extent):
@@ -1098,37 +1075,37 @@
return True
def meet_2d(self, extent):
- """!Return True if this extent (A) meets with the provided spatial
+ """Return True if this extent (A) meets with the provided spatial
extent (B) in two dimensions.
- @verbatim
- _____ _____
- | A | B |
- |_____| |
+ ::
+
+ _____ _____
+ | A | B |
+ |_____| |
+ |_____|
+ _____ _____
+ | B | A |
+ | | |
+ |_____|_____|
+ ___
+ | A |
+ | |
+ |___|
+ | B |
+ | |
+ |_____|
+ _____
+ | B |
+ | |
+ |_____|_
+ | A |
+ | |
|_____|
- _____ _____
- | B | A |
- | | |
- |_____|_____|
- ___
- | A |
- | |
- |___|
- | B |
- | |
- |_____|
- _____
- | B |
- | |
- |_____|_
- | A |
- | |
- |_____|
- @endverbatim
- @param extent The spatial extent
- @return True or False
+ :param extent: The spatial extent
+ :return: True or False
"""
eN = extent.get_north()
@@ -1183,11 +1160,11 @@
return True
def meet(self, extent):
- """!Return True if this extent meets with the provided spatial
+ """Return True if this extent meets with the provided spatial
extent in three dimensions.
- @param extent The spatial extent
- @return True or False
+ :param extent: The spatial extent
+ :return: True or False
"""
eN = extent.get_north()
eS = extent.get_south()
@@ -1263,21 +1240,21 @@
return True
def disjoint_2d(self, extent):
- """!Return True if this extent (A) is disjoint with the provided spatial
+ """Return True if this extent (A) is disjoint with the provided spatial
extent (B) in three dimensions.
- @verbatim
- _____
- | A |
- |_____|
- _______
- | B |
- |_______|
+ ::
+
+ _____
+ | A |
+ |_____|
+ _______
+ | B |
+ |_______|
- @endverbatim
- @param extent The spatial extent
- @return True or False
+ :param extent: The spatial extent
+ :return: True or False
"""
if self.is_in_2d(extent):
@@ -1304,11 +1281,11 @@
return True
def disjoint(self, extent):
- """!Return True if this extent is disjoint with the provided spatial
+ """Return True if this extent is disjoint with the provided spatial
extent in three dimensions.
- @param extent The spatial extent
- @return True or False
+ :param extent: The spatial extent
+ :return: True or False
"""
if self.is_in(extent):
@@ -1335,7 +1312,7 @@
return True
def spatial_relation_2d(self, extent):
- """!Returns the two dimensional spatial relation between this
+ """Returns the two dimensional spatial relation between this
extent and the provided spatial extent in two dimensions.
Spatial relations are:
@@ -1372,7 +1349,7 @@
return "unknown"
def spatial_relation(self, extent):
- """!Returns the two dimensional spatial relation between this
+ """Returns the two dimensional spatial relation between this
extent and the provided spatial extent in three dimensions.
Spatial relations are:
@@ -1389,167 +1366,166 @@
Usage:
- @code
+ .. code-block:: python
- >>> A = SpatialExtent(north=80, south=20, east=60, west=10, bottom=-50, top=50)
- >>> B = SpatialExtent(north=80, south=20, east=60, west=10, bottom=-50, top=50)
- >>> A.spatial_relation(B)
- 'equivalent'
- >>> B.spatial_relation(A)
- 'equivalent'
- >>> B = SpatialExtent(north=70, south=20, east=60, west=10, bottom=-50, top=50)
- >>> A.spatial_relation_2d(B)
- 'cover'
- >>> A.spatial_relation(B)
- 'cover'
- >>> B = SpatialExtent(north=70, south=30, east=60, west=10, bottom=-50, top=50)
- >>> A.spatial_relation_2d(B)
- 'cover'
- >>> A.spatial_relation(B)
- 'cover'
- >>> B.spatial_relation_2d(A)
- 'covered'
- >>> B.spatial_relation(A)
- 'covered'
- >>> B = SpatialExtent(north=70, south=30, east=50, west=10, bottom=-50, top=50)
- >>> A.spatial_relation_2d(B)
- 'cover'
- >>> B.spatial_relation_2d(A)
- 'covered'
- >>> A.spatial_relation(B)
- 'cover'
- >>> B = SpatialExtent(north=70, south=30, east=50, west=20, bottom=-50, top=50)
- >>> B.spatial_relation(A)
- 'covered'
- >>> B = SpatialExtent(north=70, south=30, east=50, west=20, bottom=-50, top=50)
- >>> A.spatial_relation_2d(B)
- 'contain'
- >>> A.spatial_relation(B)
- 'cover'
- >>> B = SpatialExtent(north=70, south=30, east=50, west=20, bottom=-40, top=50)
- >>> A.spatial_relation(B)
- 'cover'
- >>> B = SpatialExtent(north=70, south=30, east=50, west=20, bottom=-40, top=40)
- >>> A.spatial_relation(B)
- 'contain'
- >>> B.spatial_relation(A)
- 'in'
- >>> B = SpatialExtent(north=90, south=30, east=50, west=20, bottom=-40, top=40)
- >>> A.spatial_relation_2d(B)
- 'overlap'
- >>> A.spatial_relation(B)
- 'overlap'
- >>> B = SpatialExtent(north=90, south=5, east=70, west=5, bottom=-40, top=40)
- >>> A.spatial_relation_2d(B)
- 'in'
- >>> A.spatial_relation(B)
- 'overlap'
- >>> B = SpatialExtent(north=90, south=5, east=70, west=5, bottom=-40, top=60)
- >>> A.spatial_relation(B)
- 'overlap'
- >>> B = SpatialExtent(north=90, south=5, east=70, west=5, bottom=-60, top=60)
- >>> A.spatial_relation(B)
- 'in'
- >>> A = SpatialExtent(north=80, south=60, east=60, west=10, bottom=-50, top=50)
- >>> B = SpatialExtent(north=60, south=20, east=60, west=10, bottom=-50, top=50)
- >>> A.spatial_relation_2d(B)
- 'meet'
- >>> A.spatial_relation(B)
- 'meet'
- >>> A = SpatialExtent(north=60, south=40, east=60, west=10, bottom=-50, top=50)
- >>> B = SpatialExtent(north=80, south=60, east=60, west=10, bottom=-50, top=50)
- >>> A.spatial_relation_2d(B)
- 'meet'
- >>> A.spatial_relation(B)
- 'meet'
- >>> A = SpatialExtent(north=80, south=40, east=60, west=40, bottom=-50, top=50)
- >>> B = SpatialExtent(north=80, south=40, east=40, west=20, bottom=-50, top=50)
- >>> A.spatial_relation_2d(B)
- 'meet'
- >>> A.spatial_relation(B)
- 'meet'
- >>> A = SpatialExtent(north=80, south=40, east=40, west=20, bottom=-50, top=50)
- >>> B = SpatialExtent(north=90, south=30, east=60, west=40, bottom=-50, top=50)
- >>> A.spatial_relation_2d(B)
- 'meet'
- >>> A.spatial_relation(B)
- 'meet'
- >>> A = SpatialExtent(north=80, south=40, east=40, west=20, bottom=-50, top=50)
- >>> B = SpatialExtent(north=70, south=50, east=60, west=40, bottom=-50, top=50)
- >>> A.spatial_relation_2d(B)
- 'meet'
- >>> A.spatial_relation(B)
- 'meet'
- >>> A = SpatialExtent(north=80, south=40, east=40, west=20, bottom=-50, top=50)
- >>> B = SpatialExtent(north=60, south=20, east=60, west=40, bottom=-50, top=50)
- >>> A.spatial_relation_2d(B)
- 'meet'
- >>> A.spatial_relation(B)
- 'meet'
- >>> A = SpatialExtent(north=80, south=40, east=40, west=20, bottom=-50, top=50)
- >>> B = SpatialExtent(north=40, south=20, east=60, west=40, bottom=-50, top=50)
- >>> A.spatial_relation_2d(B)
- 'disjoint'
- >>> A.spatial_relation(B)
- 'disjoint'
- >>> A = SpatialExtent(north=80, south=40, east=40, west=20, bottom=-50, top=50)
- >>> B = SpatialExtent(north=60, south=20, east=60, west=40, bottom=-60, top=60)
- >>> A.spatial_relation(B)
- 'meet'
- >>> A = SpatialExtent(north=80, south=40, east=40, west=20, bottom=-50, top=50)
- >>> B = SpatialExtent(north=90, south=30, east=60, west=40, bottom=-40, top=40)
- >>> A.spatial_relation(B)
- 'meet'
- >>> A = SpatialExtent(north=80, south=40, east=60, west=20, bottom=0, top=50)
- >>> B = SpatialExtent(north=80, south=40, east=60, west=20, bottom=-50, top=0)
- >>> A.spatial_relation(B)
- 'meet'
- >>> A = SpatialExtent(north=80, south=40, east=60, west=20, bottom=0, top=50)
- >>> B = SpatialExtent(north=80, south=50, east=60, west=30, bottom=-50, top=0)
- >>> A.spatial_relation(B)
- 'meet'
- >>> A = SpatialExtent(north=80, south=40, east=60, west=20, bottom=0, top=50)
- >>> B = SpatialExtent(north=70, south=50, east=50, west=30, bottom=-50, top=0)
- >>> A.spatial_relation(B)
- 'meet'
- >>> A = SpatialExtent(north=80, south=40, east=60, west=20, bottom=0, top=50)
- >>> B = SpatialExtent(north=90, south=30, east=70, west=10, bottom=-50, top=0)
- >>> A.spatial_relation(B)
- 'meet'
- >>> A = SpatialExtent(north=80, south=40, east=60, west=20, bottom=0, top=50)
- >>> B = SpatialExtent(north=70, south=30, east=50, west=10, bottom=-50, top=0)
- >>> A.spatial_relation(B)
- 'meet'
- >>> A = SpatialExtent(north=80, south=40, east=60, west=20, bottom=-50, top=0)
- >>> B = SpatialExtent(north=80, south=40, east=60, west=20, bottom=0, top=50)
- >>> A.spatial_relation(B)
- 'meet'
- >>> A = SpatialExtent(north=80, south=40, east=60, west=20, bottom=-50, top=0)
- >>> B = SpatialExtent(north=80, south=50, east=60, west=30, bottom=0, top=50)
- >>> A.spatial_relation(B)
- 'meet'
- >>> A = SpatialExtent(north=80, south=40, east=60, west=20, bottom=-50, top=0)
- >>> B = SpatialExtent(north=70, south=50, east=50, west=30, bottom=0, top=50)
- >>> A.spatial_relation(B)
- 'meet'
- >>> A = SpatialExtent(north=80, south=40, east=60, west=20, bottom=-50, top=0)
- >>> B = SpatialExtent(north=90, south=30, east=70, west=10, bottom=0, top=50)
- >>> A.spatial_relation(B)
- 'meet'
- >>> A = SpatialExtent(north=80, south=40, east=60, west=20, bottom=-50, top=0)
- >>> B = SpatialExtent(north=70, south=30, east=50, west=10, bottom=0, top=50)
- >>> A.spatial_relation(B)
- 'meet'
- >>> A = SpatialExtent(north=80, south=20, east=60, west=10, bottom=-50, top=50)
- >>> B = SpatialExtent(north=90, south=81, east=60, west=10, bottom=-50, top=50)
- >>> A.spatial_relation(B)
- 'disjoint'
- >>> A = SpatialExtent(north=80, south=20, east=60, west=10, bottom=-50, top=50)
- >>> B = SpatialExtent(north=90, south=80, east=60, west=10, bottom=-50, top=50)
- >>> A.spatial_relation(B)
- 'meet'
+ >>> A = SpatialExtent(north=80, south=20, east=60, west=10, bottom=-50, top=50)
+ >>> B = SpatialExtent(north=80, south=20, east=60, west=10, bottom=-50, top=50)
+ >>> A.spatial_relation(B)
+ 'equivalent'
+ >>> B.spatial_relation(A)
+ 'equivalent'
+ >>> B = SpatialExtent(north=70, south=20, east=60, west=10, bottom=-50, top=50)
+ >>> A.spatial_relation_2d(B)
+ 'cover'
+ >>> A.spatial_relation(B)
+ 'cover'
+ >>> B = SpatialExtent(north=70, south=30, east=60, west=10, bottom=-50, top=50)
+ >>> A.spatial_relation_2d(B)
+ 'cover'
+ >>> A.spatial_relation(B)
+ 'cover'
+ >>> B.spatial_relation_2d(A)
+ 'covered'
+ >>> B.spatial_relation(A)
+ 'covered'
+ >>> B = SpatialExtent(north=70, south=30, east=50, west=10, bottom=-50, top=50)
+ >>> A.spatial_relation_2d(B)
+ 'cover'
+ >>> B.spatial_relation_2d(A)
+ 'covered'
+ >>> A.spatial_relation(B)
+ 'cover'
+ >>> B = SpatialExtent(north=70, south=30, east=50, west=20, bottom=-50, top=50)
+ >>> B.spatial_relation(A)
+ 'covered'
+ >>> B = SpatialExtent(north=70, south=30, east=50, west=20, bottom=-50, top=50)
+ >>> A.spatial_relation_2d(B)
+ 'contain'
+ >>> A.spatial_relation(B)
+ 'cover'
+ >>> B = SpatialExtent(north=70, south=30, east=50, west=20, bottom=-40, top=50)
+ >>> A.spatial_relation(B)
+ 'cover'
+ >>> B = SpatialExtent(north=70, south=30, east=50, west=20, bottom=-40, top=40)
+ >>> A.spatial_relation(B)
+ 'contain'
+ >>> B.spatial_relation(A)
+ 'in'
+ >>> B = SpatialExtent(north=90, south=30, east=50, west=20, bottom=-40, top=40)
+ >>> A.spatial_relation_2d(B)
+ 'overlap'
+ >>> A.spatial_relation(B)
+ 'overlap'
+ >>> B = SpatialExtent(north=90, south=5, east=70, west=5, bottom=-40, top=40)
+ >>> A.spatial_relation_2d(B)
+ 'in'
+ >>> A.spatial_relation(B)
+ 'overlap'
+ >>> B = SpatialExtent(north=90, south=5, east=70, west=5, bottom=-40, top=60)
+ >>> A.spatial_relation(B)
+ 'overlap'
+ >>> B = SpatialExtent(north=90, south=5, east=70, west=5, bottom=-60, top=60)
+ >>> A.spatial_relation(B)
+ 'in'
+ >>> A = SpatialExtent(north=80, south=60, east=60, west=10, bottom=-50, top=50)
+ >>> B = SpatialExtent(north=60, south=20, east=60, west=10, bottom=-50, top=50)
+ >>> A.spatial_relation_2d(B)
+ 'meet'
+ >>> A.spatial_relation(B)
+ 'meet'
+ >>> A = SpatialExtent(north=60, south=40, east=60, west=10, bottom=-50, top=50)
+ >>> B = SpatialExtent(north=80, south=60, east=60, west=10, bottom=-50, top=50)
+ >>> A.spatial_relation_2d(B)
+ 'meet'
+ >>> A.spatial_relation(B)
+ 'meet'
+ >>> A = SpatialExtent(north=80, south=40, east=60, west=40, bottom=-50, top=50)
+ >>> B = SpatialExtent(north=80, south=40, east=40, west=20, bottom=-50, top=50)
+ >>> A.spatial_relation_2d(B)
+ 'meet'
+ >>> A.spatial_relation(B)
+ 'meet'
+ >>> A = SpatialExtent(north=80, south=40, east=40, west=20, bottom=-50, top=50)
+ >>> B = SpatialExtent(north=90, south=30, east=60, west=40, bottom=-50, top=50)
+ >>> A.spatial_relation_2d(B)
+ 'meet'
+ >>> A.spatial_relation(B)
+ 'meet'
+ >>> A = SpatialExtent(north=80, south=40, east=40, west=20, bottom=-50, top=50)
+ >>> B = SpatialExtent(north=70, south=50, east=60, west=40, bottom=-50, top=50)
+ >>> A.spatial_relation_2d(B)
+ 'meet'
+ >>> A.spatial_relation(B)
+ 'meet'
+ >>> A = SpatialExtent(north=80, south=40, east=40, west=20, bottom=-50, top=50)
+ >>> B = SpatialExtent(north=60, south=20, east=60, west=40, bottom=-50, top=50)
+ >>> A.spatial_relation_2d(B)
+ 'meet'
+ >>> A.spatial_relation(B)
+ 'meet'
+ >>> A = SpatialExtent(north=80, south=40, east=40, west=20, bottom=-50, top=50)
+ >>> B = SpatialExtent(north=40, south=20, east=60, west=40, bottom=-50, top=50)
+ >>> A.spatial_relation_2d(B)
+ 'disjoint'
+ >>> A.spatial_relation(B)
+ 'disjoint'
+ >>> A = SpatialExtent(north=80, south=40, east=40, west=20, bottom=-50, top=50)
+ >>> B = SpatialExtent(north=60, south=20, east=60, west=40, bottom=-60, top=60)
+ >>> A.spatial_relation(B)
+ 'meet'
+ >>> A = SpatialExtent(north=80, south=40, east=40, west=20, bottom=-50, top=50)
+ >>> B = SpatialExtent(north=90, south=30, east=60, west=40, bottom=-40, top=40)
+ >>> A.spatial_relation(B)
+ 'meet'
+ >>> A = SpatialExtent(north=80, south=40, east=60, west=20, bottom=0, top=50)
+ >>> B = SpatialExtent(north=80, south=40, east=60, west=20, bottom=-50, top=0)
+ >>> A.spatial_relation(B)
+ 'meet'
+ >>> A = SpatialExtent(north=80, south=40, east=60, west=20, bottom=0, top=50)
+ >>> B = SpatialExtent(north=80, south=50, east=60, west=30, bottom=-50, top=0)
+ >>> A.spatial_relation(B)
+ 'meet'
+ >>> A = SpatialExtent(north=80, south=40, east=60, west=20, bottom=0, top=50)
+ >>> B = SpatialExtent(north=70, south=50, east=50, west=30, bottom=-50, top=0)
+ >>> A.spatial_relation(B)
+ 'meet'
+ >>> A = SpatialExtent(north=80, south=40, east=60, west=20, bottom=0, top=50)
+ >>> B = SpatialExtent(north=90, south=30, east=70, west=10, bottom=-50, top=0)
+ >>> A.spatial_relation(B)
+ 'meet'
+ >>> A = SpatialExtent(north=80, south=40, east=60, west=20, bottom=0, top=50)
+ >>> B = SpatialExtent(north=70, south=30, east=50, west=10, bottom=-50, top=0)
+ >>> A.spatial_relation(B)
+ 'meet'
+ >>> A = SpatialExtent(north=80, south=40, east=60, west=20, bottom=-50, top=0)
+ >>> B = SpatialExtent(north=80, south=40, east=60, west=20, bottom=0, top=50)
+ >>> A.spatial_relation(B)
+ 'meet'
+ >>> A = SpatialExtent(north=80, south=40, east=60, west=20, bottom=-50, top=0)
+ >>> B = SpatialExtent(north=80, south=50, east=60, west=30, bottom=0, top=50)
+ >>> A.spatial_relation(B)
+ 'meet'
+ >>> A = SpatialExtent(north=80, south=40, east=60, west=20, bottom=-50, top=0)
+ >>> B = SpatialExtent(north=70, south=50, east=50, west=30, bottom=0, top=50)
+ >>> A.spatial_relation(B)
+ 'meet'
+ >>> A = SpatialExtent(north=80, south=40, east=60, west=20, bottom=-50, top=0)
+ >>> B = SpatialExtent(north=90, south=30, east=70, west=10, bottom=0, top=50)
+ >>> A.spatial_relation(B)
+ 'meet'
+ >>> A = SpatialExtent(north=80, south=40, east=60, west=20, bottom=-50, top=0)
+ >>> B = SpatialExtent(north=70, south=30, east=50, west=10, bottom=0, top=50)
+ >>> A.spatial_relation(B)
+ 'meet'
+ >>> A = SpatialExtent(north=80, south=20, east=60, west=10, bottom=-50, top=50)
+ >>> B = SpatialExtent(north=90, south=81, east=60, west=10, bottom=-50, top=50)
+ >>> A.spatial_relation(B)
+ 'disjoint'
+ >>> A = SpatialExtent(north=80, south=20, east=60, west=10, bottom=-50, top=50)
+ >>> B = SpatialExtent(north=90, south=80, east=60, west=10, bottom=-50, top=50)
+ >>> A.spatial_relation(B)
+ 'meet'
- @endcode
"""
if self.equivalent(extent):
@@ -1572,14 +1548,14 @@
return "unknown"
def set_spatial_extent_from_values(self, north, south, east, west, top, bottom):
- """!Set the three dimensional spatial extent
+ """Set the three dimensional spatial extent
- @param north The northern edge
- @param south The southern edge
- @param east The eastern edge
- @param west The western edge
- @param top The top edge
- @param bottom The bottom edge
+ :param north: The northern edge
+ :param south: The southern edge
+ :param east: The eastern edge
+ :param west: The western edge
+ :param top: The top edge
+ :param bottom: The bottom edge
"""
self.set_north(north)
@@ -1590,9 +1566,9 @@
self.set_bottom(bottom)
def set_spatial_extent(self, spatial_extent):
- """!Set the three dimensional spatial extent
+ """Set the three dimensional spatial extent
- @param spatial_extent An object of type SpatialExtent or its subclasses
+ :param spatial_extent: An object of type SpatialExtent or its subclasses
"""
self.set_north(spatial_extent.get_north())
@@ -1603,7 +1579,7 @@
self.set_bottom(spatial_extent.get_bottom())
def set_projection(self, proj):
- """!Set the projection of the spatial extent it should be XY or LL.
+ """Set the projection of the spatial extent it should be XY or LL.
As default the projection is XY
"""
if proj is None or (proj != "XY" and proj != "LL"):
@@ -1612,12 +1588,12 @@
self.D["proj"] = proj
def set_spatial_extent_from_values_2d(self, north, south, east, west):
- """!Set the two dimensional spatial extent from values
+ """Set the two dimensional spatial extent from values
- @param north The northern edge
- @param south The southern edge
- @param east The eastern edge
- @param west The western edge
+ :param north: The northern edge
+ :param south: The southern edge
+ :param east: The eastern edge
+ :param west: The western edge
"""
self.set_north(north)
@@ -1626,9 +1602,9 @@
self.set_west(west)
def set_spatial_extent_2d(self, spatial_extent):
- """!Set the three dimensional spatial extent
+ """Set the three dimensional spatial extent
- @param spatial_extent An object of type SpatialExtent or its subclasses
+ :param spatial_extent: An object of type SpatialExtent or its subclasses
"""
self.set_north(spatial_extent.north)
@@ -1637,55 +1613,55 @@
self.set_west(spatial_extent.west)
def set_id(self, ident):
- """!Convenient method to set the unique identifier (primary key)"""
+ """Convenient method to set the unique identifier (primary key)"""
self.ident = ident
self.D["id"] = ident
def set_north(self, north):
- """!Set the northern edge of the map"""
+ """Set the northern edge of the map"""
if north is not None:
self.D["north"] = float(north)
else:
self.D["north"] = None
def set_south(self, south):
- """!Set the southern edge of the map"""
+ """Set the southern edge of the map"""
if south is not None:
self.D["south"] = float(south)
else:
self.D["south"] = None
def set_west(self, west):
- """!Set the western edge of the map"""
+ """Set the western edge of the map"""
if west is not None:
self.D["west"] = float(west)
else:
self.D["west"] = None
def set_east(self, east):
- """!Set the eastern edge of the map"""
+ """Set the eastern edge of the map"""
if east is not None:
self.D["east"] = float(east)
else:
self.D["east"] = None
def set_top(self, top):
- """!Set the top edge of the map"""
+ """Set the top edge of the map"""
if top is not None:
self.D["top"] = float(top)
else:
self.D["top"] = None
def set_bottom(self, bottom):
- """!Set the bottom edge of the map"""
+ """Set the bottom edge of the map"""
if bottom is not None:
self.D["bottom"] = float(bottom)
else:
self.D["bottom"] = None
def get_id(self):
- """!Convenient method to get the unique identifier (primary key)
- @return None if not found
+ """Convenient method to get the unique identifier (primary key)
+ :return: None if not found
"""
if "id" in self.D:
return self.D["id"]
@@ -1693,11 +1669,11 @@
return None
def get_projection(self):
- """!Get the projection of the spatial extent"""
+ """Get the projection of the spatial extent"""
return self.D["proj"]
def get_volume(self):
- """!Compute the volume of the extent, in case z is zero
+ """Compute the volume of the extent, in case z is zero
(top == bottom or top - bottom = 1) the area is returned"""
if self.get_projection() == "LL":
@@ -1716,7 +1692,7 @@
return area * z
def get_area(self):
- """!Compute the area of the extent, extent in z direction is ignored"""
+ """Compute the area of the extent, extent in z direction is ignored"""
if self.get_projection() == "LL":
self.msgr.error(_("Area computation is not supported "
@@ -1730,7 +1706,7 @@
return x * y
def get_spatial_extent_as_tuple(self):
- """!Return a tuple (north, south, east, west, top, bottom)
+ """Return a tuple (north, south, east, west, top, bottom)
of the spatial extent"""
return (
@@ -1738,53 +1714,53 @@
self.top, self.bottom)
def get_spatial_extent_as_tuple_2d(self):
- """!Return a tuple (north, south, east, west,) of the 2d spatial extent
+ """Return a tuple (north, south, east, west,) of the 2d spatial extent
"""
return (self.north, self.south, self.east, self.west)
def get_north(self):
- """!Get the northern edge of the map
- @return None if not found"""
+ """Get the northern edge of the map
+ :return: None if not found"""
if "north" in self.D:
return self.D["north"]
else:
return None
def get_south(self):
- """!Get the southern edge of the map
- @return None if not found"""
+ """Get the southern edge of the map
+ :return: None if not found"""
if "south" in self.D:
return self.D["south"]
else:
return None
def get_east(self):
- """!Get the eastern edge of the map
- @return None if not found"""
+ """Get the eastern edge of the map
+ :return: None if not found"""
if "east" in self.D:
return self.D["east"]
else:
return None
def get_west(self):
- """!Get the western edge of the map
- @return None if not found"""
+ """Get the western edge of the map
+ :return: None if not found"""
if "west" in self.D:
return self.D["west"]
else:
return None
def get_top(self):
- """!Get the top edge of the map
- @return None if not found"""
+ """Get the top edge of the map
+ :return: None if not found"""
if "top" in self.D:
return self.D["top"]
else:
return None
def get_bottom(self):
- """!Get the bottom edge of the map
- @return None if not found"""
+ """Get the bottom edge of the map
+ :return: None if not found"""
if "bottom" in self.D:
return self.D["bottom"]
else:
@@ -1799,7 +1775,7 @@
bottom= property(fget=get_bottom, fset=set_bottom)
def print_info(self):
- """!Print information about this class in human readable style"""
+ """Print information about this class in human readable style"""
# 0123456789012345678901234567890
print " +-------------------- Spatial extent ----------------------------------------+"
print " | North:...................... " + str(self.get_north())
Modified: grass/trunk/lib/python/temporal/spatial_topology_dataset_connector.py
===================================================================
--- grass/trunk/lib/python/temporal/spatial_topology_dataset_connector.py 2014-09-28 01:40:32 UTC (rev 62120)
+++ grass/trunk/lib/python/temporal/spatial_topology_dataset_connector.py 2014-09-28 01:46:15 UTC (rev 62121)
@@ -1,10 +1,7 @@
# -*- coding: utf-8 -*-
-"""!@package grass.temporal
+"""
+Spatial topology connector class
- at brief GRASS Python scripting module (temporal GIS functions)
-
-Temporal GIS related functions to be used in temporal GIS Python library package.
-
Usage:
>>> import grass.temporal as tgis
@@ -15,17 +12,18 @@
License (>=v2). Read the file COPYING that comes with GRASS
for details.
- at author Soeren Gebbert
+:authors: Soeren Gebbert
"""
import copy
class SpatialTopologyDatasetConnector(object):
- """!This class implements a spatial topology access structure to connect spatial related datasets
+ """This class implements a spatial topology access structure to connect spatial related datasets
This object will be set up by spatial topology creation method provided by the
SpatioTemporalTopologyBuilder.
The following spatial relations with access methods are supported:
+
- equivalent
- overlap
- in
@@ -36,80 +34,79 @@
Usage:
- @code
+ .. code-block:: python
- >>> import grass.temporal as tgis
- >>> tgis.init()
- >>> map = tgis.RasterDataset("a at P")
- >>> tmr = tgis.SpatialTopologyDatasetConnector()
- >>> tmr.append_equivalent(map)
- >>> tmr.append_overlap(map)
- >>> tmr.append_in(map)
- >>> tmr.append_contain(map)
- >>> tmr.append_meet(map)
- >>> tmr.append_cover(map)
- >>> tmr.append_covered(map)
- >>> tmr.print_spatial_topology_info()
- +-------------------- Spatial Topology --------------------------------------+
- | Equivalent: ................ a at P
- | Cover: ..................... a at P
- | Covered: ................... a at P
- | Overlap: ................... a at P
- | In: ........................ a at P
- | Contain: ................... a at P
- | Meet: ...................... a at P
- >>> tmr.print_spatial_topology_shell_info()
- equivalent=a at P
- cover=a at P
- covered=a at P
- overlap=a at P
- in=a at P
- contain=a at P
- meet=a at P
- >>> rlist = tmr.get_spatial_relations()
- >>> if "COVER" in rlist.keys():
- ... print rlist["COVER"][0].get_id()
- a at P
+ >>> import grass.temporal as tgis
+ >>> tgis.init()
+ >>> map = tgis.RasterDataset("a at P")
+ >>> tmr = tgis.SpatialTopologyDatasetConnector()
+ >>> tmr.append_equivalent(map)
+ >>> tmr.append_overlap(map)
+ >>> tmr.append_in(map)
+ >>> tmr.append_contain(map)
+ >>> tmr.append_meet(map)
+ >>> tmr.append_cover(map)
+ >>> tmr.append_covered(map)
+ >>> tmr.print_spatial_topology_info()
+ +-------------------- Spatial Topology --------------------------------------+
+ | Equivalent: ................ a at P
+ | Cover: ..................... a at P
+ | Covered: ................... a at P
+ | Overlap: ................... a at P
+ | In: ........................ a at P
+ | Contain: ................... a at P
+ | Meet: ...................... a at P
+ >>> tmr.print_spatial_topology_shell_info()
+ equivalent=a at P
+ cover=a at P
+ covered=a at P
+ overlap=a at P
+ in=a at P
+ contain=a at P
+ meet=a at P
+ >>> rlist = tmr.get_spatial_relations()
+ >>> if "COVER" in rlist.keys():
+ ... print rlist["COVER"][0].get_id()
+ a at P
-
- @endcode
"""
def __init__(self):
self.reset_spatial_topology()
def reset_spatial_topology(self):
- """!Reset any information about temporal topology"""
+ """Reset any information about temporal topology"""
self._spatial_topology = {}
self._has_spatial_topology = False
def get_spatial_relations(self):
- """!Return the dictionary of spatial relationships
+ """Return the dictionary of spatial relationships
Keys are the spatial relationships in upper case,
values are abstract map objects.
- @return The spatial relations dictionary
+ :return: The spatial relations dictionary
"""
return copy.copy(self._spatial_topology)
def get_number_of_spatial_relations(self):
- """! Return a dictionary in which the keys are the relation names and the value
- are the number of relations.
-
- The following relations are available:
- - equivalent
- - overlap
- - in
- - contain
- - meet
- - cover
- - covered
-
- To access topological information the spatial topology must be build first
- using the SpatialTopologyBuilder.
-
- @return the dictionary with relations as keys and number as values or None in case the topology wasn't build
+ """ Return a dictionary in which the keys are the relation names and the value
+ are the number of relations.
+
+ The following relations are available:
+
+ - equivalent
+ - overlap
+ - in
+ - contain
+ - meet
+ - cover
+ - covered
+
+ To access topological information the spatial topology must be build first
+ using the SpatialTopologyBuilder.
+
+ :return: the dictionary with relations as keys and number as values or None in case the topology wasn't build
"""
if self._has_spatial_topology == False:
return None
@@ -147,21 +144,21 @@
return relations
def set_spatial_topology_build_true(self):
- """!Same as name"""
+ """Same as name"""
self._has_spatial_topology = True
def set_spatial_topology_build_false(self):
- """!Same as name"""
+ """Same as name"""
self._has_spatial_topology = False
def is_spatial_topology_build(self):
- """!Check if the temporal topology was build"""
+ """Check if the temporal topology was build"""
return self._has_spatial_topology
def append_equivalent(self, map):
- """!Append a map with equivalent spatial extent as this map
+ """Append a map with equivalent spatial extent as this map
- @param map This object should be of type AbstractMapDataset
+ :param map: This object should be of type AbstractMapDataset
or derived classes
"""
if "EQUIVALENT" not in self._spatial_topology:
@@ -169,18 +166,18 @@
self._spatial_topology["EQUIVALENT"].append(map)
def get_equivalent(self):
- """!Return a list of map objects with equivalent spatial extent as this map
+ """Return a list of map objects with equivalent spatial extent as this map
- @return A list of map objects or None
+ :return: A list of map objects or None
"""
if "EQUIVALENT" not in self._spatial_topology:
return None
return self._spatial_topology["EQUIVALENT"]
def append_overlap(self, map):
- """!Append a map that this spatial overlap with this map
+ """Append a map that this spatial overlap with this map
- @param map This object should be of type AbstractMapDataset
+ :param map: This object should be of type AbstractMapDataset
or derived classes
"""
if "OVERLAP" not in self._spatial_topology:
@@ -188,18 +185,18 @@
self._spatial_topology["OVERLAP"].append(map)
def get_overlap(self):
- """!Return a list of map objects that this map spatial overlap with
+ """Return a list of map objects that this map spatial overlap with
- @return A list of map objects or None
+ :return: A list of map objects or None
"""
if "OVERLAP" not in self._spatial_topology:
return None
return self._spatial_topology["OVERLAP"]
def append_in(self, map):
- """!Append a map that this is spatial in this map
+ """Append a map that this is spatial in this map
- @param map This object should be of type AbstractMapDataset
+ :param map: This object should be of type AbstractMapDataset
or derived classes
"""
if "IN" not in self._spatial_topology:
@@ -207,18 +204,18 @@
self._spatial_topology["IN"].append(map)
def get_in(self):
- """!Return a list of map objects that are spatial in this map
+ """Return a list of map objects that are spatial in this map
- @return A list of map objects or None
+ :return: A list of map objects or None
"""
if "IN" not in self._spatial_topology:
return None
return self._spatial_topology["IN"]
def append_contain(self, map):
- """!Append a map that this map spatially contains
+ """Append a map that this map spatially contains
- @param map This object should be of type AbstractMapDataset
+ :param map: This object should be of type AbstractMapDataset
or derived classes
"""
if "CONTAIN" not in self._spatial_topology:
@@ -226,18 +223,18 @@
self._spatial_topology["CONTAIN"].append(map)
def get_contain(self):
- """!Return a list of map objects that this map contains
+ """Return a list of map objects that this map contains
- @return A list of map objects or None
+ :return: A list of map objects or None
"""
if "CONTAIN" not in self._spatial_topology:
return None
return self._spatial_topology["CONTAIN"]
def append_meet(self, map):
- """!Append a map that spatially meet with this map
+ """Append a map that spatially meet with this map
- @param map This object should be of type AbstractMapDataset
+ :param map: This object should be of type AbstractMapDataset
or derived classes
"""
if "MEET" not in self._spatial_topology:
@@ -245,18 +242,18 @@
self._spatial_topology["MEET"].append(map)
def get_meet(self):
- """!Return a list of map objects that spatially meet with this map
+ """Return a list of map objects that spatially meet with this map
- @return A list of map objects or None
+ :return: A list of map objects or None
"""
if "MEET" not in self._spatial_topology:
return None
return self._spatial_topology["MEET"]
def append_cover(self, map):
- """!Append a map that spatially cover this map
+ """Append a map that spatially cover this map
- @param map This object should be of type AbstractMapDataset
+ :param map: This object should be of type AbstractMapDataset
or derived classes
"""
if "COVER" not in self._spatial_topology:
@@ -264,18 +261,18 @@
self._spatial_topology["COVER"].append(map)
def get_cover(self):
- """!Return a list of map objects that spatially cover this map
+ """Return a list of map objects that spatially cover this map
- @return A list of map objects or None
+ :return: A list of map objects or None
"""
if "COVER" not in self._spatial_topology:
return None
return self._spatial_topology["COVER"]
def append_covered(self, map):
- """!Append a map that is spatially covered by this map
+ """Append a map that is spatially covered by this map
- @param map This object should be of type AbstractMapDataset
+ :param map: This object should be of type AbstractMapDataset
or derived classes
"""
if "COVERED" not in self._spatial_topology:
@@ -283,9 +280,9 @@
self._spatial_topology["COVERED"].append(map)
def get_covered(self):
- """!Return a list of map objects that are spatially covered by this map
+ """Return a list of map objects that are spatially covered by this map
- @return A list of map objects or None
+ :return: A list of map objects or None
"""
if "COVERED" not in self._spatial_topology:
return None
@@ -324,7 +321,7 @@
fset=append_meet)
def print_spatial_topology_info(self):
- """!Print information about this class in human readable style"""
+ """Print information about this class in human readable style"""
print " +-------------------- Spatial Topology --------------------------------------+"
# 0123456789012345678901234567890
@@ -351,7 +348,7 @@
self._generate_map_list_string(self.meet)
def print_spatial_topology_shell_info(self):
- """!Print information about this class in shell style"""
+ """Print information about this class in shell style"""
if self.equivalent is not None:
print "equivalent=" + self._generate_map_list_string(self.equivalent, False)
Modified: grass/trunk/lib/python/temporal/spatio_temporal_relationships.py
===================================================================
--- grass/trunk/lib/python/temporal/spatio_temporal_relationships.py 2014-09-28 01:40:32 UTC (rev 62120)
+++ grass/trunk/lib/python/temporal/spatio_temporal_relationships.py 2014-09-28 01:46:15 UTC (rev 62121)
@@ -1,24 +1,20 @@
-"""!@package grass.temporal
+"""
+Class to build the spatio-temporal topology between map lists
- at brief GRASS Python scripting module (temporal GIS functions)
-
-Temporal GIS related functions to be used in temporal GIS Python library package.
-
Usage:
- at code
-import grass.temporal as tgis
+.. code-block:: python
+ import grass.temporal as tgis
-tgis.print_temporal_relations(maps)
-...
- at endcode
+ tgis.print_temporal_relations(maps)
+
(C) 2012-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.
- at author Soeren Gebbert
+:authors: Soeren Gebbert
"""
from abstract_dataset import *
from datetime_math import *
@@ -30,333 +26,331 @@
###############################################################################
class SpatioTemporalTopologyBuilder(object):
- """!This class is designed to build the spatio-temporal topology
+ """This class is designed to build the spatio-temporal topology
of spatio-temporally related abstract dataset objects.
The abstract dataset objects must be provided as a single list, or in two lists.
Example:
- @code
+ .. code-block:: python
- # We have a space time raster dataset and build a map list
- # from all registered maps ordered by start time
- maps = strds.get_registered_maps_as_objects()
+ # We have a space time raster dataset and build a map list
+ # from all registered maps ordered by start time
+ maps = strds.get_registered_maps_as_objects()
- # Now lets build the temporal topology of the maps in the list
+ # Now lets build the temporal topology of the maps in the list
- tb = SpatioTemporalTopologyBuilder()
+ tb = SpatioTemporalTopologyBuilder()
- tb.build(maps)
+ tb.build(maps)
- dbif, connected = init_dbif(None)
+ dbif, connected = init_dbif(None)
- for map in tb:
- map.select(dbif)
- map.print_info()
+ for map in tb:
+ map.select(dbif)
+ map.print_info()
- # Same can be done with the existing map list
- # But be aware that this is might not be temporally ordered
- for map in maps:
- map.select(dbf)
- map.print_info()
+ # Same can be done with the existing map list
+ # But be aware that this is might not be temporally ordered
+ for map in maps:
+ map.select(dbf)
+ map.print_info()
- # Using the next and previous methods, we can iterate over the
- # topological related maps in this way
+ # Using the next and previous methods, we can iterate over the
+ # topological related maps in this way
- first = tb.get_first()
+ first = tb.get_first()
- while first:
- first.print_topology_info()
- first = first.next()
+ while first:
+ first.print_topology_info()
+ first = first.next()
- # Dictionary like accessed
- map = tb["name at mapset"]
+ # Dictionary like accessed
+ map = tb["name at mapset"]
- >>> # Example with two lists of maps
- >>> import grass.temporal as tgis
- >>> import datetime
- >>> # Create two list of maps with equal time stamps
- >>> mapsA = []
- >>> mapsB = []
- >>> for i in range(4):
- ... idA = "a%i at B"%(i)
- ... mapA = tgis.RasterDataset(idA)
- ... idB = "b%i at B"%(i)
- ... mapB = tgis.RasterDataset(idB)
- ... check = mapA.set_relative_time(i, i + 1, "months")
- ... check = mapB.set_relative_time(i, i + 1, "months")
- ... mapsA.append(mapA)
- ... mapsB.append(mapB)
- >>> # Build the topology between the two map lists
- >>> tb = SpatioTemporalTopologyBuilder()
- >>> tb.build(mapsA, mapsB, None)
- >>> # Check relations of mapsA
- >>> for map in mapsA:
- ... if map.get_equal():
- ... relations = map.get_equal()
- ... print "Map %s has equal relation to map %s"%(map.get_name(),
- ... relations[0].get_name())
- Map a0 has equal relation to map b0
- Map a1 has equal relation to map b1
- Map a2 has equal relation to map b2
- Map a3 has equal relation to map b3
- >>> # Check relations of mapsB
- >>> for map in mapsB:
- ... if map.get_equal():
- ... relations = map.get_equal()
- ... print "Map %s has equal relation to map %s"%(map.get_name(),
- ... relations[0].get_name())
- Map b0 has equal relation to map a0
- Map b1 has equal relation to map a1
- Map b2 has equal relation to map a2
- Map b3 has equal relation to map a3
+ >>> # Example with two lists of maps
+ >>> import grass.temporal as tgis
+ >>> import datetime
+ >>> # Create two list of maps with equal time stamps
+ >>> mapsA = []
+ >>> mapsB = []
+ >>> for i in range(4):
+ ... idA = "a%i at B"%(i)
+ ... mapA = tgis.RasterDataset(idA)
+ ... idB = "b%i at B"%(i)
+ ... mapB = tgis.RasterDataset(idB)
+ ... check = mapA.set_relative_time(i, i + 1, "months")
+ ... check = mapB.set_relative_time(i, i + 1, "months")
+ ... mapsA.append(mapA)
+ ... mapsB.append(mapB)
+ >>> # Build the topology between the two map lists
+ >>> tb = SpatioTemporalTopologyBuilder()
+ >>> tb.build(mapsA, mapsB, None)
+ >>> # Check relations of mapsA
+ >>> for map in mapsA:
+ ... if map.get_equal():
+ ... relations = map.get_equal()
+ ... print "Map %s has equal relation to map %s"%(map.get_name(),
+ ... relations[0].get_name())
+ Map a0 has equal relation to map b0
+ Map a1 has equal relation to map b1
+ Map a2 has equal relation to map b2
+ Map a3 has equal relation to map b3
+ >>> # Check relations of mapsB
+ >>> for map in mapsB:
+ ... if map.get_equal():
+ ... relations = map.get_equal()
+ ... print "Map %s has equal relation to map %s"%(map.get_name(),
+ ... relations[0].get_name())
+ Map b0 has equal relation to map a0
+ Map b1 has equal relation to map a1
+ Map b2 has equal relation to map a2
+ Map b3 has equal relation to map a3
- >>> mapsA = []
- >>> mapsB = []
- >>> for i in range(4):
- ... idA = "a%i at B"%(i)
- ... mapA = tgis.RasterDataset(idA)
- ... idB = "b%i at B"%(i)
- ... mapB = tgis.RasterDataset(idB)
- ... check = mapA.set_relative_time(i, i + 1, "months")
- ... check = mapB.set_relative_time(i + 1, i + 2, "months")
- ... mapsA.append(mapA)
- ... mapsB.append(mapB)
- >>> # Build the topology between the two map lists
- >>> tb = SpatioTemporalTopologyBuilder()
- >>> tb.build(mapsA, mapsB, None)
- >>> # Check relations of mapsA
- >>> for map in mapsA:
- ... print(map.get_temporal_extent_as_tuple())
- ... m = map.get_temporal_relations()
- ... for key in m.keys():
- ... if key not in ["NEXT", "PREV"]:
- ... print(key, m[key][0].get_temporal_extent_as_tuple())
- (0, 1)
- ('PRECEDES', (1, 2))
- (1, 2)
- ('PRECEDES', (2, 3))
- ('EQUAL', (1, 2))
- (2, 3)
- ('FOLLOWS', (1, 2))
- ('PRECEDES', (3, 4))
- ('EQUAL', (2, 3))
- (3, 4)
- ('FOLLOWS', (2, 3))
- ('EQUAL', (3, 4))
- ('PRECEDES', (4, 5))
+ >>> mapsA = []
+ >>> mapsB = []
+ >>> for i in range(4):
+ ... idA = "a%i at B"%(i)
+ ... mapA = tgis.RasterDataset(idA)
+ ... idB = "b%i at B"%(i)
+ ... mapB = tgis.RasterDataset(idB)
+ ... check = mapA.set_relative_time(i, i + 1, "months")
+ ... check = mapB.set_relative_time(i + 1, i + 2, "months")
+ ... mapsA.append(mapA)
+ ... mapsB.append(mapB)
+ >>> # Build the topology between the two map lists
+ >>> tb = SpatioTemporalTopologyBuilder()
+ >>> tb.build(mapsA, mapsB, None)
+ >>> # Check relations of mapsA
+ >>> for map in mapsA:
+ ... print(map.get_temporal_extent_as_tuple())
+ ... m = map.get_temporal_relations()
+ ... for key in m.keys():
+ ... if key not in ["NEXT", "PREV"]:
+ ... print(key, m[key][0].get_temporal_extent_as_tuple())
+ (0, 1)
+ ('PRECEDES', (1, 2))
+ (1, 2)
+ ('PRECEDES', (2, 3))
+ ('EQUAL', (1, 2))
+ (2, 3)
+ ('FOLLOWS', (1, 2))
+ ('PRECEDES', (3, 4))
+ ('EQUAL', (2, 3))
+ (3, 4)
+ ('FOLLOWS', (2, 3))
+ ('EQUAL', (3, 4))
+ ('PRECEDES', (4, 5))
- >>> mapsA = []
- >>> mapsB = []
- >>> for i in range(4):
- ... idA = "a%i at B"%(i)
- ... mapA = tgis.RasterDataset(idA)
- ... idB = "b%i at B"%(i)
- ... mapB = tgis.RasterDataset(idB)
- ... start = datetime.datetime(2000 + i, 1, 1)
- ... end = datetime.datetime(2000 + i + 1, 1, 1)
- ... check = mapA.set_absolute_time(start, end)
- ... start = datetime.datetime(2000 + i + 1, 1, 1)
- ... end = datetime.datetime(2000 + i + 2, 1, 1)
- ... check = mapB.set_absolute_time(start, end)
- ... mapsA.append(mapA)
- ... mapsB.append(mapB)
- >>> # Build the topology between the two map lists
- >>> tb = SpatioTemporalTopologyBuilder()
- >>> tb.build(mapsA, mapsB, None)
- >>> # Check relations of mapsA
- >>> for map in mapsA:
- ... print(map.get_temporal_extent_as_tuple())
- ... m = map.get_temporal_relations()
- ... for key in m.keys():
- ... if key not in ["NEXT", "PREV"]:
- ... print(key, m[key][0].get_temporal_extent_as_tuple())
- (datetime.datetime(2000, 1, 1, 0, 0), datetime.datetime(2001, 1, 1, 0, 0))
- ('PRECEDES', (datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2002, 1, 1, 0, 0)))
- (datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2002, 1, 1, 0, 0))
- ('PRECEDES', (datetime.datetime(2002, 1, 1, 0, 0), datetime.datetime(2003, 1, 1, 0, 0)))
- ('EQUAL', (datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2002, 1, 1, 0, 0)))
- (datetime.datetime(2002, 1, 1, 0, 0), datetime.datetime(2003, 1, 1, 0, 0))
- ('FOLLOWS', (datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2002, 1, 1, 0, 0)))
- ('PRECEDES', (datetime.datetime(2003, 1, 1, 0, 0), datetime.datetime(2004, 1, 1, 0, 0)))
- ('EQUAL', (datetime.datetime(2002, 1, 1, 0, 0), datetime.datetime(2003, 1, 1, 0, 0)))
- (datetime.datetime(2003, 1, 1, 0, 0), datetime.datetime(2004, 1, 1, 0, 0))
- ('FOLLOWS', (datetime.datetime(2002, 1, 1, 0, 0), datetime.datetime(2003, 1, 1, 0, 0)))
- ('EQUAL', (datetime.datetime(2003, 1, 1, 0, 0), datetime.datetime(2004, 1, 1, 0, 0)))
- ('PRECEDES', (datetime.datetime(2004, 1, 1, 0, 0), datetime.datetime(2005, 1, 1, 0, 0)))
+ >>> mapsA = []
+ >>> mapsB = []
+ >>> for i in range(4):
+ ... idA = "a%i at B"%(i)
+ ... mapA = tgis.RasterDataset(idA)
+ ... idB = "b%i at B"%(i)
+ ... mapB = tgis.RasterDataset(idB)
+ ... start = datetime.datetime(2000 + i, 1, 1)
+ ... end = datetime.datetime(2000 + i + 1, 1, 1)
+ ... check = mapA.set_absolute_time(start, end)
+ ... start = datetime.datetime(2000 + i + 1, 1, 1)
+ ... end = datetime.datetime(2000 + i + 2, 1, 1)
+ ... check = mapB.set_absolute_time(start, end)
+ ... mapsA.append(mapA)
+ ... mapsB.append(mapB)
+ >>> # Build the topology between the two map lists
+ >>> tb = SpatioTemporalTopologyBuilder()
+ >>> tb.build(mapsA, mapsB, None)
+ >>> # Check relations of mapsA
+ >>> for map in mapsA:
+ ... print(map.get_temporal_extent_as_tuple())
+ ... m = map.get_temporal_relations()
+ ... for key in m.keys():
+ ... if key not in ["NEXT", "PREV"]:
+ ... print(key, m[key][0].get_temporal_extent_as_tuple())
+ (datetime.datetime(2000, 1, 1, 0, 0), datetime.datetime(2001, 1, 1, 0, 0))
+ ('PRECEDES', (datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2002, 1, 1, 0, 0)))
+ (datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2002, 1, 1, 0, 0))
+ ('PRECEDES', (datetime.datetime(2002, 1, 1, 0, 0), datetime.datetime(2003, 1, 1, 0, 0)))
+ ('EQUAL', (datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2002, 1, 1, 0, 0)))
+ (datetime.datetime(2002, 1, 1, 0, 0), datetime.datetime(2003, 1, 1, 0, 0))
+ ('FOLLOWS', (datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2002, 1, 1, 0, 0)))
+ ('PRECEDES', (datetime.datetime(2003, 1, 1, 0, 0), datetime.datetime(2004, 1, 1, 0, 0)))
+ ('EQUAL', (datetime.datetime(2002, 1, 1, 0, 0), datetime.datetime(2003, 1, 1, 0, 0)))
+ (datetime.datetime(2003, 1, 1, 0, 0), datetime.datetime(2004, 1, 1, 0, 0))
+ ('FOLLOWS', (datetime.datetime(2002, 1, 1, 0, 0), datetime.datetime(2003, 1, 1, 0, 0)))
+ ('EQUAL', (datetime.datetime(2003, 1, 1, 0, 0), datetime.datetime(2004, 1, 1, 0, 0)))
+ ('PRECEDES', (datetime.datetime(2004, 1, 1, 0, 0), datetime.datetime(2005, 1, 1, 0, 0)))
- >>> mapsA = []
- >>> mapsB = []
- >>> for i in range(4):
- ... idA = "a%i at B"%(i)
- ... mapA = tgis.RasterDataset(idA)
- ... idB = "b%i at B"%(i)
- ... mapB = tgis.RasterDataset(idB)
- ... start = datetime.datetime(2000 + i, 1, 1)
- ... end = datetime.datetime(2000 + i + 1, 1, 1)
- ... check = mapA.set_absolute_time(start, end)
- ... start = datetime.datetime(2000 + i, 1, 1)
- ... end = datetime.datetime(2000 + i + 3, 1, 1)
- ... check = mapB.set_absolute_time(start, end)
- ... mapsA.append(mapA)
- ... mapsB.append(mapB)
- >>> # Build the topology between the two map lists
- >>> tb = SpatioTemporalTopologyBuilder()
- >>> tb.build(mapsA, mapsB, None)
- >>> # Check relations of mapsA
- >>> for map in mapsA:
- ... print(map.get_temporal_extent_as_tuple())
- ... m = map.get_temporal_relations()
- ... for key in m.keys():
- ... if key not in ["NEXT", "PREV"]:
- ... print(key, m[key][0].get_temporal_extent_as_tuple())
- (datetime.datetime(2000, 1, 1, 0, 0), datetime.datetime(2001, 1, 1, 0, 0))
- ('DURING', (datetime.datetime(2000, 1, 1, 0, 0), datetime.datetime(2003, 1, 1, 0, 0)))
- ('STARTS', (datetime.datetime(2000, 1, 1, 0, 0), datetime.datetime(2003, 1, 1, 0, 0)))
- ('PRECEDES', (datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2004, 1, 1, 0, 0)))
- (datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2002, 1, 1, 0, 0))
- ('DURING', (datetime.datetime(2000, 1, 1, 0, 0), datetime.datetime(2003, 1, 1, 0, 0)))
- ('STARTS', (datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2004, 1, 1, 0, 0)))
- ('PRECEDES', (datetime.datetime(2002, 1, 1, 0, 0), datetime.datetime(2005, 1, 1, 0, 0)))
- (datetime.datetime(2002, 1, 1, 0, 0), datetime.datetime(2003, 1, 1, 0, 0))
- ('PRECEDES', (datetime.datetime(2003, 1, 1, 0, 0), datetime.datetime(2006, 1, 1, 0, 0)))
- ('FINISHES', (datetime.datetime(2000, 1, 1, 0, 0), datetime.datetime(2003, 1, 1, 0, 0)))
- ('DURING', (datetime.datetime(2000, 1, 1, 0, 0), datetime.datetime(2003, 1, 1, 0, 0)))
- ('STARTS', (datetime.datetime(2002, 1, 1, 0, 0), datetime.datetime(2005, 1, 1, 0, 0)))
- (datetime.datetime(2003, 1, 1, 0, 0), datetime.datetime(2004, 1, 1, 0, 0))
- ('FOLLOWS', (datetime.datetime(2000, 1, 1, 0, 0), datetime.datetime(2003, 1, 1, 0, 0)))
- ('DURING', (datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2004, 1, 1, 0, 0)))
- ('FINISHES', (datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2004, 1, 1, 0, 0)))
- ('STARTS', (datetime.datetime(2003, 1, 1, 0, 0), datetime.datetime(2006, 1, 1, 0, 0)))
+ >>> mapsA = []
+ >>> mapsB = []
+ >>> for i in range(4):
+ ... idA = "a%i at B"%(i)
+ ... mapA = tgis.RasterDataset(idA)
+ ... idB = "b%i at B"%(i)
+ ... mapB = tgis.RasterDataset(idB)
+ ... start = datetime.datetime(2000 + i, 1, 1)
+ ... end = datetime.datetime(2000 + i + 1, 1, 1)
+ ... check = mapA.set_absolute_time(start, end)
+ ... start = datetime.datetime(2000 + i, 1, 1)
+ ... end = datetime.datetime(2000 + i + 3, 1, 1)
+ ... check = mapB.set_absolute_time(start, end)
+ ... mapsA.append(mapA)
+ ... mapsB.append(mapB)
+ >>> # Build the topology between the two map lists
+ >>> tb = SpatioTemporalTopologyBuilder()
+ >>> tb.build(mapsA, mapsB, None)
+ >>> # Check relations of mapsA
+ >>> for map in mapsA:
+ ... print(map.get_temporal_extent_as_tuple())
+ ... m = map.get_temporal_relations()
+ ... for key in m.keys():
+ ... if key not in ["NEXT", "PREV"]:
+ ... print(key, m[key][0].get_temporal_extent_as_tuple())
+ (datetime.datetime(2000, 1, 1, 0, 0), datetime.datetime(2001, 1, 1, 0, 0))
+ ('DURING', (datetime.datetime(2000, 1, 1, 0, 0), datetime.datetime(2003, 1, 1, 0, 0)))
+ ('STARTS', (datetime.datetime(2000, 1, 1, 0, 0), datetime.datetime(2003, 1, 1, 0, 0)))
+ ('PRECEDES', (datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2004, 1, 1, 0, 0)))
+ (datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2002, 1, 1, 0, 0))
+ ('DURING', (datetime.datetime(2000, 1, 1, 0, 0), datetime.datetime(2003, 1, 1, 0, 0)))
+ ('STARTS', (datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2004, 1, 1, 0, 0)))
+ ('PRECEDES', (datetime.datetime(2002, 1, 1, 0, 0), datetime.datetime(2005, 1, 1, 0, 0)))
+ (datetime.datetime(2002, 1, 1, 0, 0), datetime.datetime(2003, 1, 1, 0, 0))
+ ('PRECEDES', (datetime.datetime(2003, 1, 1, 0, 0), datetime.datetime(2006, 1, 1, 0, 0)))
+ ('FINISHES', (datetime.datetime(2000, 1, 1, 0, 0), datetime.datetime(2003, 1, 1, 0, 0)))
+ ('DURING', (datetime.datetime(2000, 1, 1, 0, 0), datetime.datetime(2003, 1, 1, 0, 0)))
+ ('STARTS', (datetime.datetime(2002, 1, 1, 0, 0), datetime.datetime(2005, 1, 1, 0, 0)))
+ (datetime.datetime(2003, 1, 1, 0, 0), datetime.datetime(2004, 1, 1, 0, 0))
+ ('FOLLOWS', (datetime.datetime(2000, 1, 1, 0, 0), datetime.datetime(2003, 1, 1, 0, 0)))
+ ('DURING', (datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2004, 1, 1, 0, 0)))
+ ('FINISHES', (datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2004, 1, 1, 0, 0)))
+ ('STARTS', (datetime.datetime(2003, 1, 1, 0, 0), datetime.datetime(2006, 1, 1, 0, 0)))
- >>> mapsA = []
- >>> mapsB = []
- >>> for i in range(4):
- ... idA = "a%i at B"%(i)
- ... mapA = tgis.RasterDataset(idA)
- ... idB = "b%i at B"%(i)
- ... mapB = tgis.RasterDataset(idB)
- ... start = datetime.datetime(2000 + i, 1, 1)
- ... end = datetime.datetime(2000 + i + 2, 1, 1)
- ... check = mapA.set_absolute_time(start, end)
- ... start = datetime.datetime(2000 + i, 1, 1)
- ... end = datetime.datetime(2000 + i + 3, 1, 1)
- ... check = mapB.set_absolute_time(start, end)
- ... mapsA.append(mapA)
- ... mapsB.append(mapB)
- >>> # Build the topology between the two map lists
- >>> tb = SpatioTemporalTopologyBuilder()
- >>> tb.build(mapsA, mapsB, None)
- >>> # Check relations of mapsA
- >>> for map in mapsA:
- ... print(map.get_temporal_extent_as_tuple())
- ... m = map.get_temporal_relations()
- ... for key in m.keys():
- ... if key not in ["NEXT", "PREV"]:
- ... print(key, m[key][0].get_temporal_extent_as_tuple())
- (datetime.datetime(2000, 1, 1, 0, 0), datetime.datetime(2002, 1, 1, 0, 0))
- ('OVERLAPS', (datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2004, 1, 1, 0, 0)))
- ('DURING', (datetime.datetime(2000, 1, 1, 0, 0), datetime.datetime(2003, 1, 1, 0, 0)))
- ('STARTS', (datetime.datetime(2000, 1, 1, 0, 0), datetime.datetime(2003, 1, 1, 0, 0)))
- ('PRECEDES', (datetime.datetime(2002, 1, 1, 0, 0), datetime.datetime(2005, 1, 1, 0, 0)))
- (datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2003, 1, 1, 0, 0))
- ('OVERLAPS', (datetime.datetime(2002, 1, 1, 0, 0), datetime.datetime(2005, 1, 1, 0, 0)))
- ('PRECEDES', (datetime.datetime(2003, 1, 1, 0, 0), datetime.datetime(2006, 1, 1, 0, 0)))
- ('FINISHES', (datetime.datetime(2000, 1, 1, 0, 0), datetime.datetime(2003, 1, 1, 0, 0)))
- ('DURING', (datetime.datetime(2000, 1, 1, 0, 0), datetime.datetime(2003, 1, 1, 0, 0)))
- ('STARTS', (datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2004, 1, 1, 0, 0)))
- (datetime.datetime(2002, 1, 1, 0, 0), datetime.datetime(2004, 1, 1, 0, 0))
- ('OVERLAPS', (datetime.datetime(2003, 1, 1, 0, 0), datetime.datetime(2006, 1, 1, 0, 0)))
- ('OVERLAPPED', (datetime.datetime(2000, 1, 1, 0, 0), datetime.datetime(2003, 1, 1, 0, 0)))
- ('FINISHES', (datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2004, 1, 1, 0, 0)))
- ('DURING', (datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2004, 1, 1, 0, 0)))
- ('STARTS', (datetime.datetime(2002, 1, 1, 0, 0), datetime.datetime(2005, 1, 1, 0, 0)))
- (datetime.datetime(2003, 1, 1, 0, 0), datetime.datetime(2005, 1, 1, 0, 0))
- ('OVERLAPPED', (datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2004, 1, 1, 0, 0)))
- ('DURING', (datetime.datetime(2002, 1, 1, 0, 0), datetime.datetime(2005, 1, 1, 0, 0)))
- ('FINISHES', (datetime.datetime(2002, 1, 1, 0, 0), datetime.datetime(2005, 1, 1, 0, 0)))
- ('STARTS', (datetime.datetime(2003, 1, 1, 0, 0), datetime.datetime(2006, 1, 1, 0, 0)))
- ('FOLLOWS', (datetime.datetime(2000, 1, 1, 0, 0), datetime.datetime(2003, 1, 1, 0, 0)))
+ >>> mapsA = []
+ >>> mapsB = []
+ >>> for i in range(4):
+ ... idA = "a%i at B"%(i)
+ ... mapA = tgis.RasterDataset(idA)
+ ... idB = "b%i at B"%(i)
+ ... mapB = tgis.RasterDataset(idB)
+ ... start = datetime.datetime(2000 + i, 1, 1)
+ ... end = datetime.datetime(2000 + i + 2, 1, 1)
+ ... check = mapA.set_absolute_time(start, end)
+ ... start = datetime.datetime(2000 + i, 1, 1)
+ ... end = datetime.datetime(2000 + i + 3, 1, 1)
+ ... check = mapB.set_absolute_time(start, end)
+ ... mapsA.append(mapA)
+ ... mapsB.append(mapB)
+ >>> # Build the topology between the two map lists
+ >>> tb = SpatioTemporalTopologyBuilder()
+ >>> tb.build(mapsA, mapsB, None)
+ >>> # Check relations of mapsA
+ >>> for map in mapsA:
+ ... print(map.get_temporal_extent_as_tuple())
+ ... m = map.get_temporal_relations()
+ ... for key in m.keys():
+ ... if key not in ["NEXT", "PREV"]:
+ ... print(key, m[key][0].get_temporal_extent_as_tuple())
+ (datetime.datetime(2000, 1, 1, 0, 0), datetime.datetime(2002, 1, 1, 0, 0))
+ ('OVERLAPS', (datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2004, 1, 1, 0, 0)))
+ ('DURING', (datetime.datetime(2000, 1, 1, 0, 0), datetime.datetime(2003, 1, 1, 0, 0)))
+ ('STARTS', (datetime.datetime(2000, 1, 1, 0, 0), datetime.datetime(2003, 1, 1, 0, 0)))
+ ('PRECEDES', (datetime.datetime(2002, 1, 1, 0, 0), datetime.datetime(2005, 1, 1, 0, 0)))
+ (datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2003, 1, 1, 0, 0))
+ ('OVERLAPS', (datetime.datetime(2002, 1, 1, 0, 0), datetime.datetime(2005, 1, 1, 0, 0)))
+ ('PRECEDES', (datetime.datetime(2003, 1, 1, 0, 0), datetime.datetime(2006, 1, 1, 0, 0)))
+ ('FINISHES', (datetime.datetime(2000, 1, 1, 0, 0), datetime.datetime(2003, 1, 1, 0, 0)))
+ ('DURING', (datetime.datetime(2000, 1, 1, 0, 0), datetime.datetime(2003, 1, 1, 0, 0)))
+ ('STARTS', (datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2004, 1, 1, 0, 0)))
+ (datetime.datetime(2002, 1, 1, 0, 0), datetime.datetime(2004, 1, 1, 0, 0))
+ ('OVERLAPS', (datetime.datetime(2003, 1, 1, 0, 0), datetime.datetime(2006, 1, 1, 0, 0)))
+ ('OVERLAPPED', (datetime.datetime(2000, 1, 1, 0, 0), datetime.datetime(2003, 1, 1, 0, 0)))
+ ('FINISHES', (datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2004, 1, 1, 0, 0)))
+ ('DURING', (datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2004, 1, 1, 0, 0)))
+ ('STARTS', (datetime.datetime(2002, 1, 1, 0, 0), datetime.datetime(2005, 1, 1, 0, 0)))
+ (datetime.datetime(2003, 1, 1, 0, 0), datetime.datetime(2005, 1, 1, 0, 0))
+ ('OVERLAPPED', (datetime.datetime(2001, 1, 1, 0, 0), datetime.datetime(2004, 1, 1, 0, 0)))
+ ('DURING', (datetime.datetime(2002, 1, 1, 0, 0), datetime.datetime(2005, 1, 1, 0, 0)))
+ ('FINISHES', (datetime.datetime(2002, 1, 1, 0, 0), datetime.datetime(2005, 1, 1, 0, 0)))
+ ('STARTS', (datetime.datetime(2003, 1, 1, 0, 0), datetime.datetime(2006, 1, 1, 0, 0)))
+ ('FOLLOWS', (datetime.datetime(2000, 1, 1, 0, 0), datetime.datetime(2003, 1, 1, 0, 0)))
- >>> mapsA = []
- >>> mapsB = []
- >>> for i in range(4):
- ... idA = "a%i at B"%(i)
- ... mapA = tgis.RasterDataset(idA)
- ... idB = "b%i at B"%(i)
- ... mapB = tgis.RasterDataset(idB)
- ... start = datetime.datetime(2000, 1, 1, 0, 0, i)
- ... end = datetime.datetime(2000, 1, 1, 0, 0, i + 2)
- ... check = mapA.set_absolute_time(start, end)
- ... start = datetime.datetime(2000, 1, 1, 0, 0, i + 1)
- ... end = datetime.datetime(2000, 1, 1, 0, 0, i + 3)
- ... check = mapB.set_absolute_time(start, end)
- ... mapsA.append(mapA)
- ... mapsB.append(mapB)
- >>> # Build the topology between the two map lists
- >>> tb = SpatioTemporalTopologyBuilder()
- >>> tb.build(mapsA, mapsB, None)
- >>> # Check relations of mapsA
- >>> for map in mapsA:
- ... print(map.get_temporal_extent_as_tuple())
- ... m = map.get_temporal_relations()
- ... for key in m.keys():
- ... if key not in ["NEXT", "PREV"]:
- ... print(key, m[key][0].get_temporal_extent_as_tuple())
- (datetime.datetime(2000, 1, 1, 0, 0), datetime.datetime(2000, 1, 1, 0, 0, 2))
- ('OVERLAPS', (datetime.datetime(2000, 1, 1, 0, 0, 1), datetime.datetime(2000, 1, 1, 0, 0, 3)))
- ('PRECEDES', (datetime.datetime(2000, 1, 1, 0, 0, 2), datetime.datetime(2000, 1, 1, 0, 0, 4)))
- (datetime.datetime(2000, 1, 1, 0, 0, 1), datetime.datetime(2000, 1, 1, 0, 0, 3))
- ('OVERLAPS', (datetime.datetime(2000, 1, 1, 0, 0, 2), datetime.datetime(2000, 1, 1, 0, 0, 4)))
- ('PRECEDES', (datetime.datetime(2000, 1, 1, 0, 0, 3), datetime.datetime(2000, 1, 1, 0, 0, 5)))
- ('EQUAL', (datetime.datetime(2000, 1, 1, 0, 0, 1), datetime.datetime(2000, 1, 1, 0, 0, 3)))
- (datetime.datetime(2000, 1, 1, 0, 0, 2), datetime.datetime(2000, 1, 1, 0, 0, 4))
- ('OVERLAPS', (datetime.datetime(2000, 1, 1, 0, 0, 3), datetime.datetime(2000, 1, 1, 0, 0, 5)))
- ('OVERLAPPED', (datetime.datetime(2000, 1, 1, 0, 0, 1), datetime.datetime(2000, 1, 1, 0, 0, 3)))
- ('PRECEDES', (datetime.datetime(2000, 1, 1, 0, 0, 4), datetime.datetime(2000, 1, 1, 0, 0, 6)))
- ('EQUAL', (datetime.datetime(2000, 1, 1, 0, 0, 2), datetime.datetime(2000, 1, 1, 0, 0, 4)))
- (datetime.datetime(2000, 1, 1, 0, 0, 3), datetime.datetime(2000, 1, 1, 0, 0, 5))
- ('OVERLAPS', (datetime.datetime(2000, 1, 1, 0, 0, 4), datetime.datetime(2000, 1, 1, 0, 0, 6)))
- ('FOLLOWS', (datetime.datetime(2000, 1, 1, 0, 0, 1), datetime.datetime(2000, 1, 1, 0, 0, 3)))
- ('OVERLAPPED', (datetime.datetime(2000, 1, 1, 0, 0, 2), datetime.datetime(2000, 1, 1, 0, 0, 4)))
- ('EQUAL', (datetime.datetime(2000, 1, 1, 0, 0, 3), datetime.datetime(2000, 1, 1, 0, 0, 5)))
+ >>> mapsA = []
+ >>> mapsB = []
+ >>> for i in range(4):
+ ... idA = "a%i at B"%(i)
+ ... mapA = tgis.RasterDataset(idA)
+ ... idB = "b%i at B"%(i)
+ ... mapB = tgis.RasterDataset(idB)
+ ... start = datetime.datetime(2000, 1, 1, 0, 0, i)
+ ... end = datetime.datetime(2000, 1, 1, 0, 0, i + 2)
+ ... check = mapA.set_absolute_time(start, end)
+ ... start = datetime.datetime(2000, 1, 1, 0, 0, i + 1)
+ ... end = datetime.datetime(2000, 1, 1, 0, 0, i + 3)
+ ... check = mapB.set_absolute_time(start, end)
+ ... mapsA.append(mapA)
+ ... mapsB.append(mapB)
+ >>> # Build the topology between the two map lists
+ >>> tb = SpatioTemporalTopologyBuilder()
+ >>> tb.build(mapsA, mapsB, None)
+ >>> # Check relations of mapsA
+ >>> for map in mapsA:
+ ... print(map.get_temporal_extent_as_tuple())
+ ... m = map.get_temporal_relations()
+ ... for key in m.keys():
+ ... if key not in ["NEXT", "PREV"]:
+ ... print(key, m[key][0].get_temporal_extent_as_tuple())
+ (datetime.datetime(2000, 1, 1, 0, 0), datetime.datetime(2000, 1, 1, 0, 0, 2))
+ ('OVERLAPS', (datetime.datetime(2000, 1, 1, 0, 0, 1), datetime.datetime(2000, 1, 1, 0, 0, 3)))
+ ('PRECEDES', (datetime.datetime(2000, 1, 1, 0, 0, 2), datetime.datetime(2000, 1, 1, 0, 0, 4)))
+ (datetime.datetime(2000, 1, 1, 0, 0, 1), datetime.datetime(2000, 1, 1, 0, 0, 3))
+ ('OVERLAPS', (datetime.datetime(2000, 1, 1, 0, 0, 2), datetime.datetime(2000, 1, 1, 0, 0, 4)))
+ ('PRECEDES', (datetime.datetime(2000, 1, 1, 0, 0, 3), datetime.datetime(2000, 1, 1, 0, 0, 5)))
+ ('EQUAL', (datetime.datetime(2000, 1, 1, 0, 0, 1), datetime.datetime(2000, 1, 1, 0, 0, 3)))
+ (datetime.datetime(2000, 1, 1, 0, 0, 2), datetime.datetime(2000, 1, 1, 0, 0, 4))
+ ('OVERLAPS', (datetime.datetime(2000, 1, 1, 0, 0, 3), datetime.datetime(2000, 1, 1, 0, 0, 5)))
+ ('OVERLAPPED', (datetime.datetime(2000, 1, 1, 0, 0, 1), datetime.datetime(2000, 1, 1, 0, 0, 3)))
+ ('PRECEDES', (datetime.datetime(2000, 1, 1, 0, 0, 4), datetime.datetime(2000, 1, 1, 0, 0, 6)))
+ ('EQUAL', (datetime.datetime(2000, 1, 1, 0, 0, 2), datetime.datetime(2000, 1, 1, 0, 0, 4)))
+ (datetime.datetime(2000, 1, 1, 0, 0, 3), datetime.datetime(2000, 1, 1, 0, 0, 5))
+ ('OVERLAPS', (datetime.datetime(2000, 1, 1, 0, 0, 4), datetime.datetime(2000, 1, 1, 0, 0, 6)))
+ ('FOLLOWS', (datetime.datetime(2000, 1, 1, 0, 0, 1), datetime.datetime(2000, 1, 1, 0, 0, 3)))
+ ('OVERLAPPED', (datetime.datetime(2000, 1, 1, 0, 0, 2), datetime.datetime(2000, 1, 1, 0, 0, 4)))
+ ('EQUAL', (datetime.datetime(2000, 1, 1, 0, 0, 3), datetime.datetime(2000, 1, 1, 0, 0, 5)))
- >>> mapsA = []
- >>> for i in range(4):
- ... idA = "a%i at B"%(i)
- ... mapA = tgis.RasterDataset(idA)
- ... start = datetime.datetime(2000, 1, 1, 0, 0, i)
- ... end = datetime.datetime(2000, 1, 1, 0, 0, i + 2)
- ... check = mapA.set_absolute_time(start, end)
- ... mapsA.append(mapA)
- >>> tb = SpatioTemporalTopologyBuilder()
- >>> tb.build(mapsA)
- >>> # Check relations of mapsA
- >>> for map in mapsA:
- ... print(map.get_temporal_extent_as_tuple())
- ... m = map.get_temporal_relations()
- ... for key in m.keys():
- ... if key not in ["NEXT", "PREV"]:
- ... print(key, m[key][0].get_temporal_extent_as_tuple())
- (datetime.datetime(2000, 1, 1, 0, 0), datetime.datetime(2000, 1, 1, 0, 0, 2))
- ('OVERLAPS', (datetime.datetime(2000, 1, 1, 0, 0, 1), datetime.datetime(2000, 1, 1, 0, 0, 3)))
- ('PRECEDES', (datetime.datetime(2000, 1, 1, 0, 0, 2), datetime.datetime(2000, 1, 1, 0, 0, 4)))
- (datetime.datetime(2000, 1, 1, 0, 0, 1), datetime.datetime(2000, 1, 1, 0, 0, 3))
- ('OVERLAPS', (datetime.datetime(2000, 1, 1, 0, 0, 2), datetime.datetime(2000, 1, 1, 0, 0, 4)))
- ('OVERLAPPED', (datetime.datetime(2000, 1, 1, 0, 0), datetime.datetime(2000, 1, 1, 0, 0, 2)))
- ('PRECEDES', (datetime.datetime(2000, 1, 1, 0, 0, 3), datetime.datetime(2000, 1, 1, 0, 0, 5)))
- (datetime.datetime(2000, 1, 1, 0, 0, 2), datetime.datetime(2000, 1, 1, 0, 0, 4))
- ('OVERLAPS', (datetime.datetime(2000, 1, 1, 0, 0, 3), datetime.datetime(2000, 1, 1, 0, 0, 5)))
- ('FOLLOWS', (datetime.datetime(2000, 1, 1, 0, 0), datetime.datetime(2000, 1, 1, 0, 0, 2)))
- ('OVERLAPPED', (datetime.datetime(2000, 1, 1, 0, 0, 1), datetime.datetime(2000, 1, 1, 0, 0, 3)))
- (datetime.datetime(2000, 1, 1, 0, 0, 3), datetime.datetime(2000, 1, 1, 0, 0, 5))
- ('FOLLOWS', (datetime.datetime(2000, 1, 1, 0, 0, 1), datetime.datetime(2000, 1, 1, 0, 0, 3)))
- ('OVERLAPPED', (datetime.datetime(2000, 1, 1, 0, 0, 2), datetime.datetime(2000, 1, 1, 0, 0, 4)))
+ >>> mapsA = []
+ >>> for i in range(4):
+ ... idA = "a%i at B"%(i)
+ ... mapA = tgis.RasterDataset(idA)
+ ... start = datetime.datetime(2000, 1, 1, 0, 0, i)
+ ... end = datetime.datetime(2000, 1, 1, 0, 0, i + 2)
+ ... check = mapA.set_absolute_time(start, end)
+ ... mapsA.append(mapA)
+ >>> tb = SpatioTemporalTopologyBuilder()
+ >>> tb.build(mapsA)
+ >>> # Check relations of mapsA
+ >>> for map in mapsA:
+ ... print(map.get_temporal_extent_as_tuple())
+ ... m = map.get_temporal_relations()
+ ... for key in m.keys():
+ ... if key not in ["NEXT", "PREV"]:
+ ... print(key, m[key][0].get_temporal_extent_as_tuple())
+ (datetime.datetime(2000, 1, 1, 0, 0), datetime.datetime(2000, 1, 1, 0, 0, 2))
+ ('OVERLAPS', (datetime.datetime(2000, 1, 1, 0, 0, 1), datetime.datetime(2000, 1, 1, 0, 0, 3)))
+ ('PRECEDES', (datetime.datetime(2000, 1, 1, 0, 0, 2), datetime.datetime(2000, 1, 1, 0, 0, 4)))
+ (datetime.datetime(2000, 1, 1, 0, 0, 1), datetime.datetime(2000, 1, 1, 0, 0, 3))
+ ('OVERLAPS', (datetime.datetime(2000, 1, 1, 0, 0, 2), datetime.datetime(2000, 1, 1, 0, 0, 4)))
+ ('OVERLAPPED', (datetime.datetime(2000, 1, 1, 0, 0), datetime.datetime(2000, 1, 1, 0, 0, 2)))
+ ('PRECEDES', (datetime.datetime(2000, 1, 1, 0, 0, 3), datetime.datetime(2000, 1, 1, 0, 0, 5)))
+ (datetime.datetime(2000, 1, 1, 0, 0, 2), datetime.datetime(2000, 1, 1, 0, 0, 4))
+ ('OVERLAPS', (datetime.datetime(2000, 1, 1, 0, 0, 3), datetime.datetime(2000, 1, 1, 0, 0, 5)))
+ ('FOLLOWS', (datetime.datetime(2000, 1, 1, 0, 0), datetime.datetime(2000, 1, 1, 0, 0, 2)))
+ ('OVERLAPPED', (datetime.datetime(2000, 1, 1, 0, 0, 1), datetime.datetime(2000, 1, 1, 0, 0, 3)))
+ (datetime.datetime(2000, 1, 1, 0, 0, 3), datetime.datetime(2000, 1, 1, 0, 0, 5))
+ ('FOLLOWS', (datetime.datetime(2000, 1, 1, 0, 0, 1), datetime.datetime(2000, 1, 1, 0, 0, 3)))
+ ('OVERLAPPED', (datetime.datetime(2000, 1, 1, 0, 0, 2), datetime.datetime(2000, 1, 1, 0, 0, 4)))
- @endcode
-
"""
def __init__(self):
self._reset()
@@ -383,14 +377,14 @@
self._store[t.get_id()] = t
def get_first(self):
- """!Return the first map with the earliest start time
+ """Return the first map with the earliest start time
- @return The map with the earliest start time
+ :return: The map with the earliest start time
"""
return self._first
def _build_internal_iteratable(self, maps, spatial):
- """!Build an iteratable temporal topology structure for all maps in
+ """Build an iteratable temporal topology structure for all maps in
the list and store the maps internally
Basically the "next" and "prev" relations will be set in the
@@ -398,7 +392,7 @@
The maps will be added to the object, so they can be
accessed using the iterator of this class
- @param maps A sorted (by start_time)list of abstract_dataset
+ :param maps: A sorted (by start_time)list of abstract_dataset
objects with initiated temporal extent
"""
self._build_iteratable(maps, spatial)
@@ -410,13 +404,13 @@
self._detect_first()
def _build_iteratable(self, maps, spatial):
- """!Build an iteratable temporal topology structure for
+ """Build an iteratable temporal topology structure for
all maps in the list
Basically the "next" and "prev" relations will be set in
the temporal topology structure of each map.
- @param maps A sorted (by start_time)list of abstract_dataset
+ :param maps: A sorted (by start_time)list of abstract_dataset
objects with initiated temporal extent
"""
# for i in xrange(len(maps)):
@@ -446,10 +440,10 @@
map_.set_spatial_topology_build_true()
def _map_to_rect(self, tree, map_, spatial=None):
- """!Use the spatio-temporal extent of a map to create and
+ """Use the spatio-temporal extent of a map to create and
return a RTree rectange
- @param spatial This indicates if the spatial topology is created as well:
+ :param spatial: This indicates if the spatial topology is created as well:
spatial can be None (no spatial topology), "2D" using west, east,
#south, north or "3D" using west, east, south, north, bottom, top
"""
@@ -478,10 +472,10 @@
return rect
def _build_rtree(self, maps, spatial=None):
- """!Build and return the 1-4 dimensional R*-Tree
+ """Build and return the 1-4 dimensional R*-Tree
- @param spatial This indicates if the spatial topology is created as well:
+ :param spatial: This indicates if the spatial topology is created as well:
spatial can be None (no spatial topology), "2D" using west, east,
south, north or "3D" using west, east, south, north, bottom, top
"""
@@ -501,7 +495,7 @@
return tree
def build(self, mapsA, mapsB=None, spatial=None):
- """!Build the spatio-temporal topology structure between
+ """Build the spatio-temporal topology structure between
one or two unordered lists of abstract dataset objects
This method builds the temporal or spatio-temporal topology from mapsA to
@@ -514,11 +508,11 @@
The implemented iterator assures
the chronological iteration over the mapsA.
- @param mapsA A list of abstract_dataset
+ :param mapsA: A list of abstract_dataset
objects with initiated spatio-temporal extent
- @param mapsB An optional list of abstract_dataset
+ :param mapsB: An optional list of abstract_dataset
objects with initiated spatio-temporal extent
- @param spatial This indicates if the spatial topology is created as well:
+ :param spatial: This indicates if the spatial topology is created as well:
spatial can be None (no spatial topology), "2D" using west, east,
south, north or "3D" using west, east, south, north, bottom, top
"""
@@ -763,14 +757,14 @@
###############################################################################
def print_temporal_topology_relationships(maps1, maps2=None, dbif=None):
- """!Print the temporal relationships of the
+ """Print the temporal relationships of the
map lists maps1 and maps2 to stdout.
- @param maps1 A list of abstract_dataset
+ :param maps1: A list of abstract_dataset
objects with initiated temporal extent
- @param maps2 An optional list of abstract_dataset
+ :param maps2: An optional list of abstract_dataset
objects with initiated temporal extent
- @param dbif The database interface to be used
+ :param dbif: The database interface to be used
"""
tb = SpatioTemporalTopologyBuilder()
@@ -792,16 +786,16 @@
def print_spatio_temporal_topology_relationships(maps1, maps2=None,
spatial="2D", dbif=None):
- """!Print the temporal relationships of the
+ """Print the temporal relationships of the
map lists maps1 and maps2 to stdout.
- @param maps1 A list of abstract_dataset
+ :param maps1: A list of abstract_dataset
objects with initiated temporal extent
- @param maps2 An optional list of abstract_dataset
+ :param maps2: An optional list of abstract_dataset
objects with initiated temporal extent
- @param spatial The dimension of the spatial extent to be used: "2D" using west, east,
+ :param spatial: The dimension of the spatial extent to be used: "2D" using west, east,
south, north or "3D" using west, east, south, north, bottom, top
- @param dbif The database interface to be used
+ :param dbif: The database interface to be used
"""
tb = SpatioTemporalTopologyBuilder()
@@ -822,15 +816,15 @@
###############################################################################
def count_temporal_topology_relationships(maps1, maps2=None, dbif=None):
- """!Count the temporal relations of a single list of maps or between two lists of maps
+ """Count the temporal relations of a single list of maps or between two lists of maps
- @param maps1 A list of abstract_dataset
+ :param maps1: A list of abstract_dataset
objects with initiated temporal extent
- @param maps2 A list of abstract_dataset
+ :param maps2: A list of abstract_dataset
objects with initiated temporal extent
- @param dbif The database interface to be used
- @return A dictionary with counted temporal relationships
+ :param dbif: The database interface to be used
+ :return: A dictionary with counted temporal relationships
"""
@@ -860,132 +854,132 @@
start, end, use_start=True, use_during=False,
use_overlap=False, use_contain=False, use_equal=False,
use_follows=False, use_precedes=False):
- """!Create a SQL WHERE statement for temporal relation selection of maps in space time datasets
+ """Create a SQL WHERE statement for temporal relation selection of maps in space time datasets
- @param start The start time
- @param end The end time
- @param use_start Select maps of which the start time is located in the selection granule
- @verbatim
- map : s
- granule: s-----------------e
+ :param start: The start time
+ :param end: The end time
+ :param use_start: Select maps of which the start time is located in the selection granule
+ ::
+
+ map : s
+ granule: s-----------------e
- map : s--------------------e
- granule: s-----------------e
+ map : s--------------------e
+ granule: s-----------------e
- map : s--------e
- granule: s-----------------e
- @endverbatim
+ map : s--------e
+ granule: s-----------------e
- @param use_during Select maps which are temporal during the selection granule
- @verbatim
- map : s-----------e
- granule: s-----------------e
- @endverbatim
- @param use_overlap Select maps which temporal overlap the selection granule
- @verbatim
- map : s-----------e
- granule: s-----------------e
+ :param use_during: Select maps which are temporal during the selection granule
+ ::
+
+ map : s-----------e
+ granule: s-----------------e
- map : s-----------e
- granule: s----------e
- @endverbatim
+ :param use_overlap: Select maps which temporal overlap the selection granule
+ ::
+
+ map : s-----------e
+ granule: s-----------------e
- @param use_contain Select maps which temporally contain the selection granule
- @verbatim
- map : s-----------------e
- granule: s-----------e
- @endverbatim
+ map : s-----------e
+ granule: s----------e
- @param use_equal Select maps which temporally equal to the selection granule
- @verbatim
- map : s-----------e
- granule: s-----------e
- @endverbatim
+ :param use_contain: Select maps which temporally contain the selection granule
+ ::
+
+ map : s-----------------e
+ granule: s-----------e
- @param use_follows Select maps which temporally follow the selection granule
- @verbatim
- map : s-----------e
- granule: s-----------e
- @endverbatim
+ :param use_equal: Select maps which temporally equal to the selection granule
+ ::
+
+ map : s-----------e
+ granule: s-----------e
- @param use_precedes Select maps which temporally precedes the selection granule
- @verbatim
- map : s-----------e
- granule: s-----------e
- @endverbatim
+ :param use_follows: Select maps which temporally follow the selection granule
+ ::
+
+ map : s-----------e
+ granule: s-----------e
+ :param use_precedes: Select maps which temporally precedes the selection granule
+ ::
+
+ map : s-----------e
+ granule: s-----------e
+
Usage:
- @code
+ .. code-block:: python
- >>> # Relative time
- >>> start = 1
- >>> end = 2
- >>> create_temporal_relation_sql_where_statement(start, end,
- ... use_start=False)
- >>> create_temporal_relation_sql_where_statement(start, end)
- '((start_time >= 1 and start_time < 2) )'
- >>> create_temporal_relation_sql_where_statement(start, end,
- ... use_start=True)
- '((start_time >= 1 and start_time < 2) )'
- >>> create_temporal_relation_sql_where_statement(start, end,
- ... use_start=False, use_during=True)
- '(((start_time > 1 and end_time < 2) OR (start_time >= 1 and end_time < 2) OR (start_time > 1 and end_time <= 2)))'
- >>> create_temporal_relation_sql_where_statement(start, end,
- ... use_start=False, use_overlap=True)
- '(((start_time < 1 and end_time > 1 and end_time < 2) OR (start_time < 2 and start_time > 1 and end_time > 2)))'
- >>> create_temporal_relation_sql_where_statement(start, end,
- ... use_start=False, use_contain=True)
- '(((start_time < 1 and end_time > 2) OR (start_time <= 1 and end_time > 2) OR (start_time < 1 and end_time >= 2)))'
- >>> create_temporal_relation_sql_where_statement(start, end,
- ... use_start=False, use_equal=True)
- '((start_time = 1 and end_time = 2))'
- >>> create_temporal_relation_sql_where_statement(start, end,
- ... use_start=False, use_follows=True)
- '((start_time = 2))'
- >>> create_temporal_relation_sql_where_statement(start, end,
- ... use_start=False, use_precedes=True)
- '((end_time = 1))'
- >>> create_temporal_relation_sql_where_statement(start, end,
- ... use_start=True, use_during=True, use_overlap=True, use_contain=True,
- ... use_equal=True, use_follows=True, use_precedes=True)
- '((start_time >= 1 and start_time < 2) OR ((start_time > 1 and end_time < 2) OR (start_time >= 1 and end_time < 2) OR (start_time > 1 and end_time <= 2)) OR ((start_time < 1 and end_time > 1 and end_time < 2) OR (start_time < 2 and start_time > 1 and end_time > 2)) OR ((start_time < 1 and end_time > 2) OR (start_time <= 1 and end_time > 2) OR (start_time < 1 and end_time >= 2)) OR (start_time = 1 and end_time = 2) OR (start_time = 2) OR (end_time = 1))'
+ >>> # Relative time
+ >>> start = 1
+ >>> end = 2
+ >>> create_temporal_relation_sql_where_statement(start, end,
+ ... use_start=False)
+ >>> create_temporal_relation_sql_where_statement(start, end)
+ '((start_time >= 1 and start_time < 2) )'
+ >>> create_temporal_relation_sql_where_statement(start, end,
+ ... use_start=True)
+ '((start_time >= 1 and start_time < 2) )'
+ >>> create_temporal_relation_sql_where_statement(start, end,
+ ... use_start=False, use_during=True)
+ '(((start_time > 1 and end_time < 2) OR (start_time >= 1 and end_time < 2) OR (start_time > 1 and end_time <= 2)))'
+ >>> create_temporal_relation_sql_where_statement(start, end,
+ ... use_start=False, use_overlap=True)
+ '(((start_time < 1 and end_time > 1 and end_time < 2) OR (start_time < 2 and start_time > 1 and end_time > 2)))'
+ >>> create_temporal_relation_sql_where_statement(start, end,
+ ... use_start=False, use_contain=True)
+ '(((start_time < 1 and end_time > 2) OR (start_time <= 1 and end_time > 2) OR (start_time < 1 and end_time >= 2)))'
+ >>> create_temporal_relation_sql_where_statement(start, end,
+ ... use_start=False, use_equal=True)
+ '((start_time = 1 and end_time = 2))'
+ >>> create_temporal_relation_sql_where_statement(start, end,
+ ... use_start=False, use_follows=True)
+ '((start_time = 2))'
+ >>> create_temporal_relation_sql_where_statement(start, end,
+ ... use_start=False, use_precedes=True)
+ '((end_time = 1))'
+ >>> create_temporal_relation_sql_where_statement(start, end,
+ ... use_start=True, use_during=True, use_overlap=True, use_contain=True,
+ ... use_equal=True, use_follows=True, use_precedes=True)
+ '((start_time >= 1 and start_time < 2) OR ((start_time > 1 and end_time < 2) OR (start_time >= 1 and end_time < 2) OR (start_time > 1 and end_time <= 2)) OR ((start_time < 1 and end_time > 1 and end_time < 2) OR (start_time < 2 and start_time > 1 and end_time > 2)) OR ((start_time < 1 and end_time > 2) OR (start_time <= 1 and end_time > 2) OR (start_time < 1 and end_time >= 2)) OR (start_time = 1 and end_time = 2) OR (start_time = 2) OR (end_time = 1))'
- >>> # Absolute time
- >>> start = datetime(2001, 1, 1, 12, 30)
- >>> end = datetime(2001, 3, 31, 14, 30)
- >>> create_temporal_relation_sql_where_statement(start, end,
- ... use_start=False)
- >>> create_temporal_relation_sql_where_statement(start, end)
- "((start_time >= '2001-01-01 12:30:00' and start_time < '2001-03-31 14:30:00') )"
- >>> create_temporal_relation_sql_where_statement(start, end,
- ... use_start=True)
- "((start_time >= '2001-01-01 12:30:00' and start_time < '2001-03-31 14:30:00') )"
- >>> create_temporal_relation_sql_where_statement(start, end,
- ... use_start=False, use_during=True)
- "(((start_time > '2001-01-01 12:30:00' and end_time < '2001-03-31 14:30:00') OR (start_time >= '2001-01-01 12:30:00' and end_time < '2001-03-31 14:30:00') OR (start_time > '2001-01-01 12:30:00' and end_time <= '2001-03-31 14:30:00')))"
- >>> create_temporal_relation_sql_where_statement(start, end,
- ... use_start=False, use_overlap=True)
- "(((start_time < '2001-01-01 12:30:00' and end_time > '2001-01-01 12:30:00' and end_time < '2001-03-31 14:30:00') OR (start_time < '2001-03-31 14:30:00' and start_time > '2001-01-01 12:30:00' and end_time > '2001-03-31 14:30:00')))"
- >>> create_temporal_relation_sql_where_statement(start, end,
- ... use_start=False, use_contain=True)
- "(((start_time < '2001-01-01 12:30:00' and end_time > '2001-03-31 14:30:00') OR (start_time <= '2001-01-01 12:30:00' and end_time > '2001-03-31 14:30:00') OR (start_time < '2001-01-01 12:30:00' and end_time >= '2001-03-31 14:30:00')))"
- >>> create_temporal_relation_sql_where_statement(start, end,
- ... use_start=False, use_equal=True)
- "((start_time = '2001-01-01 12:30:00' and end_time = '2001-03-31 14:30:00'))"
- >>> create_temporal_relation_sql_where_statement(start, end,
- ... use_start=False, use_follows=True)
- "((start_time = '2001-03-31 14:30:00'))"
- >>> create_temporal_relation_sql_where_statement(start, end,
- ... use_start=False, use_precedes=True)
- "((end_time = '2001-01-01 12:30:00'))"
- >>> create_temporal_relation_sql_where_statement(start, end,
- ... use_start=True, use_during=True, use_overlap=True, use_contain=True,
- ... use_equal=True, use_follows=True, use_precedes=True)
- "((start_time >= '2001-01-01 12:30:00' and start_time < '2001-03-31 14:30:00') OR ((start_time > '2001-01-01 12:30:00' and end_time < '2001-03-31 14:30:00') OR (start_time >= '2001-01-01 12:30:00' and end_time < '2001-03-31 14:30:00') OR (start_time > '2001-01-01 12:30:00' and end_time <= '2001-03-31 14:30:00')) OR ((start_time < '2001-01-01 12:30:00' and end_time > '2001-01-01 12:30:00' and end_time < '2001-03-31 14:30:00') OR (start_time < '2001-03-31 14:30:00' and start_time > '2001-01-01 12:30:00' and end_time > '2001-03-31 14:30:00')) OR ((start_time < '2001-01-01 12:30:00' and end_time > '2001-03-31 14:30:00') OR (start_time <= '2001-01-01 12:30:00' and end_time > '2001-03-31 14:30:00') OR (start_time < '2001-01-01 12:30:00' and end_time >= '2001-03-31 14:30:00')) OR (start_time = '2001-01-01 12:30:00' and end_time = '2001-03-31 14:30:00') OR (start_time = '2001-03-31 14:30:00') OR (end_time = '2001-01-01 12:30:00'))"
+ >>> # Absolute time
+ >>> start = datetime(2001, 1, 1, 12, 30)
+ >>> end = datetime(2001, 3, 31, 14, 30)
+ >>> create_temporal_relation_sql_where_statement(start, end,
+ ... use_start=False)
+ >>> create_temporal_relation_sql_where_statement(start, end)
+ "((start_time >= '2001-01-01 12:30:00' and start_time < '2001-03-31 14:30:00') )"
+ >>> create_temporal_relation_sql_where_statement(start, end,
+ ... use_start=True)
+ "((start_time >= '2001-01-01 12:30:00' and start_time < '2001-03-31 14:30:00') )"
+ >>> create_temporal_relation_sql_where_statement(start, end,
+ ... use_start=False, use_during=True)
+ "(((start_time > '2001-01-01 12:30:00' and end_time < '2001-03-31 14:30:00') OR (start_time >= '2001-01-01 12:30:00' and end_time < '2001-03-31 14:30:00') OR (start_time > '2001-01-01 12:30:00' and end_time <= '2001-03-31 14:30:00')))"
+ >>> create_temporal_relation_sql_where_statement(start, end,
+ ... use_start=False, use_overlap=True)
+ "(((start_time < '2001-01-01 12:30:00' and end_time > '2001-01-01 12:30:00' and end_time < '2001-03-31 14:30:00') OR (start_time < '2001-03-31 14:30:00' and start_time > '2001-01-01 12:30:00' and end_time > '2001-03-31 14:30:00')))"
+ >>> create_temporal_relation_sql_where_statement(start, end,
+ ... use_start=False, use_contain=True)
+ "(((start_time < '2001-01-01 12:30:00' and end_time > '2001-03-31 14:30:00') OR (start_time <= '2001-01-01 12:30:00' and end_time > '2001-03-31 14:30:00') OR (start_time < '2001-01-01 12:30:00' and end_time >= '2001-03-31 14:30:00')))"
+ >>> create_temporal_relation_sql_where_statement(start, end,
+ ... use_start=False, use_equal=True)
+ "((start_time = '2001-01-01 12:30:00' and end_time = '2001-03-31 14:30:00'))"
+ >>> create_temporal_relation_sql_where_statement(start, end,
+ ... use_start=False, use_follows=True)
+ "((start_time = '2001-03-31 14:30:00'))"
+ >>> create_temporal_relation_sql_where_statement(start, end,
+ ... use_start=False, use_precedes=True)
+ "((end_time = '2001-01-01 12:30:00'))"
+ >>> create_temporal_relation_sql_where_statement(start, end,
+ ... use_start=True, use_during=True, use_overlap=True, use_contain=True,
+ ... use_equal=True, use_follows=True, use_precedes=True)
+ "((start_time >= '2001-01-01 12:30:00' and start_time < '2001-03-31 14:30:00') OR ((start_time > '2001-01-01 12:30:00' and end_time < '2001-03-31 14:30:00') OR (start_time >= '2001-01-01 12:30:00' and end_time < '2001-03-31 14:30:00') OR (start_time > '2001-01-01 12:30:00' and end_time <= '2001-03-31 14:30:00')) OR ((start_time < '2001-01-01 12:30:00' and end_time > '2001-01-01 12:30:00' and end_time < '2001-03-31 14:30:00') OR (start_time < '2001-03-31 14:30:00' and start_time > '2001-01-01 12:30:00' and end_time > '2001-03-31 14:30:00')) OR ((start_time < '2001-01-01 12:30:00' and end_time > '2001-03-31 14:30:00') OR (start_time <= '2001-01-01 12:30:00' and end_time > '2001-03-31 14:30:00') OR (start_time < '2001-01-01 12:30:00' and end_time >= '2001-03-31 14:30:00')) OR (start_time = '2001-01-01 12:30:00' and end_time = '2001-03-31 14:30:00') OR (start_time = '2001-03-31 14:30:00') OR (end_time = '2001-01-01 12:30:00'))"
- @endcode
"""
where = "("
Modified: grass/trunk/lib/python/temporal/stds_export.py
===================================================================
--- grass/trunk/lib/python/temporal/stds_export.py 2014-09-28 01:40:32 UTC (rev 62120)
+++ grass/trunk/lib/python/temporal/stds_export.py 2014-09-28 01:46:15 UTC (rev 62121)
@@ -1,31 +1,28 @@
-"""!@package grass.temporal
+"""
+Export functions for space time datasets
- at brief GRASS Python scripting module (temporal GIS functions)
+Usage:
-Temporal GIS export functions to be used in temporal modules
+.. code-block:: python
-Usage:
+ import grass.temporal as tgis
- at code
-import grass.temporal as tgis
+ input="temp_1950_2012 at PERMANENT"
+ output="/tmp/temp_1950_2012.tar.gz"
+ compression="gzip"
+ workdir="/tmp"
+ where=None
+ format_="GTiff"
+ type_="strds"
+ tgis.export_stds(input, output, compression, workdir, where, format_, type_)
-input="temp_1950_2012 at PERMANENT"
-output="/tmp/temp_1950_2012.tar.gz"
-compression="gzip"
-workdir="/tmp"
-where=None
-format_="GTiff"
-type_="strds"
-tgis.export_stds(input, output, compression, workdir, where, format_, type_)
-...
- at endcode
(C) 2012-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.
- at author Soeren Gebbert
+:authors: Soeren Gebbert
"""
import shutil
@@ -218,30 +215,34 @@
def export_stds(input, output, compression, workdir, where, format_="pack",
type_="strds"):
- """
- !Export space time datasets as tar archive with optional compression
+ """Export space time datasets as tar archive with optional compression
- This method should be used to export space time datasets
- of type raster and vector as tar archive that can be reimported
- with the method import_stds().
+ This method should be used to export space time datasets
+ of type raster and vector as tar archive that can be reimported
+ with the method import_stds().
- @param input The name of the space time dataset to export
- @param output The name of the archive file
- @param compression The compression of the archive file:
+ :param input: The name of the space time dataset to export
+ :param output: The name of the archive file
+ :param compression: The compression of the archive file:
+
- "no" no compression
- "gzip" GNU zip compression
- "bzip2" Bzip compression
- @param workdir The working directory used for extraction and packing
- @param where The temporal WHERE SQL statement to select a subset
- of maps from the space time dataset
- @param format_ The export format:
+
+ :param workdir: The working directory used for extraction and packing
+ :param where: The temporal WHERE SQL statement to select a subset
+ of maps from the space time dataset
+ :param format_: The export format:
+
- "GTiff" Geotiff format, only for raster maps
- "AAIGrid" Arc/Info ASCII Grid format, only for raster maps
- "pack" The GRASS raster, 3D raster or vector Pack format,
this is the default setting
- "GML" GML file export format, only for vector maps,
v.out.ogr export option
- @param type_ The space time dataset type
+
+ :param type_: The space time dataset type
+
- "strds" Space time raster dataset
- "str3ds" Space time 3D raster dataset
- "stvds" Space time vector dataset
Modified: grass/trunk/lib/python/temporal/stds_import.py
===================================================================
--- grass/trunk/lib/python/temporal/stds_import.py 2014-09-28 01:40:32 UTC (rev 62120)
+++ grass/trunk/lib/python/temporal/stds_import.py 2014-09-28 01:46:15 UTC (rev 62121)
@@ -1,35 +1,32 @@
-"""!@package grass.temporal
+"""
+Space time dataset import functions
- at brief GRASS Python scripting module (temporal GIS functions)
+Usage:
-Temporal GIS export functions to be used in temporal modules
+.. code-block:: python
-Usage:
+ import grass.temporal as tgis
- at code
-import grass.temporal as tgis
+ input="/tmp/temp_1950_2012.tar.gz"
+ output="temp_1950_2012"
+ extrdir="/tmp"
+ title="My new dataset"
+ descr="May new shiny dataset"
+ location=None
+ link=True
+ exp=True
+ overr=False
+ create=False
+ tgis.import_stds(input, output, extrdir, title, descr, location,
+ link, exp, overr, create, "strds")
-input="/tmp/temp_1950_2012.tar.gz"
-output="temp_1950_2012"
-extrdir="/tmp"
-title="My new dataset"
-descr="May new shiny dataset"
-location=None
-link=True
-exp=True
-overr=False
-create=False
-tgis.import_stds(input, output, extrdir, title, descr, location,
- link, exp, overr, create, "strds")
-...
- at endcode
(C) 2012-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.
- at author Soeren Gebbert
+:authors: Soeren Gebbert
"""
import os
@@ -174,25 +171,25 @@
def import_stds(input, output, extrdir, title=None, descr=None, location=None,
link=False, exp=False, overr=False, create=False, stds_type="strds",
base=None, set_current_region=False):
- """!Import space time datasets of type raster and vector
+ """Import space time datasets of type raster and vector
- @param input Name of the input archive file
- @param output The name of the output space time dataset
- @param extrdir The extraction directory
- @param title The title of the new created space time dataset
- @param descr The description of the new created
+ :param input: Name of the input archive file
+ :param output: The name of the output space time dataset
+ :param extrdir: The extraction directory
+ :param title: The title of the new created space time dataset
+ :param descr: The description of the new created
space time dataset
- @param location The name of the location that should be created,
+ :param location: The name of the location that should be created,
maps are imported into this location
- @param link Switch to link raster maps instead importing them
- @param exp Extend location extents based on new dataset
- @param overr Override projection (use location's projection)
- @param create Create the location specified by the "location"
+ :param link: Switch to link raster maps instead importing them
+ :param exp: Extend location extents based on new dataset
+ :param overr: Override projection (use location's projection)
+ :param create: Create the location specified by the "location"
parameter and exit.
Do not import the space time datasets.
- @param stds_type The type of the space time dataset that
+ :param stds_type: The type of the space time dataset that
should be imported
- @param base The base name of the new imported maps, it will be extended
+ :param base: The base name of the new imported maps, it will be extended
using a numerical index.
"""
Modified: grass/trunk/lib/python/temporal/temporal_algebra.py
===================================================================
--- grass/trunk/lib/python/temporal/temporal_algebra.py 2014-09-28 01:40:32 UTC (rev 62120)
+++ grass/trunk/lib/python/temporal/temporal_algebra.py 2014-09-28 01:46:15 UTC (rev 62121)
@@ -1,5 +1,4 @@
-"""!@package grass.temporal
-
+"""
Temporal algebra parser class
(C) 2014 by the GRASS Development Team
@@ -7,9 +6,9 @@
License (>=v2). Read the file COPYING that comes with GRASS
for details.
- at authors Thomas Leppelt and Soeren Gebbert
+:authors: Thomas Leppelt and Soeren Gebbert
- at code
+.. code-block:: python
>>> import grass.temporal as tgis
>>> tgis.init(True)
@@ -381,7 +380,6 @@
A* = if condition True then A else B
C = A*
- at endcode
"""
try:
@@ -401,7 +399,7 @@
##############################################################################
class TemporalAlgebraLexer(object):
- """!Lexical analyzer for the GRASS GIS temporal algebra"""
+ """Lexical analyzer for the GRASS GIS temporal algebra"""
# Functions that defines an if condition, temporal buffering and snapping
conditional_functions = {
@@ -700,7 +698,7 @@
self.parser.parse(expression)
def generate_map_name(self):
- """!Generate an unique intermediate vector map name
+ """Generate an unique intermediate vector map name
and register it in the objects map list for later removement.
The vector map names are unique between processes. Do not use the
@@ -716,9 +714,9 @@
return name
def generate_new_map(self, base_map, bool_op = 'and', copy = True):
- """!Generate a new map using the spatio-temporal extent of the base map
+ """Generate a new map using the spatio-temporal extent of the base map
- @param base_map This map is used to create the new map
+ :param base_map This map is used to create the new map
"""
# Generate an intermediate name for the result map list.
name = self.generate_map_name()
@@ -733,17 +731,17 @@
def overlay_map_extent(self, mapA, mapB, bool_op = None, temp_op = '=',
copy = False):
- """!Compute the spatio-temporal extent of two topological related maps
+ """Compute the spatio-temporal extent of two topological related maps
- @param mapA The first map
- @param mapB The second maps
- @param bool_op The boolean operator specifying the spatial extent
+ :param mapA: The first map
+ :param mapB: The second maps
+ :param bool_op: The boolean operator specifying the spatial extent
operation (intersection, union, disjoint union)
- @param temp_op The temporal operator specifying the temporal
+ :param temp_op: The temporal operator specifying the temporal
extent operation (intersection, union, disjoint union)
- @param copy Specifies if the temporal extent of mapB should be
+ :param copy: Specifies if the temporal extent of mapB should be
copied to mapA
- @return 0 if there is no overlay
+ :return: 0 if there is no overlay
"""
returncode = 1
if copy:
@@ -800,12 +798,12 @@
######################### Temporal functions ##############################
def check_stds(self, input, clear = False):
- """! Check if input space time dataset exist in database and return its map list.
+ """ Check if input space time dataset exist in database and return its map list.
- @param input Name of space time data set as string or list of maps.
- @param clear Reset the stored conditional values to empty list.
+ :param input: Name of space time data set as string or list of maps.
+ :param clear: Reset the stored conditional values to empty list.
- @return List of maps.
+ :return: List of maps.
"""
if not isinstance(input, list):
@@ -861,142 +859,140 @@
def get_temporal_topo_list(self, maplistA, maplistB = None, topolist = ["EQUAL"],
assign_val = False, count_map = False):
- """!Build temporal topology for two space time data sets, copy map objects
+ """Build temporal topology for two space time data sets, copy map objects
for given relation into map list.
- @param maplistA List of maps.
- @param maplistB List of maps.
- @param topolist List of strings of temporal relations.
- @param assign_val Boolean for assigning a boolean map value based on
+ :param maplistA: List of maps.
+ :param maplistB: List of maps.
+ :param topolist: List of strings of temporal relations.
+ :param assign_val: Boolean for assigning a boolean map value based on
the map_values from the compared map list by
topological relationships.
- @param count_map Boolean if the number of topological related maps
+ :param count_map: Boolean if the number of topological related maps
should be returned.
- @return List of maps from maplistA that fulfil the topological relationships
+ :return: List of maps from maplistA that fulfil the topological relationships
to maplistB specified in topolist.
- @code
+ .. code-block:: python
+ # Example with two lists of maps
+ >>> import grass.temporal as tgis
+ >>> tgis.init(True)
+ >>> l = tgis.TemporalAlgebraParser()
+ >>> # Create two list of maps with equal time stamps
+ >>> mapsA = []
+ >>> mapsB = []
+ >>> for i in range(10):
+ ... idA = "a%i at B"%(i)
+ ... mapA = tgis.RasterDataset(idA)
+ ... idB = "b%i at B"%(i)
+ ... mapB = tgis.RasterDataset(idB)
+ ... check = mapA.set_relative_time(i, i + 1, "months")
+ ... check = mapB.set_relative_time(i, i + 1, "months")
+ ... mapsA.append(mapA)
+ ... mapsB.append(mapB)
+ >>> resultlist = l.get_temporal_topo_list(mapsA, mapsB, ['EQUAL'])
+ >>> for map in resultlist:
+ ... if map.get_equal():
+ ... relations = map.get_equal()
+ ... print "Map %s has equal relation to map %s"%(map.get_name(),
+ ... relations[0].get_name())
+ Map a0 has equal relation to map b0
+ Map a1 has equal relation to map b1
+ Map a2 has equal relation to map b2
+ Map a3 has equal relation to map b3
+ Map a4 has equal relation to map b4
+ Map a5 has equal relation to map b5
+ Map a6 has equal relation to map b6
+ Map a7 has equal relation to map b7
+ Map a8 has equal relation to map b8
+ Map a9 has equal relation to map b9
+ >>> resultlist = l.get_temporal_topo_list(mapsA, mapsB, ['DURING'])
+ >>> print(resultlist)
+ []
+ >>> # Create two list of maps with equal time stamps
+ >>> mapsA = []
+ >>> mapsB = []
+ >>> for i in range(10):
+ ... idA = "a%i at B"%(i)
+ ... mapA = tgis.RasterDataset(idA)
+ ... idB = "b%i at B"%(i)
+ ... mapB = tgis.RasterDataset(idB)
+ ... check = mapA.set_relative_time(i, i + 1, "months")
+ ... check = mapB.set_relative_time(i, i + 2, "months")
+ ... mapsA.append(mapA)
+ ... mapsB.append(mapB)
+ >>> resultlist = l.get_temporal_topo_list(mapsA, mapsB, ['starts','during'])
+ >>> for map in resultlist:
+ ... if map.get_starts():
+ ... relations = map.get_starts()
+ ... print "Map %s has start relation to map %s"%(map.get_name(),
+ ... relations[0].get_name())
+ Map a0 has start relation to map b0
+ Map a1 has start relation to map b1
+ Map a2 has start relation to map b2
+ Map a3 has start relation to map b3
+ Map a4 has start relation to map b4
+ Map a5 has start relation to map b5
+ Map a6 has start relation to map b6
+ Map a7 has start relation to map b7
+ Map a8 has start relation to map b8
+ Map a9 has start relation to map b9
+ >>> for map in resultlist:
+ ... if map.get_during():
+ ... relations = map.get_during()
+ ... print "Map %s has during relation to map %s"%(map.get_name(),
+ ... relations[0].get_name())
+ Map a0 has during relation to map b0
+ Map a1 has during relation to map b0
+ Map a2 has during relation to map b1
+ Map a3 has during relation to map b2
+ Map a4 has during relation to map b3
+ Map a5 has during relation to map b4
+ Map a6 has during relation to map b5
+ Map a7 has during relation to map b6
+ Map a8 has during relation to map b7
+ Map a9 has during relation to map b8
+ >>> # Create two list of maps with equal time stamps and map_value method.
+ >>> mapsA = []
+ >>> mapsB = []
+ >>> for i in range(10):
+ ... idA = "a%i at B"%(i)
+ ... mapA = tgis.RasterDataset(idA)
+ ... idB = "b%i at B"%(i)
+ ... mapB = tgis.RasterDataset(idB)
+ ... check = mapA.set_relative_time(i, i + 1, "months")
+ ... check = mapB.set_relative_time(i, i + 1, "months")
+ ... mapB.map_value = True
+ ... mapsA.append(mapA)
+ ... mapsB.append(mapB)
+ >>> # Create two list of maps with equal time stamps
+ >>> mapsA = []
+ >>> mapsB = []
+ >>> for i in range(10):
+ ... idA = "a%i at B"%(i)
+ ... mapA = tgis.RasterDataset(idA)
+ ... mapA.map_value = True
+ ... idB = "b%i at B"%(i)
+ ... mapB = tgis.RasterDataset(idB)
+ ... mapB.map_value = False
+ ... check = mapA.set_absolute_time(datetime(2000,1,i+1),
+ ... datetime(2000,1,i + 2))
+ ... check = mapB.set_absolute_time(datetime(2000,1,i+6),
+ ... datetime(2000,1,i + 7))
+ ... mapsA.append(mapA)
+ ... mapsB.append(mapB)
+ >>> resultlist = l.get_temporal_topo_list(mapsA, mapsB)
+ >>> for map in resultlist:
+ ... print(map.get_id())
+ a5 at B
+ a6 at B
+ a7 at B
+ a8 at B
+ a9 at B
+ >>> resultlist = l.get_temporal_topo_list(mapsA, mapsB, ['during'])
+ >>> for map in resultlist:
+ ... print(map.get_id())
- # Example with two lists of maps
- >>> import grass.temporal as tgis
- >>> tgis.init(True)
- >>> l = tgis.TemporalAlgebraParser()
- >>> # Create two list of maps with equal time stamps
- >>> mapsA = []
- >>> mapsB = []
- >>> for i in range(10):
- ... idA = "a%i at B"%(i)
- ... mapA = tgis.RasterDataset(idA)
- ... idB = "b%i at B"%(i)
- ... mapB = tgis.RasterDataset(idB)
- ... check = mapA.set_relative_time(i, i + 1, "months")
- ... check = mapB.set_relative_time(i, i + 1, "months")
- ... mapsA.append(mapA)
- ... mapsB.append(mapB)
- >>> resultlist = l.get_temporal_topo_list(mapsA, mapsB, ['EQUAL'])
- >>> for map in resultlist:
- ... if map.get_equal():
- ... relations = map.get_equal()
- ... print "Map %s has equal relation to map %s"%(map.get_name(),
- ... relations[0].get_name())
- Map a0 has equal relation to map b0
- Map a1 has equal relation to map b1
- Map a2 has equal relation to map b2
- Map a3 has equal relation to map b3
- Map a4 has equal relation to map b4
- Map a5 has equal relation to map b5
- Map a6 has equal relation to map b6
- Map a7 has equal relation to map b7
- Map a8 has equal relation to map b8
- Map a9 has equal relation to map b9
- >>> resultlist = l.get_temporal_topo_list(mapsA, mapsB, ['DURING'])
- >>> print(resultlist)
- []
- >>> # Create two list of maps with equal time stamps
- >>> mapsA = []
- >>> mapsB = []
- >>> for i in range(10):
- ... idA = "a%i at B"%(i)
- ... mapA = tgis.RasterDataset(idA)
- ... idB = "b%i at B"%(i)
- ... mapB = tgis.RasterDataset(idB)
- ... check = mapA.set_relative_time(i, i + 1, "months")
- ... check = mapB.set_relative_time(i, i + 2, "months")
- ... mapsA.append(mapA)
- ... mapsB.append(mapB)
- >>> resultlist = l.get_temporal_topo_list(mapsA, mapsB, ['starts','during'])
- >>> for map in resultlist:
- ... if map.get_starts():
- ... relations = map.get_starts()
- ... print "Map %s has start relation to map %s"%(map.get_name(),
- ... relations[0].get_name())
- Map a0 has start relation to map b0
- Map a1 has start relation to map b1
- Map a2 has start relation to map b2
- Map a3 has start relation to map b3
- Map a4 has start relation to map b4
- Map a5 has start relation to map b5
- Map a6 has start relation to map b6
- Map a7 has start relation to map b7
- Map a8 has start relation to map b8
- Map a9 has start relation to map b9
- >>> for map in resultlist:
- ... if map.get_during():
- ... relations = map.get_during()
- ... print "Map %s has during relation to map %s"%(map.get_name(),
- ... relations[0].get_name())
- Map a0 has during relation to map b0
- Map a1 has during relation to map b0
- Map a2 has during relation to map b1
- Map a3 has during relation to map b2
- Map a4 has during relation to map b3
- Map a5 has during relation to map b4
- Map a6 has during relation to map b5
- Map a7 has during relation to map b6
- Map a8 has during relation to map b7
- Map a9 has during relation to map b8
- >>> # Create two list of maps with equal time stamps and map_value method.
- >>> mapsA = []
- >>> mapsB = []
- >>> for i in range(10):
- ... idA = "a%i at B"%(i)
- ... mapA = tgis.RasterDataset(idA)
- ... idB = "b%i at B"%(i)
- ... mapB = tgis.RasterDataset(idB)
- ... check = mapA.set_relative_time(i, i + 1, "months")
- ... check = mapB.set_relative_time(i, i + 1, "months")
- ... mapB.map_value = True
- ... mapsA.append(mapA)
- ... mapsB.append(mapB)
- >>> # Create two list of maps with equal time stamps
- >>> mapsA = []
- >>> mapsB = []
- >>> for i in range(10):
- ... idA = "a%i at B"%(i)
- ... mapA = tgis.RasterDataset(idA)
- ... mapA.map_value = True
- ... idB = "b%i at B"%(i)
- ... mapB = tgis.RasterDataset(idB)
- ... mapB.map_value = False
- ... check = mapA.set_absolute_time(datetime(2000,1,i+1),
- ... datetime(2000,1,i + 2))
- ... check = mapB.set_absolute_time(datetime(2000,1,i+6),
- ... datetime(2000,1,i + 7))
- ... mapsA.append(mapA)
- ... mapsB.append(mapB)
- >>> resultlist = l.get_temporal_topo_list(mapsA, mapsB)
- >>> for map in resultlist:
- ... print(map.get_id())
- a5 at B
- a6 at B
- a7 at B
- a8 at B
- a9 at B
- >>> resultlist = l.get_temporal_topo_list(mapsA, mapsB, ['during'])
- >>> for map in resultlist:
- ... print(map.get_id())
-
- @endcode
"""
topologylist = ["EQUAL", "FOLLOWS", "PRECEDES", "OVERLAPS", "OVERLAPPED", \
"DURING", "STARTS", "FINISHES", "CONTAINS", "STARTED", \
@@ -1063,59 +1059,58 @@
return(resultlist)
def eval_toperator(self, operator):
- """!This function evaluates a string containing temporal operations.
+ """This function evaluates a string containing temporal operations.
- @param operator String of temporal operations, e.g. {equal|during,=!:}.
+ :param operator: String of temporal operations, e.g. {equal|during,=!:}.
- @return List of temporal relations (equal, during), the given function
+ :return: List of temporal relations (equal, during), the given function
(!:) and the interval/instances (=).
- @code
- >>> import grass.temporal as tgis
- >>> tgis.init()
- >>> p = tgis.TemporalAlgebraParser()
- >>> operator = "{equal,:}"
- >>> p.eval_toperator(operator)
- (['equal'], '=', ':')
- >>> operator = "{equal|during,:}"
- >>> p.eval_toperator(operator)
- (['equal', 'during'], '=', ':')
- >>> operator = "{equal,!:}"
- >>> p.eval_toperator(operator)
- (['equal'], '=', '!:')
- >>> operator = "{equal|during,!:}"
- >>> p.eval_toperator(operator)
- (['equal', 'during'], '=', '!:')
- >>> operator = "{equal|during,=!:}"
- >>> p.eval_toperator(operator)
- (['equal', 'during'], '=', '!:')
- >>> operator = "{equal|during|starts,#}"
- >>> p.eval_toperator(operator)
- (['equal', 'during', 'starts'], '=', '#')
- >>> operator = "{!:}"
- >>> p.eval_toperator(operator)
- (['equal'], '=', '!:')
- >>> operator = "{=:}"
- >>> p.eval_toperator(operator)
- (['equal'], '=', ':')
- >>> operator = "{#}"
- >>> p.eval_toperator(operator)
- (['equal'], '=', '#')
- >>> operator = "{equal|during}"
- >>> p.eval_toperator(operator)
- (['equal', 'during'], '=', '')
- >>> operator = "{equal}"
- >>> p.eval_toperator(operator)
- (['equal'], '=', '')
- >>> operator = "{equal,||}"
- >>> p.eval_toperator(operator)
- (['equal'], '=', '||')
- >>> operator = "{equal|during,&&}"
- >>> p.eval_toperator(operator)
- (['equal', 'during'], '=', '&&')
+ .. code-block:: python
+
+ >>> import grass.temporal as tgis
+ >>> tgis.init()
+ >>> p = tgis.TemporalAlgebraParser()
+ >>> operator = "{equal,:}"
+ >>> p.eval_toperator(operator)
+ (['equal'], '=', ':')
+ >>> operator = "{equal|during,:}"
+ >>> p.eval_toperator(operator)
+ (['equal', 'during'], '=', ':')
+ >>> operator = "{equal,!:}"
+ >>> p.eval_toperator(operator)
+ (['equal'], '=', '!:')
+ >>> operator = "{equal|during,!:}"
+ >>> p.eval_toperator(operator)
+ (['equal', 'during'], '=', '!:')
+ >>> operator = "{equal|during,=!:}"
+ >>> p.eval_toperator(operator)
+ (['equal', 'during'], '=', '!:')
+ >>> operator = "{equal|during|starts,#}"
+ >>> p.eval_toperator(operator)
+ (['equal', 'during', 'starts'], '=', '#')
+ >>> operator = "{!:}"
+ >>> p.eval_toperator(operator)
+ (['equal'], '=', '!:')
+ >>> operator = "{=:}"
+ >>> p.eval_toperator(operator)
+ (['equal'], '=', ':')
+ >>> operator = "{#}"
+ >>> p.eval_toperator(operator)
+ (['equal'], '=', '#')
+ >>> operator = "{equal|during}"
+ >>> p.eval_toperator(operator)
+ (['equal', 'during'], '=', '')
+ >>> operator = "{equal}"
+ >>> p.eval_toperator(operator)
+ (['equal'], '=', '')
+ >>> operator = "{equal,||}"
+ >>> p.eval_toperator(operator)
+ (['equal'], '=', '||')
+ >>> operator = "{equal|during,&&}"
+ >>> p.eval_toperator(operator)
+ (['equal', 'during'], '=', '&&')
- @endcode
-
"""
topologylist = ["EQUAL", "FOLLOWS", "PRECEDES", "OVERLAPS", "OVERLAPPED", \
"DURING", "STARTS", "FINISHES", "CONTAINS", "STARTED", \
@@ -1168,63 +1163,62 @@
def perform_temporal_selection(self, maplistA, maplistB, topolist = ["EQUAL"],
inverse = False, assign_val = False):
- """!This function performs temporal selection operation.
+ """This function performs temporal selection operation.
- @param maplistA List of maps representing the left side of a temporal
+ :param maplistA: List of maps representing the left side of a temporal
expression.
- @param maplistB List of maps representing the right side of a temporal
+ :param maplistB: List of maps representing the right side of a temporal
expression.
- @param topolist List of strings of temporal relations.
- @param inverse Boolean value that specifies if the selection should be
+ :param topolist: List of strings of temporal relations.
+ :param inverse: Boolean value that specifies if the selection should be
inverted.
- @param assign_val Boolean for assigning a boolean map value based on
+ :param assign_val: Boolean for assigning a boolean map value based on
the map_values from the compared map list by
topological relationships.
- @return List of selected maps from maplistA.
+ :return: List of selected maps from maplistA.
- @code
+ .. code-block:: python
>>> import grass.temporal as tgis
- >>> tgis.init()
- >>> l = tgis.TemporalAlgebraParser()
- >>> # Example with two lists of maps
- >>> # Create two list of maps with equal time stamps
- >>> mapsA = []
- >>> mapsB = []
- >>> for i in range(10):
- ... idA = "a%i at B"%(i)
- ... mapA = tgis.RasterDataset(idA)
- ... idB = "b%i at B"%(i)
- ... mapB = tgis.RasterDataset(idB)
- ... check = mapA.set_relative_time(i, i + 1, "months")
- ... check = mapB.set_relative_time(i + 5, i + 6, "months")
- ... mapsA.append(mapA)
- ... mapsB.append(mapB)
- >>> resultlist = l.perform_temporal_selection(mapsA, mapsB, ['EQUAL'],
- ... False)
- >>> for map in resultlist:
- ... if map.get_equal():
- ... relations = map.get_equal()
- ... print "Map %s has equal relation to map %s"%(map.get_name(),
- ... relations[0].get_name())
- Map a5 has equal relation to map b0
- Map a6 has equal relation to map b1
- Map a7 has equal relation to map b2
- Map a8 has equal relation to map b3
- Map a9 has equal relation to map b4
- >>> resultlist = l.perform_temporal_selection(mapsA, mapsB, ['EQUAL'],
- ... True)
- >>> for map in resultlist:
- ... if not map.get_equal():
- ... print "Map %s has no equal relation to mapset mapsB"%(map.get_name())
- Map a0 has no equal relation to mapset mapsB
- Map a1 has no equal relation to mapset mapsB
- Map a2 has no equal relation to mapset mapsB
- Map a3 has no equal relation to mapset mapsB
- Map a4 has no equal relation to mapset mapsB
+ >>> tgis.init()
+ >>> l = tgis.TemporalAlgebraParser()
+ >>> # Example with two lists of maps
+ >>> # Create two list of maps with equal time stamps
+ >>> mapsA = []
+ >>> mapsB = []
+ >>> for i in range(10):
+ ... idA = "a%i at B"%(i)
+ ... mapA = tgis.RasterDataset(idA)
+ ... idB = "b%i at B"%(i)
+ ... mapB = tgis.RasterDataset(idB)
+ ... check = mapA.set_relative_time(i, i + 1, "months")
+ ... check = mapB.set_relative_time(i + 5, i + 6, "months")
+ ... mapsA.append(mapA)
+ ... mapsB.append(mapB)
+ >>> resultlist = l.perform_temporal_selection(mapsA, mapsB, ['EQUAL'],
+ ... False)
+ >>> for map in resultlist:
+ ... if map.get_equal():
+ ... relations = map.get_equal()
+ ... print "Map %s has equal relation to map %s"%(map.get_name(),
+ ... relations[0].get_name())
+ Map a5 has equal relation to map b0
+ Map a6 has equal relation to map b1
+ Map a7 has equal relation to map b2
+ Map a8 has equal relation to map b3
+ Map a9 has equal relation to map b4
+ >>> resultlist = l.perform_temporal_selection(mapsA, mapsB, ['EQUAL'],
+ ... True)
+ >>> for map in resultlist:
+ ... if not map.get_equal():
+ ... print "Map %s has no equal relation to mapset mapsB"%(map.get_name())
+ Map a0 has no equal relation to mapset mapsB
+ Map a1 has no equal relation to mapset mapsB
+ Map a2 has no equal relation to mapset mapsB
+ Map a3 has no equal relation to mapset mapsB
+ Map a4 has no equal relation to mapset mapsB
- @endcode
"""
if not inverse:
topolist = self.get_temporal_topo_list(maplistA, maplistB, topolist,
@@ -1249,48 +1243,48 @@
return(resultlist)
def set_granularity(self, maplistA, maplistB, toperator = '=', topolist = ["EQUAL"]):
- """!This function sets the temporal extends of a list of maps based on
- another map list.
+ """This function sets the temporal extends of a list of maps based on
+ another map list.
- @param maplistB List of maps.
- @param maplistB List of maps.
- @param toperator String containing the temporal operator: =, +, &, |.
- @param topolist List of topological relations.
+ :param maplistB: List of maps.
+ :param maplistB: List of maps.
+ :param toperator: String containing the temporal operator: =, +, &, |.
+ :param topolist: List of topological relations.
- @return List of maps with the new temporal extends.
+ :return: List of maps with the new temporal extends.
- @code
- >>> import grass.temporal as tgis
- >>> tgis.init()
- >>> p = tgis.TemporalAlgebraParser()
- >>> # Create two list of maps with equal time stamps
- >>> mapsA = []
- >>> mapsB = []
- >>> for i in range(10):
- ... idA = "a%i at B"%(i)
- ... mapA = tgis.RasterDataset(idA)
- ... idB = "b%i at B"%(i)
- ... mapB = tgis.RasterDataset(idB)
- ... check = mapA.set_relative_time(i, i + 1, "months")
- ... check = mapB.set_relative_time(i*2, i*2 + 2, "months")
- ... mapsA.append(mapA)
- ... mapsB.append(mapB)
- >>> resultlist = p.set_granularity(mapsA, mapsB, toperator = "|", topolist = ["during"])
- >>> for map in resultlist:
- ... start,end,unit = map.get_relative_time()
- ... print(map.get_id() + ' - start: ' + str(start) + ' end: ' + str(end))
- a1 at B - start: 0 end: 2
- a0 at B - start: 0 end: 2
- a3 at B - start: 2 end: 4
- a2 at B - start: 2 end: 4
- a5 at B - start: 4 end: 6
- a4 at B - start: 4 end: 6
- a7 at B - start: 6 end: 8
- a6 at B - start: 6 end: 8
- a9 at B - start: 8 end: 10
- a8 at B - start: 8 end: 10
+ .. code-block:: python
+
+ >>> import grass.temporal as tgis
+ >>> tgis.init()
+ >>> p = tgis.TemporalAlgebraParser()
+ >>> # Create two list of maps with equal time stamps
+ >>> mapsA = []
+ >>> mapsB = []
+ >>> for i in range(10):
+ ... idA = "a%i at B"%(i)
+ ... mapA = tgis.RasterDataset(idA)
+ ... idB = "b%i at B"%(i)
+ ... mapB = tgis.RasterDataset(idB)
+ ... check = mapA.set_relative_time(i, i + 1, "months")
+ ... check = mapB.set_relative_time(i*2, i*2 + 2, "months")
+ ... mapsA.append(mapA)
+ ... mapsB.append(mapB)
+ >>> resultlist = p.set_granularity(mapsA, mapsB, toperator = "|", topolist = ["during"])
+ >>> for map in resultlist:
+ ... start,end,unit = map.get_relative_time()
+ ... print(map.get_id() + ' - start: ' + str(start) + ' end: ' + str(end))
+ a1 at B - start: 0 end: 2
+ a0 at B - start: 0 end: 2
+ a3 at B - start: 2 end: 4
+ a2 at B - start: 2 end: 4
+ a5 at B - start: 4 end: 6
+ a4 at B - start: 4 end: 6
+ a7 at B - start: 6 end: 8
+ a6 at B - start: 6 end: 8
+ a9 at B - start: 8 end: 10
+ a8 at B - start: 8 end: 10
- @endcode
"""
topologylist = ["EQUAL", "FOLLOWS", "PRECEDES", "OVERLAPS", "OVERLAPPED", \
"DURING", "STARTS", "FINISHES", "CONTAINS", "STARTED", \
@@ -1350,36 +1344,36 @@
return(resultlist)
def get_temporal_func_dict(self, map):
- """! This function creates a dictionary containing temporal functions for a
- map dataset with time stamp.
+ """ This function creates a dictionary containing temporal functions for a
+ map dataset with time stamp.
- @param map Map object with time stamps.
+ :param map: Map object with time stamps.
- @return Dictionary with temporal functions for given input map.
+ :return: Dictionary with temporal functions for given input map.
- @code
- >>> import grass.temporal as tgis
- >>> import datetime
- >>> tgis.init()
- >>> l = tgis.TemporalAlgebraParser()
- >>> # Example with one list of maps
- >>> # Create one list of maps with equal time stamps
- >>> for i in range(1):
- ... idA = "a%i at B"%(i)
- ... mapA = tgis.RasterDataset(idA)
- ... check = mapA.set_absolute_time(datetime.datetime(2000,1,1),
- ... datetime.datetime(2000,10,1))
- ... tfuncdict = l.get_temporal_func_dict(mapA)
- >>> print(tfuncdict["START_YEAR"])
- 2000
- >>> print(tfuncdict["START_TIME"])
- 00:00:00
- >>> print(tfuncdict["START_DATE"])
- 2000-01-01
- >>> print(tfuncdict["START_DATETIME"])
- 2000-01-01 00:00:00
+ .. code-block:: python
+
+ >>> import grass.temporal as tgis
+ >>> import datetime
+ >>> tgis.init()
+ >>> l = tgis.TemporalAlgebraParser()
+ >>> # Example with one list of maps
+ >>> # Create one list of maps with equal time stamps
+ >>> for i in range(1):
+ ... idA = "a%i at B"%(i)
+ ... mapA = tgis.RasterDataset(idA)
+ ... check = mapA.set_absolute_time(datetime.datetime(2000,1,1),
+ ... datetime.datetime(2000,10,1))
+ ... tfuncdict = l.get_temporal_func_dict(mapA)
+ >>> print(tfuncdict["START_YEAR"])
+ 2000
+ >>> print(tfuncdict["START_TIME"])
+ 00:00:00
+ >>> print(tfuncdict["START_DATE"])
+ 2000-01-01
+ >>> print(tfuncdict["START_DATETIME"])
+ 2000-01-01 00:00:00
- @endcode
"""
tvardict = {"START_DOY" : None, "START_DOW" : None, "START_YEAR" : None,
@@ -1455,13 +1449,13 @@
return(boolname)
def eval_global_var(self, gvar, maplist):
- """! This function evaluates a global variable expression for a map list.
+ """ This function evaluates a global variable expression for a map list.
For example: start_day() > 5 , end_month() == 2.
- @param gvar Object of type GlobalTemporalVar containing temporal.
- @param maplist List of map objects.
+ :param gvar: Object of type GlobalTemporalVar containing temporal.
+ :param maplist: List of map objects.
- @return List of maps from maplist with added conditional boolean values.
+ :return: List of maps from maplist with added conditional boolean values.
"""
boollist = []
# Loop over maps of input map list.
@@ -1500,15 +1494,15 @@
return(maplist)
def eval_map_list(self, maplist ,thenlist, topolist = ["EQUAL"]):
- """! This function transfers boolean values from temporal expression
- from one map list to another by their topology. These boolean
- values are added to the maps as condition_value.
+ """ This function transfers boolean values from temporal expression
+ from one map list to another by their topology. These boolean
+ values are added to the maps as condition_value.
- @param maplist List of map objects containing boolean map values.
- @param thenlist List of map objects where the boolean values
- should be added.
+ :param maplist: List of map objects containing boolean map values.
+ :param thenlist: List of map objects where the boolean values
+ should be added.
- @return List of maps from thenlist with added conditional boolean values.
+ :return: List of maps from thenlist with added conditional boolean values.
"""
# Get topology of then statement map list in relation to the other maplist
# and assign boolean values of the maplist to the thenlist.
@@ -1526,7 +1520,7 @@
return(resultlist)
def build_condition_list(self, tvarexpr, thenlist, topolist = ["EQUAL"]):
- """! This function evaluates temporal variable expressions of a conditional
+ """ This function evaluates temporal variable expressions of a conditional
expression related to the map list of the then statement.
Global variables or map lists with booleans are compared to the topology
of the conclusion map list and a conditional list will be appended to
@@ -1537,78 +1531,78 @@
For example: td(A) == 1 && start_day() > 5 --> [True || False]
(for one map.condition_value in a then map list)
- @param tvarexpr List of GlobalTemporalVar objects and map lists.
+ :param tvarexpr: List of GlobalTemporalVar objects and map lists.
The list is constructed by the TemporalAlgebraParser
in order of expression evaluation in the parser.
- @param thenlist Map list object of the conclusion statement.
+ :param thenlist: Map list object of the conclusion statement.
It will be compared and evaluated by the conditions.
- @return Map list with conditional values for all temporal expressions.
+ :return: Map list with conditional values for all temporal expressions.
- @code
- >>> import grass.temporal as tgis
- >>> tgis.init()
- >>> p = tgis.TemporalAlgebraParser()
- >>> # Example with two lists of maps
- >>> # Create two list of maps with equal time stamps
- >>> mapsA = []
- >>> mapsB = []
- >>> for i in range(10):
- ... idA = "a%i at B"%(i)
- ... mapA = tgis.RasterDataset(idA)
- ... idB = "b%i at B"%(i)
- ... mapB = tgis.RasterDataset(idB)
- ... check = mapA.set_absolute_time(datetime(2000,1,i + 1),
- ... datetime(2000,1,i + 2))
- ... check = mapB.set_absolute_time(datetime(2000,1,i + 6),
- ... datetime(2000,1,i + 7))
- ... mapsA.append(mapA)
- ... mapsB.append(mapB)
- >>> mapsA = p.check_stds(mapsA)
- >>> mapsB = p.check_stds(mapsB)
- >>> # Create global expression object.
- >>> gvarA = tgis.GlobalTemporalVar()
- >>> gvarA.tfunc = "start_day"
- >>> gvarA.compop = ">"
- >>> gvarA.value = 5
- >>> gvarB = tgis.GlobalTemporalVar()
- >>> gvarB.tfunc = "start_day"
- >>> gvarB.compop = "<="
- >>> gvarB.value = 8
- >>> gvarOP = tgis.GlobalTemporalVar()
- >>> gvarOP.relationop = "&&"
- >>> gvarOP.topology.append("EQUAL")
- >>> tvarexpr = gvarA
- >>> result = p.build_condition_list(tvarexpr, mapsA)
- >>> for map_i in result:
- ... print(map_i.get_map_id() + ' ' + str(map_i.condition_value))
- a0 at B [False]
- a1 at B [False]
- a2 at B [False]
- a3 at B [False]
- a4 at B [False]
- a5 at B [True]
- a6 at B [True]
- a7 at B [True]
- a8 at B [True]
- a9 at B [True]
- >>> tvarexpr = [gvarA, gvarOP, gvarB]
- >>> result = p.build_condition_list(tvarexpr, mapsB)
- >>> for map_i in result:
- ... print(map_i.get_map_id() + ' ' + str(map_i.condition_value))
- b0 at B [True, ['EQUAL'], '&&', True]
- b1 at B [True, ['EQUAL'], '&&', True]
- b2 at B [True, ['EQUAL'], '&&', True]
- b3 at B [True, ['EQUAL'], '&&', False]
- b4 at B [True, ['EQUAL'], '&&', False]
- b5 at B [True, ['EQUAL'], '&&', False]
- b6 at B [True, ['EQUAL'], '&&', False]
- b7 at B [True, ['EQUAL'], '&&', False]
- b8 at B [True, ['EQUAL'], '&&', False]
- b9 at B [True, ['EQUAL'], '&&', False]
+ .. code-block:: python
- @endcode
+ >>> import grass.temporal as tgis
+ >>> tgis.init()
+ >>> p = tgis.TemporalAlgebraParser()
+ >>> # Example with two lists of maps
+ >>> # Create two list of maps with equal time stamps
+ >>> mapsA = []
+ >>> mapsB = []
+ >>> for i in range(10):
+ ... idA = "a%i at B"%(i)
+ ... mapA = tgis.RasterDataset(idA)
+ ... idB = "b%i at B"%(i)
+ ... mapB = tgis.RasterDataset(idB)
+ ... check = mapA.set_absolute_time(datetime(2000,1,i + 1),
+ ... datetime(2000,1,i + 2))
+ ... check = mapB.set_absolute_time(datetime(2000,1,i + 6),
+ ... datetime(2000,1,i + 7))
+ ... mapsA.append(mapA)
+ ... mapsB.append(mapB)
+ >>> mapsA = p.check_stds(mapsA)
+ >>> mapsB = p.check_stds(mapsB)
+ >>> # Create global expression object.
+ >>> gvarA = tgis.GlobalTemporalVar()
+ >>> gvarA.tfunc = "start_day"
+ >>> gvarA.compop = ">"
+ >>> gvarA.value = 5
+ >>> gvarB = tgis.GlobalTemporalVar()
+ >>> gvarB.tfunc = "start_day"
+ >>> gvarB.compop = "<="
+ >>> gvarB.value = 8
+ >>> gvarOP = tgis.GlobalTemporalVar()
+ >>> gvarOP.relationop = "&&"
+ >>> gvarOP.topology.append("EQUAL")
+ >>> tvarexpr = gvarA
+ >>> result = p.build_condition_list(tvarexpr, mapsA)
+ >>> for map_i in result:
+ ... print(map_i.get_map_id() + ' ' + str(map_i.condition_value))
+ a0 at B [False]
+ a1 at B [False]
+ a2 at B [False]
+ a3 at B [False]
+ a4 at B [False]
+ a5 at B [True]
+ a6 at B [True]
+ a7 at B [True]
+ a8 at B [True]
+ a9 at B [True]
+ >>> tvarexpr = [gvarA, gvarOP, gvarB]
+ >>> result = p.build_condition_list(tvarexpr, mapsB)
+ >>> for map_i in result:
+ ... print(map_i.get_map_id() + ' ' + str(map_i.condition_value))
+ b0 at B [True, ['EQUAL'], '&&', True]
+ b1 at B [True, ['EQUAL'], '&&', True]
+ b2 at B [True, ['EQUAL'], '&&', True]
+ b3 at B [True, ['EQUAL'], '&&', False]
+ b4 at B [True, ['EQUAL'], '&&', False]
+ b5 at B [True, ['EQUAL'], '&&', False]
+ b6 at B [True, ['EQUAL'], '&&', False]
+ b7 at B [True, ['EQUAL'], '&&', False]
+ b8 at B [True, ['EQUAL'], '&&', False]
+ b9 at B [True, ['EQUAL'], '&&', False]
+
"""
# Check if the input expression is a valid single global variable.
@@ -1649,9 +1643,9 @@
return(resultlist)
def eval_condition_list(self, maplist, inverse = False):
- """! This function evaluates conditional values of a map list.
- A recursive function is used to evaluate comparison statements
- from left to right in the given conditional list.
+ """ This function evaluates conditional values of a map list.
+ A recursive function is used to evaluate comparison statements
+ from left to right in the given conditional list.
For example: [True, '||', False, '&&', True] -> True
[True, '||', False, '&&', False] -> False
@@ -1663,48 +1657,48 @@
[True, '&&', False] -> False
[False, '||', True] -> True
- @param tvarexpr List of GlobalTemporalVar objects and map lists.
+ :param tvarexpr: List of GlobalTemporalVar objects and map lists.
The list is constructed by the TemporalAlgebraParser
in order of expression evaluation in the parser.
- @return Map list with conditional values for all temporal expressions.
+ :return: Map list with conditional values for all temporal expressions.
- @code
- >>> import grass.temporal as tgis
- >>> tgis.init()
- >>> p = tgis.TemporalAlgebraParser()
- >>> # Example with two lists of maps
- >>> # Create two list of maps with equal time stamps
- >>> mapsA = []
- >>> mapsB = []
- >>> for i in range(10):
- ... idA = "a%i at B"%(i)
- ... mapA = tgis.RasterDataset(idA)
- ... idB = "b%i at B"%(i)
- ... mapB = tgis.RasterDataset(idB)
- ... check = mapA.set_absolute_time(datetime(2000,1,i + 1),
- ... datetime(2000,1,i + 2))
- ... check = mapB.set_absolute_time(datetime(2000,1,i + 6),
- ... datetime(2000,1,i + 7))
- ... mapsA.append(mapA)
- ... mapsB.append(mapB)
- >>> mapsA = p.check_stds(mapsA)
- >>> mapsB = p.check_stds(mapsB)
- >>> # Create global expression object.
- >>> gvarA = tgis.GlobalTemporalVar()
- >>> gvarA.tfunc = "start_day"
- >>> gvarA.compop = ">"
- >>> gvarA.value = 5
- >>> gvarB = tgis.GlobalTemporalVar()
- >>> gvarB.tfunc = "start_day"
- >>> gvarB.compop = "<="
- >>> gvarB.value = 8
- >>> gvarOP = tgis.GlobalTemporalVar()
- >>> gvarOP.relationop = "&&"
- >>> gvarOP.topology.append("EQUAL")
- >>> tvarexpr = [mapsA, gvarOP,gvarA]
+ .. code-block:: python
+
+ >>> import grass.temporal as tgis
+ >>> tgis.init()
+ >>> p = tgis.TemporalAlgebraParser()
+ >>> # Example with two lists of maps
+ >>> # Create two list of maps with equal time stamps
+ >>> mapsA = []
+ >>> mapsB = []
+ >>> for i in range(10):
+ ... idA = "a%i at B"%(i)
+ ... mapA = tgis.RasterDataset(idA)
+ ... idB = "b%i at B"%(i)
+ ... mapB = tgis.RasterDataset(idB)
+ ... check = mapA.set_absolute_time(datetime(2000,1,i + 1),
+ ... datetime(2000,1,i + 2))
+ ... check = mapB.set_absolute_time(datetime(2000,1,i + 6),
+ ... datetime(2000,1,i + 7))
+ ... mapsA.append(mapA)
+ ... mapsB.append(mapB)
+ >>> mapsA = p.check_stds(mapsA)
+ >>> mapsB = p.check_stds(mapsB)
+ >>> # Create global expression object.
+ >>> gvarA = tgis.GlobalTemporalVar()
+ >>> gvarA.tfunc = "start_day"
+ >>> gvarA.compop = ">"
+ >>> gvarA.value = 5
+ >>> gvarB = tgis.GlobalTemporalVar()
+ >>> gvarB.tfunc = "start_day"
+ >>> gvarB.compop = "<="
+ >>> gvarB.value = 8
+ >>> gvarOP = tgis.GlobalTemporalVar()
+ >>> gvarOP.relationop = "&&"
+ >>> gvarOP.topology.append("EQUAL")
+ >>> tvarexpr = [mapsA, gvarOP,gvarA]
- @endcode
"""
def recurse_compare(conditionlist):
for ele in conditionlist:
Modified: grass/trunk/lib/python/temporal/temporal_extent.py
===================================================================
--- grass/trunk/lib/python/temporal/temporal_extent.py 2014-09-28 01:40:32 UTC (rev 62120)
+++ grass/trunk/lib/python/temporal/temporal_extent.py 2014-09-28 01:46:15 UTC (rev 62121)
@@ -1,34 +1,30 @@
-"""!@package grass.temporal
+"""
+Temporal extent classes
- at brief GRASS Python scripting module (temporal GIS functions)
-
-Temporal GIS related temporal extent functions to be used in Python scripts and tgis packages.
-
Usage:
- at code
+.. code-block:: python
->>> import grass.temporal as tgis
->>> from datetime import datetime
->>> tgis.init()
->>> t = tgis.RasterRelativeTime()
->>> t = tgis.RasterAbsoluteTime()
+ >>> import grass.temporal as tgis
+ >>> from datetime import datetime
+ >>> tgis.init()
+ >>> t = tgis.RasterRelativeTime()
+ >>> t = tgis.RasterAbsoluteTime()
- at endcode
(C) 2012-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.
- at author Soeren Gebbert
+:authors: Soeren Gebbert
"""
from base import *
###############################################################################
class TemporalExtent(SQLDatabaseInterface):
- """!This is the abstract time base class for relative and absolute time objects
+ """This is the abstract time base class for relative and absolute time objects
It abstract class implements the interface to absolute and relative time.
Absolute time is represented by datetime time stamps,
@@ -39,41 +35,40 @@
Usage:
- @code
+ .. code-block:: python
- >>> init()
- >>> A = TemporalExtent(table="raster_absolute_time",
- ... ident="soil at PERMANENT", start_time=datetime(2001, 01, 01),
- ... end_time=datetime(2005,01,01) )
- >>> A.id
- 'soil at PERMANENT'
- >>> A.start_time
- datetime.datetime(2001, 1, 1, 0, 0)
- >>> A.end_time
- datetime.datetime(2005, 1, 1, 0, 0)
- >>> A.print_info()
- | Start time:................. 2001-01-01 00:00:00
- | End time:................... 2005-01-01 00:00:00
- >>> A.print_shell_info()
- start_time=2001-01-01 00:00:00
- end_time=2005-01-01 00:00:00
- >>> # relative time
- >>> A = TemporalExtent(table="raster_absolute_time",
- ... ident="soil at PERMANENT", start_time=0, end_time=1 )
- >>> A.id
- 'soil at PERMANENT'
- >>> A.start_time
- 0
- >>> A.end_time
- 1
- >>> A.print_info()
- | Start time:................. 0
- | End time:................... 1
- >>> A.print_shell_info()
- start_time=0
- end_time=1
+ >>> init()
+ >>> A = TemporalExtent(table="raster_absolute_time",
+ ... ident="soil at PERMANENT", start_time=datetime(2001, 01, 01),
+ ... end_time=datetime(2005,01,01) )
+ >>> A.id
+ 'soil at PERMANENT'
+ >>> A.start_time
+ datetime.datetime(2001, 1, 1, 0, 0)
+ >>> A.end_time
+ datetime.datetime(2005, 1, 1, 0, 0)
+ >>> A.print_info()
+ | Start time:................. 2001-01-01 00:00:00
+ | End time:................... 2005-01-01 00:00:00
+ >>> A.print_shell_info()
+ start_time=2001-01-01 00:00:00
+ end_time=2005-01-01 00:00:00
+ >>> # relative time
+ >>> A = TemporalExtent(table="raster_absolute_time",
+ ... ident="soil at PERMANENT", start_time=0, end_time=1 )
+ >>> A.id
+ 'soil at PERMANENT'
+ >>> A.start_time
+ 0
+ >>> A.end_time
+ 1
+ >>> A.print_info()
+ | Start time:................. 0
+ | End time:................... 1
+ >>> A.print_shell_info()
+ start_time=0
+ end_time=1
- @endcode
"""
def __init__(self, table=None, ident=None, start_time=None, end_time=None):
@@ -84,91 +79,90 @@
self.set_end_time(end_time)
def intersect(self, extent):
- """!Intersect this temporal extent with the provided temporal extent and
+ """Intersect this temporal extent with the provided temporal extent and
return a new temporal extent with the new start and end time
- @param extent The temporal extent to intersect with
- @return The new temporal extent with start and end time,
+ :param extent: The temporal extent to intersect with
+ :return: The new temporal extent with start and end time,
or None in case of no intersection
Usage:
- @code
+ .. code-block:: python
- >>> A = TemporalExtent(start_time=5, end_time=6 )
- >>> inter = A.intersect(A)
- >>> inter.print_info()
- | Start time:................. 5
- | End time:................... 6
+ >>> A = TemporalExtent(start_time=5, end_time=6 )
+ >>> inter = A.intersect(A)
+ >>> inter.print_info()
+ | Start time:................. 5
+ | End time:................... 6
- >>> A = TemporalExtent(start_time=5, end_time=6 )
- >>> B = TemporalExtent(start_time=5, end_time=7 )
- >>> inter = A.intersect(B)
- >>> inter.print_info()
- | Start time:................. 5
- | End time:................... 6
- >>> inter = B.intersect(A)
- >>> inter.print_info()
- | Start time:................. 5
- | End time:................... 6
+ >>> A = TemporalExtent(start_time=5, end_time=6 )
+ >>> B = TemporalExtent(start_time=5, end_time=7 )
+ >>> inter = A.intersect(B)
+ >>> inter.print_info()
+ | Start time:................. 5
+ | End time:................... 6
+ >>> inter = B.intersect(A)
+ >>> inter.print_info()
+ | Start time:................. 5
+ | End time:................... 6
- >>> A = TemporalExtent(start_time=3, end_time=6 )
- >>> B = TemporalExtent(start_time=5, end_time=7 )
- >>> inter = A.intersect(B)
- >>> inter.print_info()
- | Start time:................. 5
- | End time:................... 6
- >>> inter = B.intersect(A)
- >>> inter.print_info()
- | Start time:................. 5
- | End time:................... 6
+ >>> A = TemporalExtent(start_time=3, end_time=6 )
+ >>> B = TemporalExtent(start_time=5, end_time=7 )
+ >>> inter = A.intersect(B)
+ >>> inter.print_info()
+ | Start time:................. 5
+ | End time:................... 6
+ >>> inter = B.intersect(A)
+ >>> inter.print_info()
+ | Start time:................. 5
+ | End time:................... 6
- >>> A = TemporalExtent(start_time=3, end_time=8 )
- >>> B = TemporalExtent(start_time=5, end_time=6 )
- >>> inter = A.intersect(B)
- >>> inter.print_info()
- | Start time:................. 5
- | End time:................... 6
- >>> inter = B.intersect(A)
- >>> inter.print_info()
- | Start time:................. 5
- | End time:................... 6
+ >>> A = TemporalExtent(start_time=3, end_time=8 )
+ >>> B = TemporalExtent(start_time=5, end_time=6 )
+ >>> inter = A.intersect(B)
+ >>> inter.print_info()
+ | Start time:................. 5
+ | End time:................... 6
+ >>> inter = B.intersect(A)
+ >>> inter.print_info()
+ | Start time:................. 5
+ | End time:................... 6
- >>> A = TemporalExtent(start_time=5, end_time=8 )
- >>> B = TemporalExtent(start_time=3, end_time=6 )
- >>> inter = A.intersect(B)
- >>> inter.print_info()
- | Start time:................. 5
- | End time:................... 6
- >>> inter = B.intersect(A)
- >>> inter.print_info()
- | Start time:................. 5
- | End time:................... 6
+ >>> A = TemporalExtent(start_time=5, end_time=8 )
+ >>> B = TemporalExtent(start_time=3, end_time=6 )
+ >>> inter = A.intersect(B)
+ >>> inter.print_info()
+ | Start time:................. 5
+ | End time:................... 6
+ >>> inter = B.intersect(A)
+ >>> inter.print_info()
+ | Start time:................. 5
+ | End time:................... 6
- >>> A = TemporalExtent(start_time=5, end_time=None )
- >>> B = TemporalExtent(start_time=3, end_time=6 )
- >>> inter = A.intersect(B)
- >>> inter.print_info()
- | Start time:................. 5
- | End time:................... None
- >>> inter = B.intersect(A)
- >>> inter.print_info()
- | Start time:................. 5
- | End time:................... None
+ >>> A = TemporalExtent(start_time=5, end_time=None )
+ >>> B = TemporalExtent(start_time=3, end_time=6 )
+ >>> inter = A.intersect(B)
+ >>> inter.print_info()
+ | Start time:................. 5
+ | End time:................... None
+ >>> inter = B.intersect(A)
+ >>> inter.print_info()
+ | Start time:................. 5
+ | End time:................... None
- >>> A = TemporalExtent(start_time=5, end_time=8 )
- >>> B = TemporalExtent(start_time=3, end_time=4 )
- >>> inter = A.intersect(B)
- >>> print inter
- None
+ >>> A = TemporalExtent(start_time=5, end_time=8 )
+ >>> B = TemporalExtent(start_time=3, end_time=4 )
+ >>> inter = A.intersect(B)
+ >>> print inter
+ None
- >>> A = TemporalExtent(start_time=5, end_time=8 )
- >>> B = TemporalExtent(start_time=3, end_time=None )
- >>> inter = A.intersect(B)
- >>> print inter
- None
+ >>> A = TemporalExtent(start_time=5, end_time=8 )
+ >>> B = TemporalExtent(start_time=3, end_time=None )
+ >>> inter = A.intersect(B)
+ >>> print inter
+ None
- @endcode
"""
relation = self.temporal_relation(extent)
@@ -203,151 +197,150 @@
return TemporalExtent(start_time=start, end_time=end)
def disjoint_union(self, extent):
- """!Creates a disjoint union with this temporal extent and the provided one.
+ """Creates a disjoint union with this temporal extent and the provided one.
Return a new temporal extent with the new start and end time.
- @param extent The temporal extent to create a union with
- @return The new temporal extent with start and end time
+ :param extent: The temporal extent to create a union with
+ :return: The new temporal extent with start and end time
Usage:
- @code
+ .. code-block:: python
- >>> A = TemporalExtent(start_time=5, end_time=6 )
- >>> inter = A.intersect(A)
- >>> inter.print_info()
- | Start time:................. 5
- | End time:................... 6
+ >>> A = TemporalExtent(start_time=5, end_time=6 )
+ >>> inter = A.intersect(A)
+ >>> inter.print_info()
+ | Start time:................. 5
+ | End time:................... 6
- >>> A = TemporalExtent(start_time=5, end_time=6 )
- >>> B = TemporalExtent(start_time=5, end_time=7 )
- >>> inter = A.disjoint_union(B)
- >>> inter.print_info()
- | Start time:................. 5
- | End time:................... 7
- >>> inter = B.disjoint_union(A)
- >>> inter.print_info()
- | Start time:................. 5
- | End time:................... 7
+ >>> A = TemporalExtent(start_time=5, end_time=6 )
+ >>> B = TemporalExtent(start_time=5, end_time=7 )
+ >>> inter = A.disjoint_union(B)
+ >>> inter.print_info()
+ | Start time:................. 5
+ | End time:................... 7
+ >>> inter = B.disjoint_union(A)
+ >>> inter.print_info()
+ | Start time:................. 5
+ | End time:................... 7
- >>> A = TemporalExtent(start_time=3, end_time=6 )
- >>> B = TemporalExtent(start_time=5, end_time=7 )
- >>> inter = A.disjoint_union(B)
- >>> inter.print_info()
- | Start time:................. 3
- | End time:................... 7
- >>> inter = B.disjoint_union(A)
- >>> inter.print_info()
- | Start time:................. 3
- | End time:................... 7
+ >>> A = TemporalExtent(start_time=3, end_time=6 )
+ >>> B = TemporalExtent(start_time=5, end_time=7 )
+ >>> inter = A.disjoint_union(B)
+ >>> inter.print_info()
+ | Start time:................. 3
+ | End time:................... 7
+ >>> inter = B.disjoint_union(A)
+ >>> inter.print_info()
+ | Start time:................. 3
+ | End time:................... 7
- >>> A = TemporalExtent(start_time=3, end_time=8 )
- >>> B = TemporalExtent(start_time=5, end_time=6 )
- >>> inter = A.disjoint_union(B)
- >>> inter.print_info()
- | Start time:................. 3
- | End time:................... 8
- >>> inter = B.disjoint_union(A)
- >>> inter.print_info()
- | Start time:................. 3
- | End time:................... 8
+ >>> A = TemporalExtent(start_time=3, end_time=8 )
+ >>> B = TemporalExtent(start_time=5, end_time=6 )
+ >>> inter = A.disjoint_union(B)
+ >>> inter.print_info()
+ | Start time:................. 3
+ | End time:................... 8
+ >>> inter = B.disjoint_union(A)
+ >>> inter.print_info()
+ | Start time:................. 3
+ | End time:................... 8
- >>> A = TemporalExtent(start_time=5, end_time=8 )
- >>> B = TemporalExtent(start_time=3, end_time=6 )
- >>> inter = A.disjoint_union(B)
- >>> inter.print_info()
- | Start time:................. 3
- | End time:................... 8
- >>> inter = B.disjoint_union(A)
- >>> inter.print_info()
- | Start time:................. 3
- | End time:................... 8
+ >>> A = TemporalExtent(start_time=5, end_time=8 )
+ >>> B = TemporalExtent(start_time=3, end_time=6 )
+ >>> inter = A.disjoint_union(B)
+ >>> inter.print_info()
+ | Start time:................. 3
+ | End time:................... 8
+ >>> inter = B.disjoint_union(A)
+ >>> inter.print_info()
+ | Start time:................. 3
+ | End time:................... 8
- >>> A = TemporalExtent(start_time=5, end_time=None )
- >>> B = TemporalExtent(start_time=3, end_time=6 )
- >>> inter = A.disjoint_union(B)
- >>> inter.print_info()
- | Start time:................. 3
- | End time:................... 6
- >>> inter = B.disjoint_union(A)
- >>> inter.print_info()
- | Start time:................. 3
- | End time:................... 6
+ >>> A = TemporalExtent(start_time=5, end_time=None )
+ >>> B = TemporalExtent(start_time=3, end_time=6 )
+ >>> inter = A.disjoint_union(B)
+ >>> inter.print_info()
+ | Start time:................. 3
+ | End time:................... 6
+ >>> inter = B.disjoint_union(A)
+ >>> inter.print_info()
+ | Start time:................. 3
+ | End time:................... 6
- >>> A = TemporalExtent(start_time=5, end_time=8 )
- >>> B = TemporalExtent(start_time=3, end_time=4 )
- >>> inter = A.disjoint_union(B)
- >>> inter.print_info()
- | Start time:................. 3
- | End time:................... 8
- >>> inter = B.disjoint_union(A)
- >>> inter.print_info()
- | Start time:................. 3
- | End time:................... 8
- >>> A = TemporalExtent(start_time=5, end_time=8 )
- >>> B = TemporalExtent(start_time=3, end_time=None )
- >>> inter = A.disjoint_union(B)
- >>> inter.print_info()
- | Start time:................. 3
- | End time:................... 8
- >>> inter = B.disjoint_union(A)
- >>> inter.print_info()
- | Start time:................. 3
- | End time:................... 8
- >>> A = TemporalExtent(start_time=5, end_time=None )
- >>> B = TemporalExtent(start_time=3, end_time=8 )
- >>> inter = A.disjoint_union(B)
- >>> inter.print_info()
- | Start time:................. 3
- | End time:................... 8
- >>> inter = B.disjoint_union(A)
- >>> inter.print_info()
- | Start time:................. 3
- | End time:................... 8
- >>> A = TemporalExtent(start_time=5, end_time=None )
- >>> B = TemporalExtent(start_time=3, end_time=None )
- >>> inter = A.disjoint_union(B)
- >>> inter.print_info()
- | Start time:................. 3
- | End time:................... 5
- >>> inter = B.disjoint_union(A)
- >>> inter.print_info()
- | Start time:................. 3
- | End time:................... 5
+ >>> A = TemporalExtent(start_time=5, end_time=8 )
+ >>> B = TemporalExtent(start_time=3, end_time=4 )
+ >>> inter = A.disjoint_union(B)
+ >>> inter.print_info()
+ | Start time:................. 3
+ | End time:................... 8
+ >>> inter = B.disjoint_union(A)
+ >>> inter.print_info()
+ | Start time:................. 3
+ | End time:................... 8
+ >>> A = TemporalExtent(start_time=5, end_time=8 )
+ >>> B = TemporalExtent(start_time=3, end_time=None )
+ >>> inter = A.disjoint_union(B)
+ >>> inter.print_info()
+ | Start time:................. 3
+ | End time:................... 8
+ >>> inter = B.disjoint_union(A)
+ >>> inter.print_info()
+ | Start time:................. 3
+ | End time:................... 8
+ >>> A = TemporalExtent(start_time=5, end_time=None )
+ >>> B = TemporalExtent(start_time=3, end_time=8 )
+ >>> inter = A.disjoint_union(B)
+ >>> inter.print_info()
+ | Start time:................. 3
+ | End time:................... 8
+ >>> inter = B.disjoint_union(A)
+ >>> inter.print_info()
+ | Start time:................. 3
+ | End time:................... 8
+ >>> A = TemporalExtent(start_time=5, end_time=None )
+ >>> B = TemporalExtent(start_time=3, end_time=None )
+ >>> inter = A.disjoint_union(B)
+ >>> inter.print_info()
+ | Start time:................. 3
+ | End time:................... 5
+ >>> inter = B.disjoint_union(A)
+ >>> inter.print_info()
+ | Start time:................. 3
+ | End time:................... 5
- >>> A = RelativeTemporalExtent(start_time=5, end_time=None, unit="years" )
- >>> B = RelativeTemporalExtent(start_time=3, end_time=None, unit="years" )
- >>> inter = A.disjoint_union(B)
- >>> inter.print_info()
- +-------------------- Relative time -----------------------------------------+
- | Start time:................. 3
- | End time:................... 5
- | Relative time unit:......... years
+ >>> A = RelativeTemporalExtent(start_time=5, end_time=None, unit="years" )
+ >>> B = RelativeTemporalExtent(start_time=3, end_time=None, unit="years" )
+ >>> inter = A.disjoint_union(B)
+ >>> inter.print_info()
+ +-------------------- Relative time -----------------------------------------+
+ | Start time:................. 3
+ | End time:................... 5
+ | Relative time unit:......... years
- >>> inter = B.disjoint_union(A)
- >>> inter.print_info()
- +-------------------- Relative time -----------------------------------------+
- | Start time:................. 3
- | End time:................... 5
- | Relative time unit:......... years
+ >>> inter = B.disjoint_union(A)
+ >>> inter.print_info()
+ +-------------------- Relative time -----------------------------------------+
+ | Start time:................. 3
+ | End time:................... 5
+ | Relative time unit:......... years
- >>> from datetime import datetime as dt
- >>> A = AbsoluteTemporalExtent(start_time=dt(2001,1,10), end_time=dt(2003,1,1))
- >>> B = AbsoluteTemporalExtent(start_time=dt(2005,1,10), end_time=dt(2008,1,1))
- >>> inter = A.disjoint_union(B)
- >>> inter.print_info()
- +-------------------- Absolute time -----------------------------------------+
- | Start time:................. 2001-01-10 00:00:00
- | End time:................... 2008-01-01 00:00:00
+ >>> from datetime import datetime as dt
+ >>> A = AbsoluteTemporalExtent(start_time=dt(2001,1,10), end_time=dt(2003,1,1))
+ >>> B = AbsoluteTemporalExtent(start_time=dt(2005,1,10), end_time=dt(2008,1,1))
+ >>> inter = A.disjoint_union(B)
+ >>> inter.print_info()
+ +-------------------- Absolute time -----------------------------------------+
+ | Start time:................. 2001-01-10 00:00:00
+ | End time:................... 2008-01-01 00:00:00
- >>> inter = B.disjoint_union(A)
- >>> inter.print_info()
- +-------------------- Absolute time -----------------------------------------+
- | Start time:................. 2001-01-10 00:00:00
- | End time:................... 2008-01-01 00:00:00
+ >>> inter = B.disjoint_union(A)
+ >>> inter.print_info()
+ +-------------------- Absolute time -----------------------------------------+
+ | Start time:................. 2001-01-10 00:00:00
+ | End time:................... 2008-01-01 00:00:00
- @endcode
"""
start = None
@@ -388,28 +381,27 @@
return TemporalExtent(start_time=start, end_time=end)
def union(self, extent):
- """!Creates a union with this temporal extent and the provided one.
+ """Creates a union with this temporal extent and the provided one.
Return a new temporal extent with the new start and end time.
- @param extent The temporal extent to create a union with
- @return The new temporal extent with start and end time,
+ :param extent: The temporal extent to create a union with
+ :return: The new temporal extent with start and end time,
or None in case the temporal extents are unrelated (before or after)
- @code
+ .. code-block:: python
- >>> A = TemporalExtent(start_time=5, end_time=8 )
- >>> B = TemporalExtent(start_time=3, end_time=4 )
- >>> inter = A.intersect(B)
- >>> print inter
- None
+ >>> A = TemporalExtent(start_time=5, end_time=8 )
+ >>> B = TemporalExtent(start_time=3, end_time=4 )
+ >>> inter = A.intersect(B)
+ >>> print inter
+ None
- >>> A = TemporalExtent(start_time=5, end_time=8 )
- >>> B = TemporalExtent(start_time=3, end_time=None )
- >>> inter = A.intersect(B)
- >>> print inter
- None
+ >>> A = TemporalExtent(start_time=5, end_time=8 )
+ >>> B = TemporalExtent(start_time=3, end_time=None )
+ >>> inter = A.intersect(B)
+ >>> print inter
+ None
- @endcode
"""
relation = self.temporal_relation(extent)
@@ -420,27 +412,27 @@
return self.disjoint_union(extent)
def starts(self, extent):
- """!Return True if this temporal extent (A) starts at the start of the
+ """Return True if this temporal extent (A) starts at the start of the
provided temporal extent (B) and finishes within it
- @verbatim
- A |-----|
- B |---------|
- @endverbatim
+ ::
+
+ A |-----|
+ B |---------|
- @param extent The temporal extent object with which this extent starts
+ :param extent: The temporal extent object with which this extent starts
+
Usage:
- @code
+ .. code-block:: python
- >>> A = TemporalExtent(start_time=5, end_time=6 )
- >>> B = TemporalExtent(start_time=5, end_time=7 )
- >>> A.starts(B)
- True
- >>> B.starts(A)
- False
+ >>> A = TemporalExtent(start_time=5, end_time=6 )
+ >>> B = TemporalExtent(start_time=5, end_time=7 )
+ >>> A.starts(B)
+ True
+ >>> B.starts(A)
+ False
- @endcode
"""
if self.D["end_time"] is None or extent.D["end_time"] is None:
return False
@@ -452,27 +444,26 @@
return False
def started(self, extent):
- """!Return True if this temporal extent (A) started at the start of the
+ """Return True if this temporal extent (A) started at the start of the
provided temporal extent (B) and finishes after it
- @verbatim
- A |---------|
- B |-----|
- @endverbatim
+ ::
+
+ A |---------|
+ B |-----|
- @param extent The temporal extent object with which this extent started
+ :param extent: The temporal extent object with which this extent started
Usage:
- @code
+ .. code-block:: python
- >>> A = TemporalExtent(start_time=5, end_time=7 )
- >>> B = TemporalExtent(start_time=5, end_time=6 )
- >>> A.started(B)
- True
- >>> B.started(A)
- False
+ >>> A = TemporalExtent(start_time=5, end_time=7 )
+ >>> B = TemporalExtent(start_time=5, end_time=6 )
+ >>> A.started(B)
+ True
+ >>> B.started(A)
+ False
- @endcode
"""
if self.D["end_time"] is None or extent.D["end_time"] is None:
return False
@@ -484,27 +475,26 @@
return False
def finishes(self, extent):
- """!Return True if this temporal extent (A) starts after the start of the
+ """Return True if this temporal extent (A) starts after the start of the
provided temporal extent (B) and finishes with it
- @verbatim
- A |-----|
- B |---------|
- @endverbatim
+ ::
+
+ A |-----|
+ B |---------|
- @param extent The temporal extent object with which this extent finishes
+ :param extent: The temporal extent object with which this extent finishes
Usage:
- @code
+ .. code-block:: python
- >>> A = TemporalExtent(start_time=6, end_time=7 )
- >>> B = TemporalExtent(start_time=5, end_time=7 )
- >>> A.finishes(B)
- True
- >>> B.finishes(A)
- False
+ >>> A = TemporalExtent(start_time=6, end_time=7 )
+ >>> B = TemporalExtent(start_time=5, end_time=7 )
+ >>> A.finishes(B)
+ True
+ >>> B.finishes(A)
+ False
- @endcode
"""
if self.D["end_time"] is None or extent.D["end_time"] is None:
return False
@@ -516,27 +506,26 @@
return False
def finished(self, extent):
- """!Return True if this temporal extent (A) starts before the start of the
+ """Return True if this temporal extent (A) starts before the start of the
provided temporal extent (B) and finishes with it
- @verbatim
- A |---------|
- B |-----|
- @endverbatim
+ ::
+
+ A |---------|
+ B |-----|
- @param extent The temporal extent object with which this extent finishes
+ :param extent: The temporal extent object with which this extent finishes
Usage:
- @code
+ .. code-block:: python
- >>> A = TemporalExtent(start_time=5, end_time=7 )
- >>> B = TemporalExtent(start_time=6, end_time=7 )
- >>> A.finished(B)
- True
- >>> B.finished(A)
- False
+ >>> A = TemporalExtent(start_time=5, end_time=7 )
+ >>> B = TemporalExtent(start_time=6, end_time=7 )
+ >>> A.finished(B)
+ True
+ >>> B.finished(A)
+ False
- @endcode
"""
if self.D["end_time"] is None or extent.D["end_time"] is None:
return False
@@ -548,27 +537,26 @@
return False
def after(self, extent):
- """!Return True if this temporal extent (A) is located after the
+ """Return True if this temporal extent (A) is located after the
provided temporal extent (B)
- @verbatim
- A |---------|
- B |---------|
- @endverbatim
+ ::
+
+ A |---------|
+ B |---------|
- @param extent The temporal extent object that is located before this extent
+ :param extent: The temporal extent object that is located before this extent
Usage:
- @code
+ .. code-block:: python
- >>> A = TemporalExtent(start_time=8, end_time=9 )
- >>> B = TemporalExtent(start_time=6, end_time=7 )
- >>> A.after(B)
- True
- >>> B.after(A)
- False
+ >>> A = TemporalExtent(start_time=8, end_time=9 )
+ >>> B = TemporalExtent(start_time=6, end_time=7 )
+ >>> A.after(B)
+ True
+ >>> B.after(A)
+ False
- @endcode
"""
if extent.D["end_time"] is None:
if self.D["start_time"] > extent.D["start_time"]:
@@ -582,27 +570,26 @@
return False
def before(self, extent):
- """!Return True if this temporal extent (A) is located before the
+ """Return True if this temporal extent (A) is located before the
provided temporal extent (B)
- @verbatim
- A |---------|
- B |---------|
- @endverbatim
+ ::
+
+ A |---------|
+ B |---------|
- @param extent The temporal extent object that is located after this extent
+ :param extent: The temporal extent object that is located after this extent
Usage:
- @code
+ .. code-block:: python
- >>> A = TemporalExtent(start_time=6, end_time=7 )
- >>> B = TemporalExtent(start_time=8, end_time=9 )
- >>> A.before(B)
- True
- >>> B.before(A)
- False
+ >>> A = TemporalExtent(start_time=6, end_time=7 )
+ >>> B = TemporalExtent(start_time=8, end_time=9 )
+ >>> A.before(B)
+ True
+ >>> B.before(A)
+ False
- @endcode
"""
if self.D["end_time"] is None:
if self.D["start_time"] < extent.D["start_time"]:
@@ -616,36 +603,35 @@
return False
def adjacent(self, extent):
- """!Return True if this temporal extent (A) is a meeting neighbor the
+ """Return True if this temporal extent (A) is a meeting neighbor the
provided temporal extent (B)
- @verbatim
- A |---------|
- B |---------|
- A |---------|
- B |---------|
- @endverbatim
+ ::
+
+ A |---------|
+ B |---------|
+ A |---------|
+ B |---------|
- @param extent The temporal extent object that is a meeting neighbor
+ :param extent: The temporal extent object that is a meeting neighbor
of this extent
Usage:
- @code
+ .. code-block:: python
- >>> A = TemporalExtent(start_time=5, end_time=7 )
- >>> B = TemporalExtent(start_time=7, end_time=9 )
- >>> A.adjacent(B)
- True
- >>> B.adjacent(A)
- True
- >>> A = TemporalExtent(start_time=5, end_time=7 )
- >>> B = TemporalExtent(start_time=3, end_time=5 )
- >>> A.adjacent(B)
- True
- >>> B.adjacent(A)
- True
+ >>> A = TemporalExtent(start_time=5, end_time=7 )
+ >>> B = TemporalExtent(start_time=7, end_time=9 )
+ >>> A.adjacent(B)
+ True
+ >>> B.adjacent(A)
+ True
+ >>> A = TemporalExtent(start_time=5, end_time=7 )
+ >>> B = TemporalExtent(start_time=3, end_time=5 )
+ >>> A.adjacent(B)
+ True
+ >>> B.adjacent(A)
+ True
- @endcode
"""
if self.D["end_time"] is None and extent.D["end_time"] is None:
return False
@@ -657,28 +643,27 @@
return False
def follows(self, extent):
- """!Return True if this temporal extent (A) follows the
+ """Return True if this temporal extent (A) follows the
provided temporal extent (B)
- @verbatim
- A |---------|
- B |---------|
- @endverbatim
+ ::
+
+ A |---------|
+ B |---------|
- @param extent The temporal extent object that is the predecessor
+ :param extent: The temporal extent object that is the predecessor
of this extent
Usage:
- @code
+ .. code-block:: python
- >>> A = TemporalExtent(start_time=5, end_time=7 )
- >>> B = TemporalExtent(start_time=3, end_time=5 )
- >>> A.follows(B)
- True
- >>> B.follows(A)
- False
+ >>> A = TemporalExtent(start_time=5, end_time=7 )
+ >>> B = TemporalExtent(start_time=3, end_time=5 )
+ >>> A.follows(B)
+ True
+ >>> B.follows(A)
+ False
- @endcode
"""
if extent.D["end_time"] is None:
return False
@@ -689,28 +674,29 @@
return False
def precedes(self, extent):
- """!Return True if this temporal extent (A) precedes the provided
+ """Return True if this temporal extent (A) precedes the provided
temporal extent (B)
- @verbatim
- A |---------|
- B |---------|
- @endverbatim
+ ::
+
+ A |---------|
+ B |---------|
- @param extent The temporal extent object that is the successor
+
+ :param extent: The temporal extent object that is the successor
of this extent
Usage:
- @code
+ .. code-block:: python
- >>> A = TemporalExtent(start_time=5, end_time=7 )
- >>> B = TemporalExtent(start_time=7, end_time=9 )
- >>> A.precedes(B)
- True
- >>> B.precedes(A)
- False
+ >>> A = TemporalExtent(start_time=5, end_time=7 )
+ >>> B = TemporalExtent(start_time=7, end_time=9 )
+ >>> A.precedes(B)
+ True
+ >>> B.precedes(A)
+ False
- @endcode
+
"""
if self.D["end_time"] is None:
return False
@@ -721,27 +707,26 @@
return False
def during(self, extent):
- """!Return True if this temporal extent (A) is located during the provided
+ """Return True if this temporal extent (A) is located during the provided
temporal extent (B)
- @verbatim
- A |-------|
- B |---------|
- @endverbatim
+ ::
+
+ A |-------|
+ B |---------|
- @param extent The temporal extent object that contains this extent
+ :param extent: The temporal extent object that contains this extent
Usage:
- @code
+ .. code-block:: python
- >>> A = TemporalExtent(start_time=5, end_time=7 )
- >>> B = TemporalExtent(start_time=4, end_time=9 )
- >>> A.during(B)
- True
- >>> B.during(A)
- False
+ >>> A = TemporalExtent(start_time=5, end_time=7 )
+ >>> B = TemporalExtent(start_time=4, end_time=9 )
+ >>> A.during(B)
+ True
+ >>> B.during(A)
+ False
- @endcode
"""
# Check single point of time in interval
if extent.D["end_time"] is None:
@@ -762,28 +747,27 @@
return False
def contains(self, extent):
- """!Return True if this temporal extent (A) contains the provided
+ """Return True if this temporal extent (A) contains the provided
temporal extent (B)
- @verbatim
- A |---------|
- B |-------|
- @endverbatim
+ ::
+
+ A |---------|
+ B |-------|
- @param extent The temporal extent object that is located
+ :param extent: The temporal extent object that is located
during this extent
Usage:
- @code
+ .. code-block:: python
- >>> A = TemporalExtent(start_time=4, end_time=9 )
- >>> B = TemporalExtent(start_time=5, end_time=8 )
- >>> A.contains(B)
- True
- >>> B.contains(A)
- False
+ >>> A = TemporalExtent(start_time=4, end_time=9 )
+ >>> B = TemporalExtent(start_time=5, end_time=8 )
+ >>> A.contains(B)
+ True
+ >>> B.contains(A)
+ False
- @endcode
"""
# Check single point of time in interval
if self.D["end_time"] is None:
@@ -804,28 +788,27 @@
return False
def equal(self, extent):
- """!Return True if this temporal extent (A) is equal to the provided
+ """Return True if this temporal extent (A) is equal to the provided
temporal extent (B)
- @verbatim
- A |---------|
- B |---------|
- @endverbatim
+ ::
+
+ A |---------|
+ B |---------|
- @param extent The temporal extent object that is equal
+ :param extent: The temporal extent object that is equal
during this extent
Usage:
- @code
+ .. code-block:: python
- >>> A = TemporalExtent(start_time=5, end_time=6 )
- >>> B = TemporalExtent(start_time=5, end_time=6 )
- >>> A.equal(B)
- True
- >>> B.equal(A)
- True
+ >>> A = TemporalExtent(start_time=5, end_time=6 )
+ >>> B = TemporalExtent(start_time=5, end_time=6 )
+ >>> A.equal(B)
+ True
+ >>> B.equal(A)
+ True
- @endcode
"""
if self.D["end_time"] is None and extent.D["end_time"] is None:
if self.D["start_time"] == extent.D["start_time"]:
@@ -843,34 +826,34 @@
return False
def overlaps(self, extent):
- """!Return True if this temporal extent (A) overlapped the provided
+ """Return True if this temporal extent (A) overlapped the provided
temporal extent (B)
- @verbatim
- A |---------|
- B |---------|
- @endverbatim
- @param extent The temporal extent object that is overlaps
+ ::
+
+ A |---------|
+ B |---------|
+
+ :param extent: The temporal extent object that is overlaps
this extent
Usage:
- @code
+ .. code-block:: python
- >>> A = TemporalExtent(start_time=5, end_time=7 )
- >>> B = TemporalExtent(start_time=6, end_time=8 )
- >>> A.overlaps(B)
- True
- >>> B.overlaps(A)
- False
+ >>> A = TemporalExtent(start_time=5, end_time=7 )
+ >>> B = TemporalExtent(start_time=6, end_time=8 )
+ >>> A.overlaps(B)
+ True
+ >>> B.overlaps(A)
+ False
- >>> A = TemporalExtent(start_time=5, end_time=6 )
- >>> B = TemporalExtent(start_time=6, end_time=8 )
- >>> A.overlaps(B)
- False
- >>> B.overlaps(A)
- False
+ >>> A = TemporalExtent(start_time=5, end_time=6 )
+ >>> B = TemporalExtent(start_time=6, end_time=8 )
+ >>> A.overlaps(B)
+ False
+ >>> B.overlaps(A)
+ False
- @endcode
"""
if self.D["end_time"] is None or extent.D["end_time"] is None:
return False
@@ -883,35 +866,35 @@
return False
def overlapped(self, extent):
- """!Return True if this temporal extent (A) overlapps the provided
+ """Return True if this temporal extent (A) overlapps the provided
temporal extent (B)
- @verbatim
- A |---------|
- B |---------|
- @endverbatim
+ ::
+
+ A |---------|
+ B |---------|
- @param extent The temporal extent object that is overlapped
+
+ :param extent: The temporal extent object that is overlapped
this extent
Usage:
- @code
+ .. code-block:: python
- >>> A = TemporalExtent(start_time=6, end_time=8 )
- >>> B = TemporalExtent(start_time=5, end_time=7 )
- >>> A.overlapped(B)
- True
- >>> B.overlapped(A)
- False
+ >>> A = TemporalExtent(start_time=6, end_time=8 )
+ >>> B = TemporalExtent(start_time=5, end_time=7 )
+ >>> A.overlapped(B)
+ True
+ >>> B.overlapped(A)
+ False
- >>> A = TemporalExtent(start_time=6, end_time=8 )
- >>> B = TemporalExtent(start_time=5, end_time=6 )
- >>> A.overlapped(B)
- False
- >>> B.overlapped(A)
- False
+ >>> A = TemporalExtent(start_time=6, end_time=8 )
+ >>> B = TemporalExtent(start_time=5, end_time=6 )
+ >>> A.overlapped(B)
+ False
+ >>> B.overlapped(A)
+ False
- @endcode
"""
if self.D["end_time"] is None or extent.D["end_time"] is None:
return False
@@ -924,7 +907,7 @@
return False
def temporal_relation(self, extent):
- """!Returns the temporal relation between temporal objects
+ """Returns the temporal relation between temporal objects
Temporal relationships are implemented after
[Allen and Ferguson 1994 Actions and Events in Interval Temporal Logic]
@@ -944,8 +927,8 @@
- follows
- precedes
- @param extent The temporal extent
- @return The name of the temporal relation or None if no relation found
+ :param extent: The temporal extent
+ :return: The name of the temporal relation or None if no relation found
"""
# First check for correct time
@@ -990,21 +973,21 @@
return None
def set_id(self, ident):
- """!Convenient method to set the unique identifier (primary key)"""
+ """Convenient method to set the unique identifier (primary key)"""
self.ident = ident
self.D["id"] = ident
def set_start_time(self, start_time):
- """!Set the valid start time of the extent"""
+ """Set the valid start time of the extent"""
self.D["start_time"] = start_time
def set_end_time(self, end_time):
- """!Set the valid end time of the extent"""
+ """Set the valid end time of the extent"""
self.D["end_time"] = end_time
def get_id(self):
- """!Convenient method to get the unique identifier (primary key)
- @return None if not found
+ """Convenient method to get the unique identifier (primary key)
+ :return: None if not found
"""
if "id" in self.D:
return self.D["id"]
@@ -1012,16 +995,16 @@
return None
def get_start_time(self):
- """!Get the valid start time of the extent
- @return None if not found"""
+ """Get the valid start time of the extent
+ :return: None if not found"""
if "start_time" in self.D:
return self.D["start_time"]
else:
return None
def get_end_time(self):
- """!Get the valid end time of the extent
- @return None if not found"""
+ """Get the valid end time of the extent
+ :return: None if not found"""
if "end_time" in self.D:
return self.D["end_time"]
else:
@@ -1033,13 +1016,13 @@
end_time = property(fget=get_end_time, fset=set_end_time)
def print_info(self):
- """!Print information about this class in human readable style"""
+ """Print information about this class in human readable style"""
# 0123456789012345678901234567890
print " | Start time:................. " + str(self.get_start_time())
print " | End time:................... " + str(self.get_end_time())
def print_shell_info(self):
- """!Print information about this class in shell style"""
+ """Print information about this class in shell style"""
print "start_time=" + str(self.get_start_time())
print "end_time=" + str(self.get_end_time())
@@ -1047,7 +1030,7 @@
class AbsoluteTemporalExtent(TemporalExtent):
- """!This is the absolute time class for all maps and spacetime datasets
+ """This is the absolute time class for all maps and spacetime datasets
start_time and end_time must be of type datetime
"""
@@ -1057,13 +1040,13 @@
self, table, ident, start_time, end_time)
def print_info(self):
- """!Print information about this class in human readable style"""
+ """Print information about this class in human readable style"""
# 0123456789012345678901234567890
print " +-------------------- Absolute time -----------------------------------------+"
TemporalExtent.print_info(self)
def print_shell_info(self):
- """!Print information about this class in shell style"""
+ """Print information about this class in shell style"""
TemporalExtent.print_shell_info(self)
###############################################################################
@@ -1086,43 +1069,42 @@
###############################################################################
class STDSAbsoluteTime(AbsoluteTemporalExtent):
- """!This class implements the absolute time extent for space time dataset
+ """This class implements the absolute time extent for space time dataset
In addition to the existing functionality the granularity and the
map_time are added.
Usage:
- @code
+ .. code-block:: python
- >>> init()
- >>> A = STDSAbsoluteTime(table="strds_absolute_time",
- ... ident="strds at PERMANENT", start_time=datetime(2001, 01, 01),
- ... end_time=datetime(2005,01,01), granularity="1 days",
- ... map_time="interval")
- >>> A.id
- 'strds at PERMANENT'
- >>> A.start_time
- datetime.datetime(2001, 1, 1, 0, 0)
- >>> A.end_time
- datetime.datetime(2005, 1, 1, 0, 0)
- >>> A.granularity
- '1 days'
- >>> A.map_time
- 'interval'
- >>> A.print_info()
- +-------------------- Absolute time -----------------------------------------+
- | Start time:................. 2001-01-01 00:00:00
- | End time:................... 2005-01-01 00:00:00
- | Granularity:................ 1 days
- | Temporal type of maps:...... interval
- >>> A.print_shell_info()
- start_time=2001-01-01 00:00:00
- end_time=2005-01-01 00:00:00
- granularity=1 days
- map_time=interval
+ >>> init()
+ >>> A = STDSAbsoluteTime(table="strds_absolute_time",
+ ... ident="strds at PERMANENT", start_time=datetime(2001, 01, 01),
+ ... end_time=datetime(2005,01,01), granularity="1 days",
+ ... map_time="interval")
+ >>> A.id
+ 'strds at PERMANENT'
+ >>> A.start_time
+ datetime.datetime(2001, 1, 1, 0, 0)
+ >>> A.end_time
+ datetime.datetime(2005, 1, 1, 0, 0)
+ >>> A.granularity
+ '1 days'
+ >>> A.map_time
+ 'interval'
+ >>> A.print_info()
+ +-------------------- Absolute time -----------------------------------------+
+ | Start time:................. 2001-01-01 00:00:00
+ | End time:................... 2005-01-01 00:00:00
+ | Granularity:................ 1 days
+ | Temporal type of maps:...... interval
+ >>> A.print_shell_info()
+ start_time=2001-01-01 00:00:00
+ end_time=2005-01-01 00:00:00
+ granularity=1 days
+ map_time=interval
- @endcode
"""
def __init__(self, table=None, ident=None, start_time=None, end_time=None,
granularity=None, map_time=None):
@@ -1133,13 +1115,14 @@
self.set_map_time(map_time)
def set_granularity(self, granularity):
- """!Set the granularity of the space time dataset"""
+ """Set the granularity of the space time dataset"""
self.D["granularity"] = granularity
def set_map_time(self, map_time):
- """!Set the type of the map time
+ """Set the type of the map time
Registered maps may have different types of time:
+
- Single point of time "point"
- Time intervals "interval"
- Single point and interval time "mixed"
@@ -1149,20 +1132,21 @@
self.D["map_time"] = map_time
def get_granularity(self):
- """!Get the granularity of the space time dataset
- @return None if not found"""
+ """Get the granularity of the space time dataset
+ :return: None if not found"""
if "granularity" in self.D:
return self.D["granularity"]
else:
return None
def get_map_time(self):
- """!Get the type of the map time
+ """Get the type of the map time
Registered maps may have different types of time:
- Single point of time "point"
- Time intervals "interval"
- Or single point and interval time "mixed"
+
+ - Single point of time "point"
+ - Time intervals "interval"
+ - Single point and interval time "mixed"
This variable will be set automatically when maps are registered.
"""
@@ -1176,14 +1160,14 @@
map_time = property(fget=get_map_time, fset=set_map_time)
def print_info(self):
- """!Print information about this class in human readable style"""
+ """Print information about this class in human readable style"""
AbsoluteTemporalExtent.print_info(self)
# 0123456789012345678901234567890
print " | Granularity:................ " + str(self.get_granularity())
print " | Temporal type of maps:...... " + str(self.get_map_time())
def print_shell_info(self):
- """!Print information about this class in shell style"""
+ """Print information about this class in shell style"""
AbsoluteTemporalExtent.print_shell_info(self)
print "granularity=" + str(self.get_granularity())
print "map_time=" + str(self.get_map_time())
@@ -1213,36 +1197,35 @@
###############################################################################
class RelativeTemporalExtent(TemporalExtent):
- """!This is the relative time class for all maps and space time datasets
+ """This is the relative time class for all maps and space time datasets
start_time and end_time must be of type integer
Usage:
- @code
+ .. code-block:: python
- >>> init()
- >>> A = RelativeTemporalExtent(table="raster_relative_time",
- ... ident="soil at PERMANENT", start_time=0, end_time=1, unit="years")
- >>> A.id
- 'soil at PERMANENT'
- >>> A.start_time
- 0
- >>> A.end_time
- 1
- >>> A.unit
- 'years'
- >>> A.print_info()
- +-------------------- Relative time -----------------------------------------+
- | Start time:................. 0
- | End time:................... 1
- | Relative time unit:......... years
- >>> A.print_shell_info()
- start_time=0
- end_time=1
- unit=years
+ >>> init()
+ >>> A = RelativeTemporalExtent(table="raster_relative_time",
+ ... ident="soil at PERMANENT", start_time=0, end_time=1, unit="years")
+ >>> A.id
+ 'soil at PERMANENT'
+ >>> A.start_time
+ 0
+ >>> A.end_time
+ 1
+ >>> A.unit
+ 'years'
+ >>> A.print_info()
+ +-------------------- Relative time -----------------------------------------+
+ | Start time:................. 0
+ | End time:................... 1
+ | Relative time unit:......... years
+ >>> A.print_shell_info()
+ start_time=0
+ end_time=1
+ unit=years
- @endcode
"""
def __init__(self, table=None, ident=None, start_time=None, end_time=None,
unit=None):
@@ -1252,7 +1235,7 @@
self.set_unit(unit)
def set_unit(self, unit):
- """!Set the unit of the relative time. Valid units are:
+ """Set the unit of the relative time. Valid units are:
- years
- months
@@ -1264,15 +1247,15 @@
self.D["unit"] = unit
def get_unit(self):
- """!Get the unit of the relative time
- @return None if not found"""
+ """Get the unit of the relative time
+ :return: None if not found"""
if "unit" in self.D:
return self.D["unit"]
else:
return None
def temporal_relation(self, map):
- """!Returns the temporal relation between temporal objects
+ """Returns the temporal relation between temporal objects
Temporal relationships are implemented after
[Allen and Ferguson 1994 Actions and Events in Interval Temporal Logic]
"""
@@ -1293,14 +1276,14 @@
unit = property(fget=get_unit, fset=set_unit)
def print_info(self):
- """!Print information about this class in human readable style"""
+ """Print information about this class in human readable style"""
# 0123456789012345678901234567890
print " +-------------------- Relative time -----------------------------------------+"
TemporalExtent.print_info(self)
print " | Relative time unit:......... " + str(self.get_unit())
def print_shell_info(self):
- """!Print information about this class in shell style"""
+ """Print information about this class in shell style"""
TemporalExtent.print_shell_info(self)
print "unit=" + str(self.get_unit())
@@ -1329,45 +1312,44 @@
###############################################################################
class STDSRelativeTime(RelativeTemporalExtent):
- """!This is the relative time class for all maps and space time datasets
+ """This is the relative time class for all maps and space time datasets
start_time and end_time must be of type integer
Usage:
- @code
+ .. code-block:: python
- >>> init()
- >>> A = STDSRelativeTime(table="strds_relative_time",
- ... ident="strds at PERMANENT", start_time=0, end_time=1, unit="years",
- ... granularity=5, map_time="interval")
- >>> A.id
- 'strds at PERMANENT'
- >>> A.start_time
- 0
- >>> A.end_time
- 1
- >>> A.unit
- 'years'
- >>> A.granularity
- 5
- >>> A.map_time
- 'interval'
- >>> A.print_info()
- +-------------------- Relative time -----------------------------------------+
- | Start time:................. 0
- | End time:................... 1
- | Relative time unit:......... years
- | Granularity:................ 5
- | Temporal type of maps:...... interval
- >>> A.print_shell_info()
- start_time=0
- end_time=1
- unit=years
- granularity=5
- map_time=interval
+ >>> init()
+ >>> A = STDSRelativeTime(table="strds_relative_time",
+ ... ident="strds at PERMANENT", start_time=0, end_time=1, unit="years",
+ ... granularity=5, map_time="interval")
+ >>> A.id
+ 'strds at PERMANENT'
+ >>> A.start_time
+ 0
+ >>> A.end_time
+ 1
+ >>> A.unit
+ 'years'
+ >>> A.granularity
+ 5
+ >>> A.map_time
+ 'interval'
+ >>> A.print_info()
+ +-------------------- Relative time -----------------------------------------+
+ | Start time:................. 0
+ | End time:................... 1
+ | Relative time unit:......... years
+ | Granularity:................ 5
+ | Temporal type of maps:...... interval
+ >>> A.print_shell_info()
+ start_time=0
+ end_time=1
+ unit=years
+ granularity=5
+ map_time=interval
- @endcode
"""
def __init__(self, table=None, ident=None, start_time=None, end_time=None,
unit=None, granularity=None, map_time=None):
@@ -1378,36 +1360,38 @@
self.set_map_time(map_time)
def set_granularity(self, granularity):
- """!Set the granularity of the space time dataset"""
+ """Set the granularity of the space time dataset"""
self.D["granularity"] = granularity
def set_map_time(self, map_time):
- """!Set the type of the map time
+ """Set the type of the map time
Registered maps may have different types of time:
- Single point of time "point"
- Time intervals "interval"
- Or single point and interval time "mixed"
+
+ - Single point of time "point"
+ - Time intervals "interval"
+ - Single point and interval time "mixed"
This variable will be set automatically when maps are registered.
"""
self.D["map_time"] = map_time
def get_granularity(self):
- """!Get the granularity of the space time dataset
- @return None if not found"""
+ """Get the granularity of the space time dataset
+ :return: None if not found"""
if "granularity" in self.D:
return self.D["granularity"]
else:
return None
def get_map_time(self):
- """!Get the type of the map time
+ """Get the type of the map time
Registered maps may have different types of time:
- Single point of time "point"
- Time intervals "interval"
- Or single point and interval time "mixed"
+
+ - Single point of time "point"
+ - Time intervals "interval"
+ - Single point and interval time "mixed"
This variable will be set automatically when maps are registered.
"""
@@ -1421,14 +1405,14 @@
map_time = property(fget=get_map_time, fset=set_map_time)
def print_info(self):
- """!Print information about this class in human readable style"""
+ """Print information about this class in human readable style"""
RelativeTemporalExtent.print_info(self)
# 0123456789012345678901234567890
print " | Granularity:................ " + str(self.get_granularity())
print " | Temporal type of maps:...... " + str(self.get_map_time())
def print_shell_info(self):
- """!Print information about this class in shell style"""
+ """Print information about this class in shell style"""
RelativeTemporalExtent.print_shell_info(self)
print "granularity=" + str(self.get_granularity())
print "map_time=" + str(self.get_map_time())
Modified: grass/trunk/lib/python/temporal/temporal_granularity.py
===================================================================
--- grass/trunk/lib/python/temporal/temporal_granularity.py 2014-09-28 01:40:32 UTC (rev 62120)
+++ grass/trunk/lib/python/temporal/temporal_granularity.py 2014-09-28 01:46:15 UTC (rev 62121)
@@ -1,24 +1,21 @@
-"""!@package grass.temporal
+"""
+Functions to compute the temporal granularity of a map list
- at brief GRASS Python scripting module (temporal GIS functions)
+Usage:
-Temporal GIS related functions to be used in temporal GIS Python library package.
+.. code-block:: python
-Usage:
+ import grass.temporal as tgis
- at code
-import grass.temporal as tgis
+ tgis.compute_relative_time_granularity(maps)
-tgis.compute_relative_time_granularity(maps)
-...
- at endcode
(C) 2012-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.
- at author Soeren Gebbert
+:authors: Soeren Gebbert
"""
from abstract_dataset import *
from datetime_math import *
@@ -26,50 +23,49 @@
###############################################################################
def check_granularity_string(granularity, temporal_type):
- """!Check if the granularity string is valid
+ """Check if the granularity string is valid
- @param granularity The granularity string
- @param temporal_type The temporal type of the granularity relative or absolute
- @return True if valid, False if invalid
+ :param granularity: The granularity string
+ :param temporal_type: The temporal type of the granularity relative or absolute
+ :return: True if valid, False if invalid
- @code
+ .. code-block:: python
- >>> check_granularity_string("1 year", "absolute")
- True
- >>> check_granularity_string("1 month", "absolute")
- True
- >>> check_granularity_string("1 day", "absolute")
- True
- >>> check_granularity_string("1 minute", "absolute")
- True
- >>> check_granularity_string("1 hour", "absolute")
- True
- >>> check_granularity_string("1 second", "absolute")
- True
- >>> check_granularity_string("5 months", "absolute")
- True
- >>> check_granularity_string("5 days", "absolute")
- True
- >>> check_granularity_string("5 minutes", "absolute")
- True
- >>> check_granularity_string("5 years", "absolute")
- True
- >>> check_granularity_string("5 hours", "absolute")
- True
- >>> check_granularity_string("2 seconds", "absolute")
- True
- >>> check_granularity_string("1 secondo", "absolute")
- False
- >>> check_granularity_string("bla second", "absolute")
- False
- >>> check_granularity_string("bla", "absolute")
- False
- >>> check_granularity_string(1, "relative")
- True
- >>> check_granularity_string("bla", "relative")
- False
+ >>> check_granularity_string("1 year", "absolute")
+ True
+ >>> check_granularity_string("1 month", "absolute")
+ True
+ >>> check_granularity_string("1 day", "absolute")
+ True
+ >>> check_granularity_string("1 minute", "absolute")
+ True
+ >>> check_granularity_string("1 hour", "absolute")
+ True
+ >>> check_granularity_string("1 second", "absolute")
+ True
+ >>> check_granularity_string("5 months", "absolute")
+ True
+ >>> check_granularity_string("5 days", "absolute")
+ True
+ >>> check_granularity_string("5 minutes", "absolute")
+ True
+ >>> check_granularity_string("5 years", "absolute")
+ True
+ >>> check_granularity_string("5 hours", "absolute")
+ True
+ >>> check_granularity_string("2 seconds", "absolute")
+ True
+ >>> check_granularity_string("1 secondo", "absolute")
+ False
+ >>> check_granularity_string("bla second", "absolute")
+ False
+ >>> check_granularity_string("bla", "absolute")
+ False
+ >>> check_granularity_string(1, "relative")
+ True
+ >>> check_granularity_string("bla", "relative")
+ False
- @endcode
"""
temporal_type
@@ -103,102 +99,101 @@
###############################################################################
def compute_relative_time_granularity(maps):
- """!Compute the relative time granularity
+ """Compute the relative time granularity
Attention: The computation of the granularity
is only correct in case of not overlapping intervals.
Hence a correct temporal topology is required for computation.
- @param maps a ordered by start_time list of map objects
- @return An integer
+ :param maps: a ordered by start_time list of map objects
+ :return: An integer
- @code
+ .. code-block:: python
- >>> import grass.temporal as tgis
- >>> tgis.init()
- >>> maps = []
- >>> for i in range(5):
- ... map = tgis.RasterDataset("a%i at P"%i)
- ... check = map.set_relative_time(i,i + 1,"seconds")
- ... if check:
- ... maps.append(map)
- >>> tgis.compute_relative_time_granularity(maps)
- 1
+ >>> import grass.temporal as tgis
+ >>> tgis.init()
+ >>> maps = []
+ >>> for i in range(5):
+ ... map = tgis.RasterDataset("a%i at P"%i)
+ ... check = map.set_relative_time(i,i + 1,"seconds")
+ ... if check:
+ ... maps.append(map)
+ >>> tgis.compute_relative_time_granularity(maps)
+ 1
- >>> maps = []
- >>> count = 0
- >>> timelist = ((0,3), (3,6), (6,9))
- >>> for t in timelist:
- ... map = tgis.RasterDataset("a%i at P"%count)
- ... check = map.set_relative_time(t[0],t[1],"years")
- ... if check:
- ... maps.append(map)
- ... count += 1
- >>> tgis.compute_relative_time_granularity(maps)
- 3
+ >>> maps = []
+ >>> count = 0
+ >>> timelist = ((0,3), (3,6), (6,9))
+ >>> for t in timelist:
+ ... map = tgis.RasterDataset("a%i at P"%count)
+ ... check = map.set_relative_time(t[0],t[1],"years")
+ ... if check:
+ ... maps.append(map)
+ ... count += 1
+ >>> tgis.compute_relative_time_granularity(maps)
+ 3
- >>> maps = []
- >>> count = 0
- >>> timelist = ((0,3), (4,6), (8,11))
- >>> for t in timelist:
- ... map = tgis.RasterDataset("a%i at P"%count)
- ... check = map.set_relative_time(t[0],t[1],"years")
- ... if check:
- ... maps.append(map)
- ... count += 1
- >>> tgis.compute_relative_time_granularity(maps)
- 1
+ >>> maps = []
+ >>> count = 0
+ >>> timelist = ((0,3), (4,6), (8,11))
+ >>> for t in timelist:
+ ... map = tgis.RasterDataset("a%i at P"%count)
+ ... check = map.set_relative_time(t[0],t[1],"years")
+ ... if check:
+ ... maps.append(map)
+ ... count += 1
+ >>> tgis.compute_relative_time_granularity(maps)
+ 1
- >>> maps = []
- >>> count = 0
- >>> timelist = ((0,8), (2,6), (5,9))
- >>> for t in timelist:
- ... map = tgis.RasterDataset("a%i at P"%count)
- ... check = map.set_relative_time(t[0],t[1],"months")
- ... if check:
- ... maps.append(map)
- ... count += 1
- >>> tgis.compute_relative_time_granularity(maps)
- 4
+ >>> maps = []
+ >>> count = 0
+ >>> timelist = ((0,8), (2,6), (5,9))
+ >>> for t in timelist:
+ ... map = tgis.RasterDataset("a%i at P"%count)
+ ... check = map.set_relative_time(t[0],t[1],"months")
+ ... if check:
+ ... maps.append(map)
+ ... count += 1
+ >>> tgis.compute_relative_time_granularity(maps)
+ 4
- >>> maps = []
- >>> count = 0
- >>> timelist = ((0,8), (8,12), (12,18))
- >>> for t in timelist:
- ... map = tgis.RasterDataset("a%i at P"%count)
- ... check = map.set_relative_time(t[0],t[1],"days")
- ... if check:
- ... maps.append(map)
- ... count += 1
- >>> tgis.compute_relative_time_granularity(maps)
- 2
+ >>> maps = []
+ >>> count = 0
+ >>> timelist = ((0,8), (8,12), (12,18))
+ >>> for t in timelist:
+ ... map = tgis.RasterDataset("a%i at P"%count)
+ ... check = map.set_relative_time(t[0],t[1],"days")
+ ... if check:
+ ... maps.append(map)
+ ... count += 1
+ >>> tgis.compute_relative_time_granularity(maps)
+ 2
- >>> maps = []
- >>> count = 0
- >>> timelist = ((0,None), (8,None), (12,None), (24,None))
- >>> for t in timelist:
- ... map = tgis.RasterDataset("a%i at P"%count)
- ... check = map.set_relative_time(t[0],t[1],"minutes")
- ... if check:
- ... maps.append(map)
- ... count += 1
- >>> tgis.compute_relative_time_granularity(maps)
- 4
+ >>> maps = []
+ >>> count = 0
+ >>> timelist = ((0,None), (8,None), (12,None), (24,None))
+ >>> for t in timelist:
+ ... map = tgis.RasterDataset("a%i at P"%count)
+ ... check = map.set_relative_time(t[0],t[1],"minutes")
+ ... if check:
+ ... maps.append(map)
+ ... count += 1
+ >>> tgis.compute_relative_time_granularity(maps)
+ 4
- >>> maps = []
- >>> count = 0
- >>> timelist = ((0,None), (8,14), (18,None), (24,None))
- >>> for t in timelist:
- ... map = tgis.RasterDataset("a%i at P"%count)
- ... check = map.set_relative_time(t[0],t[1],"hours")
- ... if check:
- ... maps.append(map)
- ... count += 1
- >>> tgis.compute_relative_time_granularity(maps)
- 2
+ >>> maps = []
+ >>> count = 0
+ >>> timelist = ((0,None), (8,14), (18,None), (24,None))
+ >>> for t in timelist:
+ ... map = tgis.RasterDataset("a%i at P"%count)
+ ... check = map.set_relative_time(t[0],t[1],"hours")
+ ... if check:
+ ... maps.append(map)
+ ... count += 1
+ >>> tgis.compute_relative_time_granularity(maps)
+ 2
- @endcode
"""
# The interval time must be scaled to days resolution
@@ -244,7 +239,7 @@
def compute_absolute_time_granularity(maps):
- """!Compute the absolute time granularity
+ """Compute the absolute time granularity
Attention: The computation of the granularity
is only correct in case of not overlapping intervals.
@@ -253,76 +248,75 @@
The computed granularity is returned as number of seconds or minutes or hours
or days or months or years.
- @param maps a ordered by start_time list of map objects
- @return The temporal topology as string "integer unit"
+ :param maps: a ordered by start_time list of map objects
+ :return: The temporal topology as string "integer unit"
- @code
+ .. code-block:: python
- >>> import grass.temporal as tgis
- >>> import datetime
- >>> dt = datetime.datetime
- >>> tgis.init()
- >>> maps = []
- >>> count = 0
- >>> timelist = ((dt(2000,01,01),None), (dt(2000,02,01),None))
- >>> for t in timelist:
- ... map = tgis.RasterDataset("a%i at P"%count)
- ... check = map.set_absolute_time(t[0],t[1])
- ... if check:
- ... maps.append(map)
- ... count += 1
- >>> tgis.compute_absolute_time_granularity(maps)
- '1 month'
+ >>> import grass.temporal as tgis
+ >>> import datetime
+ >>> dt = datetime.datetime
+ >>> tgis.init()
+ >>> maps = []
+ >>> count = 0
+ >>> timelist = ((dt(2000,01,01),None), (dt(2000,02,01),None))
+ >>> for t in timelist:
+ ... map = tgis.RasterDataset("a%i at P"%count)
+ ... check = map.set_absolute_time(t[0],t[1])
+ ... if check:
+ ... maps.append(map)
+ ... count += 1
+ >>> tgis.compute_absolute_time_granularity(maps)
+ '1 month'
- >>> maps = []
- >>> count = 0
- >>> timelist = ((dt(2000,01,01),None), (dt(2000,01,02),None), (dt(2000,01,03),None))
- >>> for t in timelist:
- ... map = tgis.RasterDataset("a%i at P"%count)
- ... check = map.set_absolute_time(t[0],t[1])
- ... if check:
- ... maps.append(map)
- ... count += 1
- >>> tgis.compute_absolute_time_granularity(maps)
- '1 day'
+ >>> maps = []
+ >>> count = 0
+ >>> timelist = ((dt(2000,01,01),None), (dt(2000,01,02),None), (dt(2000,01,03),None))
+ >>> for t in timelist:
+ ... map = tgis.RasterDataset("a%i at P"%count)
+ ... check = map.set_absolute_time(t[0],t[1])
+ ... if check:
+ ... maps.append(map)
+ ... count += 1
+ >>> tgis.compute_absolute_time_granularity(maps)
+ '1 day'
- >>> maps = []
- >>> count = 0
- >>> timelist = ((dt(2000,01,01),None), (dt(2000,01,02),None), (dt(2000,05,04,0,5,30),None))
- >>> for t in timelist:
- ... map = tgis.RasterDataset("a%i at P"%count)
- ... check = map.set_absolute_time(t[0],t[1])
- ... if check:
- ... maps.append(map)
- ... count += 1
- >>> tgis.compute_absolute_time_granularity(maps)
- '30 seconds'
+ >>> maps = []
+ >>> count = 0
+ >>> timelist = ((dt(2000,01,01),None), (dt(2000,01,02),None), (dt(2000,05,04,0,5,30),None))
+ >>> for t in timelist:
+ ... map = tgis.RasterDataset("a%i at P"%count)
+ ... check = map.set_absolute_time(t[0],t[1])
+ ... if check:
+ ... maps.append(map)
+ ... count += 1
+ >>> tgis.compute_absolute_time_granularity(maps)
+ '30 seconds'
- >>> maps = []
- >>> count = 0
- >>> timelist = ((dt(2000,01,01),dt(2000,05,02)), (dt(2000,05,04,2),None))
- >>> for t in timelist:
- ... map = tgis.RasterDataset("a%i at P"%count)
- ... check = map.set_absolute_time(t[0],t[1])
- ... if check:
- ... maps.append(map)
- ... count += 1
- >>> tgis.compute_absolute_time_granularity(maps)
- '2 hours'
+ >>> maps = []
+ >>> count = 0
+ >>> timelist = ((dt(2000,01,01),dt(2000,05,02)), (dt(2000,05,04,2),None))
+ >>> for t in timelist:
+ ... map = tgis.RasterDataset("a%i at P"%count)
+ ... check = map.set_absolute_time(t[0],t[1])
+ ... if check:
+ ... maps.append(map)
+ ... count += 1
+ >>> tgis.compute_absolute_time_granularity(maps)
+ '2 hours'
- >>> maps = []
- >>> count = 0
- >>> timelist = ((dt(2000,01,01),dt(2000,02,01)), (dt(2005,05,04,12),dt(2007,05,20,6)))
- >>> for t in timelist:
- ... map = tgis.RasterDataset("a%i at P"%count)
- ... check = map.set_absolute_time(t[0],t[1])
- ... if check:
- ... maps.append(map)
- ... count += 1
- >>> tgis.compute_absolute_time_granularity(maps)
- '6 hours'
+ >>> maps = []
+ >>> count = 0
+ >>> timelist = ((dt(2000,01,01),dt(2000,02,01)), (dt(2005,05,04,12),dt(2007,05,20,6)))
+ >>> for t in timelist:
+ ... map = tgis.RasterDataset("a%i at P"%count)
+ ... check = map.set_absolute_time(t[0],t[1])
+ ... if check:
+ ... maps.append(map)
+ ... count += 1
+ >>> tgis.compute_absolute_time_granularity(maps)
+ '6 hours'
- @endcode
"""
has_seconds = False
@@ -495,7 +489,7 @@
def gcd(a, b):
- """!The Euclidean Algorithm """
+ """The Euclidean Algorithm """
a = abs(a)
b = abs(b)
while a:
@@ -506,7 +500,7 @@
def gcd_list(list):
- """!Finds the GCD of numbers in a list.
+ """Finds the GCD of numbers in a list.
Input: List of numbers you want to find the GCD of
E.g. [8, 24, 12]
Returns: GCD of all numbers
Modified: grass/trunk/lib/python/temporal/temporal_raster3d_algebra.py
===================================================================
--- grass/trunk/lib/python/temporal/temporal_raster3d_algebra.py 2014-09-28 01:40:32 UTC (rev 62120)
+++ grass/trunk/lib/python/temporal/temporal_raster3d_algebra.py 2014-09-28 01:46:15 UTC (rev 62121)
@@ -1,13 +1,12 @@
-"""!@package grass.temporal
+"""
+Temporal 3d raster algebra
-Temporal raster algebra
-
(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.
- at author Thomas Leppelt and Soeren Gebbert
+:authors: Thomas Leppelt and Soeren Gebbert
"""
Modified: grass/trunk/lib/python/temporal/temporal_raster_algebra.py
===================================================================
--- grass/trunk/lib/python/temporal/temporal_raster_algebra.py 2014-09-28 01:40:32 UTC (rev 62120)
+++ grass/trunk/lib/python/temporal/temporal_raster_algebra.py 2014-09-28 01:46:15 UTC (rev 62121)
@@ -1,5 +1,4 @@
-"""!@package grass.temporal
-
+"""
Temporal raster algebra
(C) 2013 by the GRASS Development Team
@@ -7,9 +6,9 @@
License (>=v2). Read the file COPYING that comes with GRASS
for details.
- at author Thomas Leppelt and Soeren Gebbert
+:authors: Thomas Leppelt and Soeren Gebbert
- at code
+.. code-block:: python
>>> p = TemporalRasterAlgebraLexer()
>>> p.build()
@@ -50,7 +49,6 @@
LexToken(SUB,'-',1,40)
LexToken(FLOAT,2.45,1,42)
- at endcode
"""
from temporal_raster_base_algebra import *
Modified: grass/trunk/lib/python/temporal/temporal_raster_base_algebra.py
===================================================================
--- grass/trunk/lib/python/temporal/temporal_raster_base_algebra.py 2014-09-28 01:40:32 UTC (rev 62120)
+++ grass/trunk/lib/python/temporal/temporal_raster_base_algebra.py 2014-09-28 01:46:15 UTC (rev 62121)
@@ -1,15 +1,14 @@
-"""!@package grass.temporal
+"""
+Temporal raster algebra base class
-Temporal raster algebra
-
(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.
- at author Thomas Leppelt and Soeren Gebbert
+:authors: Thomas Leppelt and Soeren Gebbert
- at code
+.. code-block:: python
>>> p = TemporalRasterAlgebraLexer()
>>> p.build()
@@ -93,7 +92,6 @@
LexToken(NAME,'D',1,45)
LexToken(RPAREN,')',1,46)
- at endcode
"""
import grass.pygrass.modules as pymod
@@ -103,7 +101,7 @@
##############################################################################
class TemporalRasterAlgebraLexer(TemporalAlgebraLexer):
- """!Lexical analyzer for the GRASS GIS temporal algebra"""
+ """Lexical analyzer for the GRASS GIS temporal algebra"""
def __init__(self):
TemporalAlgebraLexer.__init__(self)
@@ -204,57 +202,57 @@
######################### Temporal functions ##############################
def eval_toperator(self, operator, comparison = False):
- """!This function evaluates a string containing temporal operations.
+ """This function evaluates a string containing temporal operations.
- @param operator String of temporal operations, e.g. {equal|during,=!:}.
+ :param operator: String of temporal operations, e.g. {equal|during,=!:}.
- @return List of temporal relations (equal, during), the given function
+ :return: List of temporal relations (equal, during), the given function
(!:) and the interval/instances (=).
- @code
- >>> init(True)
- >>> p = TemporalRasterBaseAlgebraParser()
- >>> operator = "{equal,:}"
- >>> p.eval_toperator(operator)
- (['EQUAL'], '=', ':')
- >>> operator = "{equal|during,:}"
- >>> p.eval_toperator(operator)
- (['EQUAL', 'DURING'], '=', ':')
- >>> operator = "{equal,!:}"
- >>> p.eval_toperator(operator)
- (['EQUAL'], '=', '!:')
- >>> operator = "{equal|during,!:}"
- >>> p.eval_toperator(operator)
- (['EQUAL', 'DURING'], '=', '!:')
- >>> operator = "{equal|during,=!:}"
- >>> p.eval_toperator(operator)
- (['EQUAL', 'DURING'], '=', '!:')
- >>> operator = "{equal|during|starts,#}"
- >>> p.eval_toperator(operator)
- (['EQUAL', 'DURING', 'STARTS'], '=', '#')
- >>> operator = "{!:}"
- >>> p.eval_toperator(operator)
- (['EQUAL'], '=', '!:')
- >>> operator = "{=:}"
- >>> p.eval_toperator(operator)
- (['EQUAL'], '=', ':')
- >>> operator = "{#}"
- >>> p.eval_toperator(operator)
- (['EQUAL'], '=', '#')
- >>> operator = "{equal|during}"
- >>> p.eval_toperator(operator)
- (['EQUAL', 'DURING'], None, None)
- >>> operator = "{equal}"
- >>> p.eval_toperator(operator)
- (['EQUAL'], None, None)
- >>> operator = "{equal,||}"
- >>> p.eval_toperator(operator, True)
- (['EQUAL'], '=', '||')
- >>> operator = "{equal|during,&&}"
- >>> p.eval_toperator(operator, True)
- (['EQUAL', 'DURING'], '=', '&&')
+
+ .. code-block:: python
+
+ >>> init(True)
+ >>> p = TemporalRasterBaseAlgebraParser()
+ >>> operator = "{equal,:}"
+ >>> p.eval_toperator(operator)
+ (['EQUAL'], '=', ':')
+ >>> operator = "{equal|during,:}"
+ >>> p.eval_toperator(operator)
+ (['EQUAL', 'DURING'], '=', ':')
+ >>> operator = "{equal,!:}"
+ >>> p.eval_toperator(operator)
+ (['EQUAL'], '=', '!:')
+ >>> operator = "{equal|during,!:}"
+ >>> p.eval_toperator(operator)
+ (['EQUAL', 'DURING'], '=', '!:')
+ >>> operator = "{equal|during,=!:}"
+ >>> p.eval_toperator(operator)
+ (['EQUAL', 'DURING'], '=', '!:')
+ >>> operator = "{equal|during|starts,#}"
+ >>> p.eval_toperator(operator)
+ (['EQUAL', 'DURING', 'STARTS'], '=', '#')
+ >>> operator = "{!:}"
+ >>> p.eval_toperator(operator)
+ (['EQUAL'], '=', '!:')
+ >>> operator = "{=:}"
+ >>> p.eval_toperator(operator)
+ (['EQUAL'], '=', ':')
+ >>> operator = "{#}"
+ >>> p.eval_toperator(operator)
+ (['EQUAL'], '=', '#')
+ >>> operator = "{equal|during}"
+ >>> p.eval_toperator(operator)
+ (['EQUAL', 'DURING'], None, None)
+ >>> operator = "{equal}"
+ >>> p.eval_toperator(operator)
+ (['EQUAL'], None, None)
+ >>> operator = "{equal,||}"
+ >>> p.eval_toperator(operator, True)
+ (['EQUAL'], '=', '||')
+ >>> operator = "{equal|during,&&}"
+ >>> p.eval_toperator(operator, True)
+ (['EQUAL', 'DURING'], '=', '&&')
- @endcode
-
"""
p = TemporalRasterOperatorParser()
p.parse(operator, comparison)
Modified: grass/trunk/lib/python/temporal/temporal_raster_operator.py
===================================================================
--- grass/trunk/lib/python/temporal/temporal_raster_operator.py 2014-09-28 01:40:32 UTC (rev 62120)
+++ grass/trunk/lib/python/temporal/temporal_raster_operator.py 2014-09-28 01:46:15 UTC (rev 62121)
@@ -1,5 +1,4 @@
-"""!@package grass.temporal
-
+"""
Temporal operator evaluation with PLY
(C) 2013 by the GRASS Development Team
@@ -7,9 +6,10 @@
License (>=v2). Read the file COPYING that comes with GRASS
for details.
- at author Thomas Leppelt and Soeren Gebbert
+:authors: Thomas Leppelt and Soeren Gebbert
- at code
+.. code-block:: python
+
>>> p = TemporalRasterOperatorParser()
>>> expression = "{equal| during | follows,+!:}"
>>> p.parse(expression)
@@ -64,7 +64,6 @@
>>> print(p.relations, p.temporal, p.function)
(['equal', 'during', 'contains'], '|', '*')
- at endcode
"""
try:
@@ -74,7 +73,7 @@
pass
class TemporalRasterOperatorLexer(object):
- """!Lexical analyzer for the GRASS GIS temporal operator"""
+ """Lexical analyzer for the GRASS GIS temporal operator"""
# Functions that defines topological relations.
relations = {
Modified: grass/trunk/lib/python/temporal/temporal_topology_dataset_connector.py
===================================================================
--- grass/trunk/lib/python/temporal/temporal_topology_dataset_connector.py 2014-09-28 01:40:32 UTC (rev 62120)
+++ grass/trunk/lib/python/temporal/temporal_topology_dataset_connector.py 2014-09-28 01:46:15 UTC (rev 62121)
@@ -1,26 +1,25 @@
# -*- coding: utf-8 -*-
-"""!@package grass.temporal
+"""
+Temporal topology dataset connector class
- at brief GRASS Python scripting module (temporal GIS functions)
-
-Temporal GIS related functions to be used in temporal GIS Python library package.
-
Usage:
->>> import grass.temporal as tgis
->>> tmr = tgis.TemporalTopologyDatasetConnector()
+.. code-block:: python:
+ >>> import grass.temporal as tgis
+ >>> tmr = tgis.TemporalTopologyDatasetConnector()
+
(C) 2012-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.
- at author Soeren Gebbert
+:authors: Soeren Gebbert
"""
import copy
class TemporalTopologyDatasetConnector(object):
- """!This class implements a temporal topology access structure to connect temporal related datasets
+ """This class implements a temporal topology access structure to connect temporal related datasets
This object will be set up by temporal topology creation method provided by the
SpatioTemporalTopologyBuilder.
@@ -29,6 +28,7 @@
let the user walk temporally forward and backward in time.
The following temporal relations with access methods are supported:
+
- equal
- follows
- precedes
@@ -42,100 +42,96 @@
- finished
- @code:
- # We have build the temporal topology and we know the first map
- start = first
- while start:
+ .. code-block:: python:
+
+ # We have build the temporal topology and we know the first map
+ start = first
+ while start:
- # Print all maps this map temporally contains
- dlist = start.get_contains()
- for map in dlist:
- map.print_info()
+ # Print all maps this map temporally contains
+ dlist = start.get_contains()
+ for map in dlist:
+ map.print_info()
- start = start.next()
- @endcode
+ start = start.next()
- Usage:
-
- @code
-
- >>> import grass.temporal as tgis
- >>> tgis.init()
- >>> map = tgis.RasterDataset("a at P")
- >>> tmr = tgis.TemporalTopologyDatasetConnector()
- >>> tmr.set_next(map)
- >>> tmr.set_prev(map)
- >>> tmr.append_equal(map)
- >>> tmr.append_follows(map)
- >>> tmr.append_precedes(map)
- >>> tmr.append_overlapped(map)
- >>> tmr.append_overlaps(map)
- >>> tmr.append_during(map)
- >>> tmr.append_contains(map)
- >>> tmr.append_starts(map)
- >>> tmr.append_started(map)
- >>> tmr.append_finishes(map)
- >>> tmr.append_finished(map)
- >>> tmr.print_temporal_topology_info()
- +-------------------- Temporal Topology -------------------------------------+
- | Next: ...................... a at P
- | Previous: .................. a at P
- | Equal:...................... a at P
- | Follows: ................... a at P
- | Precedes: .................. a at P
- | Overlaps: .................. a at P
- | Overlapped: ................ a at P
- | During: .................... a at P
- | Contains: .................. a at P
- | Starts:.. .................. a at P
- | Started:. .................. a at P
- | Finishes:................... a at P
- | Finished:................... a at P
- >>> tmr.print_temporal_topology_shell_info()
- next=a at P
- prev=a at P
- equal=a at P
- follows=a at P
- precedes=a at P
- overlaps=a at P
- overlapped=a at P
- during=a at P
- contains=a at P
- starts=a at P
- started=a at P
- finishes=a at P
- finished=a at P
- >>> rlist = tmr.get_temporal_relations()
- >>> if "FINISHED" in rlist.keys():
- ... print rlist["FINISHED"][0].get_id()
- a at P
+ >>> import grass.temporal as tgis
+ >>> tgis.init()
+ >>> map = tgis.RasterDataset("a at P")
+ >>> tmr = tgis.TemporalTopologyDatasetConnector()
+ >>> tmr.set_next(map)
+ >>> tmr.set_prev(map)
+ >>> tmr.append_equal(map)
+ >>> tmr.append_follows(map)
+ >>> tmr.append_precedes(map)
+ >>> tmr.append_overlapped(map)
+ >>> tmr.append_overlaps(map)
+ >>> tmr.append_during(map)
+ >>> tmr.append_contains(map)
+ >>> tmr.append_starts(map)
+ >>> tmr.append_started(map)
+ >>> tmr.append_finishes(map)
+ >>> tmr.append_finished(map)
+ >>> tmr.print_temporal_topology_info()
+ +-------------------- Temporal Topology -------------------------------------+
+ | Next: ...................... a at P
+ | Previous: .................. a at P
+ | Equal:...................... a at P
+ | Follows: ................... a at P
+ | Precedes: .................. a at P
+ | Overlaps: .................. a at P
+ | Overlapped: ................ a at P
+ | During: .................... a at P
+ | Contains: .................. a at P
+ | Starts:.. .................. a at P
+ | Started:. .................. a at P
+ | Finishes:................... a at P
+ | Finished:................... a at P
+ >>> tmr.print_temporal_topology_shell_info()
+ next=a at P
+ prev=a at P
+ equal=a at P
+ follows=a at P
+ precedes=a at P
+ overlaps=a at P
+ overlapped=a at P
+ during=a at P
+ contains=a at P
+ starts=a at P
+ started=a at P
+ finishes=a at P
+ finished=a at P
+ >>> rlist = tmr.get_temporal_relations()
+ >>> if "FINISHED" in rlist.keys():
+ ... print rlist["FINISHED"][0].get_id()
+ a at P
- @endcode
"""
def __init__(self):
self.reset_temporal_topology()
def reset_temporal_topology(self):
- """!Reset any information about temporal topology"""
+ """Reset any information about temporal topology"""
self._temporal_topology = {}
self._has_temporal_topology = False
def get_temporal_relations(self):
- """!Return the dictionary of temporal relationships
+ """Return the dictionary of temporal relationships
Keys are the temporal relationships in upper case,
values are abstract map objects.
- @return The temporal relations dictionary
+ :return: The temporal relations dictionary
"""
return copy.copy(self._temporal_topology)
def get_number_of_temporal_relations(self):
- """! Return a dictionary in which the keys are the relation names and the value
+ """ Return a dictionary in which the keys are the relation names and the value
are the number of relations.
The following relations are available:
+
- equal
- follows
- precedes
@@ -151,7 +147,7 @@
To access topological information the temporal topology must be build first
using the SpatioTemporalTopologyBuilder.
- @return the dictionary with relations as keys and number as values or None in case the topology wasn't build
+ :return: the dictionary with relations as keys and number as values or None in case the topology wasn't build
"""
if self._has_temporal_topology == False:
return None
@@ -205,65 +201,65 @@
return relations
def set_temporal_topology_build_true(self):
- """!Same as name"""
+ """Same as name"""
self._has_temporal_topology = True
def set_temporal_topology_build_false(self):
- """!Same as name"""
+ """Same as name"""
self._has_temporal_topology = False
def is_temporal_topology_build(self):
- """!Check if the temporal topology was build"""
+ """Check if the temporal topology was build"""
return self._has_temporal_topology
def set_next(self, map):
- """!Set the map that is temporally as closest located after this map.
+ """Set the map that is temporally as closest located after this map.
Temporally located means that the start time of the "next" map is
temporally located AFTER the start time of this map, but temporally
near than other maps of the same dataset.
- @param map This object should be of type AbstractMapDataset
+ :param map: This object should be of type AbstractMapDataset
or derived classes
"""
self._temporal_topology["NEXT"] = map
def set_prev(self, map):
- """!Set the map that is temporally as closest located before this map.
+ """Set the map that is temporally as closest located before this map.
Temporally located means that the start time of the "previous" map is
temporally located BEFORE the start time of this map, but temporally
near than other maps of the same dataset.
- @param map This object should be of type AbstractMapDataset
+ :param map: This object should be of type AbstractMapDataset
or derived classes
"""
self._temporal_topology["PREV"] = map
def next(self):
- """!Return the map with a start time temporally located after
+ """Return the map with a start time temporally located after
the start time of this map, but temporal closer than other maps
- @return A map object or None
+ :return: A map object or None
"""
if "NEXT" not in self._temporal_topology:
return None
return self._temporal_topology["NEXT"]
def prev(self):
- """!Return the map with a start time temporally located before
+ """Return the map with a start time temporally located before
the start time of this map, but temporal closer than other maps
- @return A map object or None
+ :return: A map object or None
"""
if "PREV" not in self._temporal_topology:
return None
return self._temporal_topology["PREV"]
def append_equal(self, map):
- """!Append a map with equivalent temporal extent as this map
+ """Append a map with equivalent temporal extent as this map
- @param map This object should be of type AbstractMapDataset
+ :param map: This object should be of type AbstractMapDataset
or derived classes
"""
if "EQUAL" not in self._temporal_topology:
@@ -271,18 +267,18 @@
self._temporal_topology["EQUAL"].append(map)
def get_equal(self):
- """!Return a list of map objects with equivalent temporal extent as this map
+ """Return a list of map objects with equivalent temporal extent as this map
- @return A list of map objects or None
+ :return: A list of map objects or None
"""
if "EQUAL" not in self._temporal_topology:
return None
return self._temporal_topology["EQUAL"]
def append_starts(self, map):
- """!Append a map that this map temporally starts with
+ """Append a map that this map temporally starts with
- @param map This object should be of type AbstractMapDataset
+ :param map: This object should be of type AbstractMapDataset
or derived classes
"""
if "STARTS" not in self._temporal_topology:
@@ -290,18 +286,18 @@
self._temporal_topology["STARTS"].append(map)
def get_starts(self):
- """!Return a list of map objects that this map temporally starts with
+ """Return a list of map objects that this map temporally starts with
- @return A list of map objects or None
+ :return: A list of map objects or None
"""
if "STARTS" not in self._temporal_topology:
return None
return self._temporal_topology["STARTS"]
def append_started(self, map):
- """!Append a map that this map temporally started with
+ """Append a map that this map temporally started with
- @param map This object should be of type AbstractMapDataset
+ :param map: This object should be of type AbstractMapDataset
or derived classes
"""
if "STARTED" not in self._temporal_topology:
@@ -309,18 +305,18 @@
self._temporal_topology["STARTED"].append(map)
def get_started(self):
- """!Return a list of map objects that this map temporally started with
+ """Return a list of map objects that this map temporally started with
- @return A list of map objects or None
+ :return: A list of map objects or None
"""
if "STARTED" not in self._temporal_topology:
return None
return self._temporal_topology["STARTED"]
def append_finishes(self, map):
- """!Append a map that this map temporally finishes with
+ """Append a map that this map temporally finishes with
- @param map This object should be of type AbstractMapDataset
+ :param map: This object should be of type AbstractMapDataset
or derived classes
"""
if "FINISHES" not in self._temporal_topology:
@@ -328,18 +324,18 @@
self._temporal_topology["FINISHES"].append(map)
def get_finishes(self):
- """!Return a list of map objects that this map temporally finishes with
+ """Return a list of map objects that this map temporally finishes with
- @return A list of map objects or None
+ :return: A list of map objects or None
"""
if "FINISHES" not in self._temporal_topology:
return None
return self._temporal_topology["FINISHES"]
def append_finished(self, map):
- """!Append a map that this map temporally finished with
+ """Append a map that this map temporally finished with
- @param map This object should be of type AbstractMapDataset
+ :param map: This object should be of type AbstractMapDataset
or derived classes
"""
if "FINISHED" not in self._temporal_topology:
@@ -347,18 +343,18 @@
self._temporal_topology["FINISHED"].append(map)
def get_finished(self):
- """!Return a list of map objects that this map temporally finished with
+ """Return a list of map objects that this map temporally finished with
- @return A list of map objects or None
+ :return: A list of map objects or None
"""
if "FINISHED" not in self._temporal_topology:
return None
return self._temporal_topology["FINISHED"]
def append_overlaps(self, map):
- """!Append a map that this map temporally overlaps
+ """Append a map that this map temporally overlaps
- @param map This object should be of type AbstractMapDataset
+ :param map: This object should be of type AbstractMapDataset
or derived classes
"""
if "OVERLAPS" not in self._temporal_topology:
@@ -366,18 +362,18 @@
self._temporal_topology["OVERLAPS"].append(map)
def get_overlaps(self):
- """!Return a list of map objects that this map temporally overlaps
+ """Return a list of map objects that this map temporally overlaps
- @return A list of map objects or None
+ :return: A list of map objects or None
"""
if "OVERLAPS" not in self._temporal_topology:
return None
return self._temporal_topology["OVERLAPS"]
def append_overlapped(self, map):
- """!Append a map that this map temporally overlapped
+ """Append a map that this map temporally overlapped
- @param map This object should be of type AbstractMapDataset
+ :param map: This object should be of type AbstractMapDataset
or derived classes
"""
if "OVERLAPPED" not in self._temporal_topology:
@@ -385,18 +381,18 @@
self._temporal_topology["OVERLAPPED"].append(map)
def get_overlapped(self):
- """!Return a list of map objects that this map temporally overlapped
+ """Return a list of map objects that this map temporally overlapped
- @return A list of map objects or None
+ :return: A list of map objects or None
"""
if "OVERLAPPED" not in self._temporal_topology:
return None
return self._temporal_topology["OVERLAPPED"]
def append_follows(self, map):
- """!Append a map that this map temporally follows
+ """Append a map that this map temporally follows
- @param map This object should be of type AbstractMapDataset
+ :param map: This object should be of type AbstractMapDataset
or derived classes
"""
if "FOLLOWS" not in self._temporal_topology:
@@ -404,18 +400,18 @@
self._temporal_topology["FOLLOWS"].append(map)
def get_follows(self):
- """!Return a list of map objects that this map temporally follows
+ """Return a list of map objects that this map temporally follows
- @return A list of map objects or None
+ :return: A list of map objects or None
"""
if "FOLLOWS" not in self._temporal_topology:
return None
return self._temporal_topology["FOLLOWS"]
def append_precedes(self, map):
- """!Append a map that this map temporally precedes
+ """Append a map that this map temporally precedes
- @param map This object should be of type AbstractMapDataset
+ :param map: This object should be of type AbstractMapDataset
or derived classes
"""
if "PRECEDES" not in self._temporal_topology:
@@ -423,19 +419,19 @@
self._temporal_topology["PRECEDES"].append(map)
def get_precedes(self):
- """!Return a list of map objects that this map temporally precedes
+ """Return a list of map objects that this map temporally precedes
- @return A list of map objects or None
+ :return: A list of map objects or None
"""
if "PRECEDES" not in self._temporal_topology:
return None
return self._temporal_topology["PRECEDES"]
def append_during(self, map):
- """!Append a map that this map is temporally located during
+ """Append a map that this map is temporally located during
This includes temporal relationships starts and finishes
- @param map This object should be of type
+ :param map: This object should be of type
AbstractMapDataset or derived classes
"""
if "DURING" not in self._temporal_topology:
@@ -443,20 +439,20 @@
self._temporal_topology["DURING"].append(map)
def get_during(self):
- """!Return a list of map objects that this map is temporally located during
+ """Return a list of map objects that this map is temporally located during
This includes temporally relationships starts and finishes
- @return A list of map objects or None
+ :return: A list of map objects or None
"""
if "DURING" not in self._temporal_topology:
return None
return self._temporal_topology["DURING"]
def append_contains(self, map):
- """!Append a map that this map temporally contains
+ """Append a map that this map temporally contains
This includes temporal relationships started and finished
- @param map This object should be of type AbstractMapDataset
+ :param map: This object should be of type AbstractMapDataset
or derived classes
"""
if "CONTAINS" not in self._temporal_topology:
@@ -464,10 +460,10 @@
self._temporal_topology["CONTAINS"].append(map)
def get_contains(self):
- """!Return a list of map objects that this map temporally contains
+ """Return a list of map objects that this map temporally contains
This includes temporal relationships started and finished
- @return A list of map objects or None
+ :return: A list of map objects or None
"""
if "CONTAINS" not in self._temporal_topology:
return None
@@ -513,7 +509,7 @@
fset=append_finished)
def print_temporal_topology_info(self):
- """!Print information about this class in human readable style"""
+ """Print information about this class in human readable style"""
print " +-------------------- Temporal Topology -------------------------------------+"
# 0123456789012345678901234567890
@@ -556,7 +552,7 @@
self._generate_map_list_string(self.finished)
def print_temporal_topology_shell_info(self):
- """!Print information about this class in shell style"""
+ """Print information about this class in shell style"""
if self.next() is not None:
print "next=" + self.next().get_id()
Modified: grass/trunk/lib/python/temporal/temporal_vector_algebra.py
===================================================================
--- grass/trunk/lib/python/temporal/temporal_vector_algebra.py 2014-09-28 01:40:32 UTC (rev 62120)
+++ grass/trunk/lib/python/temporal/temporal_vector_algebra.py 2014-09-28 01:46:15 UTC (rev 62121)
@@ -1,5 +1,4 @@
-"""!@package grass.temporal
-
+"""
Temporal vector algebra
(C) 2014 by the GRASS Development Team
@@ -7,9 +6,9 @@
License (>=v2). Read the file COPYING that comes with GRASS
for details.
- at authors Thomas Leppelt and Soeren Gebbert
+:authors: Thomas Leppelt and Soeren Gebbert
- at code
+.. code-block:: python
>>> import grass.temporal as tgis
>>> tgis.init(True)
@@ -416,7 +415,6 @@
A* = if condition True then A else B
C = A*
- at endcode
"""
import grass.pygrass.modules as pygrass
@@ -426,7 +424,7 @@
##############################################################################
class TemporalVectorAlgebraLexer(TemporalAlgebraLexer):
- """!Lexical analyzer for the GRASS GIS temporal vector algebra"""
+ """Lexical analyzer for the GRASS GIS temporal vector algebra"""
def __init__(self):
TemporalAlgebraLexer.__init__(self)
@@ -511,7 +509,7 @@
######################### Temporal functions ##############################
def remove_intermediate_vector_maps(self):
- """! Removes the intermediate vector maps.
+ """ Removes the intermediate vector maps.
"""
if self.names != {}:
namelist = self.names.values()
@@ -530,62 +528,61 @@
m.run()
def eval_toperator(self, operator, comparison = False):
- """!This function evaluates a string containing temporal operations.
+ """This function evaluates a string containing temporal operations.
- @param operator String of temporal operations, e.g. {equal|during,=!:}.
+ :param operator: String of temporal operations, e.g. {equal|during,=!:}.
- @return List of temporal relations (equal, during), the given function
+ :return: List of temporal relations (equal, during), the given function
(!:) and the interval/instances (=).
- @code
- >>> import grass.temporal as tgis
- >>> tgis.init(True)
- >>> p = tgis.TemporalVectorAlgebraParser()
- >>> operator = "{equal,:}"
- >>> p.eval_toperator(operator)
- (['EQUAL'], '=', ':')
- >>> operator = "{equal|during,:}"
- >>> p.eval_toperator(operator)
- (['EQUAL', 'DURING'], '=', ':')
- >>> operator = "{equal,!:}"
- >>> p.eval_toperator(operator)
- (['EQUAL'], '=', '!:')
- >>> operator = "{equal|during,!:}"
- >>> p.eval_toperator(operator)
- (['EQUAL', 'DURING'], '=', '!:')
- >>> operator = "{equal|during,=!:}"
- >>> p.eval_toperator(operator)
- (['EQUAL', 'DURING'], '=', '!:')
- >>> operator = "{equal|during|starts,#}"
- >>> p.eval_toperator(operator)
- (['EQUAL', 'DURING', 'STARTS'], '=', '#')
- >>> operator = "{!:}"
- >>> p.eval_toperator(operator)
- (['EQUAL'], '=', '!:')
- >>> operator = "{=:}"
- >>> p.eval_toperator(operator)
- (['EQUAL'], '=', ':')
- >>> operator = "{#}"
- >>> p.eval_toperator(operator)
- (['EQUAL'], '=', '#')
- >>> operator = "{equal|during}"
- >>> p.eval_toperator(operator)
- (['EQUAL', 'DURING'], None, None)
- >>> operator = "{equal}"
- >>> p.eval_toperator(operator)
- (['EQUAL'], None, None)
- >>> operator = "{equal,||}"
- >>> p.eval_toperator(operator, True)
- (['EQUAL'], '=', '||')
- >>> operator = "{equal|during,&&}"
- >>> p.eval_toperator(operator, True)
- (['EQUAL', 'DURING'], '=', '&&')
- >>> operator = "{&}"
- >>> p.eval_toperator(operator)
- (['EQUAL'], '=', '&')
+ .. code-block:: python
+
+ >>> import grass.temporal as tgis
+ >>> tgis.init(True)
+ >>> p = tgis.TemporalVectorAlgebraParser()
+ >>> operator = "{equal,:}"
+ >>> p.eval_toperator(operator)
+ (['EQUAL'], '=', ':')
+ >>> operator = "{equal|during,:}"
+ >>> p.eval_toperator(operator)
+ (['EQUAL', 'DURING'], '=', ':')
+ >>> operator = "{equal,!:}"
+ >>> p.eval_toperator(operator)
+ (['EQUAL'], '=', '!:')
+ >>> operator = "{equal|during,!:}"
+ >>> p.eval_toperator(operator)
+ (['EQUAL', 'DURING'], '=', '!:')
+ >>> operator = "{equal|during,=!:}"
+ >>> p.eval_toperator(operator)
+ (['EQUAL', 'DURING'], '=', '!:')
+ >>> operator = "{equal|during|starts,#}"
+ >>> p.eval_toperator(operator)
+ (['EQUAL', 'DURING', 'STARTS'], '=', '#')
+ >>> operator = "{!:}"
+ >>> p.eval_toperator(operator)
+ (['EQUAL'], '=', '!:')
+ >>> operator = "{=:}"
+ >>> p.eval_toperator(operator)
+ (['EQUAL'], '=', ':')
+ >>> operator = "{#}"
+ >>> p.eval_toperator(operator)
+ (['EQUAL'], '=', '#')
+ >>> operator = "{equal|during}"
+ >>> p.eval_toperator(operator)
+ (['EQUAL', 'DURING'], None, None)
+ >>> operator = "{equal}"
+ >>> p.eval_toperator(operator)
+ (['EQUAL'], None, None)
+ >>> operator = "{equal,||}"
+ >>> p.eval_toperator(operator, True)
+ (['EQUAL'], '=', '||')
+ >>> operator = "{equal|during,&&}"
+ >>> p.eval_toperator(operator, True)
+ (['EQUAL', 'DURING'], '=', '&&')
+ >>> operator = "{&}"
+ >>> p.eval_toperator(operator)
+ (['EQUAL'], '=', '&')
- @endcode
-
"""
p = TemporalVectorOperatorParser()
@@ -596,15 +593,15 @@
def overlay_map_extent(self, mapA, mapB, bool_op = None, temp_op = '=',
copy = False):
- """!Compute the spatio-temporal extent of two topological related maps
+ """Compute the spatio-temporal extent of two topological related maps
- @param mapA The first map
- @param mapB The second maps
- @param bool_op The boolean operator specifying the spatial extent
+ :param mapA: The first map
+ :param mapB: The second maps
+ :param bool_op: The boolean operator specifying the spatial extent
operation (intersection, union, disjoint union)
- @param temp_op The temporal operator specifying the temporal
+ :param temp_op: The temporal operator specifying the temporal
exntent operation (intersection, union, disjoint union)
- @param copy Specifies if the temporal extent of mapB should be
+ :param copy: Specifies if the temporal extent of mapB should be
copied to mapA
"""
returncode = TemporalAlgebraParser.overlay_map_extent(self, mapA, mapB,
@@ -789,15 +786,15 @@
t[0] = t[1]
def create_overlay_operations(self, maplistA, maplistB, relations, temporal, function):
- """!Create the spatial overlay operation commad list
+ """Create the spatial overlay operation commad list
- @param maplistA A list of map objects
- @param maplistB A list of map objects
- @param relations The temporal relationships that must be fullfilled as list of strings
+ :param maplistA: A list of map objects
+ :param maplistB: A list of map objects
+ :param relations: The temporal relationships that must be fullfilled as list of strings
("EQUAL", "DURING", ...)
- @param temporal The temporal operator as string "=" or "&", ...
- @param function The spatial overlay operations as string "&", "|", ...
- @return Return the list of maps with overlay commands
+ :param temporal: The temporal operator as string "=" or "&", ...
+ :param function: The spatial overlay operations as string "&", "|", ...
+ :return: Return the list of maps with overlay commands
"""
topolist = self.get_temporal_topo_list(maplistA, maplistB, topolist = relations)
Modified: grass/trunk/lib/python/temporal/temporal_vector_operator.py
===================================================================
--- grass/trunk/lib/python/temporal/temporal_vector_operator.py 2014-09-28 01:40:32 UTC (rev 62120)
+++ grass/trunk/lib/python/temporal/temporal_vector_operator.py 2014-09-28 01:46:15 UTC (rev 62121)
@@ -1,5 +1,4 @@
-"""!@package grass.temporal
-
+"""
Temporal vector operator evaluation with PLY
(C) 2014 by the GRASS Development Team
@@ -7,9 +6,10 @@
License (>=v2). Read the file COPYING that comes with GRASS
for details.
- at authors Thomas Leppelt and Soeren Gebbert
+:authors: Thomas Leppelt and Soeren Gebbert
- at code
+.. code-block:: python
+
>>> import grass.temporal as tgis
>>> tgis.init(True)
>>> p = tgis.TemporalVectorOperatorParser()
@@ -62,7 +62,6 @@
>>> print(p.relations, p.temporal, p.function)
([['overlaps', 'overlapped'], 'equal'], '|', '|')
- at endcode
"""
try:
import ply.lex as lex
@@ -71,7 +70,7 @@
pass
class TemporalVectorOperatorLexer(object):
- """!Lexical analyzer for the GRASS GIS temporal vector operators"""
+ """Lexical analyzer for the GRASS GIS temporal vector operators"""
# Functions that defines topological relations.
relations = {
@@ -164,7 +163,7 @@
print tok
class TemporalVectorOperatorParser(object):
- """!The parser for the GRASS GIS temporal vector operators"""
+ """The parser for the GRASS GIS temporal vector operators"""
def __init__(self):
self.lexer = TemporalVectorOperatorLexer()
@@ -346,4 +345,4 @@
if __name__ == "__main__":
import doctest
doctest.testmod()
-
\ No newline at end of file
+
Modified: grass/trunk/lib/python/temporal/unit_tests.py
===================================================================
--- grass/trunk/lib/python/temporal/unit_tests.py 2014-09-28 01:40:32 UTC (rev 62120)
+++ grass/trunk/lib/python/temporal/unit_tests.py 2014-09-28 01:46:15 UTC (rev 62121)
@@ -1,24 +1,12 @@
-"""!@package grass.temporal
+"""
+Depricazed unittests
- at brief GRASS Python scripting module (temporal GIS functions)
-
-Temporal GIS unit tests
-
-Usage:
-
- at code
-import grass.temporal as tgis
-
-tgis.test_increment_datetime_by_string()
-...
- at endcode
-
(C) 2008-2011 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.
- at author Soeren Gebbert
+:authors: Soeren Gebbert
"""
import copy
from datetime import datetime, date, time, timedelta
Modified: grass/trunk/lib/python/temporal/univar_statistics.py
===================================================================
--- grass/trunk/lib/python/temporal/univar_statistics.py 2014-09-28 01:40:32 UTC (rev 62120)
+++ grass/trunk/lib/python/temporal/univar_statistics.py 2014-09-28 01:46:15 UTC (rev 62121)
@@ -1,26 +1,22 @@
-"""!@package grass.temporal
+"""
+Univariate statistic function for space time datasets
- at brief GRASS Python scripting module (temporal GIS functions)
-
-Temporal GIS related functions to be used in Python scripts.
-
Usage:
- at code
+.. code-block:: python
+
import grass.temporal as tgis
-tgis.print_gridded_dataset_univar_statistics(
- type, input, where, extended, no_header, fs)
+ tgis.print_gridded_dataset_univar_statistics(
+ type, input, where, extended, no_header, fs)
-...
- at endcode
(C) 2012-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.
- at author Soeren Gebbert
+:authors: Soeren Gebbert
"""
from open_stds import *
@@ -31,14 +27,14 @@
def print_gridded_dataset_univar_statistics(type, input, where, extended,
no_header=False, fs="|"):
- """!Print univariate statistics for a space time raster or raster3d dataset
+ """Print univariate statistics for a space time raster or raster3d dataset
- @param type Must be "strds" or "str3ds"
- @param input The name of the space time dataset
- @param where A temporal database where statement
- @param extended If True compute extended statistics
- @param no_header Supress the printing of column names
- @param fs Field separator
+ :param type: Must be "strds" or "str3ds"
+ :param input: The name of the space time dataset
+ :param where: A temporal database where statement
+ :param extended: If True compute extended statistics
+ :param no_header: Supress the printing of column names
+ :param fs: Field separator
"""
# We need a database interface
@@ -108,18 +104,18 @@
def print_vector_dataset_univar_statistics(input, twhere, layer, type, column,
where, extended, no_header=False, fs="|"):
- """!Print univariate statistics for a space time vector dataset
+ """Print univariate statistics for a space time vector dataset
- @param input The name of the space time dataset
- @param twhere A temporal database where statement
- @param layer The layer number used in case no layer is present
+ :param input: The name of the space time dataset
+ :param twhere: A temporal database where statement
+ :param layer: The layer number used in case no layer is present
in the temporal dataset
- @param type options: point,line,boundary,centroid,area
- @param column The name of the attribute column
- @param where A temporal database where statement
- @param extended If True compute extended statistics
- @param no_header Supress the printing of column names
- @param fs Field separator
+ :param type: options: point,line,boundary,centroid,area
+ :param column: The name of the attribute column
+ :param where: A temporal database where statement
+ :param extended: If True compute extended statistics
+ :param no_header: Supress the printing of column names
+ :param fs: Field separator
"""
# We need a database interface
More information about the grass-commit
mailing list