def get_process_list(node: Node) -> Tuple[list, list]: """Analyse the process node and return the Actinia process chain and the name of the processing result :param node: The process node :return: (output_objects, actinia_process_list) """ input_names, process_list = check_node_parents(node=node) output_objects = [] if "data" not in node.arguments: raise Exception("Process %s requires parameter <data>" % PROCESS_NAME) # Catch the first input for data_object in node.get_parent_by_name( parent_name="data").output_objects: pc = create_process_chain_entry(data_object=data_object) process_list.append(pc) break for data_object in node.get_parent_by_name( parent_name="data").output_objects: output_objects.append(data_object) node.add_output(data_object) return output_objects, process_list
def get_process_list(node: Node): """Analyse the process node and return the Actinia process chain and the name of the processing result :param node: The process node :return: (output_objects, actinia_process_list) """ input_objects, process_list = check_node_parents(node=node) output_objects = [] if "data" not in node.arguments: raise Exception("Process %s requires parameter data" % PROCESS_NAME) input_objects = node.get_parent_by_name(parent_name="data").output_objects if not input_objects: raise Exception("Process %s requires an input strds" % PROCESS_NAME) input_object = list(input_objects)[-1] output_object = DataObject(name=create_output_name(input_object.name, PROCESS_NAME), datatype=GrassDataType.STRDS) output_objects.append(output_object) # pc = create_process_chain_entry(input_object, vector_object, output_object) # process_list.append(pc) return output_objects, process_list
def get_process_list(node: Node): """Analyse the process description and return the Actinia process chain and the name of the processing result layer which is a single raster layer :param node: The process node :return: (output_objects, actinia_process_list) """ tree, operators = construct_tree( node.as_dict()['arguments']['process']['process_graph']) # print (operators) formula = None output_datatype = GrassDataType.RASTER formula = serialize_tree(tree) # print(formula) output_datatype = GrassDataType.STRDS input_objects, process_list = check_node_parents(node=node) output_objects = [] for input_object in node.get_parent_by_name("data").output_objects: output_object = DataObject(name=create_output_name( input_object.name, PROCESS_NAME), datatype=output_datatype) output_objects.append(output_object) node.add_output(output_object=output_object) pc = create_process_chain_entry(input_object, formula, operators, output_object) process_list.append(pc) return output_objects, process_list
def get_process_list(node: Node): """Analyse the process description and return the Actinia process chain and the name of the processing result layer which is a single raster layer :param node: The process node :return: (output_objects, actinia_process_list) """ input_objects, process_list = check_node_parents(node=node) output_objects = [] if "percentile" not in node.arguments: raise Exception("Parameter percentile is required.") for data_object in node.get_parent_by_name("data").output_objects: # multiple strds as input ? # multiple raster layers as output ! output_object = DataObject(name=create_output_name( data_object.name, node), datatype=GrassDataType.STRDS) output_objects.append(output_object) node.add_output(output_object=output_object) pc = create_process_chain_entry(data_object, node.arguments["percentile"], output_object) process_list.append(pc) return output_objects, process_list
def get_process_list(node: Node) -> Tuple[list, list]: """Analyse the process node and return the Actinia process chain and the name of the processing result :param node: The process node :return: (output_objects, actinia_process_list) """ input_objects, process_list = check_node_parents(node=node) output_objects = [] if "data" not in node.arguments or \ "min" not in node.arguments or \ "max" not in node.arguments: raise Exception("Process %s requires parameter data, min, max" % PROCESS_NAME) newmin = node.arguments["min"] newmax = node.arguments["max"] # for each raster separately for input_object in node.get_parent_by_name("data").output_objects: output_object = DataObject(name=create_output_name( input_object.name, PROCESS_NAME), datatype=GrassDataType.RASTER) output_objects.append(output_object) node.add_output(output_object=output_object) pc = create_process_chain_entry(input_object, newmin, newmax, output_object) process_list.append(pc) # TODO: create strds from output raster maps return output_objects, process_list
def get_process_list(node: Node): """Analyse the process description and return the Actinia process chain and the name of the processing result layer which is a single raster layer :param node: The process node :return: (output_objects, actinia_process_list) """ input_objects, process_list = check_node_parents(node=node) output_objects = [] options = {} if "options" in node.arguments: options = node.arguments["options"] # Pipe the inputs to the outputs for input_object in node.get_parent_by_name("data").output_objects: output_objects.append(input_object) node.add_output(output_object=input_object) pc = create_process_chain_entry(input_object=input_object, options=options) process_list.extend(pc) return output_objects, process_list
def get_process_list(node: Node): """Analyse the process description and return the Actinia process chain and the name of the processing result layer which is a single raster layer :param node: The process node :return: (output_objects, actinia_process_list) """ input_objects, process_list = check_node_parents(node=node) output_objects = [] for input_object in input_objects: output_objects.append(input_object) node.add_output(output_object=input_object) if "polygons" in node.arguments: polygons = node.arguments["polygons"] else: raise Exception( "The vector polygon is missing in the process description") pc = create_process_chain_entry(input_object=input_object, polygons=polygons) process_list.extend(pc) return output_objects, process_list
def get_process_list(node: Node): """Analyse the process description and return the Actinia process chain and the name of the processing result layer which is a single raster layer :param node: The process node :return: (output_objects, actinia_process_list) """ input_objects, process_list = check_node_parents(node=node) output_objects = [] if "method" not in node.arguments: raise Exception("Parameter method is required.") for input_object in node.get_parent_by_name("data").output_objects: output_object = DataObject( name=create_output_name(input_object.name, PROCESS_NAME), datatype=GrassDataType.RASTER) output_objects.append(output_object) node.add_output(output_object=output_object) pc = create_process_chain_entry( input_object, node.arguments["method"], output_object) process_list.append(pc) return output_objects, process_list
def get_process_list(node: Node): """Analyse the process description and return the Actinia process chain and the name of the processing result layer which is a single raster layer :param node: The process node :return: (output_objects, actinia_process_list) """ input_objects, process_list = check_node_parents(node=node) output_objects = [] for input_object in input_objects: output_objects.append(input_object) node.add_output(output_object=input_object) geometries = None if "geometries" in node.arguments: geometries = node.arguments["geometries"] else: raise Exception( "The vector geometries are missing in the process description") # TODO: support a reducer # reducer = node.arguments["reducer"] pc = create_process_chain_entry(input_object=input_object, geometries=geometries) process_list.extend(pc) return output_objects, process_list
def get_process_list(node: Node): """Analyse the process description and return the Actinia process chain and the name of the processing result layer which is a single raster layer :param args: The process description :return: (output_names, actinia_process_list) """ # Get the input description and the process chain to attach this process input_objects, process_list = check_node_parents(node=node) output_objects = [] input_objects = node.get_parent_by_name(parent_name="data").output_objects python_file_url = node.arguments["udf"] udf_runtime = None if "runtime" in node.arguments: udf_runtime = node.arguments["runtime"] udf_version = None if "version" in node.arguments: udf_version = node.arguments["version"] for input_object in input_objects: output_object = DataObject(name=create_output_name( input_object.name, PROCESS_NAME), datatype=GrassDataType.STRDS) output_objects.append(output_object) pc = create_process_chain_entry(input_object, python_file_url, udf_runtime, udf_version, output_object) process_list.append(pc) return output_objects, process_list
def get_process_list(node: Node) -> Tuple[list, list]: """Analyse the process node and return the Actinia process chain and the name of the processing result :param node: The process node :return: (output_objects, actinia_process_list) """ input_objects, process_list = check_node_parents(node=node) output_objects = [] if "data" not in node.arguments or \ "min" not in node.arguments or \ "max" not in node.arguments: raise Exception("Process %s requires parameter data, min, max" % PROCESS_NAME) vmin = node.arguments["min"] vmax = node.arguments["max"] for data_object in input_objects: output_object = DataObject(name=create_output_name( data_object.name, node), datatype=GrassDataType.STRDS) output_objects.append(output_object) node.add_output(output_object=output_object) pc = create_process_chain_entry(data_object, vmin, vmax, output_object) process_list.append(pc) return output_objects, process_list
def get_process_list(node: Node): """Analyse the process description and return the Actinia process chain and the name of the processing result strds that was filtered by start and end date :param node: The process node :return: (output_names, actinia_process_list) """ input_objects, process_list = check_node_parents(node=node) output_objects = [] for data_object in node.get_parent_by_name( parent_name="data").output_objects: # Skip if the datatype is not a strds and put the input into the output if data_object.is_strds() is False: output_objects.append(data_object) continue if "dimension" not in node.arguments or \ node.arguments["dimension"] != "bands": raise Exception( "Process %s requires dimension to be set to bands" % PROCESS_NAME) output_object = DataObject(name=create_output_name( data_object.name, node), datatype=GrassDataType.STRDS) output_objects.append(output_object) node.add_output(output_object=output_object) if not isinstance(node.arguments["target"], list): raise Exception("Process %s requires target to be a list" % PROCESS_NAME) target = node.arguments["target"] source = None if "source" in node.arguments: if not isinstance(node.arguments["source"], list): raise Exception("Process %s requires source to be a list" % PROCESS_NAME) source = node.arguments["source"] if len(source) != len(target): raise Exception( "Process %s requires source and target to have the same number of items" % PROCESS_NAME) else: if len(target) != 1: raise Exception( "Process %s requires one item in target if source is not given" % PROCESS_NAME) pc = create__process_chain_entry(input_object=data_object, target=target, source=source, output_object=output_object) process_list.extend(pc) return output_objects, process_list
def get_process_list(node: Node): """Analyse the process description and return the Actinia process chain and the name of the processing result layer which is a single raster layer :param node: The process node :return: (output_objects, actinia_process_list) """ input_objects, process_list = check_node_parents(node=node) output_objects = [] if "nf" not in node.arguments: raise Exception("Parameter nf is required.") nf = int(node.arguments["nf"]) dod = 0 if "dod" in node.arguments: dod = int(node.arguments["dod"]) fet = 1.7977e308 if "fet" in node.arguments: fet = float(node.arguments["fet"]) range_low = -1.7977e308 if "range_low" in node.arguments: range_low = float(node.arguments["range_low"]) range_high = 1.7977e308 if "range_high" in node.arguments: range_high = float(node.arguments["range_high"]) reject_low = False if "reject_low" in node.arguments: reject_low = bool(node.arguments["reject_low"]) reject_high = False if "reject_high" in node.arguments: reject_high = bool(node.arguments["reject_high"]) for data_object in node.get_parent_by_name("data").output_objects: # Skip if the datatype is not a strds and put the input into the output if data_object.is_strds() is False: output_objects.append(data_object) continue # multiple strds as input ? output_object = DataObject(name=create_output_name( data_object.name, PROCESS_NAME), datatype=GrassDataType.STRDS) output_objects.append(output_object) node.add_output(output_object=output_object) pc = create_process_chain_entry(data_object, nf, dod, fet, range_low, range_high, reject_low, reject_high, output_object) process_list.append(pc) return output_objects, process_list
def get_process_list(node: Node): """Analyse the process description and return the Actinia process chain and the name of the processing result :param node: The process node :return: (output_objects, actinia_process_list) """ input_objects, process_list = check_node_parents(node=node) output_objects = [] if "result" not in node.arguments: raise Exception("The result name must be specified as parameter") if "expression" not in node.arguments: raise Exception("The expression must be specified as parameter") if "basename" not in node.arguments: raise Exception("The basename must be specified as parameter") result = DataObject( name=node.arguments["result"], datatype=GrassDataType.STRDS) expression = node.arguments["expression"] basename = node.arguments["basename"] if "a" in node.arguments: a = list(node.get_parent_by_name(parent_name="a").output_objects)[-1] expression = expression.replace("$a", a.grass_name()) if "b" in node.arguments: b = list(node.get_parent_by_name(parent_name="b").output_objects)[-1] expression = expression.replace("$b", b.grass_name()) if "c" in node.arguments: c = list(node.get_parent_by_name(parent_name="c").output_objects)[-1] expression = expression.replace("$c", c.grass_name()) if "d" in node.arguments: d = list(node.get_parent_by_name(parent_name="d").output_objects)[-1] expression = expression.replace("$d", d.grass_name()) if "e" in node.arguments: e = list(node.get_parent_by_name(parent_name="e").output_objects)[-1] expression = expression.replace("$e", e.grass_name()) if "f" in node.arguments: f = list(node.get_parent_by_name(parent_name="f").output_objects)[-1] expression = expression.replace("$f", f.grass_name()) expression = expression.replace("$result", result.grass_name()) output_objects.append(result) node.add_output(output_object=result) pc = create_process_chain_entry(expression=expression, basename=basename) process_list.extend(pc) return output_objects, process_list
def get_process_list(node: Node): """Analyse the process description and return the Actinia process chain and the name of the processing result :param node: The process node :return: (output_objects, actinia_process_list) """ input_objects, process_list = check_node_parents(node=node) output_objects = [] # Get the input data input_objects = node.get_parent_by_name(parent_name="data").output_objects input_strds = list(input_objects)[-1] nir_band = "nir" red_band = "red" if "nir" in node.arguments and \ node.arguments["nir"] is not None and \ node.arguments["nir"] != "null": nir_band = node.arguments["nir"] if "red" in node.arguments and \ node.arguments["red"] is not None and \ node.arguments["red"] != "null": red_band = node.arguments["red"] target_band = None if "target_band" in node.arguments and \ node.arguments["target_band"] is not None and \ node.arguments["target_band"] != "null": target_band = node.arguments["target_band"] output_objects.extend(list(input_objects)) output_object = DataObject( name=create_output_name(input_strds.name, node), datatype=GrassDataType.STRDS) if target_band is None: output_objects.append(output_object) node.add_output(output_object=output_object) else: # if target band is given, extend the input strds output_objects.append(input_strds) node.add_output(output_object=input_strds) pc = create_process_chain_entry( input_strds, nir_band, red_band, target_band, output_object) process_list.extend(pc) return output_objects, process_list
def get_process_list(node: Node): """Analyse the process description and return the Actinia process chain and the name of the processing result :param node: The process node :return: (output_objects, actinia_process_list) """ input_objects, process_list = check_node_parents(node=node) output_objects = [] # First analyse the data entry if "id" not in node.arguments: raise Exception("Process %s requires parameter <id>" % PROCESS_NAME) input_object = DataObject.from_string(node.arguments["id"]) spatial_extent = None if "spatial_extent" in node.arguments: spatial_extent = node.arguments["spatial_extent"] temporal_extent = None if "temporal_extent" in node.arguments: temporal_extent = node.arguments["temporal_extent"] bands = None if "bands" in node.arguments: bands = node.arguments["bands"] if input_object.is_strds() and \ (temporal_extent is not None or bands is not None): output_object = DataObject( name=create_output_name(input_object.name, node), datatype=input_object.datatype) elif input_object.is_stac(): output_object = DataObject( name=create_output_name(input_object.name, node), datatype=input_object.datatype) else: output_object = input_object output_objects.append(output_object) node.add_output(output_object) pc = create_process_chain_entry(input_object, spatial_extent, temporal_extent, bands, output_object) process_list.extend(pc) return output_objects, process_list
def get_process_list(node: Node): """Analyse the process description and return the Actinia process chain and the name of the processing result :param node: The process node :return: (output_objects, actinia_process_list) """ input_objects, process_list = check_node_parents(node=node) output_objects = [] # First analyse the data entries if "band1" not in node.arguments: raise Exception("Process %s requires parameter <band1>" % PROCESS_NAME) if "band2" not in node.arguments: raise Exception("Process %s requires parameter <band2>" % PROCESS_NAME) # Get the red and nir data separately band1_input_objects = node.get_parent_by_name( parent_name="band1").output_objects band2_input_objects = node.get_parent_by_name( parent_name="band2").output_objects if not band1_input_objects: raise Exception( "Process %s requires an input strds for band 1" % PROCESS_NAME) if not band2_input_objects: raise Exception( "Process %s requires an input strds for band 2" % PROCESS_NAME) band1_strds = list(band1_input_objects)[-1] band2_strds = list(band2_input_objects)[-1] output_objects.extend(list(band1_input_objects)) output_objects.extend(list(band2_input_objects)) output_object = DataObject( name=create_output_name(band1_strds.name, node), datatype=GrassDataType.STRDS) output_objects.append(output_object) node.add_output(output_object=output_object) pc = create_process_chain_entry(band1_strds, band2_strds, output_object) process_list.extend(pc) return output_objects, process_list
def get_process_list(node: Node) -> Tuple[list, list]: """Analyse the process node and return the Actinia process chain and the name of the processing result :param node: The process node :return: (output_objects, actinia_process_list) """ input_objects, process_list = check_node_parents(node=node) output_objects = [] if "data" not in node.arguments or \ "extent" not in node.arguments or \ "north" not in node.arguments["extent"] or \ "south" not in node.arguments["extent"] or \ "east" not in node.arguments["extent"] or \ "west" not in node.arguments["extent"] or \ "crs" not in node.arguments["extent"]: raise Exception( "Process %s requires parameter data and extent with north, south, east, west, " "crs" % PROCESS_NAME) north = node.arguments["extent"]["north"] south = node.arguments["extent"]["south"] west = node.arguments["extent"]["west"] east = node.arguments["extent"]["east"] if "crs" in node.arguments["extent"]: crs = str(node.arguments["extent"]["crs"]) else: crs = "4326" if crs.isnumeric(): crs = "EPSG:" + crs pc = create_process_chain_entry(north=north, south=south, east=east, west=west, crs=crs) process_list.append(pc) for data_object in node.get_parent_by_name( parent_name="data").output_objects: output_objects.append(data_object) node.add_output(data_object) return output_objects, process_list
def get_process_list(node: Node): """Analyse the process description and return the Actinia process chain and the name of the processing result layer which is a single raster layer :param node: The process node :return: (output_objects, actinia_process_list) """ # get dimension type dimtype = get_dimension_type(node.arguments["dimension"]) if dimtype is None: raise Exception( 'Unable to determine dimension type for dimension <%s>.' % (node.arguments["dimension"])) tree, operators = construct_tree( node.as_dict()['arguments']['reducer']['process_graph']) # print (operators) formula = None output_datatype = GrassDataType.STRDS if dimtype == 'bands': formula = serialize_tree(tree) # print (formula) output_datatype = GrassDataType.STRDS elif dimtype == 'temporal': if len(operators) != 1: raise Exception( 'Only one method is supported by reduce process on the temporal dimension.' ) input_objects, process_list = check_node_parents(node=node) output_objects = [] for input_object in node.get_parent_by_name("data").output_objects: output_object = DataObject(name=create_output_name( input_object.name, node), datatype=output_datatype) output_objects.append(output_object) node.add_output(output_object=output_object) pc = create_process_chain_entry(input_object, dimtype, formula, operators, output_object) process_list.extend(pc) return output_objects, process_list
def get_process_list(node: Node): """Analyse the process node and return the Actinia process chain and the name of the processing result :param node: The process node :return: (output_objects, actinia_process_list) """ input_objects, process_list = check_node_parents(node=node) output_objects = [] if "cube1" not in node.arguments or \ "cube2" not in node.arguments: raise Exception( "Process %s requires parameter cube1, cube2" % PROCESS_NAME) cube1_objects = node.get_parent_by_name(parent_name="cube1").output_objects cube2_objects = node.get_parent_by_name(parent_name="cube2").output_objects if "overlap_resolver" in node.arguments and \ (node.arguments["overlap_resolver"] is not None or node.arguments["overlap_resolver"] != "null"): raise Exception( "Process %s does not support yet the parameter \"overlap_resolver\"" % PROCESS_NAME) if not cube1_objects: raise Exception("Process %s requires two input strds's, cube1 is missing" % PROCESS_NAME) if not cube2_objects: raise Exception("Process %s requires two input strds's, cube2 is missing" % PROCESS_NAME) cube1_object = list(cube1_objects)[-1] cube2_object = list(cube2_objects)[-1] output_object = DataObject( name=create_output_name(cube1_object.name, node), datatype=GrassDataType.STRDS) output_objects.append(output_object) node.add_output(output_object=output_object) pc = create_process_chain_entry(cube1_object, cube2_object, output_object) process_list.append(pc) return output_objects, process_list
def get_process_list(node: Node): """Analyse the process node and return the Actinia process chain and the name of the processing result :param node: The process node :return: (output_objects, actinia_process_list) """ input_objects, process_list = check_node_parents(node=node) output_objects = [] if "data" not in node.arguments or \ "mask" not in node.arguments: raise Exception("Process %s requires parameter data, polygons" % PROCESS_NAME) if "replacement" in node.arguments: mask_value = node.arguments["replacement"] else: mask_value = "null" inside = False if "inside" in node.arguments: if node.arguments["inside"] == "true": inside = True input_objects = node.get_parent_by_name(parent_name="data").output_objects vector_object = node.arguments["mask"] if not input_objects: raise Exception("Process %s requires an input strds" % PROCESS_NAME) input_object = list(input_objects)[-1] output_object = DataObject(name=create_output_name(input_object.name, PROCESS_NAME), datatype=GrassDataType.STRDS) output_objects.append(output_object) pc = create_process_chain_entry(input_object, vector_object, mask_value, inside, output_object) process_list.extend(pc) return output_objects, process_list
def get_process_list(node: Node): """Analyse the process description and return the Actinia process chain and the name of the processing result layer which is a single raster layer :param node: The process node :return: (output_objects, actinia_process_list) """ input_objects, process_list = check_node_parents(node=node) output_objects = [] if "mask" not in node.arguments: raise Exception("Parameter mask is required.") nmasks = len(node.get_parent_by_name("mask").output_objects) ninputs = len(node.get_parent_by_name("data").output_objects) if nmasks > 1 and nmasks != ninputs: raise Exception( "Either a single mask or a separate mask for each layer is required." ) mask_object = None if nmasks == 1: mask_object = node.get_parent_by_name("mask").output_objects[0] for i in range(len(node.get_parent_by_name("data").output_objects)): input_object = node.get_parent_by_name("data").output_objects[i] if nmasks > 1: mask_object = node.get_parent_by_name("mask").output_objects[i] output_object = DataObject(name=create_output_name( input_object.name, node), datatype=GrassDataType.RASTER) output_objects.append(output_object) node.add_output(output_object=output_object) pc = create_process_chain_entry(input_object, mask_object, output_object) process_list.append(pc) return output_objects, process_list
def get_process_list(node: Node) -> Tuple[list, list]: """Analyse the process node and return the Actinia process chain and the name of the processing result :param node: The process node :return: (output_objects, actinia_process_list) """ input_objects, process_list = check_node_parents(node=node) output_objects = [] # at least one of bands, common_names, wavelengths must be given if "data" not in node.arguments or \ ("bands" not in node.arguments and "wavelengths" not in node.arguments): raise Exception( "Process %s requires parameter data and at least one of " "bands, wavelengths" % PROCESS_NAME) bands = None if "bands" in node.arguments: bands = node.arguments["bands"] wavelengths = None if "wavelengths" in node.arguments: wavelengths = node.arguments["wavelengths"] data_object = list(node.get_parent_by_name( parent_name="data").output_objects)[-1] output_object = DataObject( name=create_output_name(data_object.name, PROCESS_NAME), datatype=GrassDataType.STRDS) output_objects.append(output_object) node.add_output(output_object=output_object) pc = create_process_chain_entry(data_object, bands, wavelengths, output_object) process_list.append(pc) return output_objects, process_list
def get_process_list(node: Node): """Analyse the process description and return the Actinia process chain and the name of the processing result strds that was filtered by start and end date :param node: The process node :return: (output_names, actinia_process_list) """ input_objects, process_list = check_node_parents(node=node) output_objects = [] for data_object in node.get_parent_by_name( parent_name="data").output_objects: # Skip if the datatype is not a strds and put the input into the output if data_object.is_strds() is False: output_objects.append(data_object) continue output_object = DataObject(name=create_output_name( data_object.name, PROCESS_NAME), datatype=GrassDataType.STRDS) output_objects.append(output_object) node.add_output(output_object=output_object) start_time = None end_time = None if "extent" in node.arguments: start_time = node.arguments["extent"][0] end_time = node.arguments["extent"][1] pc = create__process_chain_entry(input_object=data_object, start_time=start_time, end_time=end_time, output_object=output_object) process_list.append(pc) return output_objects, process_list
def get_process_list(node: Node): """Analyse the process description and return the Actinia process chain and the name of the processing result layer which is a single raster layer :param node: The process node :return: (output_objects, actinia_process_list) """ input_objects, process_list = check_node_parents(node=node) output_objects = [] data_object = list(input_objects)[-1] output_object = DataObject(name=create_output_name(data_object.name, node), datatype=GrassDataType.RASTER) output_objects.append(output_object) node.add_output(output_object=output_object) pc = create_process_chain_entry(data_object, output_object) process_list.append(pc) return output_objects, process_list
def get_process_list(node: Node): """Analyse the process description and return the Actinia process chain and the name of the processing result layer which is a single raster layer :param node: The process node :return: (output_objects, actinia_process_list) """ input_objects, process_list = check_node_parents(node=node) output_objects = [] # Pipe the inputs to the outputs for data_object in node.get_parent_by_name("data").output_objects: # Export raster maps if data_object.is_raster(): output_objects.append(data_object) node.add_output(output_object=data_object) pc = create_process_chain_entry(data_object=data_object) process_list.extend(pc) return output_objects, process_list
def get_process_list(node: Node) -> Tuple[list, list]: """Analyse the process node and return the Actinia process chain and the name of the processing result :param node: The process node :return: (output_objects, actinia_process_list) """ input_objects, process_list = check_node_parents(node=node) output_objects = [] if "data" not in node.arguments or \ "mask" not in node.arguments: raise Exception("Process %s requires parameter data, mask" % PROCESS_NAME) if "replacement" in node.arguments: mask_value = node.arguments["replacement"] else: mask_value = "null" # Get the input and mask data separately data_object = list( node.get_parent_by_name(parent_name="data").output_objects)[0] mask_object = list( node.get_parent_by_name(parent_name="mask").output_objects)[0] output_object = DataObject(name=create_output_name(data_object.name, PROCESS_NAME), datatype=GrassDataType.STRDS) output_objects.append(output_object) node.add_output(output_object=output_object) pc = create_process_chain_entry(data_object, mask_object, mask_value, output_object) process_list.append(pc) return output_objects, process_list
def get_process_list(node: Node): """Analyse the process node and return the Actinia process chain and the name of the processing result :param node: The process node :return: (output_objects, actinia_process_list) """ input_objects, process_list = check_node_parents(node=node) output_objects = [] input_objects = node.get_parent_by_name(parent_name="data").output_objects if not input_objects: raise Exception("Process %s requires an input strds" % PROCESS_NAME) for data_object in input_objects: output_objects.append(data_object) node.add_output(data_object) # dummy process, does nothing # pc = create_process_chain_entry(input_object, output_object) # process_list.append(pc) return output_objects, process_list
def get_process_list(node: Node): """Analyse the process description and return the Actinia process chain and the name of the processing result :param node: The process node :return: (output_objects, actinia_process_list) """ input_objects, process_list = check_node_parents(node=node) output_objects = [] # First analyse the data entries if "red" not in node.arguments: raise Exception("Process %s requires parameter <red>" % PROCESS_NAME) if "green" not in node.arguments: raise Exception("Process %s requires parameter <green>" % PROCESS_NAME) if "blue" not in node.arguments: raise Exception("Process %s requires parameter <blue>" % PROCESS_NAME) # Get the red, green and blue data separately red_input_objects = node.get_parent_by_name( parent_name="red").output_objects green_input_objects = node.get_parent_by_name( parent_name="green").output_objects blue_input_objects = node.get_parent_by_name( parent_name="blue").output_objects if not red_input_objects: raise Exception( "Process %s requires an input raster for band <red>" % PROCESS_NAME) if not green_input_objects: raise Exception( "Process %s requires an input raster for band <green>" % PROCESS_NAME) if not blue_input_objects: raise Exception( "Process %s requires an input raster for band <blue>" % PROCESS_NAME) red_object = list(red_input_objects)[-1] green_object = list(green_input_objects)[-1] blue_object = list(blue_input_objects)[-1] output_objects.extend(list(red_input_objects)) output_objects.extend(list(green_input_objects)) output_objects.extend(list(blue_input_objects)) rn = randint(0, 1000000) output_object = DataObject( name="red_green_blue_composite_%i" % rn, datatype=GrassDataType.STRDS) output_objects.append(output_object) node.add_output(output_object=output_object) pc = create_process_chain_entry( output_object=output_object, red_object=red_object, green_object=green_object, blue_object=blue_object) process_list.extend(pc) return output_objects, process_list
def get_process_list(node: Node): """Analyse the process description and return the Actinia process chain and the name of the processing result :param node: The process node :return: (output_objects, actinia_process_list) """ input_objects, process_list = check_node_parents(node=node) output_objects = [] # First analyse the data entries if "red" not in node.arguments: raise Exception("Process %s requires parameter <red>" % PROCESS_NAME) if "nir" not in node.arguments: raise Exception("Process %s requires parameter <nir>" % PROCESS_NAME) if "blue" not in node.arguments: raise Exception("Process %s requires parameter <blue>" % PROCESS_NAME) # Get the red and nir data separately red_input_objects = node.get_parent_by_name( parent_name="red").output_objects nir_input_objects = node.get_parent_by_name( parent_name="nir").output_objects blue_input_objects = node.get_parent_by_name( parent_name="blue").output_objects if not red_input_objects: raise Exception( "Process %s requires an input strds for band <red>" % PROCESS_NAME) if not nir_input_objects: raise Exception( "Process %s requires an input strds for band <nir>" % PROCESS_NAME) if not blue_input_objects: raise Exception( "Process %s requires an input strds for band <blue>" % PROCESS_NAME) scale = 1.0 if "scale" in node.arguments: scale = float(node.arguments["scale"]) red_strds = list(red_input_objects)[-1] nir_strds = list(nir_input_objects)[-1] blue_strds = list(blue_input_objects)[-1] output_objects.extend(list(red_input_objects)) output_objects.extend(list(nir_input_objects)) output_objects.extend(list(blue_input_objects)) output_object = DataObject( name=create_output_name(red_strds.name, node), datatype=GrassDataType.STRDS) output_objects.append(output_object) node.add_output(output_object=output_object) pc = create_process_chain_entry( nir_strds, red_strds, blue_strds, scale, output_object) process_list.extend(pc) return output_objects, process_list