Geografic-Information-System/lib/python/temporal/abstract_temporal_dataset.py

# -*- coding: utf-8 -*-
"""!@package grass.temporal

@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.AbstractTemporalDataset()

(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.

@author Soeren Gebbert
"""
from abstract_dataset import *
from datetime_math import *


class AbstractTemporalDataset(AbstractDataset):
    """!This class implements a temporal topology access structure for an abstract dataset

       This object will be set up by temporal topology creation method provided by the 
       TemporallyTopologyBuilder.

       If correctly initialize the calls next() and prev() 
       let the user walk temporally forward and backward in time.

       The following temporal relations with access methods are supported:
       * equal
       * follows
       * precedes
       * overlaps
       * overlapped
       * during (including starts, finishes)
       * contains (including started, finished)
       * starts
       * started
       * finishes
       * finished


       @code:
       # 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()

           start = start.next()
         @endcode  
        
        Usage:
        
        @code
        
        >>> tmr = AbstractTemporalDataset()
        >>> tmr.print_topology_info()
         +-------------------- Temporal Topology -------------------------------------+
        >>> tmr.print_topology_shell_info()
        
        @endcode
    """

    def __init__(self):
        AbstractDataset.__init__(self)
        self.reset_topology()

    def reset_topology(self):
        """!Reset any information about temporal topology"""
        self._topology = {}
        self._has_topology = False
        
    def get_number_of_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:
        * equal
        * follows
        * precedes
        * overlaps
        * overlapped
        * during (including starts, finishes)
        * contains (including started, finished)
        * starts
        * started
        * finishes
        * finished
        
        To access topological information the temporal topology must be build first
        using the TemporalTopologyBuilder.
        
        @return the dictionary with relations as keys and number as values or None in case the topology wasn't build
        """
        if self._has_topology == False:
            return None
    
        relations = {}
        try:
            relations["equal"] = len(self._topology["EQUAL"]) 
        except:
            relations["equal"] = 0
        try: 
            relations["follows"] = len(self._topology["FOLLOWS"]) 
        except: 
            relations["follows"] = 0
        try: 
            relations["precedes"] = len(self._topology["PRECEDES"])
        except: 
            relations["precedes"] = 0
        try: 
            relations["overlaps"] = len(self._topology["OVERLAPS"])
        except: 
            relations["overlaps"] = 0
        try: 
            relations["overlapped"] = len(self._topology["OVERLAPPED"])
        except: 
            relations["overlapped"] = 0
        try: 
            relations["during"] = len(self._topology["DURING"])
        except: 
            relations["during"] = 0
        try: 
            relations["contains"] = len(self._topology["CONTAINS"])
        except: 
            relations["contains"] = 0
        try: 
            relations["starts"] = len(self._topology["STARTS"])
        except: 
            relations["starts"] = 0
        try:    
            relations["started"] = len(self._topology["STARTED"])
        except: 
            relations["started"] = 0
        try: 
            relations["finishes"] = len(self._topology["FINISHES"])
        except: 
            relations["finishes"] = 0
        try: 
            relations["finished"] = len(self._topology["FINISHED"])
        except: 
            relations["finished"] = 0
            
        return relations

    def set_topology_build_true(self):
        """!Same as name"""
        self._has_topology = True

    def set_topology_build_false(self):
        """!Same as name"""
        self._has_topology = False

    def is_topology_build(self):
        """!Check if the temporal topology was build"""
        return self._has_topology

    def set_next(self, 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 
                        or derived classes
        """
        self._topology["NEXT"] = map_

    def set_prev(self, 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 
                        or derived classes
        """
        self._topology["PREV"] = map_

    def next(self):
        """!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
        """
        if "NEXT" not in self._topology:
            return None
        return self._topology["NEXT"]

    def prev(self):
        """!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
        """
        if "PREV" not in self._topology:
            return None
        return self._topology["PREV"]

    def append_equivalent(self, map_):
        """!Append a map with equivalent temporal extent as this map

           @param map_: This object should be of type AbstractMapDataset 
                        or derived classes
        """
        if "EQUAL" not in self._topology:
            self._topology["EQUAL"] = []
        self._topology["EQUAL"].append(map_)

    def get_equivalent(self):
        """!Return a list of map objects with equivalent temporal extent as this map

           @return A list of map objects or None
        """
        if "EQUAL" not in self._topology:
            return None
        return self._topology["EQUAL"]

    def append_starts(self, map_):
        """!Append a map that this map temporally starts with

           @param map_: This object should be of type AbstractMapDataset 
                        or derived classes
        """
        if "STARTS" not in self._topology:
            self._topology["STARTS"] = []
        self._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 or None
        """
        if "STARTS" not in self._topology:
            return None
        return self._topology["STARTS"]

    def append_started(self, map_):
        """!Append a map that this map temporally started with

           @param map_: This object should be of type AbstractMapDataset 
                        or derived classes
        """
        if "STARTED" not in self._topology:
            self._topology["STARTED"] = []
        self._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 or None
        """
        if "STARTED" not in self._topology:
            return None
        return self._topology["STARTED"]

    def append_finishes(self, map_):
        """!Append a map that this map temporally finishes with

           @param map_: This object should be of type AbstractMapDataset 
                        or derived classes
        """
        if "FINISHES" not in self._topology:
            self._topology["FINISHES"] = []
        self._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 or None
        """
        if "FINISHES" not in self._topology:
            return None
        return self._topology["FINISHES"]

    def append_finished(self, map_):
        """!Append a map that this map temporally finished with

           @param map_: This object should be of type AbstractMapDataset 
                        or derived classes
        """
        if "FINISHED" not in self._topology:
            self._topology["FINISHED"] = []
        self._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 or None
        """
        if "FINISHED" not in self._topology:
            return None
        return self._topology["FINISHED"]

    def append_overlaps(self, map_):
        """!Append a map that this map temporally overlaps

           @param map_: This object should be of type AbstractMapDataset 
                        or derived classes
        """
        if "OVERLAPS" not in self._topology:
            self._topology["OVERLAPS"] = []
        self._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 or None
        """
        if "OVERLAPS" not in self._topology:
            return None
        return self._topology["OVERLAPS"]

    def append_overlapped(self, map_):
        """!Append a map that this map temporally overlapped

           @param map_: This object should be of type AbstractMapDataset 
                        or derived classes
        """
        if "OVERLAPPED" not in self._topology:
            self._topology["OVERLAPPED"] = []
        self._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 or None
        """
        if "OVERLAPPED" not in self._topology:
            return None
        return self._topology["OVERLAPPED"]

    def append_follows(self, map_):
        """!Append a map that this map temporally follows

           @param map_: This object should be of type AbstractMapDataset 
                        or derived classes
        """
        if "FOLLOWS" not in self._topology:
            self._topology["FOLLOWS"] = []
        self._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 or None
        """
        if "FOLLOWS" not in self._topology:
            return None
        return self._topology["FOLLOWS"]

    def append_precedes(self, map_):
        """!Append a map that this map temporally precedes

           @param map_: This object should be of type AbstractMapDataset 
                        or derived classes
        """
        if "PRECEDES" not in self._topology:
            self._topology["PRECEDES"] = []
        self._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 or None
        """
        if "PRECEDES" not in self._topology:
            return None
        return self._topology["PRECEDES"]

    def append_during(self, map_):
        """!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 
                        AbstractMapDataset or derived classes
        """
        if "DURING" not in self._topology:
            self._topology["DURING"] = []
        self._topology["DURING"].append(map_)

    def get_during(self):
        """!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
        """
        if "DURING" not in self._topology:
            return None
        return self._topology["DURING"]

    def append_contains(self, map_):
        """!Append a map that this map temporally contains
           This includes temporal relationships started and finished

           @param map_: This object should be of type AbstractMapDataset 
                        or derived classes
        """
        if "CONTAINS" not in self._topology:
            self._topology["CONTAINS"] = []
        self._topology["CONTAINS"].append(map_)

    def get_contains(self):
        """!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
        """
        if "CONTAINS" not in self._topology:
            return None
        return self._topology["CONTAINS"]

    def _generate_map_list_string(self, map_list, line_wrap=True):
        count = 0
        string = ""
        for map_ in map_list:
            if line_wrap and count > 0 and count % 3 == 0:
                string += "\n | ............................ "
                count = 0
            if count == 0:
                string += map_.get_id()
            else:
                string += ",%s" % map_.get_id()
            count += 1

        return string
    
    # Set the properties
    equivalent = property(fget=get_equivalent, 
                                       fset=append_equivalent)
    follows = property(fget=get_follows, 
                                    fset=append_follows)
    precedes = property(fget=get_precedes, 
                                     fset=append_precedes)
    overlaps = property(fget=get_overlaps, 
                                     fset=append_overlaps)
    overlapped = property(fget=get_overlapped, 
                                       fset=append_overlapped)
    during = property(fget=get_during, 
                                   fset=append_during)
    contains = property(fget=get_contains, 
                                     fset=append_contains)
    starts = property(fget=get_starts, 
                                     fset=append_starts)
    started = property(fget=get_started, 
                                     fset=append_started)
    finishes = property(fget=get_finishes, 
                                     fset=append_finishes)
    finished = property(fget=get_finished, 
                                     fset=append_finished)

    def print_topology_info(self):
        """!Print information about this class in human readable style"""
        _next = self.next()
        _prev = self.prev()
        _equal = self.get_equivalent()
        _follows = self.get_follows()
        _precedes = self.get_precedes()
        _overlaps = self.get_overlaps()
        _overlapped = self.get_overlapped()
        _during = self.get_during()
        _contains = self.get_contains()
        _starts = self.get_starts()
        _started = self.get_started()
        _finishes = self.get_finishes()
        _finished = self.get_finished()
        
        print " +-------------------- Temporal Topology -------------------------------------+"
        #          0123456789012345678901234567890
        if _next is not None:
            print " | Next: ...................... " + str(_next.get_id())
        if _prev is not None:
            print " | Previous: .................. " + str(_prev.get_id())
        if _equal is not None:
            print " | Equivalent: ................ " + \
                self._generate_map_list_string(_equal)
        if _follows is not None:
            print " | Follows: ................... " + \
                self._generate_map_list_string(_follows)
        if _precedes is not None:
            print " | Precedes: .................. " + \
                self._generate_map_list_string(_precedes)
        if _overlaps is not None:
            print " | Overlaps: .................. " + \
                self._generate_map_list_string(_overlaps)
        if _overlapped is not None:
            print " | Overlapped: ................ " + \
                self._generate_map_list_string(_overlapped)
        if _during is not None:
            print " | During: .................... " + \
                self._generate_map_list_string(_during)
        if _contains is not None:
            print " | Contains: .................. " + \
                self._generate_map_list_string(_contains)
        if _starts is not None:
            print " | Starts:.. .................. " + \
                self._generate_map_list_string(_starts)
        if _started is not None:
            print " | Started:. .................. " + \
                self._generate_map_list_string(_started)
        if _finishes is not None:
            print " | Finishes:................... " + \
                self._generate_map_list_string(_finishes)
        if _finished is not None:
            print " | Finished:................... " + \
                self._generate_map_list_string(_finished)

    def print_topology_shell_info(self):
        """!Print information about this class in shell style"""

        _next = self.next()
        _prev = self.prev()
        _equal = self.get_equivalent()
        _follows = self.get_follows()
        _precedes = self.get_precedes()
        _overlaps = self.get_overlaps()
        _overlapped = self.get_overlapped()
        _during = self.get_during()
        _contains = self.get_contains()
        _starts = self.get_starts()
        _started = self.get_started()
        _finishes = self.get_finishes()
        _finished = self.get_finished()
        
        if _next is not None:
            print "next=" + _next.get_id()
        if _prev is not None:
            print "prev=" + _prev.get_id()
        if _equal is not None:
            print "equivalent=" + self._generate_map_list_string(_equal, False)
        if _follows is not None:
            print "follows=" + self._generate_map_list_string(_follows, False)
        if _precedes is not None:
            print "precedes=" + self._generate_map_list_string(
                _precedes, False)
        if _overlaps is not None:
            print "overlaps=" + self._generate_map_list_string(
                _overlaps, False)
        if _overlapped is not None:
            print "overlapped=" + \
                self._generate_map_list_string(_overlapped, False)
        if _during is not None:
            print "during=" + self._generate_map_list_string(_during, False)
        if _contains is not None:
            print "contains=" + self._generate_map_list_string(
                _contains, False)
        if _starts is not None:
            print "starts=" + \
                self._generate_map_list_string(_starts)
        if _started is not None:
            print "started=" + \
                self._generate_map_list_string(_started)
        if _finishes is not None:
            print "finishes=" + \
                self._generate_map_list_string(_finishes)
        if _finished is not None:
            print "finished=" + \
                self._generate_map_list_string(_finished)

###############################################################################

if __name__ == "__main__":
    import doctest
    doctest.testmod()