"""@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
[docs]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
[docs] 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
[docs]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)
[docs] 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)
[docs] 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
[docs] 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
[docs] 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
[docs] 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]
[docs] 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]))
[docs] 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]))
[docs] 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
[docs] def p_buff_function(self, t):
"""buff_function : BUFF_POINT
| BUFF_LINE
| BUFF_AREA
"""
t[0] = t[1]
# Handle errors.
[docs] 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()
