# Source code for grass.temporal.temporal_vector_algebra

    """@package grass.temporal

    Temporal vector algebra

    (C) 2014 by the GRASS Development Team
    This program is free software under the GNU General Public
    License (>=v2). Read the file COPYING that comes with GRASS
    for details.

    :authors: Thomas Leppelt and Soeren Gebbert

    .. code-block:: python

        >>> import grass.temporal as tgis
        >>> tgis.init(True)
        >>> p = tgis.TemporalVectorAlgebraLexer()
        >>> p.build()
        >>> p.debug = True
        >>> expression =  'E = A : B ^ C : D'
        >>> p.test(expression)
        E = A : B ^ C : D
        LexToken(NAME,'E',1,0)
        LexToken(EQUALS,'=',1,2)
        LexToken(NAME,'A',1,4)
        LexToken(T_SELECT,':',1,6)
        LexToken(NAME,'B',1,8)
        LexToken(XOR,'^',1,10)
        LexToken(NAME,'C',1,12)
        LexToken(T_SELECT,':',1,14)
        LexToken(NAME,'D',1,16)
        >>> expression =  'E = buff_a(A, 10)'
        >>> p.test(expression)
        E = buff_a(A, 10)
        LexToken(NAME,'E',1,0)
        LexToken(EQUALS,'=',1,2)
        LexToken(BUFF_AREA,'buff_a',1,4)
        LexToken(LPAREN,'(',1,10)
        LexToken(NAME,'A',1,11)
        LexToken(COMMA,',',1,12)
        LexToken(INT,10,1,14)
        LexToken(RPAREN,')',1,16)

    """
    from __future__ import print_function

    try:
        import ply.yacc as yacc
    except ImportError:
        pass

    import grass.pygrass.modules as pygrass

    import copy
    from .temporal_algebra import (
        TemporalAlgebraLexer,
        TemporalAlgebraParser,
        GlobalTemporalVar,
    )
    from .core import init_dbif, get_current_mapset
    from .abstract_dataset import AbstractDatasetComparisonKeyStartTime
    from .open_stds import open_new_stds
    from .spatio_temporal_relationships import SpatioTemporalTopologyBuilder
    from .space_time_datasets import VectorDataset

    class TemporalVectorAlgebraLexer(TemporalAlgebraLexer):
        """Lexical analyzer for the GRASS GIS temporal vector algebra"""

        def __init__(self):
            TemporalAlgebraLexer.__init__(self)

        # Buffer functions from v.buffer
        vector_buff_functions = {
            "buff_p": "BUFF_POINT",
            "buff_l": "BUFF_LINE",
            "buff_a": "BUFF_AREA",
        }

        # This is the list of token names.
        vector_tokens = (
            "DISOR",
            "XOR",
            "NOT",
            "T_OVERLAY_OPERATOR",
        )

        # Build the token list
        tokens = (
            TemporalAlgebraLexer.tokens
            + vector_tokens
            + tuple(vector_buff_functions.values())
        )

        # Regular expression rules for simple tokens
        t_DISOR = r"\+"
        t_XOR = r"\^"
        t_NOT = r"\~"
        # t_T_OVERLAY_OPERATOR = r'\{([a-zA-Z\|]+[,])?([\|&+=]?[\|&+=\^\~])\}'
        t_T_OVERLAY_OPERATOR = r"\{[\|&+\^\~][,]?[a-zA-Z\| ]*([,])?([lrudi]|left|right|union|disjoint|intersect)?\}"

        # Parse symbols
        def temporal_symbol(self, t):
            # Check for reserved words
            if t.value in TemporalVectorAlgebraLexer.time_functions.keys():
                t.type = TemporalVectorAlgebraLexer.time_functions.get(t.value)
            elif t.value in TemporalVectorAlgebraLexer.datetime_functions.keys():
                t.type = TemporalVectorAlgebraLexer.datetime_functions.get(t.value)
            elif t.value in TemporalVectorAlgebraLexer.conditional_functions.keys():
                t.type = TemporalVectorAlgebraLexer.conditional_functions.get(t.value)
            elif t.value in TemporalVectorAlgebraLexer.vector_buff_functions.keys():
                t.type = TemporalVectorAlgebraLexer.vector_buff_functions.get(t.value)
            else:
                t.type = "NAME"
            return t

    class TemporalVectorAlgebraParser(TemporalAlgebraParser):
        """The temporal algebra class"""

        # Get the tokens from the lexer class
        tokens = TemporalVectorAlgebraLexer.tokens

        # Setting equal precedence level for select and hash operations.
        precedence = (
            (
                "left",
                "T_SELECT_OPERATOR",
                "T_SELECT",
                "T_NOT_SELECT",
                "T_HASH_OPERATOR",
                "HASH",
            ),  # 1
            (
                "left",
                "AND",
                "OR",
                "T_COMP_OPERATOR",
                "T_OVERLAY_OPERATOR",
                "DISOR",
                "NOT",
                "XOR",
            ),  # 2
        )

        def __init__(self, pid=None, run=False, debug=True, spatial=False):
            TemporalAlgebraParser.__init__(self, pid, run, debug, spatial)

            self.m_overlay = pygrass.Module("v.overlay", quiet=True, run_=False)
            self.m_rename = pygrass.Module("g.rename", quiet=True, run_=False)
            self.m_patch = pygrass.Module("v.patch", quiet=True, run_=False)
            self.m_mremove = pygrass.Module("g.remove", quiet=True, run_=False)
            self.m_buffer = pygrass.Module("v.buffer", quiet=True, run_=False)

        def parse(self, expression, basename=None, overwrite=False):
            # Check for space time dataset type definitions from temporal algebra
            l = TemporalVectorAlgebraLexer()
            l.build()
            l.lexer.input(expression)

            while True:
                tok = l.lexer.token()
                if not tok:
                    break

                if tok.type == "STVDS" or tok.type == "STRDS" or tok.type == "STR3DS":
                    raise SyntaxError("Syntax error near '%s'" % (tok.type))

            self.lexer = TemporalVectorAlgebraLexer()
            self.lexer.build()
            self.parser = yacc.yacc(module=self, debug=self.debug, write_tables=False)

            self.overwrite = overwrite
            self.count = 0
            self.stdstype = "stvds"
            self.maptype = "vector"
            self.mapclass = VectorDataset
            self.basename = basename
            self.expression = expression
            self.parser.parse(expression)

        def build_spatio_temporal_topology_list(
            self,
            maplistA,
            maplistB=None,
            topolist=["EQUAL"],
            assign_val=False,
            count_map=False,
            compare_bool=False,
            compare_cmd=False,
            compop=None,
            aggregate=None,
            new=False,
            convert=False,
            overlay_cmd=False,
        ):
            """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
                              the map_values from the compared map list by
                              topological relationships.
            :param count_map: Boolean if the number of topological related maps
                             should be returned.
            :param compare_bool: Boolean for comparing boolean map values based on
                              related map list and compariosn operator.
            :param compare_cmd: Boolean for comparing command list values based on
                              related map list and compariosn operator.
            :param compop: Comparison operator, && or ||.
            :param aggregate: Aggregation operator for relation map list, & or |.
            :param new: Boolean if new temporary maps should be created.
            :param convert: Boolean if conditional values should be converted to
                          r.mapcalc command strings.
            :param overlay_cmd: Boolean for aggregate overlay operators implicitly
                          in command list values based on related map lists.

            :return: List of maps from maplistA that fulfil the topological relationships
                    to maplistB specified in topolist.
            """
            topologylist = [
                "EQUAL",
                "FOLLOWS",
                "PRECEDES",
                "OVERLAPS",
                "OVERLAPPED",
                "DURING",
                "STARTS",
                "FINISHES",
                "CONTAINS",
                "STARTED",
                "FINISHED",
            ]
            complementdict = {
                "EQUAL": "EQUAL",
                "FOLLOWS": "PRECEDES",
                "PRECEDES": "FOLLOWS",
                "OVERLAPS": "OVERLAPPED",
                "OVERLAPPED": "OVERLAPS",
                "DURING": "CONTAINS",
                "CONTAINS": "DURING",
                "STARTS": "STARTED",
                "STARTED": "STARTS",
                "FINISHES": "FINISHED",
                "FINISHED": "FINISHES",
            }
            resultdict = {}
            # Check if given temporal relation are valid.
            for topo in topolist:
                if topo.upper() not in topologylist:
                    raise SyntaxError("Unpermitted temporal relation name '" + topo + "'")

            # Create temporal topology for maplistA to maplistB.
            tb = SpatioTemporalTopologyBuilder()
            # Dictionary with different spatial variables used for topology builder.
            spatialdict = {"strds": "2D", "stvds": "2D", "str3ds": "3D"}
            # Build spatial temporal topology
            if self.spatial:
                tb.build(maplistA, maplistB, spatial=spatialdict[self.stdstype])
            else:
                tb.build(maplistA, maplistB)
            # Iterate through maps in maplistA and search for relationships given
            # in topolist.
            for map_i in maplistA:
                tbrelations = map_i.get_temporal_relations()
                # Check for boolean parameters for further calculations.
                if assign_val:
                    self.assign_bool_value(map_i, tbrelations, topolist)
                elif compare_bool:
                    self.compare_bool_value(map_i, tbrelations, compop, aggregate, topolist)
                elif compare_cmd:
                    self.compare_cmd_value(
                        map_i, tbrelations, compop, aggregate, topolist, convert
                    )
                elif overlay_cmd:
                    self.overlay_cmd_value(map_i, tbrelations, compop, topolist)

                for topo in topolist:
                    if topo.upper() in tbrelations.keys():
                        if count_map:
                            relationmaplist = tbrelations[topo.upper()]
                            gvar = GlobalTemporalVar()
                            gvar.td = len(relationmaplist)
                            if "map_value" in dir(map_i):
                                map_i.map_value.append(gvar)
                            else:
                                map_i.map_value = gvar
                        # Use unique identifier, since map names may be equal
                        resultdict[map_i.uid] = map_i
            resultlist = resultdict.values()

            # Sort list of maps chronological.
            resultlist = sorted(resultlist, key=AbstractDatasetComparisonKeyStartTime)

            return resultlist

        def overlay_cmd_value(self, map_i, tbrelations, function, topolist=["EQUAL"]):
            """Function to evaluate two map lists by given overlay operator.

            :param map_i: Map object with temporal extent.
            :param tbrelations: List of temporal relation to map_i.
            :param topolist: List of strings for given temporal relations.
            :param function: Overlay operator, &|+^~.

            :return: Map object with command list with  operators that has been
                          evaluated by implicit aggregration.
            """
            # Build comandlist list with elements from related maps and given relation operator.
            resultlist = []
            # Define overlay operation dictionary.
            overlaydict = {"&": "and", "|": "or", "^": "xor", "~": "not", "+": "disor"}
            operator = overlaydict[function]
            # Set first input for overlay module.
            mapainput = map_i.get_id()
            # Append command list of given map to result command list.
            if "cmd_list" in dir(map_i):
                resultlist = resultlist + map_i.cmd_list
            for topo in topolist:
                if topo.upper() in tbrelations.keys():
                    relationmaplist = tbrelations[topo.upper()]
                    for relationmap in relationmaplist:
                        # Append command list of given map to result command list.
                        if "cmd_list" in dir(relationmap):
                            resultlist = resultlist + relationmap.cmd_list
                        # Generate an intermediate name
                        name = self.generate_map_name()
                        # Put it into the removalbe map list
                        self.removable_maps[name] = VectorDataset(
                            name + "@%s" % (self.mapset)
                        )
                        map_i.set_id(name + "@" + self.mapset)
                        # Set second input for overlay module.
                        mapbinput = relationmap.get_id()
                        # Create module command in PyGRASS for v.overlay and v.patch.
                        if operator != "disor":
                            m = copy.deepcopy(self.m_overlay)
                            m.run_ = False
                            m.inputs["operator"].value = operator
                            m.inputs["ainput"].value = str(mapainput)
                            m.inputs["binput"].value = str(mapbinput)
                            m.outputs["output"].value = name
                            m.flags["overwrite"].value = self.overwrite
                        else:
                            patchinput = str(mapainput) + "," + str(mapbinput)
                            m = copy.deepcopy(self.m_patch)
                            m.run_ = False
                            m.inputs["input"].value = patchinput
                            m.outputs["output"].value = name
                            m.flags["overwrite"].value = self.overwrite
                        # Conditional append of module command.
                        resultlist.append(m)
                        # Set new map name to temporary map name.
                        mapainput = name
            # Add command list to result map.
            map_i.cmd_list = resultlist

            return resultlist

        def set_temporal_extent_list(self, maplist, topolist=["EQUAL"], temporal="l"):
            """Change temporal extent of map list based on temporal relations to
                other map list and given temporal operator.

            :param maplist: List of map objects for which relations has been build
                                        correctely.
            :param topolist: List of strings of temporal relations.
            :param temporal: The temporal operator specifying the temporal
                                            extent operation (intersection, union, disjoint
                                            union, right reference, left reference).

            :return: Map list with specified temporal extent.
            """
            resultdict = {}

            for map_i in maplist:
                # Loop over temporal related maps and create overlay modules.
                tbrelations = map_i.get_temporal_relations()
                # Generate an intermediate map for the result map list.
                map_new = self.generate_new_map(
                    base_map=map_i, bool_op="and", copy=True, rename=False, remove=True
                )
                # Combine temporal and spatial extents of intermediate map with related maps.
                for topo in topolist:
                    if topo in tbrelations.keys():
                        for map_j in tbrelations[topo]:
                            if temporal == "r":
                                # Generate an intermediate map for the result map list.
                                map_new = self.generate_new_map(
                                    base_map=map_i,
                                    bool_op="and",
                                    copy=True,
                                    rename=False,
                                    remove=True,
                                )
                            # Create overlaid map extent.
                            returncode = self.overlay_map_extent(
                                map_new, map_j, "and", temp_op=temporal
                            )
                            # Stop the loop if no temporal or spatial relationship exist.
                            if returncode == 0:
                                break
                            # Append map to result map list.
                            elif returncode == 1:
                                # resultlist.append(map_new)
                                resultdict[map_new.get_id()] = map_new
                        if returncode == 0:
                            break
                # Append map to result map list.
                # if returncode == 1:
                #    resultlist.append(map_new)
            # Get sorted map objects as values from result dictionary.
            resultlist = resultdict.values()
            resultlist = sorted(resultlist, key=AbstractDatasetComparisonKeyStartTime)
            return resultlist

        def p_statement_assign(self, t):
            # The expression should always return a list of maps.
            """
            statement : stds EQUALS expr

            """
            # Execute the command lists
            if self.run:
                # Open connection to temporal database.
                dbif, connection_state_changed = init_dbif(dbif=self.dbif)
                if isinstance(t[3], list):
                    num = len(t[3])
                    count = 0
                    returncode = 0
                    register_list = []
                    leadzero = len(str(num))
                    for i in range(num):
                        # Check if resultmap names exist in GRASS database.
                        vectorname = self.basename + "_" + str(i).zfill(leadzero)
                        vectormap = VectorDataset(vectorname + "@" + get_current_mapset())
                        if vectormap.map_exists() and self.overwrite is False:
                            self.msgr.fatal(
                                _(
                                    "Error vector maps with basename %s exist. "
                                    "Use --o flag to overwrite existing file"
                                )
                                % (vectorname)
                            )
                    for map_i in t[3]:
                        if "cmd_list" in dir(map_i):
                            # Execute command list.
                            for cmd in map_i.cmd_list:
                                try:
                                    # We need to check if the input maps have areas in case of v.overlay
                                    # otherwise v.overlay will break
                                    if cmd.name == "v.overlay":
                                        for name in (
                                            cmd.inputs["ainput"].value,
                                            cmd.inputs["binput"].value,
                                        ):
                                            # self.msgr.message("Check if map <" + name + "> exists")
                                            if name.find("@") < 0:
                                                name = name + "@" + get_current_mapset()
                                            tmp_map = map_i.get_new_instance(name)
                                            if not tmp_map.map_exists():
                                                raise Exception
                                            # self.msgr.message("Check if map <" + name + "> has areas")
                                            tmp_map.load()
                                            if tmp_map.metadata.get_number_of_areas() == 0:
                                                raise Exception
                                except Exception:
                                    returncode = 1
                                    break

                                # run the command
                                # print the command that will be executed
                                self.msgr.message("Run command:\n" + cmd.get_bash())
                                cmd.run()

                                if cmd.returncode != 0:
                                    self.msgr.fatal(
                                        _("Error starting %s : \n%s")
                                        % (cmd.get_bash(), cmd.outputs.stderr)
                                    )
                                mapname = cmd.outputs["output"].value
                                if mapname.find("@") >= 0:
                                    map_test = map_i.get_new_instance(mapname)
                                else:
                                    map_test = map_i.get_new_instance(
                                        mapname + "@" + self.mapset
                                    )
                                if not map_test.map_exists():
                                    returncode = 1
                                    break
                            if returncode == 0:
                                # We remove the invalid vector name from the remove list.
                                if map_i.get_name() in self.removable_maps:
                                    self.removable_maps.pop(map_i.get_name())
                                mapset = map_i.get_mapset()
                                # Change map name to given basename.
                                newident = self.basename + "_" + str(count).zfill(leadzero)
                                m = copy.deepcopy(self.m_rename)
                                m.inputs["vector"].value = (map_i.get_name(), newident)
                                m.flags["overwrite"].value = self.overwrite
                                m.run()
                                map_i.set_id(newident + "@" + mapset)
                                count += 1
                                register_list.append(map_i)
                        else:
                            # Test if temporal extents have been changed by temporal
                            # relation operators (i|r). This is a code copy from temporal_algebra.py
                            map_i_extent = map_i.get_temporal_extent_as_tuple()
                            map_test = map_i.get_new_instance(map_i.get_id())
                            map_test.select(dbif)
                            map_test_extent = map_test.get_temporal_extent_as_tuple()
                            if map_test_extent != map_i_extent:
                                # Create new map with basename
                                newident = self.basename + "_" + str(count).zfill(leadzero)
                                map_result = map_i.get_new_instance(
                                    newident + "@" + self.mapset
                                )

                                if map_test.map_exists() and self.overwrite is False:
                                    self.msgr.fatal(
                                        "Error raster maps with basename %s exist. "
                                        "Use --o flag to overwrite existing file"
                                        % (mapname)
                                    )

                                map_result.set_temporal_extent(map_i.get_temporal_extent())
                                map_result.set_spatial_extent(map_i.get_spatial_extent())
                                # Attention we attach a new attribute
                                map_result.is_new = True
                                count += 1
                                register_list.append(map_result)

                                # Copy the map
                                m = copy.deepcopy(self.m_copy)
                                m.inputs["vector"].value = map_i.get_id(), newident
                                m.flags["overwrite"].value = self.overwrite
                                m.run()
                            else:
                                register_list.append(map_i)

                    if len(register_list) > 0:
                        # Create result space time dataset.
                        resultstds = open_new_stds(
                            t[1],
                            self.stdstype,
                            "absolute",
                            t[1],
                            t[1],
                            "temporal vector algebra",
                            self.dbif,
                            overwrite=self.overwrite,
                        )
                        for map_i in register_list:
                            # Check if modules should be executed from command list.
                            if hasattr(map_i, "cmd_list") or hasattr(map_i, "is_new"):
                                # Get meta data from grass database.
                                map_i.load()
                                if map_i.is_in_db(dbif=dbif) and self.overwrite:
                                    # Update map in temporal database.
                                    map_i.update_all(dbif=dbif)
                                elif map_i.is_in_db(dbif=dbif) and self.overwrite is False:
                                    # Raise error if map exists and no overwrite flag is given.
                                    self.msgr.fatal(
                                        _(
                                            "Error vector map %s exist in temporal database. "
                                            "Use overwrite flag.  : \n%s"
                                        )
                                        % (map_i.get_map_id(), cmd.outputs.stderr)
                                    )
                                else:
                                    # Insert map into temporal database.
                                    map_i.insert(dbif=dbif)
                            else:
                                # Map is original from an input STVDS
                                map_i.load()
                            # Register map in result space time dataset.
                            if self.debug:
                                print(map_i.get_temporal_extent_as_tuple())
                            success = resultstds.register_map(map_i, dbif=dbif)
                        resultstds.update_from_registered_maps(dbif)

                # Remove intermediate maps
                self.remove_maps()
                if connection_state_changed:
                    dbif.close()
                t[0] = t[3]

        def p_overlay_operation(self, t):
            """
            expr : stds AND stds
                 | expr AND stds
                 | stds AND expr
                 | expr AND expr
                 | stds OR stds
                 | expr OR stds
                 | stds OR expr
                 | expr OR expr
                 | stds XOR stds
                 | expr XOR stds
                 | stds XOR expr
                 | expr XOR expr
                 | stds NOT stds
                 | expr NOT stds
                 | stds NOT expr
                 | expr NOT expr
                 | stds DISOR stds
                 | expr DISOR stds
                 | stds DISOR expr
                 | expr DISOR expr
            """
            if self.run:
                # Check input stds and operator.
                maplistA = self.check_stds(t[1])
                maplistB = self.check_stds(t[3])
                relations = ["EQUAL"]
                temporal = "l"
                function = t[2]
                # Build command list for related maps.
                complist = self.build_spatio_temporal_topology_list(
                    maplistA,
                    maplistB,
                    topolist=relations,
                    compop=function,
                    overlay_cmd=True,
                )
                # Set temporal extent based on topological relationships.
                resultlist = self.set_temporal_extent_list(
                    complist, topolist=relations, temporal=temporal
                )

                t[0] = resultlist
            if self.debug:
                print(str(t[1]) + t[2] + str(t[3]))

        def p_overlay_operation_relation(self, t):
            """
            expr : stds T_OVERLAY_OPERATOR stds
                 | expr T_OVERLAY_OPERATOR stds
                 | stds T_OVERLAY_OPERATOR expr
                 | expr T_OVERLAY_OPERATOR expr
            """
            if self.run:
                # Check input stds and operator.
                maplistA = self.check_stds(t[1])
                maplistB = self.check_stds(t[3])
                relations, temporal, function, aggregate = self.eval_toperator(
                    t[2], optype="overlay"
                )
                # Build command list for related maps.
                complist = self.build_spatio_temporal_topology_list(
                    maplistA,
                    maplistB,
                    topolist=relations,
                    compop=function,
                    overlay_cmd=True,
                )
                # Set temporal extent based on topological relationships.
                resultlist = self.set_temporal_extent_list(
                    complist, topolist=relations, temporal=temporal
                )

                t[0] = resultlist
            if self.debug:
                print(str(t[1]) + t[2] + str(t[3]))

        def p_buffer_operation(self, t):
            """
            expr : buff_function LPAREN stds COMMA number RPAREN
                 | buff_function LPAREN expr COMMA number RPAREN
            """

            if self.run:
                # Check input stds.
                bufflist = self.check_stds(t[3])
                # Create empty result list.
                resultlist = []

                for map_i in bufflist:
                    # Generate an intermediate name for the result map list.
                    map_new = self.generate_new_map(
                        base_map=map_i, bool_op=None, copy=True, remove=True
                    )
                    # Change spatial extent based on buffer size.
                    map_new.spatial_buffer(float(t[5]))
                    # Check buff type.
                    if t[1] == "buff_p":
                        buff_type = "point"
                    elif t[1] == "buff_l":
                        buff_type = "line"
                    elif t[1] == "buff_a":
                        buff_type = "area"
                    m = copy.deepcopy(self.m_buffer)
                    m.run_ = False
                    m.inputs["type"].value = buff_type
                    m.inputs["input"].value = str(map_i.get_id())
                    m.inputs["distance"].value = float(t[5])
                    m.outputs["output"].value = map_new.get_name()
                    m.flags["overwrite"].value = self.overwrite

                    # Conditional append of module command.
                    if "cmd_list" in dir(map_new):
                        map_new.cmd_list.append(m)
                    else:
                        map_new.cmd_list = [m]
                    resultlist.append(map_new)

                t[0] = resultlist

        def p_buff_function(self, t):
            """buff_function    : BUFF_POINT
            | BUFF_LINE
            | BUFF_AREA
            """
            t[0] = t[1]

        # Handle errors.
        def p_error(self, t):
            raise SyntaxError(
                "syntax error on line %d near '%s' expression '%s'"
                % (t.lineno, t.value, self.expression)
            )

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

    if __name__ == "__main__":
        import doctest

        doctest.testmod()

Help Index | Topics Index | Keywords Index | Full Index

© 2003-2024 GRASS Development Team, GRASS GIS 8.2.2dev Reference Manual