""" Temporal raster algebra base class (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. :authors: Thomas Leppelt and Soeren Gebbert .. code-block:: python >>> p = TemporalRasterAlgebraLexer() >>> p.build() >>> p.debug = True >>> expression = 'R = A / B * 20 + C - 2.45' >>> p.test(expression) R = A / B * 20 + C - 2.45 LexToken(NAME,'R',1,0) LexToken(EQUALS,'=',1,2) LexToken(NAME,'A',1,4) LexToken(DIV,'/',1,6) LexToken(NAME,'B',1,8) LexToken(MULT,'*',1,10) LexToken(INT,20,1,12) LexToken(ADD,'+',1,15) LexToken(NAME,'C',1,17) LexToken(SUB,'-',1,19) LexToken(FLOAT,2.45,1,21) >>> expression = 'R = A {equal,|/} B' >>> p.test(expression) R = A {equal,|/} B LexToken(NAME,'R',1,0) LexToken(EQUALS,'=',1,2) LexToken(NAME,'A',1,4) LexToken(T_ARITH1_OPERATOR,'{equal,|/}',1,6) LexToken(NAME,'B',1,17) >>> expression = 'R = A {equal,||} B' >>> p.test(expression) R = A {equal,||} B LexToken(NAME,'R',1,0) LexToken(EQUALS,'=',1,2) LexToken(NAME,'A',1,4) LexToken(T_COMP_OPERATOR,'{equal,||}',1,6) LexToken(NAME,'B',1,17) >>> expression = 'R = A {equal,&&} B' >>> p.test(expression) R = A {equal,&&} B LexToken(NAME,'R',1,0) LexToken(EQUALS,'=',1,2) LexToken(NAME,'A',1,4) LexToken(T_COMP_OPERATOR,'{equal,&&}',1,6) LexToken(NAME,'B',1,17) >>> expression = 'R = A {equal | during,+*} B' >>> p.test(expression) R = A {equal | during,+*} B LexToken(NAME,'R',1,0) LexToken(EQUALS,'=',1,2) LexToken(NAME,'A',1,4) LexToken(T_ARITH1_OPERATOR,'{equal | during,+*}',1,6) LexToken(NAME,'B',1,26) >>> expression = 'R = A {equal | during,+:} B' >>> p.test(expression) R = A {equal | during,+:} B LexToken(NAME,'R',1,0) LexToken(EQUALS,'=',1,2) LexToken(NAME,'A',1,4) LexToken(T_SELECT_OPERATOR,'{equal | during,+:}',1,6) LexToken(NAME,'B',1,26) >>> expression = 'R = abs(A) {equal,+:} exp(B) / sqrt(C) - log(D)' >>> p.test(expression) R = abs(A) {equal,+:} exp(B) / sqrt(C) - log(D) LexToken(NAME,'R',1,0) LexToken(EQUALS,'=',1,2) LexToken(ABS,'abs',1,4) LexToken(LPAREN,'(',1,7) LexToken(NAME,'A',1,8) LexToken(RPAREN,')',1,9) LexToken(T_SELECT_OPERATOR,'{equal,+:}',1,11) LexToken(EXP,'exp',1,22) LexToken(LPAREN,'(',1,25) LexToken(NAME,'B',1,26) LexToken(RPAREN,')',1,27) LexToken(DIV,'/',1,29) LexToken(SQRT,'sqrt',1,31) LexToken(LPAREN,'(',1,35) LexToken(NAME,'C',1,36) LexToken(RPAREN,')',1,37) LexToken(SUB,'-',1,39) LexToken(LOG,'log',1,41) LexToken(LPAREN,'(',1,44) LexToken(NAME,'D',1,45) LexToken(RPAREN,')',1,46) """ import grass.pygrass.modules as pymod from temporal_raster_operator import * from temporal_algebra import * ############################################################################## class TemporalRasterAlgebraLexer(TemporalAlgebraLexer): """Lexical analyzer for the GRASS GIS temporal algebra""" def __init__(self): TemporalAlgebraLexer.__init__(self) # Supported r.mapcalc functions. mapcalc_functions = { 'exp': 'EXP', 'log': 'LOG', 'sqrt': 'SQRT', 'abs': 'ABS', 'cos': 'COS', 'acos': 'ACOS', 'sin': 'SIN', 'asin': 'ASIN', 'tan': 'TAN', 'double': 'DOUBLE', 'float': 'FLOATEXP', 'int': 'INTEXP', 'isnull': 'ISNULL', 'isntnull': 'ISNTNULL', 'null': 'NULL', 'exist': 'EXIST', } # This is the list of token names. raster_tokens = ( 'MOD', 'DIV', 'MULT', 'ADD', 'SUB', 'T_ARITH1_OPERATOR', 'T_ARITH2_OPERATOR', 'L_SPAREN', 'R_SPAREN', ) # Build the token list tokens = TemporalAlgebraLexer.tokens + raster_tokens \ + tuple(mapcalc_functions.values()) # Regular expression rules for simple tokens t_MOD = r'[\%]' t_DIV = r'[\/]' t_MULT = r'[\*]' t_ADD = r'[\+]' t_SUB = r'[-]' t_T_ARITH1_OPERATOR = r'\{([a-zA-Z\| ]+[,])?([\|&+=]?[\%\*\/])\}' t_T_ARITH2_OPERATOR = r'\{([a-zA-Z\| ]+[,])?([\|&+=]?[+-])\}' t_L_SPAREN = r'\[' t_R_SPAREN = r'\]' # Parse symbols def temporal_symbol(self, t): # Check for reserved words if t.value in TemporalRasterAlgebraLexer.time_functions.keys(): t.type = TemporalRasterAlgebraLexer.time_functions.get(t.value) elif t.value in TemporalRasterAlgebraLexer.datetime_functions.keys(): t.type = TemporalRasterAlgebraLexer.datetime_functions.get(t.value) elif t.value in TemporalRasterAlgebraLexer.conditional_functions.keys(): t.type = TemporalRasterAlgebraLexer.conditional_functions.get(t.value) elif t.value in TemporalRasterAlgebraLexer.mapcalc_functions.keys(): t.type = TemporalRasterAlgebraLexer.mapcalc_functions.get(t.value) else: t.type = 'NAME' return t ######### ##################################################################### class TemporalRasterBaseAlgebraParser(TemporalAlgebraParser): """The temporal algebra class""" # Get the tokens from the lexer class tokens = TemporalRasterAlgebraLexer.tokens # Setting equal precedence level for select and hash operations. precedence = ( ('left', 'T_SELECT_OPERATOR', 'T_SELECT', 'T_NOT_SELECT'), # 1 ('left', 'ADD', 'SUB', 'T_ARITH2_OPERATOR'), #2 ('left', 'AND', 'OR', 'T_COMP_OPERATOR', 'MOD', 'DIV', 'MULT', 'T_ARITH1_OPERATOR')) def __init__(self, pid=None, run=True, debug=False, spatial=False, nprocs=1, register_null=False): TemporalAlgebraParser.__init__(self, pid, run, debug, spatial) self.nprocs = nprocs self.empty_maps = {} self.register_null = register_null def check_null(self, t): try: int(t) return t except ValueError: return "null()" ######################### Temporal functions ############################## def eval_toperator(self, operator, comparison=False): """This function evaluates a string containing temporal operations. :param operator: String of temporal operations, e.g. {equal|during,=!:}. :return: List of temporal relations (equal, during), the given function (!:) and the interval/instances (=). .. 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'], '=', '&&') """ p = TemporalRasterOperatorParser() p.parse(operator, comparison) p.relations = [rel.upper() for rel in p.relations] return(p.relations, p.temporal, p.function) ########################################################################### def p_statement_assign(self, t): # The expression should always return a list of maps. """ statement : stds EQUALS expr """ if self.run: # Create the process queue for parallel mapcalc processing process_queue = pymod.ParallelModuleQueue(int(self.nprocs)) if isinstance(t[3], list): num = len(t[3]) count = 0 register_list = [] for i in range(num): # Check if resultmap names exist in GRASS database. rastername = self.basename + "_" + str(i) + "@" + self.mapset rastermap = RasterDataset(rastername) if rastermap.map_exists() and self.overwrite is False: self.msgr.fatal("Error raster maps with basename %s " "exist. Use --o flag to overwrite " "existing file" % (rastername)) map_test_list = [] for map_i in t[3]: newident = self.basename + "_" + str(count) if "cmd_list" in dir(map_i): print(newident + ' = ' + map_i.cmd_list) # Build r.mapcalc module and execute expression. # Change map name to given basename. # Create deepcopy of r.mapcalc module. map_test = map_i.get_new_instance(newident + "@" + self.mapset) map_test.set_temporal_extent(map_i.get_temporal_extent()) map_test.set_spatial_extent(map_i.get_spatial_extent()) map_test_list.append(map_test) m = copy.deepcopy(self.m_mapcalc) m_expression = newident + "=" + map_i.cmd_list m.inputs["expression"].value = str(m_expression) m.flags["overwrite"].value = self.overwrite process_queue.put(m) else: map_i.set_id(newident + "@" + self.mapset) map_test_list.append(map_i) count += 1 process_queue.wait() for map_i in map_test_list: if not map_test.map_exists(): self.msgr.error(_("Error computing map <%s>" % (map_i.get_id()))) else: register_list.append(map_i) # Open connection to temporal database. dbif, connect = init_dbif(self.dbif) # Create result space time dataset. resultstds = open_new_stds(t[1], self.stdstype, 'absolute', t[1], t[1], 'mean', self.dbif, overwrite=self.overwrite) for map_i in register_list: # Get meta data from grass database. map_i.load() # Do not register empty maps if not required # In case of a null map continue, do not register null maps if map_i.metadata.get_min() is None and \ map_i.metadata.get_max() is None: if not self.register_null: self.empty_maps[map_i.get_name()] = map_i.get_name() continue if map_i.is_in_db(dbif) and self.overwrite: # Update map in temporal database. map_i.update_all(dbif) elif map_i.is_in_db(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.popen.stderr)) else: # Insert map into temporal database. map_i.insert(dbif) # Register map in result space time dataset. success = resultstds.register_map(map_i, dbif) resultstds.update_from_registered_maps(dbif) dbif.close() t[0] = register_list self.remove_empty_maps() def p_arith1_operation(self, t): """ expr : stds MOD stds | expr MOD stds | stds MOD expr | expr MOD expr | stds DIV stds | expr DIV stds | stds DIV expr | expr DIV expr | stds MULT stds | expr MULT stds | stds MULT expr | expr MULT expr | stds MOD t_td_var | expr MOD t_td_var | stds DIV t_td_var | expr DIV t_td_var | stds MULT t_td_var | expr MULT t_td_var """ # Check input stds. maplistA = self.check_stds(t[1]) maplistB = self.check_stds(t[3]) topolist = self.get_temporal_topo_list(maplistA, maplistB) if self.run: resultlist = [] for map_i in topolist: # Generate an intermediate map for the result map list. map_new = self.generate_new_map(base_map=map_i, bool_op='and', copy=True) # Set first input for overlay module. mapainput = map_i.get_id() # Loop over temporal related maps and create overlay modules. tbrelations = map_i.get_temporal_relations() count = 0 for map_j in (tbrelations['EQUAL']): # Create overlayed map extent. returncode = self.overlay_map_extent(map_new, map_j, 'and', temp_op='=') # Stop the loop if no temporal or spatial relationship exist. if returncode == 0: break if count == 0: # Set map name. name = map_new.get_id() else: # Generate an intermediate map name = self.generate_map_name() if "map_value" in dir(map_j) and len(map_j.map_value) > 0 and map_j.map_value[0].get_type() == "timediff": mapbinput = map_j.map_value[0].get_type_value()[0] else: # Set first input for overlay module. mapbinput = map_j.get_id() # Create r.mapcalc expression string for the operation. if "cmd_list" in dir(map_new) and "cmd_list" not in dir(map_j): cmdstring = "(%s %s %s)" % (map_new.cmd_list, t[2], mapbinput) elif "cmd_list" in dir(map_j) and "cmd_list" not in dir(map_new): cmdstring = "(%s %s %s)" % (mapainput, t[2], map_j.cmd_list) elif "cmd_list" in dir(map_j) and "cmd_list" in dir(map_new): cmdstring = "(%s %s %s)" % (map_new.cmd_list, t[2], map_j.cmd_list) else: cmdstring = "(%s %s %s)" % (mapainput, t[2], mapbinput) # Conditional append of module command. map_new.cmd_list = cmdstring # Set new map name to temporary map name. mapainput = name count += 1 # Append map to result map list. if returncode == 1: resultlist.append(map_new) t[0] = resultlist if self.debug: for map in resultlist: print map.cmd_list def p_arith1_operation_numeric1(self, t): """ expr : stds MOD number | expr MOD number | stds DIV number | expr DIV number | stds MULT number | expr MULT number """ # Check input stds. maplist = self.check_stds(t[1]) if self.run: resultlist = [] for map_i in maplist: mapinput = map_i.get_id() # Create r.mapcalc expression string for the operation. if "cmd_list" in dir(map_i): cmdstring = "(%s %s %s)" % (map_i.cmd_list, t[2], t[3]) else: cmdstring = "(%s %s %s)" % (mapinput, t[2], t[3]) # Conditional append of module command. map_i.cmd_list = cmdstring # Append map to result map list. resultlist.append(map_i) t[0] = resultlist if self.debug: for map in resultlist: print map.cmd_list def p_arith1_operation_numeric2(self, t): """ expr : number MOD stds | number MOD expr | number DIV stds | number DIV expr | number MULT stds | number MULT expr """ # Check input stds. maplist = self.check_stds(t[3]) if self.run: resultlist = [] for map_i in maplist: mapinput = map_i.get_id() # Create r.mapcalc expression string for the operation. if "cmd_list" in dir(map_i): cmdstring = "(%s %s %s)" % (t[1], t[2], map_i.cmd_list) else: cmdstring = "(%s %s %s)" % (t[1], t[2], mapinput) # Conditional append of module command. map_i.cmd_list = cmdstring # Append map to result map list. resultlist.append(map_i) t[0] = resultlist if self.debug: for map in resultlist: print map.cmd_list def p_arith2_operation(self, t): """ expr : stds ADD stds | expr ADD stds | stds ADD expr | expr ADD expr | stds SUB stds | expr SUB stds | stds SUB expr | expr SUB expr | stds ADD t_td_var | expr ADD t_td_var | expr SUB t_td_var | stds SUB t_td_var """ # Check input stds. maplistA = self.check_stds(t[1]) maplistB = self.check_stds(t[3]) topolist = self.get_temporal_topo_list(maplistA, maplistB) if self.run: resultlist = [] for map_i in topolist: # Generate an intermediate map for the result map list. map_new = self.generate_new_map(base_map=map_i, bool_op='and', copy=True) # Set first input for overlay module. mapainput = map_i.get_id() # Loop over temporal related maps and create overlay modules. tbrelations = map_i.get_temporal_relations() count = 0 for map_j in (tbrelations['EQUAL']): # Create overlayed map extent. returncode = self.overlay_map_extent(map_new, map_j, 'and', temp_op='=') # Stop the loop if no temporal or spatial relationship exist. if returncode == 0: break if count == 0: # Set map name. name = map_new.get_id() else: # Generate an intermediate map name = self.generate_map_name() if "map_value" in dir(map_j) and len(map_j.map_value) > 0 and map_j.map_value[0].get_type() == "timediff": mapbinput = map_j.map_value[0].get_type_value()[0] else: # Set first input for overlay module. mapbinput = map_j.get_id() # Create r.mapcalc expression string for the operation. if "cmd_list" in dir(map_new) and "cmd_list" not in dir(map_j): cmdstring = "(%s %s %s)" % (map_new.cmd_list, t[2], mapbinput) elif "cmd_list" in dir(map_j) and "cmd_list" not in dir(map_new): cmdstring = "(%s %s %s)" % (mapainput, t[2], map_j.cmd_list) elif "cmd_list" in dir(map_j) and "cmd_list" in dir(map_new): cmdstring = "(%s %s %s)" % (map_new.cmd_list, t[2], map_j.cmd_list) else: cmdstring = "(%s %s %s)" % (mapainput, t[2], mapbinput) # Conditional append of module command. map_new.cmd_list = cmdstring # Set new map name to temporary map name. mapainput = name count += 1 # Append map to result map list. if returncode == 1: resultlist.append(map_new) t[0] = resultlist if self.debug: for map in resultlist: print map.cmd_list def p_arith2_operation_numeric1(self, t): """ expr : stds ADD number | expr ADD number | stds SUB number | expr SUB number """ # Check input stds. maplist = self.check_stds(t[1]) if self.run: resultlist = [] for map_i in maplist: mapinput = map_i.get_id() # Create r.mapcalc expression string for the operation. if "cmd_list" in dir(map_i): cmdstring = "(%s %s %s)" % (map_i.cmd_list, t[2], t[3]) else: cmdstring = "(%s %s %s)" % (mapinput, t[2], t[3]) # Conditional append of module command. map_i.cmd_list = cmdstring # Append map to result map list. resultlist.append(map_i) t[0] = resultlist if self.debug: for map in resultlist: print map.cmd_list def p_arith2_operation_numeric2(self, t): """ expr : number ADD stds | number ADD expr | number SUB stds | number SUB expr """ # Check input stds. maplist = self.check_stds(t[3]) if self.run: resultlist = [] for map_i in maplist: mapinput = map_i.get_id() # Create r.mapcalc expression string for the operation. if "cmd_list" in dir(map_i): cmdstring = "(%s %s %s)" % (t[1], t[2], map_i.cmd_list) else: cmdstring = "(%s %s %s)" % (t[1], t[2], mapinput) # Conditional append of module command. map_i.cmd_list = cmdstring # Append map to result map list. resultlist.append(map_i) t[0] = resultlist if self.debug: for map in resultlist: print map.cmd_list def p_arith1_operation_relation(self, t): """ expr : stds T_ARITH1_OPERATOR stds | expr T_ARITH1_OPERATOR stds | stds T_ARITH1_OPERATOR expr | expr T_ARITH1_OPERATOR expr | stds T_ARITH1_OPERATOR t_td_var | expr T_ARITH1_OPERATOR t_td_var """ # Check input stds. maplistA = self.check_stds(t[1]) maplistB = self.check_stds(t[3]) relations, temporal, function = self.eval_toperator(t[2]) topolist = self.get_temporal_topo_list(maplistA, maplistB, topolist=relations) if self.run: resultlist = [] for map_i in topolist: # Generate an intermediate map for the result map list. map_new = self.generate_new_map(base_map=map_i, bool_op='and', copy=True) # Set first input for overlay module. mapainput = map_i.get_id() # Loop over temporal related maps and create overlay modules. tbrelations = map_i.get_temporal_relations() count = 0 for topo in relations: if topo in tbrelations.keys(): for map_j in (tbrelations[topo]): # Create overlayed map extent. returncode = self.overlay_map_extent(map_new, map_j, 'and', temp_op=temporal) print(returncode) # Stop the loop if no temporal or spatial # relationship exist. if returncode == 0: break if count == 0: # Set map name. name = map_new.get_id() else: # Generate an intermediate map name = self.generate_map_name() map_new.set_id(name + "@" + mapset) # Set second input for overlay module. if "map_value" in dir(map_j) and len(map_j.map_value) > 0 and map_j.map_value[0].get_type() == "timediff": mapbinput = map_j.map_value[0].get_type_value()[0] else: # Set first input for overlay module. mapbinput = map_j.get_id() # Create r.mapcalc expression string for the operation. if "cmd_list" in dir(map_new): cmdstring = "(%s %s %s)" % (map_new.cmd_list, function, mapbinput) print('with cmd in a: ' + map_j.get_id()) elif "cmd_list" in dir(map_j): cmdstring = "(%s %s %s)" % (mapainput, function, map_j.cmd_list) print('with cmd in b') elif "cmd_list" in dir(map_j) and "cmd_list" in dir(map_new): cmdstring = "(%s %s %s)" % (map_new.cmd_list, function, map_j.cmd_list) print('with cmd in b') else: cmdstring = "(%s %s %s)" % (mapainput, function, mapbinput) print(cmdstring) # Conditional append of module command. map_new.cmd_list = cmdstring # Set new map name to temporary map name. mapainput = name count += 1 if returncode == 0: break # Append map to result map list. if returncode == 1: resultlist.append(map_new) t[0] = resultlist if self.debug: for map in resultlist: print map.cmd_list def p_arith2_operation_relation(self, t): """ expr : stds T_ARITH2_OPERATOR stds | expr T_ARITH2_OPERATOR stds | stds T_ARITH2_OPERATOR expr | expr T_ARITH2_OPERATOR expr | stds T_ARITH2_OPERATOR t_td_var | expr T_ARITH2_OPERATOR t_td_var """ # Check input stds. maplistA = self.check_stds(t[1]) maplistB = self.check_stds(t[3]) relations, temporal, function = self.eval_toperator(t[2]) topolist = self.get_temporal_topo_list(maplistA, maplistB, topolist=relations) if self.run: resultlist = [] for map_i in topolist: # Generate an intermediate map for the result map list. map_new = self.generate_new_map(base_map=map_i, bool_op='and', copy=True) # Set first input for overlay module. mapainput = map_i.get_id() # Loop over temporal related maps and create overlay modules. tbrelations = map_i.get_temporal_relations() count = 0 for topo in relations: if topo in tbrelations.keys(): for map_j in (tbrelations[topo]): # Create overlayed 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 if count == 0: # Set map name. name = map_new.get_id() else: # Generate an intermediate map name = self.generate_map_name() map_new.set_id(name + "@" + self.mapset) # Set second input for overlay module. if "map_value" in dir(map_j) and len(map_j.map_value) > 0 and map_j.map_value[0].get_type() == "timediff": mapbinput = map_j.map_value[0].get_type_value()[0] else: # Set first input for overlay module. mapbinput = map_j.get_id() # Create r.mapcalc expression string for the operation. if "cmd_list" in dir(map_new) and "cmd_list" not in dir(map_j): cmdstring = "(%s %s %s)" % (map_new.cmd_list, function, mapbinput) elif "cmd_list" in dir(map_j) and "cmd_list" not in dir(map_new): cmdstring = "(%s %s %s)" % (mapainput, function, map_j.cmd_list) elif "cmd_list" in dir(map_j) and "cmd_list" in dir(map_new): cmdstring = "(%s %s %s)" % (map_new.cmd_list, function, map_j.cmd_list) else: cmdstring = "(%s %s %s)" % (mapainput, function, mapbinput) # Conditional append of module command. map_new.cmd_list = cmdstring # Set new map name to temporary map name. mapainput = name count += 1 if returncode == 0: break # Append map to result map list. if returncode == 1: resultlist.append(map_new) t[0] = resultlist if self.debug: for map in resultlist: print map.cmd_list def p_mapcalc_function(self, t): # Supported mapcalc functions. """ mapcalc_arith : ABS | LOG | SQRT | EXP | COS | ACOS | SIN | ASIN | TAN | DOUBLE | FLOATEXP | INTEXP """ t[0] = t[1] if self.debug: for map in resultlist: print map.cmd_list def p_mapcalc_operation(self, t): # Examples: # sin(A) # log(B) """ expr : mapcalc_arith LPAREN stds RPAREN | mapcalc_arith LPAREN expr RPAREN """ # Check input stds. maplist = self.check_stds(t[3]) if self.run: resultlist = [] for map_i in maplist: # Create r.mapcalc expression string for the operation. if "cmd_list" in dir(map_i): cmdstring = "%s(%s)" % (t[1].lower(), map_i.cmd_list) else: cmdstring = "%s(%s)" % (t[1].lower(), map_i.get_id()) # Set new command list for map. map_i.cmd_list = cmdstring # Append map with updated command list to result list. resultlist.append(map_i) t[0] = resultlist if self.debug: for map in resultlist: print map.cmd_list def p_s_var_expr(self, t): # Examples: # isnull(A) """ s_var_expr : ISNULL LPAREN stds RPAREN | ISNULL LPAREN expr RPAREN """ # Check input stds. maplist = self.check_stds(t[3]) if self.run: resultlist = [] for map_i in maplist: # Create r.mapcalc expression string for the operation. if "cmd_list" in dir(map_i): cmdstring = "%s(%s)" % (t[1].lower(), map_i.cmd_list) else: cmdstring = "%s(%s)" % (t[1].lower(), map_i.get_id()) # Set new command list for map. map_i.cmd_list = cmdstring # Append map with updated command list to result list. resultlist.append(map_i) t[0] = resultlist if self.debug: for map in resultlist: print map.cmd_list def p_s_var_expr_1(self, t): # Examples: # isntnull(A) """ s_var_expr : ISNTNULL LPAREN stds RPAREN | ISNTNULL LPAREN expr RPAREN """ # Check input stds. maplist = self.check_stds(t[3]) if self.run: resultlist = [] for map_i in maplist: # Create r.mapcalc expression string for the operation. if "cmd_list" in dir(map_i): cmdstring = "!isnull(%s)" % (map_i.cmd_list) else: cmdstring = "!isnull(%s)" % (map_i.get_id()) # Set new command list for map. map_i.cmd_list = cmdstring # Append map with updated command list to result list. resultlist.append(map_i) t[0] = resultlist if self.debug: for map in resultlist: print map.cmd_list def p_s_var_expr2(self, t): # Examples: # A <= 2 """ s_var_expr : stds comp_op number | expr comp_op number """ # Check input stds. maplist = self.check_stds(t[1]) if self.run: resultlist = [] for map_i in maplist: # Create r.mapcalc expression string for the operation. if "cmd_list" in dir(map_i): cmdstring = "%s %s %s" % (map_i.cmd_list, t[2], t[3]) else: cmdstring = "%s %s %s" % (map_i.get_id(), t[2], t[3]) # Set new command list for map. map_i.cmd_list = cmdstring # Append map with updated command list to result list. resultlist.append(map_i) t[0] = resultlist if self.debug: for map in resultlist: print map.cmd_list def p_s_var_expr3(self, t): # Examples: # A <= 2 || B == 10 # A < 3 && A > 1 """ s_var_expr : s_var_expr AND AND s_var_expr | s_var_expr OR OR s_var_expr """ # Check input stds. maplistA = self.check_stds(t[1]) maplistB = self.check_stds(t[4]) topolist = self.get_temporal_topo_list(maplistA, maplistB) if self.run: resultlist = [] for map_i in topolist: # Loop over temporal related maps and create overlay modules. tbrelations = map_i.get_temporal_relations() count = 0 for map_j in (tbrelations['EQUAL']): # Generate an intermediate map for the result map list. map_new = self.generate_new_map(base_map=map_i, bool_op='and', copy=True) # Set first input for overlay module. mapainput = map_i.get_id() # Create overlayed map extent. returncode = self.overlay_map_extent(map_new, map_j, 'and', temp_op='=') # Stop the loop if no temporal or spatial relationship exist. if returncode == 0: break if count == 0: # Set map name. name = map_new.get_id() else: # Generate an intermediate map name = self.generate_map_name() # Set first input for overlay module. mapbinput = map_j.get_id() # Create r.mapcalc expression string for the operation. if "cmd_list" in dir(map_new) and "cmd_list" not in dir(map_j): cmdstring = "%s %s %s" % (map_new.cmd_list, t[2] + t[3], mapbinput) elif "cmd_list" in dir(map_j) and "cmd_list" not in dir(map_new): cmdstring = "%s %s %s" % (mapainput, t[2] + t[3], map_j.cmd_list) elif "cmd_list" in dir(map_j) and "cmd_list" in dir(map_new): cmdstring = "%s %s %s" % (map_new.cmd_list, t[2] + t[3], map_j.cmd_list) else: cmdstring = "%s %s %s" % (mapainput, t[2] + t[3], mapbinput) # Conditional append of module command. map_new.cmd_list = cmdstring # Set new map name to temporary map name. #mapainput = name count += 1 # Append map to result map list. if returncode == 1: resultlist.append(map_new) t[0] = resultlist if self.debug: for map in resultlist: print map.cmd_list def p_s_var_expr4(self, t): # Examples: # exist(B) """ s_var_expr : EXIST LPAREN stds RPAREN | EXIST LPAREN expr RPAREN """ # Check input stds. maplist = self.check_stds(t[3]) if self.run: resultlist = [] for map_i in maplist: # Create r.mapcalc expression string for the operation. if "cmd_list" in dir(map_i): cmdstring = "%s" % (map_i.cmd_list) else: cmdstring = "%s" % (map_i.get_id()) # Set new command list for map. map_i.cmd_list = cmdstring # Append map with updated command list to result list. resultlist.append(map_i) t[0] = resultlist if self.debug: for map in resultlist: print map.cmd_list def p_s_expr_condition_if(self, t): # Examples: # if(s_var_expr, B) # if(A == 1, B) """ expr : IF LPAREN s_var_expr COMMA stds RPAREN | IF LPAREN s_var_expr COMMA expr RPAREN """ ifmaplist = self.check_stds(t[3]) thenmaplist = self.check_stds(t[5]) topolist = self.get_temporal_topo_list(ifmaplist, thenmaplist) resultlist = [] for map_i in topolist: #print(map_i.get_id()) # Loop over temporal related maps and create overlay modules. tbrelations = map_i.get_temporal_relations() count = 0 for map_j in (tbrelations['EQUAL']): # Generate an intermediate map for the result map list. map_new = self.generate_new_map(base_map=map_i, bool_op='and', copy=True) # Set first input for overlay module. mapainput = map_i.get_id() # Create overlayed map extent. returncode = self.overlay_map_extent(map_new, map_j, 'and', temp_op='=') # Stop the loop if no temporal or spatial relationship exist. if returncode == 0: break if count == 0: # Set map name. name = map_new.get_id() else: # Generate an intermediate map name = self.generate_map_name() # Set first input for overlay module. mapbinput = map_j.get_id() # Create r.mapcalc expression string for the operation. if "cmd_list" in dir(map_new) and "cmd_list" not in dir(map_j): cmdstring = "if(%s,%s)" % (map_new.cmd_list, mapbinput) elif "cmd_list" in dir(map_j) and "cmd_list" not in dir(map_new): cmdstring = "if(%s,%s)" % (mapainput, map_j.cmd_list) elif "cmd_list" in dir(map_j) and "cmd_list" in dir(map_new): cmdstring = "if(%s,%s)" % (map_new.cmd_list, map_j.cmd_list) else: cmdstring = "if(%s,%s)" % (mapainput, mapbinput) # Conditional append of module command. map_new.cmd_list = cmdstring # Set new map name to temporary map name. #mapainput = name count += 1 # Append map to result map list. if returncode == 1: resultlist.append(map_new) t[0] = resultlist if self.debug: for map in resultlist: print map.cmd_list def p_s_numeric_condition_if(self, t): # Examples: # if(s_var_expr, 1) # if(A == 5, 10) """ expr : IF LPAREN s_var_expr COMMA number RPAREN | IF LPAREN s_var_expr COMMA NULL LPAREN RPAREN RPAREN """ ifmaplist = self.check_stds(t[3]) resultlist = [] # Select input for r.mapcalc expression based on length of PLY object. if len(t) == 7: numinput = t[5] elif len(t) == 9: numinput = self.check_null(t[5]) # Iterate over condition map list. for map_i in ifmaplist: mapinput = map_i.get_id() # Create r.mapcalc expression string for the operation. if "cmd_list" in dir(map_i): cmdstring = "if(%s,%s)" % (map_i.cmd_list, numinput) else: cmdstring = "if(%s,%s)" % (mapinput, numinput) # Conditional append of module command. map_i.cmd_list = cmdstring # Append map to result map list. resultlist.append(map_i) t[0] = resultlist if self.debug: for map in resultlist: print map.cmd_list def p_s_expr_condition_if_relation(self, t): # Examples: # if({equal||during}, s_var_expr, A) """ expr : IF LPAREN T_REL_OPERATOR COMMA s_var_expr COMMA stds RPAREN | IF LPAREN T_REL_OPERATOR COMMA s_var_expr COMMA expr RPAREN """ relations, temporal, function = self.eval_toperator(t[3]) ifmaplist = self.check_stds(t[5]) thenmaplist = self.check_stds(t[7]) topolist = self.get_temporal_topo_list(ifmaplist, thenmaplist, topolist=relations) resultlist = [] for map_i in topolist: #print(map_i.get_id()) # Loop over temporal related maps. tbrelations = map_i.get_temporal_relations() count = 0 for topo in relations: if topo in tbrelations.keys(): for map_j in (tbrelations[topo]): # Generate an intermediate map for the result map list. map_new = self.generate_new_map(base_map=map_i, bool_op='and', copy=True) # Set first input for overlay module. mapainput = map_i.get_id() # Create overlayed map extent. returncode = self.overlay_map_extent(map_new, map_j, 'and', temp_op='=') # Stop the loop if no temporal or spatial relationship exist. if returncode == 0: break if count == 0: # Set map name. name = map_new.get_id() else: # Generate an intermediate map name = self.generate_map_name() # Set first input for overlay module. mapbinput = map_j.get_id() #print(mapbinput) #mapbinput = mapbinput.split('@')[0] # Create r.mapcalc expression string for the operation. if "cmd_list" in dir(map_new) and "cmd_list" not in dir(map_j): cmdstring = "if(%s,%s)" % (map_new.cmd_list, mapbinput) elif "cmd_list" in dir(map_j) and "cmd_list" not in dir(map_new): cmdstring = "if(%s,%s)" % (mapainput, map_j.cmd_list) elif "cmd_list" in dir(map_j) and "cmd_list" in dir(map_new): cmdstring = "if(%s,%s)" % (map_new.cmd_list, map_j.cmd_list) else: cmdstring = "if(%s,%s)" % (mapainput, mapbinput) # Conditional append of module command. map_new.cmd_list = cmdstring # Set new map name to temporary map name. #mapainput = name count += 1 # Append map to result map list. if returncode == 1: resultlist.append(map_new) t[0] = resultlist if self.debug: for map in resultlist: print map.cmd_list def p_s_expr_condition_elif(self, t): # Examples: # if(s_var_expr, A, B) """ expr : IF LPAREN s_var_expr COMMA stds COMMA stds RPAREN | IF LPAREN s_var_expr COMMA stds COMMA expr RPAREN | IF LPAREN s_var_expr COMMA expr COMMA stds RPAREN | IF LPAREN s_var_expr COMMA expr COMMA expr RPAREN """ ifmaplist = self.check_stds(t[3]) thenmaplist = self.check_stds(t[5]) elsemaplist = self.check_stds(t[7]) resultlist = [] thendict = {} elsedict = {} # Get topologies for the appropriate conclusion term. thentopolist = self.get_temporal_topo_list(ifmaplist, thenmaplist) # Fill dictionaries with related maps for both conclusion terms. for map_i in thentopolist: thenrelations = map_i.get_temporal_relations() relationmaps = thenrelations['EQUAL'] thendict[map_i.get_id()] = relationmaps # Get topologies for the alternative conclusion term. elsetopolist = self.get_temporal_topo_list(ifmaplist, elsemaplist) for map_i in elsetopolist: elserelations = map_i.get_temporal_relations() relationmaps = elserelations['EQUAL'] elsedict[map_i.get_id()] = relationmaps # Loop through conditional map list. for map_i in ifmaplist: if map_i.get_id() in thendict.keys(): thenlist = thendict[map_i.get_id()] else: thenlist = [] if map_i.get_id() in elsedict.keys(): elselist = elsedict[map_i.get_id()] else: elselist = [] # Set iteration amount to maximal or minimum number of related # conclusion maps, depending on null map creation flag. if self.null: iternum = max(len(thenlist), len(elselist)) else: iternum = min(len(thenlist), len(elselist)) # Calculate difference in conclusion lengths. iterthen = iternum - len(thenlist) iterelse = iternum - len(elselist) # Extend null maps to the list to get conclusions with same length. if iterthen != 0: for i in range(iterthen): thenlist.extend(['null()']) if iterelse != 0: for i in range(iterelse): elselist.extend(['null()']) # Combine the conclusions in a paired list. conclusionlist = zip(thenlist, elselist) for i in range(iternum): conclusionmaps = conclusionlist[i] # Generate an intermediate map for the result map list. map_new = self.generate_new_map(base_map=map_i, bool_op='and', copy=True) # Set first input for overlay module. mapifinput = map_i.get_id() # Get conclusion maps. map_then = conclusionmaps[0] map_else = conclusionmaps[1] # Check if conclusions are map objects. if map_then != 'null()': # Create overlayed map extent. returncode = self.overlay_map_extent(map_new, map_then, 'and', temp_op='=') maptheninput = map_then.get_id() # Continue the loop if no temporal or spatial relationship exist. if returncode == 0: continue else: maptheninput = 'null()' # Check if conclusions are map objects. if map_else != 'null()': # Create overlayed map extent. returncode = self.overlay_map_extent(map_new, map_else, 'and', temp_op='=') mapelseinput = map_else.get_id() # Continue the loop if no temporal or spatial relationship exist. if returncode == 0: continue else: mapelseinput = 'null()' #if map_then != 'null()' and map_else != 'null()': # Create r.mapcalc expression string for the operation. if "cmd_list" in dir(map_new) and "cmd_list" not in dir(map_then) \ and "cmd_list" not in dir(map_else): cmdstring = "if(%s, %s, %s)" % (map_new.cmd_list, maptheninput, mapelseinput) elif "cmd_list" in dir(map_new) and "cmd_list" in dir(map_then) \ and "cmd_list" not in dir(map_else): cmdstring = "if(%s, %s, %s)" % (map_new.cmd_list, map_then.cmd_list, mapelseinput) elif "cmd_list" in dir(map_new) and "cmd_list" not in dir(map_then) \ and "cmd_list" in dir(map_else): cmdstring = "if(%s, %s, %s)" % (map_new.cmd_list, maptheninput, map_else.cmd_list) elif "cmd_list" in dir(map_new) and "cmd_list" in dir(map_then) \ and "cmd_list" in dir(map_else): cmdstring = "if(%s, %s, %s)" % (map_new.cmd_list, map_then.cmd_list, map_else.cmd_list) elif "cmd_list" not in dir(map_new) and "cmd_list" in dir(map_then) \ and "cmd_list" not in dir(map_else): cmdstring = "if(%s, %s, %s)" % (mapifinput, map_then.cmd_list, mapelseinput) elif "cmd_list" not in dir(map_new) and "cmd_list" not in dir(map_then) \ and "cmd_list" in dir(map_else): cmdstring = "if(%s, %s, %s)" % (mapifinput, maptheninput, map_else.cmd_list) elif "cmd_list" not in dir(map_new) and "cmd_list" in dir(map_then) \ and "cmd_list" in dir(map_else): cmdstring = "if(%s, %s, %s)" % (mapifinput, map_then.cmd_list, map_else.cmd_list) else: cmdstring = "if(%s, %s, %s)" % (mapifinput, maptheninput, mapelseinput) # Conditional append of module command. map_new.cmd_list = cmdstring # Append map to result map list. if returncode == 1: resultlist.append(map_new) t[0] = resultlist if self.debug: for map in resultlist: print map.cmd_list def p_s_numeric_condition_elif(self, t): # Examples: # if(s_var_expr, 1, 2) # if(A == 5, 10, 0) """ expr : IF LPAREN s_var_expr COMMA number COMMA number RPAREN | IF LPAREN s_var_expr COMMA NULL LPAREN RPAREN COMMA number RPAREN | IF LPAREN s_var_expr COMMA number COMMA NULL LPAREN RPAREN RPAREN | IF LPAREN s_var_expr COMMA NULL LPAREN RPAREN COMMA NULL LPAREN RPAREN RPAREN """ ifmaplist = self.check_stds(t[3]) resultlist = [] # Select input for r.mapcalc expression based on length of PLY object. if len(t) == 9: numthen = t[5] numelse = t[7] elif len(t) == 11 and t[6] == '(': numthen = t[5] + t[6] + t[7] numelse = t[9] elif len(t) == 11 and t[6] == ',': numthen = t[5] numelse = t[7] + t[8] + t[9] elif len(t) == 13: numthen = t[5] + t[6] + t[7] numelse = t[9] + t[10] + t[11] # Iterate over condition map list. for map_i in ifmaplist: mapinput = map_i.get_id() # Create r.mapcalc expression string for the operation. if "cmd_list" in dir(map_i): cmdstring = "if(%s, %s, %s)" % (map_i.cmd_list, numthen, numelse) else: cmdstring = "if(%s, %s, %s)" % (mapinput, numthen, numelse) # Conditional append of module command. map_i.cmd_list = cmdstring # Append map to result map list. resultlist.append(map_i) t[0] = resultlist if self.debug: for map in resultlist: print map.cmd_list def p_s_numeric_expr_condition_elif(self, t): # Examples: # if(s_var_expr, 1, A) # if(A == 5 && C > 5, A, null()) """ expr : IF LPAREN s_var_expr COMMA number COMMA stds RPAREN | IF LPAREN s_var_expr COMMA NULL LPAREN RPAREN COMMA stds RPAREN | IF LPAREN s_var_expr COMMA number COMMA expr RPAREN | IF LPAREN s_var_expr COMMA NULL LPAREN RPAREN COMMA expr RPAREN | IF LPAREN s_var_expr COMMA stds COMMA number RPAREN | IF LPAREN s_var_expr COMMA stds COMMA NULL LPAREN RPAREN RPAREN | IF LPAREN s_var_expr COMMA expr COMMA number RPAREN | IF LPAREN s_var_expr COMMA expr COMMA NULL LPAREN RPAREN RPAREN """ ifmaplist = self.check_stds(t[3]) resultlist = [] thenmaplist = [] numthen = '' elsemaplist = [] numelse = '' # Select input for r.mapcalc expression based on length of PLY object. if len(t) == 9: try: thenmaplist = self.check_stds(t[5]) except: numthen = self.check_null(t[5]) try: elsemaplist = self.check_stds(t[7]) except: numelse = self.check_null(t[7]) elif len(t) == 11: try: thenmaplist = self.check_stds(t[5]) except: numthen = self.check_null(t[5]) try: elsemaplist = self.check_stds(t[9]) except: numelse = self.check_null(t[7]) if thenmaplist != []: topolist = self.get_temporal_topo_list(ifmaplist, thenmaplist) elif elsemaplist != []: topolist = self.get_temporal_topo_list(ifmaplist, elsemaplist) if numthen != '': numinput = numthen elif numelse != '': numinput = numelse # Iterate over condition map lists with temporal relations. for map_i in topolist: # Loop over temporal related maps and create overlay modules. tbrelations = map_i.get_temporal_relations() count = 0 for map_j in (tbrelations['EQUAL']): # Generate an intermediate map for the result map list. map_new = self.generate_new_map(base_map=map_i, bool_op='and', copy=True) # Set first input for overlay module. mapainput = map_i.get_id() # Create overlayed map extent. returncode = self.overlay_map_extent(map_new, map_j, 'and', temp_op='=') # Stop the loop if no temporal or spatial relationship exist. if returncode == 0: break if count == 0: # Set map name. name = map_new.get_id() else: # Generate an intermediate map name = self.generate_map_name() # Set first input for overlay module. mapbinput = map_j.get_id() # Create r.mapcalc expression string for the operation. if thenmaplist != []: if "cmd_list" in dir(map_new) and "cmd_list" not in dir(map_j): cmdstring = "if(%s,%s,%s)" % (map_new.cmd_list, mapbinput, numinput) elif "cmd_list" in dir(map_j) and "cmd_list" not in dir(map_new): cmdstring = "if(%s,%s,%s)" % (mapainput, map_j.cmd_list, numinput) elif "cmd_list" in dir(map_j) and "cmd_list" in dir(map_new): cmdstring = "if(%s,%s,%s)" % (map_new.cmd_list, map_j.cmd_list, numinput) else: cmdstring = "if(%s,%s,%s)" % (mapainput, mapbinput, numinput) if elsemaplist != []: if "cmd_list" in dir(map_new) and "cmd_list" not in dir(map_j): cmdstring = "if(%s,%s,%s)" % (map_new.cmd_list, numinput, mapbinput) elif "cmd_list" in dir(map_j) and "cmd_list" not in dir(map_new): cmdstring = "if(%s,%s,%s)" % (mapainput, numinput, map_j.cmd_list) elif "cmd_list" in dir(map_j) and "cmd_list" in dir(map_new): cmdstring = "if(%s,%s,%s)" % (map_new.cmd_list, numinput, map_j.cmd_list) else: cmdstring = "if(%s,%s,%s)" % (mapainput, numinput, mapbinput) # Conditional append of module command. map_new.cmd_list = cmdstring # Set new map name to temporary map name. #mapainput = name count += 1 # Append map to result map list. if returncode == 1: resultlist.append(map_new) t[0] = resultlist if self.debug: for map in resultlist: print map.cmd_list def p_s_numeric_expr_condition_elif_relation(self, t): # Examples: # if({during},s_var_expr, 1, A) # if({during}, A == 5, A, null()) """ expr : IF LPAREN T_REL_OPERATOR COMMA s_var_expr COMMA number COMMA stds RPAREN | IF LPAREN T_REL_OPERATOR COMMA s_var_expr COMMA NULL LPAREN RPAREN COMMA stds RPAREN | IF LPAREN T_REL_OPERATOR COMMA s_var_expr COMMA number COMMA expr RPAREN | IF LPAREN T_REL_OPERATOR COMMA s_var_expr COMMA NULL LPAREN RPAREN COMMA expr RPAREN | IF LPAREN T_REL_OPERATOR COMMA s_var_expr COMMA stds COMMA number RPAREN | IF LPAREN T_REL_OPERATOR COMMA s_var_expr COMMA stds COMMA NULL LPAREN RPAREN RPAREN | IF LPAREN T_REL_OPERATOR COMMA s_var_expr COMMA expr COMMA number RPAREN | IF LPAREN T_REL_OPERATOR COMMA s_var_expr COMMA expr COMMA NULL LPAREN RPAREN RPAREN """ relations, temporal, function = self.eval_toperator(t[3]) ifmaplist = self.check_stds(t[5]) resultlist = [] thenmaplist = [] numthen = '' elsemaplist = [] numelse = '' # Select input for r.mapcalc expression based on length of PLY object. if len(t) == 11: try: thenmaplist = self.check_stds(t[7]) except: numthen = self.check_null(t[7]) try: elsemaplist = self.check_stds(t[9]) except: numelse = self.check_null(t[9]) elif len(t) == 13: try: thenmaplist = self.check_stds(t[7]) except: numthen = self.check_null(t[7]) try: elsemaplist = self.check_stds(t[11]) except: numelse = self.check_null(t[9]) if thenmaplist != []: topolist = self.get_temporal_topo_list(ifmaplist, thenmaplist, topolist=relations) elif elsemaplist != []: topolist = self.get_temporal_topo_list(ifmaplist, elsemaplist, topolist=relations) if numthen != '': numinput = numthen elif numelse != '': numinput = numelse # Iterate over condition map lists with temporal relations. for map_i in topolist: # Loop over temporal related maps and create overlay modules. tbrelations = map_i.get_temporal_relations() count = 0 for topo in relations: if topo in tbrelations.keys(): for map_j in (tbrelations[topo]): # Generate an intermediate map for the result map list. map_new = self.generate_new_map(base_map=map_i, bool_op='and', copy=True) # Set first input for overlay module. mapainput = map_i.get_id() # Create overlayed map extent. returncode = self.overlay_map_extent(map_new, map_j, 'and', temp_op='=') # Stop the loop if no temporal or spatial relationship exist. if returncode == 0: break if count == 0: # Set map name. name = map_new.get_id() else: # Generate an intermediate map name = self.generate_map_name() # Set first input for overlay module. mapbinput = map_j.get_id() # Create r.mapcalc expression string for the operation. if thenmaplist != []: if "cmd_list" in dir(map_new) and "cmd_list" not in dir(map_j): cmdstring = "if(%s,%s,%s)" % (map_new.cmd_list, mapbinput, numinput) elif "cmd_list" in dir(map_j) and "cmd_list" not in dir(map_new): cmdstring = "if(%s,%s,%s)" % (mapainput, map_j.cmd_list, numinput) elif "cmd_list" in dir(map_j) and "cmd_list" in dir(map_new): cmdstring = "if(%s,%s,%s)" % (map_new.cmd_list, map_j.cmd_list, numinput) else: cmdstring = "if(%s,%s,%s)" % (mapainput, mapbinput, numinput) if elsemaplist != []: if "cmd_list" in dir(map_new) and "cmd_list" not in dir(map_j): cmdstring = "if(%s,%s,%s)" % (map_new.cmd_list, numinput, mapbinput) elif "cmd_list" in dir(map_j) and "cmd_list" not in dir(map_new): cmdstring = "if(%s,%s,%s)" % (mapainput, numinput, map_j.cmd_list) elif "cmd_list" in dir(map_j) and "cmd_list" in dir(map_new): cmdstring = "if(%s,%s,%s)" % (map_new.cmd_list, numinput, map_j.cmd_list) else: cmdstring = "if(%s,%s,%s)" % (mapainput, numinput, mapbinput) # Conditional append of module command. map_new.cmd_list = cmdstring # Set new map name to temporary map name. #mapainput = name count += 1 # Append map to result map list. if returncode == 1: resultlist.append(map_new) t[0] = resultlist if self.debug: for map in resultlist: print map.cmd_list def p_s_expr_condition_elif_relation(self, t): # Examples: # if({equal||during}, s_var_expr, A, B) """ expr : IF LPAREN T_REL_OPERATOR COMMA s_var_expr COMMA stds COMMA stds RPAREN | IF LPAREN T_REL_OPERATOR COMMA s_var_expr COMMA stds COMMA expr RPAREN | IF LPAREN T_REL_OPERATOR COMMA s_var_expr COMMA expr COMMA stds RPAREN | IF LPAREN T_REL_OPERATOR COMMA s_var_expr COMMA expr COMMA expr RPAREN """ relations, temporal, function = self.eval_toperator(t[3]) ifmaplist = self.check_stds(t[5]) thenmaplist = self.check_stds(t[7]) elsemaplist = self.check_stds(t[9]) resultlist = [] thendict = {} elsedict = {} # Get topologies for the appropriate conclusion term. thentopolist = self.get_temporal_topo_list(ifmaplist, thenmaplist, topolist=relations) # Fill dictionaries with related maps for both conclusion terms. for map_i in thentopolist: thenrelations = map_i.get_temporal_relations() relationmaps = [] for topo in relations: if topo in thenrelations.keys(): relationmaps = relationmaps + thenrelations[topo] thendict[map_i.get_id()] = relationmaps # Get topologies for the alternative conclusion term. elsetopolist = self.get_temporal_topo_list(ifmaplist, elsemaplist, topolist=relations) for map_i in elsetopolist: elserelations = map_i.get_temporal_relations() relationmaps = [] for topo in relations: if topo in elserelations.keys(): relationmaps = relationmaps + elserelations[topo] elsedict[map_i.get_id()] = relationmaps # Loop trough conditional map list. for map_i in ifmaplist: if map_i.get_id() in thendict.keys(): thenlist = thendict[map_i.get_id()] else: thenlist = [] if map_i.get_id() in elsedict.keys(): elselist = elsedict[map_i.get_id()] else: elselist = [] # Set iteration amount to maximal or minimum number of related # conclusion maps, depending on null map creation flag. if self.null: iternum = max(len(thenlist), len(elselist)) else: iternum = min(len(thenlist), len(elselist)) # Calculate difference in conclusion lengths. iterthen = iternum - len(thenlist) iterelse = iternum - len(elselist) # Extend null maps to the list to get conclusions with same length. if iterthen != 0: for i in range(iterthen): thenlist.extend(['null()']) if iterelse != 0: for i in range(iterelse): elselist.extend(['null()']) # Combine the conclusions in a paired list. conclusionlist = zip(thenlist, elselist) for i in range(iternum): conclusionmaps = conclusionlist[i] # Generate an intermediate map for the result map list. map_new = self.generate_new_map(base_map=map_i, bool_op='and', copy=True) # Set first input for overlay module. mapifinput = map_i.get_id() # Get conclusion maps. map_then = conclusionmaps[0] map_else = conclusionmaps[1] # Check if conclusions are map objects. if map_then != 'null()': # Create overlayed map extent. returncode = self.overlay_map_extent(map_new, map_then, 'and', temp_op='=') maptheninput = map_then.get_id() # Continue the loop if no temporal or spatial relationship exist. if returncode == 0: continue else: maptheninput = 'null()' # Check if conclusions are map objects. if map_else != 'null()': # Create overlayed map extent. returncode = self.overlay_map_extent(map_new, map_else, 'and', temp_op='=') mapelseinput = map_else.get_id() # Continue the loop if no temporal or spatial relationship exist. if returncode == 0: continue else: mapelseinput = 'null()' #if map_then != 'null()' and map_else != 'null()': # Create r.mapcalc expression string for the operation. if "cmd_list" in dir(map_new) and "cmd_list" not in dir(map_then) \ and "cmd_list" not in dir(map_else): cmdstring = "if(%s, %s, %s)" % (map_new.cmd_list, maptheninput, mapelseinput) elif "cmd_list" in dir(map_new) and "cmd_list" in dir(map_then) \ and "cmd_list" not in dir(map_else): cmdstring = "if(%s, %s, %s)" % (map_new.cmd_list, map_then.cmd_list, mapelseinput) elif "cmd_list" in dir(map_new) and "cmd_list" not in dir(map_then) \ and "cmd_list" in dir(map_else): cmdstring = "if(%s, %s, %s)" % (map_new.cmd_list, maptheninput, map_else.cmd_list) elif "cmd_list" in dir(map_new) and "cmd_list" in dir(map_then) \ and "cmd_list" in dir(map_else): cmdstring = "if(%s, %s, %s)" % (map_new.cmd_list, map_then.cmd_list, map_else.cmd_list) elif "cmd_list" not in dir(map_new) and "cmd_list" in dir(map_then) \ and "cmd_list" not in dir(map_else): cmdstring = "if(%s, %s, %s)" % (mapifinput, map_then.cmd_list, mapelseinput) elif "cmd_list" not in dir(map_new) and "cmd_list" not in dir(map_then) \ and "cmd_list" in dir(map_else): cmdstring = "if(%s, %s, %s)" % (mapifinput, maptheninput, map_else.cmd_list) elif "cmd_list" not in dir(map_new) and "cmd_list" in dir(map_then) \ and "cmd_list" in dir(map_else): cmdstring = "if(%s, %s, %s)" % (mapifinput, map_then.cmd_list, map_else.cmd_list) else: cmdstring = "if(%s, %s, %s)" % (mapifinput, maptheninput, mapelseinput) # Conditional append of module command. map_new.cmd_list = cmdstring # Append map to result map list. if returncode == 1: resultlist.append(map_new) t[0] = resultlist if self.debug: for map in resultlist: print map.cmd_list def p_ts_var_expr1(self, t): # Combination of spatial and temporal conditional expressions. # Examples: # A <= 2 || start_date <= 2013-01-01 # end_date > 2013-01-15 && A > 10 # IMPORTANT: Only the intersection of map lists in conditionals are # exported. """ ts_var_expr : s_var_expr AND AND t_var_expr | t_var_expr AND AND s_var_expr | t_var_expr OR OR s_var_expr | s_var_expr OR OR t_var_expr | ts_var_expr AND AND s_var_expr | ts_var_expr AND AND t_var_expr | ts_var_expr OR OR s_var_expr | ts_var_expr OR OR t_var_expr | s_var_expr AND AND ts_var_expr | t_var_expr AND AND ts_var_expr | s_var_expr OR OR ts_var_expr | t_var_expr OR OR ts_var_expr """ # Check whether inputs are map lists or global temporal variables and # store each in separate lists. ts_var_dict = {"temporal": [], "spatial": []} temporal_list = [] spatial_list = [] operator = t[2] + t[3] temporalop = GlobalTemporalVar() temporalop.relationop = operator temporalop.topology.append("EQUAL") if isinstance(t[1], dict) and "spatial" in t[1]: temporal_list = temporal_list + t[1]["temporal"] spatial_list.append(t[1]["spatial"]) elif isinstance(t[1], list): if all([isinstance(i, ta.GlobalTemporalVar) for i in t[1]]): temporal_list = temporal_list + t[1] else: tsexprA = self.check_stds(t[1]) spatial_list.append(tsexprA) elif isinstance(t[1], ta.GlobalTemporalVar): temporal_list.append(t[1]) if temporal_list != [] and isinstance(t[4], ta.GlobalTemporalVar): temporal_list.append(temporalop) if temporal_list != [] and \ isinstance(t[4], list) and \ all([isinstance(i, ta.GlobalTemporalVar) for i in t[4]]): temporal_list.append(temporalop) if isinstance(t[4], dict) and "spatial" in t[4]: temporal_list = temporal_list + t[4]["temporal"] spatial_list.append(t[4]["spatial"]) elif isinstance(t[4], list): if all([isinstance(i, ta.GlobalTemporalVar) for i in t[4]]): temporal_list = temporal_list + t[4] else: tsexprB = self.check_stds(t[4]) spatial_list.append(tsexprB) elif isinstance(t[4], ta.GlobalTemporalVar): temporal_list.append(t[4]) ts_var_dict["temporal"] = temporal_list # Condition for two map lists in spatio temporal expression. if len(spatial_list) == 2: # Build topology for both map lists in spatio temporal expression. topolist = self.get_temporal_topo_list(spatial_list[0], spatial_list[1]) resultlist = [] for map_i in topolist: # Loop over temporal related maps and create overlay modules. tbrelations = map_i.get_temporal_relations() count = 0 for map_j in (tbrelations['EQUAL']): # Generate an intermediate map for the result map list. map_new = self.generate_new_map(base_map=map_i, bool_op='and', copy=True) # Set first input for overlay module. mapainput = map_i.get_id() # Create overlayed map extent. returncode = self.overlay_map_extent(map_new, map_j, 'and', temp_op='=') # Stop the loop if no temporal or spatial relationship exist. if returncode == 0: break if count == 0: # Set map name. name = map_new.get_id() else: # Generate an intermediate map name = self.generate_map_name() # Set first input for overlay module. mapbinput = map_j.get_id() # Create r.mapcalc expression string for the operation. if "cmd_list" in dir(map_new) and "cmd_list" not in dir(map_j): cmdstring = "%s %s %s" % (map_new.cmd_list, operator, mapbinput) elif "cmd_list" in dir(map_j) and "cmd_list" not in dir(map_new): cmdstring = "%s %s %s" % (mapainput, operator, map_j.cmd_list) elif "cmd_list" in dir(map_j) and "cmd_list" in dir(map_new): cmdstring = "%s %s %s" % (map_new.cmd_list, operator, map_j.cmd_list) else: cmdstring = "%s %s %s" % (mapainput, operator, mapbinput) # Conditional append of module command. map_new.cmd_list = cmdstring # Set new map name to temporary map name. #mapainput = name count += 1 # Append map to result map list. if returncode == 1: resultlist.append(map_new) # Return dictionary with spatial map list of temporal # intersected maps and temporal expression in list form. ts_var_dict["spatial"] = resultlist # Condition for only one map list in spatio temporal expression. elif len(spatial_list) == 1: ts_var_dict["spatial"] = spatial_list[0] t[0] = ts_var_dict def p_ts_expr_condition_if(self, t): # Examples: # if(ts_var_expr, A) # if(start_year == 2013 || B != 5, A) """ expr : IF LPAREN ts_var_expr COMMA stds RPAREN | IF LPAREN ts_var_expr COMMA expr RPAREN """ ts_var_dict = t[3] spatialcond = ts_var_dict["spatial"] # Extract spatial map list from condition. ifmaplist = self.check_stds(spatialcond) thenmaplist = self.check_stds(t[5]) topolist = self.get_temporal_topo_list(ifmaplist, thenmaplist) resultlist = [] resultspatial = [] for map_i in topolist: #print(map_i.get_id()) # Loop over temporal related maps and create overlay modules. tbrelations = map_i.get_temporal_relations() count = 0 for map_j in (tbrelations['EQUAL']): # Generate an intermediate map for the result map list. map_new = self.generate_new_map(base_map=map_i, bool_op='and', copy=True) # Set first input for overlay module. mapainput = map_i.get_id() # Create overlayed map extent. returncode = self.overlay_map_extent(map_new, map_j, 'and', temp_op='=') # Stop the loop if no temporal or spatial relationship exist. if returncode == 0: break if count == 0: # Set map name. name = map_new.get_id() else: # Generate an intermediate map name = self.generate_map_name() # Set first input for overlay module. mapbinput = map_j.get_id() # Create r.mapcalc expression string for the operation. if "cmd_list" in dir(map_new) and "cmd_list" not in dir(map_j): cmdstring = "if(%s,%s)" % (map_new.cmd_list, mapbinput) elif "cmd_list" in dir(map_j) and "cmd_list" not in dir(map_new): cmdstring = "if(%s,%s)" % (mapainput, map_j.cmd_list) elif "cmd_list" in dir(map_j) and "cmd_list" in dir(map_new): cmdstring = "if(%s,%s)" % (map_new.cmd_list, map_j.cmd_list) else: cmdstring = "if(%s,%s)" % (mapainput, mapbinput) # Conditional append of module command. map_new.cmd_list = cmdstring # Set new map name to temporary map name. #mapainput = name count += 1 # Append map to result map list. if returncode == 1: resultspatial.append(map_new) # Evaluate temporal statements in spatio temporal condition. #if len(ts_var_dict["temporal"]) == 1: #temporalcond = ts_var_dict["temporal"][0] #else: temporalcond = ts_var_dict["temporal"] resultspatial = self.check_stds(resultspatial) thencond = self.build_condition_list(temporalcond, resultspatial) thenresult = self.eval_condition_list(thencond) # Clear the map list. resultlist = self.check_stds(thenresult, clear=True) t[0] = resultlist if self.debug: for map in resultlist: print map.cmd_list def p_ts_expr_condition_if_relation(self, t): # Examples: # if({equal||during}, ts_var_expr, A) # if({starts||during}, B > 2 || end_month() == 4, A) """ expr : IF LPAREN T_REL_OPERATOR COMMA ts_var_expr COMMA stds RPAREN | IF LPAREN T_REL_OPERATOR COMMA ts_var_expr COMMA expr RPAREN """ relations, temporal, function = self.eval_toperator(t[3]) ts_var_dict = t[5] spatialcond = ts_var_dict["spatial"] # Extract spatial map list from condition. ifmaplist = self.check_stds(spatialcond) thenmaplist = self.check_stds(t[7]) topolist = self.get_temporal_topo_list(ifmaplist, thenmaplist, topolist=relations) resultspatial = [] for map_i in topolist: #print(map_i.get_id()) # Loop over temporal related maps and create overlay modules. tbrelations = map_i.get_temporal_relations() count = 0 for topo in relations: if topo in tbrelations.keys(): for map_j in (tbrelations[topo]): # Generate an intermediate map for the result map list. map_new = self.generate_new_map(base_map=map_i, bool_op='and', copy=True) # Set first input for overlay module. mapainput = map_i.get_id() # Create overlayed map extent. returncode = self.overlay_map_extent(map_new, map_j, 'and', temp_op='=') # Stop the loop if no temporal or spatial relationship exist. if returncode == 0: break if count == 0: # Set map name. name = map_new.get_id() else: # Generate an intermediate map name = self.generate_map_name() # Set first input for overlay module. mapbinput = map_j.get_id() # Create r.mapcalc expression string for the operation. if "cmd_list" in dir(map_new) and "cmd_list" not in dir(map_j): cmdstring = "if(%s,%s)" % (map_new.cmd_list, mapbinput) elif "cmd_list" in dir(map_j) and "cmd_list" not in dir(map_new): cmdstring = "if(%s,%s)" % (mapainput, map_j.cmd_list) elif "cmd_list" in dir(map_j) and "cmd_list" in dir(map_new): cmdstring = "if(%s,%s)" % (map_new.cmd_list, map_j.cmd_list) else: cmdstring = "if(%s,%s)" % (mapainput, mapbinput) # Conditional append of module command. map_new.cmd_list = cmdstring # Set new map name to temporary map name. #mapainput = name count += 1 # Append map to result map list. if returncode == 1: resultspatial.append(map_new) # Evaluate temporal statements in spatio temporal condition. #if len(ts_var_dict["temporal"]) == 1: #temporalcond = ts_var_dict["temporal"][0] #else: temporalcond = ts_var_dict["temporal"] resultspatial = self.check_stds(resultspatial) thencond = self.build_condition_list(temporalcond, resultspatial, relations) thenresult = self.eval_condition_list(thencond) # Clear the map list. resultlist = self.check_stds(thenresult, clear=True) t[0] = resultlist if self.debug: for map in resultlist: print map.cmd_list def p_ts_numeric_condition_if(self, t): # Examples: # if(ts_var_expr, 1) # if(A == 5 && start_day() > 5, 10) """ expr : IF LPAREN ts_var_expr COMMA number RPAREN | IF LPAREN ts_var_expr COMMA NULL LPAREN RPAREN RPAREN """ ts_var_dict = t[3] spatialcond = ts_var_dict["spatial"] ifmaplist = self.check_stds(spatialcond) resultspatial = [] # Select input for r.mapcalc expression based on length of PLY object. if len(t) == 7: numinput = t[5] elif len(t) == 9: numinput = t[5] + t[6] + t[7] # Iterate over condition map list. for map_i in ifmaplist: mapinput = map_i.get_id() # Create r.mapcalc expression string for the operation. if "cmd_list" in dir(map_i): cmdstring = "if(%s,%s)" % (map_i.cmd_list, numinput) else: cmdstring = "if(%s,%s)" % (mapinput, numinput) # Conditional append of module command. map_i.cmd_list = cmdstring # Append map to result map list. resultspatial.append(map_i) temporalcond = ts_var_dict["temporal"] resultspatial = self.check_stds(resultspatial) thencond = self.build_condition_list(temporalcond, resultspatial) thenresult = self.eval_condition_list(thencond) # Clear the map list. resultlist = self.check_stds(thenresult, clear=True) t[0] = resultlist if self.debug: for map in resultlist: print map.cmd_list def p_ts_expr_condition_elif(self, t): # Examples: # if(s_var_expr, A, B) # if(start_day() < 20 && B > 2, A, B) """ expr : IF LPAREN ts_var_expr COMMA stds COMMA stds RPAREN | IF LPAREN ts_var_expr COMMA stds COMMA expr RPAREN | IF LPAREN ts_var_expr COMMA expr COMMA stds RPAREN | IF LPAREN ts_var_expr COMMA expr COMMA expr RPAREN """ ts_var_dict = t[3] spatialcond = ts_var_dict["spatial"] ifmaplist = self.check_stds(spatialcond) thenmaplist = self.check_stds(t[5]) elsemaplist = self.check_stds(t[7]) resultspatial = [] thendict = {} elsedict = {} # Get topologies for the appropriate conclusion term. thentopolist = self.get_temporal_topo_list(ifmaplist, thenmaplist) # Fill dictionaries with related maps for both conclusion terms. for map_i in thentopolist: thenrelations = map_i.get_temporal_relations() relationmaps = thenrelations['EQUAL'] thendict[map_i.get_id()] = relationmaps # Get topologies for the alternative conclusion term. elsetopolist = self.get_temporal_topo_list(ifmaplist, elsemaplist) for map_i in elsetopolist: elserelations = map_i.get_temporal_relations() relationmaps = elserelations['EQUAL'] elsedict[map_i.get_id()] = relationmaps # Loop through conditional map list. for map_i in ifmaplist: if map_i.get_id() in thendict.keys(): thenlist = thendict[map_i.get_id()] else: thenlist = [] if map_i.get_id() in elsedict.keys(): elselist = elsedict[map_i.get_id()] else: elselist = [] # Set iteration amount to maximal or minimum number of related # conclusion maps, depending on null map creation flag. if self.null: iternum = max(len(thenlist), len(elselist)) else: iternum = min(len(thenlist), len(elselist)) # Calculate difference in conclusion lengths. iterthen = iternum - len(thenlist) iterelse = iternum - len(elselist) # Extend null maps to the list to get conclusions with same length. if iterthen != 0: for i in range(iterthen): thenlist.extend(['null()']) if iterelse != 0: for i in range(iterelse): elselist.extend(['null()']) # Combine the conclusions in a paired list. conclusionlist = zip(thenlist, elselist) for i in range(iternum): conclusionmaps = conclusionlist[i] # Generate an intermediate map for the result map list. map_new = self.generate_new_map(base_map=map_i, bool_op='and', copy=True) # Set first input for overlay module. mapifinput = map_i.get_id() # Get conclusion maps. map_then = conclusionmaps[0] map_else = conclusionmaps[1] # Check if conclusions are map objects. if map_then != 'null()': # Create overlayed map extent. returncode = self.overlay_map_extent(map_new, map_then, 'and', temp_op='=') maptheninput = map_then.get_id() # Continue the loop if no temporal or spatial relationship exist. if returncode == 0: continue else: maptheninput = 'null()' # Check if conclusions are map objects. if map_else != 'null()': # Create overlayed map extent. returncode = self.overlay_map_extent(map_new, map_else, 'and', temp_op='=') mapelseinput = map_else.get_id() # Continue the loop if no temporal or spatial relationship exist. if returncode == 0: continue else: mapelseinput = 'null()' #if map_then != 'null()' and map_else != 'null()': # Create r.mapcalc expression string for the operation. if "cmd_list" in dir(map_new) and "cmd_list" not in dir(map_then) \ and "cmd_list" not in dir(map_else): cmdstring = "if(%s, %s, %s)" % (map_new.cmd_list, maptheninput, mapelseinput) elif "cmd_list" in dir(map_new) and "cmd_list" in dir(map_then) \ and "cmd_list" not in dir(map_else): cmdstring = "if(%s, %s, %s)" % (map_new.cmd_list, map_then.cmd_list, mapelseinput) elif "cmd_list" in dir(map_new) and "cmd_list" not in dir(map_then) \ and "cmd_list" in dir(map_else): cmdstring = "if(%s, %s, %s)" % (map_new.cmd_list, maptheninput, map_else.cmd_list) elif "cmd_list" in dir(map_new) and "cmd_list" in dir(map_then) \ and "cmd_list" in dir(map_else): cmdstring = "if(%s, %s, %s)" % (map_new.cmd_list, map_then.cmd_list, map_else.cmd_list) elif "cmd_list" not in dir(map_new) and "cmd_list" in dir(map_then) \ and "cmd_list" not in dir(map_else): cmdstring = "if(%s, %s, %s)" % (mapifinput, map_then.cmd_list, mapelseinput) elif "cmd_list" not in dir(map_new) and "cmd_list" not in dir(map_then) \ and "cmd_list" in dir(map_else): cmdstring = "if(%s, %s, %s)" % (mapifinput, maptheninput, map_else.cmd_list) elif "cmd_list" not in dir(map_new) and "cmd_list" in dir(map_then) \ and "cmd_list" in dir(map_else): cmdstring = "if(%s, %s, %s)" % (mapifinput, map_then.cmd_list, map_else.cmd_list) else: cmdstring = "if(%s, %s, %s)" % (mapifinput, maptheninput, mapelseinput) # Conditional append of module command. map_new.cmd_list = cmdstring # Append map to result map list. if returncode == 1: resultspatial.append(map_new) temporalcond = ts_var_dict["temporal"] resultspatial = self.check_stds(resultspatial) thencond = self.build_condition_list(temporalcond, resultspatial) thenresult = self.eval_condition_list(thencond) #elseresult = self.eval_condition_list(thencond, inverse = True) # Combine and sort else and then statement to result map list. #combilist = thenresult + elseresult #resultlist = sorted(combilist, key = AbstractDatasetComparisonKeyStartTime) # Clear the map list. #resultlist = self.check_stds(resultlist, clear = True) resultlist = self.check_stds(thenresult, clear=True) t[0] = resultlist if self.debug: for map in resultlist: print map.cmd_list def p_ts_expr_condition_elif_relation(self, t): # Examples: # if({equal||during}, s_var_expr, A, B) # if({contains}, start_day() == 3 || C != 2, A, B) """ expr : IF LPAREN T_REL_OPERATOR COMMA ts_var_expr COMMA stds COMMA stds RPAREN | IF LPAREN T_REL_OPERATOR COMMA ts_var_expr COMMA stds COMMA expr RPAREN | IF LPAREN T_REL_OPERATOR COMMA ts_var_expr COMMA expr COMMA stds RPAREN | IF LPAREN T_REL_OPERATOR COMMA ts_var_expr COMMA expr COMMA expr RPAREN """ relations, temporal, function = self.eval_toperator(t[3]) ts_var_dict = t[5] spatialcond = ts_var_dict["spatial"] # Extract spatial map list from condition. ifmaplist = self.check_stds(spatialcond) thenmaplist = self.check_stds(t[7]) elsemaplist = self.check_stds(t[9]) resultspatial = [] thendict = {} elsedict = {} # Get topologies for the appropriate conclusion term. thentopolist = self.get_temporal_topo_list(ifmaplist, thenmaplist, topolist=relations) # Fill dictionaries with related maps for both conclusion terms. for map_i in thentopolist: thenrelations = map_i.get_temporal_relations() relationmaps = [] for topo in relations: if topo in thenrelations.keys(): relationmaps = relationmaps + thenrelations[topo] thendict[map_i.get_id()] = relationmaps # Get topologies for the alternative conclusion term. elsetopolist = self.get_temporal_topo_list(ifmaplist, elsemaplist, topolist=relations) for map_i in elsetopolist: elserelations = map_i.get_temporal_relations() relationmaps = [] for topo in relations: if topo in elserelations.keys(): relationmaps = relationmaps + elserelations[topo] elsedict[map_i.get_id()] = relationmaps # Loop trough conditional map list. for map_i in ifmaplist: if map_i.get_id() in thendict.keys(): thenlist = thendict[map_i.get_id()] else: thenlist = [] if map_i.get_id() in elsedict.keys(): elselist = elsedict[map_i.get_id()] else: elselist = [] # Set iteration amount to maximal or minimum number of related # conclusion maps, depending on null map creation flag. if self.null: iternum = max(len(thenlist), len(elselist)) else: iternum = min(len(thenlist), len(elselist)) # Calculate difference in conclusion lengths. iterthen = iternum - len(thenlist) iterelse = iternum - len(elselist) # Extend null maps to the list to get conclusions with same length. if iterthen != 0: for i in range(iterthen): thenlist.extend(['null()']) if iterelse != 0: for i in range(iterelse): elselist.extend(['null()']) # Combine the conclusions in a paired list. conclusionlist = zip(thenlist, elselist) for i in range(iternum): conclusionmaps = conclusionlist[i] # Generate an intermediate map for the result map list. map_new = self.generate_new_map(base_map=map_i, bool_op='and', copy=True) # Set first input for overlay module. mapifinput = map_i.get_id() # Get conclusion maps. map_then = conclusionmaps[0] map_else = conclusionmaps[1] # Check if conclusions are map objects. if map_then != 'null()': # Create overlayed map extent. returncode = self.overlay_map_extent(map_new, map_then, 'and', temp_op='=') maptheninput = map_then.get_id() # Continue the loop if no temporal or spatial relationship exist. if returncode == 0: continue else: maptheninput = 'null()' # Check if conclusions are map objects. if map_else != 'null()': # Create overlayed map extent. returncode = self.overlay_map_extent(map_new, map_else, 'and', temp_op='=') mapelseinput = map_else.get_id() # Continue the loop if no temporal or spatial relationship exist. if returncode == 0: continue else: mapelseinput = 'null()' #if map_then != 'null()' and map_else != 'null()': # Create r.mapcalc expression string for the operation. if "cmd_list" in dir(map_new) and "cmd_list" not in dir(map_then) \ and "cmd_list" not in dir(map_else): cmdstring = "if(%s, %s, %s)" % (map_new.cmd_list, maptheninput, mapelseinput) elif "cmd_list" in dir(map_new) and "cmd_list" in dir(map_then) \ and "cmd_list" not in dir(map_else): cmdstring = "if(%s, %s, %s)" % (map_new.cmd_list, map_then.cmd_list, mapelseinput) elif "cmd_list" in dir(map_new) and "cmd_list" not in dir(map_then) \ and "cmd_list" in dir(map_else): cmdstring = "if(%s, %s, %s)" % (map_new.cmd_list, maptheninput, map_else.cmd_list) elif "cmd_list" in dir(map_new) and "cmd_list" in dir(map_then) \ and "cmd_list" in dir(map_else): cmdstring = "if(%s, %s, %s)" % (map_new.cmd_list, map_then.cmd_list, map_else.cmd_list) elif "cmd_list" not in dir(map_new) and "cmd_list" in dir(map_then) \ and "cmd_list" not in dir(map_else): cmdstring = "if(%s, %s, %s)" % (mapifinput, map_then.cmd_list, mapelseinput) elif "cmd_list" not in dir(map_new) and "cmd_list" not in dir(map_then) \ and "cmd_list" in dir(map_else): cmdstring = "if(%s, %s, %s)" % (mapifinput, maptheninput, map_else.cmd_list) elif "cmd_list" not in dir(map_new) and "cmd_list" in dir(map_then) \ and "cmd_list" in dir(map_else): cmdstring = "if(%s, %s, %s)" % (mapifinput, map_then.cmd_list, map_else.cmd_list) else: cmdstring = "if(%s, %s, %s)" % (mapifinput, maptheninput, mapelseinput) # Conditional append of module command. map_new.cmd_list = cmdstring # Append map to result map list. if returncode == 1: resultspatial.append(map_new) temporalcond = ts_var_dict["temporal"] resultspatial = self.check_stds(resultspatial) thencond = self.build_condition_list(temporalcond, resultspatial, relations) thenresult = self.eval_condition_list(thencond) #elseresult = self.eval_condition_list(thencond, inverse = True) # Combine and sort else and then statement to result map list. #combilist = thenresult + elseresult #resultlist = sorted(combilist, key = AbstractDatasetComparisonKeyStartTime) # Clear the map list. resultlist = self.check_stds(thenresult, clear=True) t[0] = resultlist if self.debug: for map in resultlist: print map.cmd_list def p_ts_numeric_condition_elif(self, t): # Examples: # if(ts_var_expr, 1, 2) # if(A == 1 || end_year == 2013, 10, null()) """ expr : IF LPAREN ts_var_expr COMMA number COMMA number RPAREN | IF LPAREN ts_var_expr COMMA NULL LPAREN RPAREN COMMA number RPAREN | IF LPAREN ts_var_expr COMMA number COMMA NULL LPAREN RPAREN RPAREN | IF LPAREN ts_var_expr COMMA NULL LPAREN RPAREN COMMA NULL LPAREN RPAREN RPAREN """ ts_var_dict = t[3] spatialcond = ts_var_dict["spatial"] # Extract spatial map list from condition. ifmaplist = self.check_stds(spatialcond) resultspatial = [] # Select input for r.mapcalc expression based on length of PLY object. if len(t) == 9: numthen = t[5] numelse = t[7] elif len(t) == 11: numthen = self.check_null(t[5]) numelse = self.check_null(t[7]) elif len(t) == 13: numthen = self.check_null(t[5]) numelse = self.check_null(t[9]) # Iterate over condition map list. for map_i in ifmaplist: mapinput = map_i.get_id() # Create r.mapcalc expression string for the operation. if "cmd_list" in dir(map_i): cmdstring = "if(%s, %s, %s)" % (map_i.cmd_list, numthen, numelse) else: cmdstring = "if(%s, %s, %s)" % (mapinput, numthen, numelse) # Conditional append of module command. map_i.cmd_list = cmdstring # Append map to result map list. resultspatial.append(map_i) temporalcond = ts_var_dict["temporal"] resultspatial = self.check_stds(resultspatial) thencond = self.build_condition_list(temporalcond, resultspatial) thenresult = self.eval_condition_list(thencond) #elseresult = self.eval_condition_list(thencond, inverse = True) # Combine and sort else and then statement to result map list. #combilist = thenresult + elseresult #resultlist = sorted(combilist, key = AbstractDatasetComparisonKeyStartTime) # Clear the map list. #resultlist = self.check_stds(resultlist, clear = True) resultlist = self.check_stds(thenresult, clear=True) t[0] = resultlist def p_ts_numeric_expr_condition_elif(self, t): # Examples: # if(ts_var_expr, 1, A) # if(A == 5 && start_day() > 5, A, null()) """ expr : IF LPAREN ts_var_expr COMMA number COMMA stds RPAREN | IF LPAREN ts_var_expr COMMA NULL LPAREN RPAREN COMMA stds RPAREN | IF LPAREN ts_var_expr COMMA number COMMA expr RPAREN | IF LPAREN ts_var_expr COMMA NULL LPAREN RPAREN COMMA expr RPAREN | IF LPAREN ts_var_expr COMMA stds COMMA number RPAREN | IF LPAREN ts_var_expr COMMA stds COMMA NULL LPAREN RPAREN RPAREN | IF LPAREN ts_var_expr COMMA expr COMMA number RPAREN | IF LPAREN ts_var_expr COMMA expr COMMA NULL LPAREN RPAREN RPAREN """ ts_var_dict = t[3] spatialcond = ts_var_dict["spatial"] ifmaplist = self.check_stds(spatialcond) resultspatial = [] thenmaplist = [] numthen = '' elsemaplist = [] numelse = '' # Select input for r.mapcalc expression based on length of PLY object. if len(t) == 9: try: thenmaplist = self.check_stds(t[5]) except: numthen = t[5] try: elsemaplist = self.check_stds(t[7]) except: numelse = t[7] elif len(t) == 11: try: thenmaplist = self.check_stds(t[5]) except: numthen = t[5] + t[6] + t[7] try: elsemaplist = self.check_stds(t[9]) except: numelse = t[7] + t[8] + t[9] if thenmaplist != []: topolist = self.get_temporal_topo_list(ifmaplist, thenmaplist) elif elsemaplist != []: topolist = self.get_temporal_topo_list(ifmaplist, elsemaplist) if numthen != '': numinput = numthen elif numelse != '': numinput = numelse # Iterate over condition map lists with temporal relations. for map_i in topolist: # Loop over temporal related maps and create overlay modules. tbrelations = map_i.get_temporal_relations() count = 0 for map_j in (tbrelations['EQUAL']): # Generate an intermediate map for the result map list. map_new = self.generate_new_map(base_map=map_i, bool_op='and', copy=True) # Set first input for overlay module. mapainput = map_i.get_id() # Create overlayed map extent. returncode = self.overlay_map_extent(map_new, map_j, 'and', temp_op='=') # Stop the loop if no temporal or spatial relationship exist. if returncode == 0: break if count == 0: # Set map name. name = map_new.get_id() else: # Generate an intermediate map name = self.generate_map_name() # Set first input for overlay module. mapbinput = map_j.get_id() # Create r.mapcalc expression string for the operation. if thenmaplist != []: if "cmd_list" in dir(map_new) and "cmd_list" not in dir(map_j): cmdstring = "if(%s,%s,%s)" % (map_new.cmd_list, mapbinput, numinput) elif "cmd_list" in dir(map_j) and "cmd_list" not in dir(map_new): cmdstring = "if(%s,%s,%s)" % (mapainput, map_j.cmd_list, numinput) elif "cmd_list" in dir(map_j) and "cmd_list" in dir(map_new): cmdstring = "if(%s,%s,%s)" % (map_new.cmd_list, map_j.cmd_list, numinput) else: cmdstring = "if(%s,%s,%s)" % (mapainput, mapbinput, numinput) if elsemaplist != []: if "cmd_list" in dir(map_new) and "cmd_list" not in dir(map_j): cmdstring = "if(%s,%s,%s)" % (map_new.cmd_list, numinput, mapbinput) elif "cmd_list" in dir(map_j) and "cmd_list" not in dir(map_new): cmdstring = "if(%s,%s,%s)" % (mapainput, numinput, map_j.cmd_list) elif "cmd_list" in dir(map_j) and "cmd_list" in dir(map_new): cmdstring = "if(%s,%s,%s)" % (map_new.cmd_list, numinput, map_j.cmd_list) else: cmdstring = "if(%s,%s,%s)" % (mapainput, numinput, mapbinput) # Conditional append of module command. map_new.cmd_list = cmdstring # Set new map name to temporary map name. #mapainput = name count += 1 # Append map to result map list. if returncode == 1: resultspatial.append(map_new) temporalcond = ts_var_dict["temporal"] resultspatial = self.check_stds(resultspatial) thencond = self.build_condition_list(temporalcond, resultspatial) thenresult = self.eval_condition_list(thencond) # Clear the map list. resultlist = self.check_stds(thenresult, clear=True) t[0] = resultlist if self.debug: for map in resultlist: print map.cmd_list def p_ts_numeric_expr_condition_elif_relation(self, t): # Examples: # if({during},ts_var_expr, 1, A) # if({during}, A == 5 && start_day() > 5, A, null()) """ expr : IF LPAREN T_REL_OPERATOR COMMA ts_var_expr COMMA number COMMA stds RPAREN | IF LPAREN T_REL_OPERATOR COMMA ts_var_expr COMMA NULL LPAREN RPAREN COMMA stds RPAREN | IF LPAREN T_REL_OPERATOR COMMA ts_var_expr COMMA number COMMA expr RPAREN | IF LPAREN T_REL_OPERATOR COMMA ts_var_expr COMMA NULL LPAREN RPAREN COMMA expr RPAREN | IF LPAREN T_REL_OPERATOR COMMA ts_var_expr COMMA stds COMMA number RPAREN | IF LPAREN T_REL_OPERATOR COMMA ts_var_expr COMMA stds COMMA NULL LPAREN RPAREN RPAREN | IF LPAREN T_REL_OPERATOR COMMA ts_var_expr COMMA expr COMMA number RPAREN | IF LPAREN T_REL_OPERATOR COMMA ts_var_expr COMMA expr COMMA NULL LPAREN RPAREN RPAREN """ relations, temporal, function = self.eval_toperator(t[3]) ts_var_dict = t[5] spatialcond = ts_var_dict["spatial"] ifmaplist = self.check_stds(spatialcond) resultspatial = [] thenmaplist = [] numthen = '' elsemaplist = [] numelse = '' # Select input for r.mapcalc expression based on length of PLY object. if len(t) == 11: try: thenmaplist = self.check_stds(t[7]) except: numthen = t[7] try: elsemaplist = self.check_stds(t[9]) except: numelse = t[9] elif len(t) == 13: try: thenmaplist = self.check_stds(t[7]) except: numthen = t[9] + t[10] + t[11] try: elsemaplist = self.check_stds(t[11]) except: numelse = t[9] + t[10] + t[11] if thenmaplist != []: topolist = self.get_temporal_topo_list(ifmaplist, thenmaplist, topolist=relations) elif elsemaplist != []: topolist = self.get_temporal_topo_list(ifmaplist, elsemaplist, topolist=relations) if numthen != '': numinput = numthen elif numelse != '': numinput = numelse # Iterate over condition map lists with temporal relations. for map_i in topolist: # Loop over temporal related maps and create overlay modules. tbrelations = map_i.get_temporal_relations() count = 0 for topo in relations: if topo in tbrelations.keys(): for map_j in (tbrelations[topo]): # Generate an intermediate map for the result map list. map_new = self.generate_new_map(base_map=map_i, bool_op='and', copy=True) # Set first input for overlay module. mapainput = map_i.get_id() # Create overlayed map extent. returncode = self.overlay_map_extent(map_new, map_j, 'and', temp_op='=') # Stop the loop if no temporal or spatial relationship exist. if returncode == 0: break if count == 0: # Set map name. name = map_new.get_id() else: # Generate an intermediate map name = self.generate_map_name() # Set first input for overlay module. mapbinput = map_j.get_id() # Create r.mapcalc expression string for the operation. if thenmaplist != []: if "cmd_list" in dir(map_new) and "cmd_list" not in dir(map_j): cmdstring = "if(%s,%s,%s)" % (map_new.cmd_list, mapbinput, numinput) elif "cmd_list" in dir(map_j) and "cmd_list" not in dir(map_new): cmdstring = "if(%s,%s,%s)" % (mapainput, map_j.cmd_list, numinput) elif "cmd_list" in dir(map_j) and "cmd_list" in dir(map_new): cmdstring = "if(%s,%s,%s)" % (map_new.cmd_list, map_j.cmd_list, numinput) else: cmdstring = "if(%s,%s,%s)" % (mapainput, mapbinput, numinput) if elsemaplist != []: if "cmd_list" in dir(map_new) and "cmd_list" not in dir(map_j): cmdstring = "if(%s,%s,%s)" % (map_new.cmd_list, numinput, mapbinput) elif "cmd_list" in dir(map_j) and "cmd_list" not in dir(map_new): cmdstring = "if(%s,%s,%s)" % (mapainput, numinput, map_j.cmd_list) elif "cmd_list" in dir(map_j) and "cmd_list" in dir(map_new): cmdstring = "if(%s,%s,%s)" % (map_new.cmd_list, numinput, map_j.cmd_list) else: cmdstring = "if(%s,%s,%s)" % (mapainput, numinput, mapbinput) # Conditional append of module command. map_new.cmd_list = cmdstring # Set new map name to temporary map name. #mapainput = name count += 1 # Append map to result map list. if returncode == 1: resultspatial.append(map_new) temporalcond = ts_var_dict["temporal"] resultspatial = self.check_stds(resultspatial) thencond = self.build_condition_list(temporalcond, resultspatial) thenresult = self.eval_condition_list(thencond) # Clear the map list. resultlist = self.check_stds(thenresult, clear=True) t[0] = resultlist if self.debug: for map in resultlist: print map.cmd_list ############################################################################### if __name__ == "__main__": import doctest doctest.testmod()