def create_process_description():
p_x = Parameter(description="A number.",
schema={"type": ["number", "null"]})
rv = ReturnValue(description="The computed signum value of `x`.",
schema={
"type": ["number", "null"],
})
# Example
arguments = {"x": -2}
node = ProcessGraphNode(process_id=PROCESS_NAME, arguments=arguments)
graph = ProcessGraph(title="title",
description="description",
process_graph={"sgn_1": node})
examples = [
ProcessExample(title="Simple example",
description="Simple example",
process_graph=graph)
]
pd = ProcessDescription(
id=PROCESS_NAME,
description=
"The signum (also known as *sign*) of `x` is defined as:\n\n* *1* if *x > 0*\n* *0* if *x = 0*\n* *-1* if *x < 0*.",
summary="Signum",
parameters={"x": p_x},
returns=rv,
examples=examples)
return json.loads(pd.to_json())
def create_process_description():
p_x = Parameter(description="The data to check.",
schema={"description": "Any data type is allowed."})
rv = ReturnValue(
description="`true` if the data is a no-data value, otherwise `false`",
schema={"type": "boolean"})
# Example
arguments = {"x": 1}
node = ProcessGraphNode(process_id=PROCESS_NAME, arguments=arguments)
graph = ProcessGraph(title="title",
description="description",
process_graph={"isnodata_1": node})
examples = [
ProcessExample(title="Simple example",
description="Simple example",
process_graph=graph)
]
pd = ProcessDescription(
id=PROCESS_NAME,
description=
"Checks whether the specified data is a missing data, i.e. equals to any of the no-data values",
summary="Value is a no-data value",
parameters={"x": p_x},
returns=rv,
examples=examples)
return json.loads(pd.to_json())
def create_process_description():
p_x = Parameter(description="A number",
schema={"type": ["number", "null"]})
rv = ReturnValue(description="Integer part of the number.",
schema={
"type": ["number", "null"],
})
# Example
arguments = {"x": 3.5}
node = ProcessGraphNode(process_id=PROCESS_NAME, arguments=arguments)
graph = ProcessGraph(title="title",
description="description",
process_graph={"int_1": node})
examples = [
ProcessExample(title="Simple example",
description="Simple example",
process_graph=graph)
]
pd = ProcessDescription(
id=PROCESS_NAME,
description="The integer part of the real number `x`.",
summary="Integer part of a number",
parameters={"x": p_x},
returns=rv,
examples=examples)
return json.loads(pd.to_json())
def create_process_description():
p_data = Parameter(description="A number.",
schema={"type": ["number", "null"]})
rv = ReturnValue(description="The computed absolute value.",
schema={
"type": ["number", "null"],
})
# Example
arguments = {"x": 0}
node = ProcessGraphNode(process_id=PROCESS_NAME, arguments=arguments)
graph = ProcessGraph(title="title",
description="description",
process_graph={"abs_1": node})
examples = [
ProcessExample(title="Simple example",
description="Simple example",
process_graph=graph)
]
pd = ProcessDescription(
id=PROCESS_NAME,
description="Computes the absolute value of a real number `x`.",
summary="Absolute value",
parameters={
"x": p_data,
},
returns=rv,
examples=examples)
return json.loads(pd.to_json())
def create_process_description():
p_x = Parameter(description="First operand.",
schema={"description": "Any data type is allowed."})
p_y = Parameter(description="Second operand.",
schema={"description": "Any data type is allowed."})
rv = ReturnValue(
description=
"`true` if `x` is strictly greater than `y` or `null` if any operand is `null`, otherwise `false`.",
schema={"type": ["boolean", "null"]})
# Example
arguments = {"x": 1, "y": None}
node = ProcessGraphNode(process_id=PROCESS_NAME, arguments=arguments)
graph = ProcessGraph(title="title",
description="description",
process_graph={"gt_1": node})
examples = [
ProcessExample(title="Simple example",
description="Simple example",
process_graph=graph)
]
pd = ProcessDescription(
id=PROCESS_NAME,
description="Compares whether `x` is strictly greater than `y`.",
summary="Greater than comparison",
parameters={
"x": p_x,
"y": p_y
},
returns=rv,
examples=examples)
return json.loads(pd.to_json())
def create_process_description():
p_band1 = Parameter(
description=
"Any openEO process object that returns a single space-time raster datasets "
"that contains the first band for normalized difference computation.",
schema={
"type": "object",
"subtype": "raster-cube"
},
optional=False)
p_band2 = Parameter(
description=
"Any openEO process object that returns a single space-time raster datasets "
"that contains the second band for normalized difference computation.",
schema={
"type": "object",
"subtype": "raster-cube"
},
optional=False)
rv = ReturnValue(description="Processed EO data.",
schema={
"type": "object",
"subtype": "raster-cube"
})
# Example
arguments = {
"band1": {
"from_node": "get_band1_data"
},
"band2": {
"from_node": "get_band2_data"
},
}
node = ProcessGraphNode(process_id=PROCESS_NAME, arguments=arguments)
graph = ProcessGraph(title="title",
description="description",
process_graph={"nnormalized difference_1": node})
examples = [
ProcessExample(title="Simple example",
description="Simple example",
process_graph=graph)
]
pd = ProcessDescription(
id=PROCESS_NAME,
description=
"The normalized difference is computed as *(band1 - band2) / (band1 + band2).",
summary=
"The normalized difference is computed as *(band1 - band2) / (band1 + band2).",
parameters={
"band1": p_band1,
"band2": p_band2
},
returns=rv,
examples=examples)
return json.loads(pd.to_json())
def create_process_description():
p_x = Parameter(description="A boolean value.",
schema={"type": ["boolean", "null"]})
p_y = Parameter(description="A boolean value.",
schema={"type": ["boolean", "null"]})
rv = ReturnValue(description="Boolean result of the logical OR.",
schema={
"type": ["boolean", "null"],
})
# Example
arguments = {"x": True, "y": True}
node = ProcessGraphNode(process_id=PROCESS_NAME, arguments=arguments)
graph = ProcessGraph(title="title",
description="description",
process_graph={"or_1": node})
examples = [
ProcessExample(title="Simple example",
description="Simple example",
process_graph=graph)
]
pd = ProcessDescription(
id=PROCESS_NAME,
description="Checks if **at least one** of the values is true.",
summary="Logical OR",
parameters={
"x": p_x,
"y": p_y
},
returns=rv,
examples=examples)
return json.loads(pd.to_json())
def create_process_description():
p_x = Parameter(
description="A number to compute the natural logarithm for.",
schema={"type": ["number", "null"]})
rv = ReturnValue(description="The computed natural logarithm.",
schema={
"type": ["number", "null"],
})
# Example
arguments = {"x": 1}
node = ProcessGraphNode(process_id=PROCESS_NAME, arguments=arguments)
graph = ProcessGraph(title="title",
description="description",
process_graph={"ln_1": node})
examples = [
ProcessExample(title="Simple example",
description="Simple example",
process_graph=graph)
]
pd = ProcessDescription(
id=PROCESS_NAME,
description=
"The natural logarithm is the logarithm to the base *e* of the number `x`.",
summary="Natural logarithm",
parameters={"x": p_x},
returns=rv,
examples=examples)
return json.loads(pd.to_json())
def create_process_description():
p_x = Parameter(description="Boolean value to invert.",
schema={"type": ["boolean", "null"]})
rv = ReturnValue(description="Inverted boolean value.",
schema={
"type": ["boolean", "null"],
})
# Example
arguments = {"x": False}
node = ProcessGraphNode(process_id=PROCESS_NAME, arguments=arguments)
graph = ProcessGraph(title="title",
description="description",
process_graph={"not_1": node})
examples = [
ProcessExample(title="Simple example",
description="Simple example",
process_graph=graph)
]
pd = ProcessDescription(
id=PROCESS_NAME,
description=
"Inverts a single boolean so that `true` gets `false` and `false` gets `true`.",
summary="Inverting a boolean",
parameters={"x": p_x},
returns=rv,
examples=examples)
return json.loads(pd.to_json())
def create_process_description():
p_data = Parameter(
description="Any openEO process object that returns raster datasets "
"or space-time raster dataset",
schema={
"type": "object",
"subtype": "raster-cube"
},
optional=False)
p_min = Parameter(description="New minimum value",
schema={
"type": "object",
"format": "float"
},
optional=False)
p_max = Parameter(description="New maximum value",
schema={
"type": "object",
"format": "float"
},
optional=False)
rv = ReturnValue(description="Processed EO data.",
schema={
"type": "object",
"subtype": "raster-cube"
})
# Example
arguments = {
"data": {
"from_node": "get_data_1"
},
"min": 1,
"max": 255,
}
node = ProcessGraphNode(process_id=PROCESS_NAME, arguments=arguments)
graph = ProcessGraph(title="title",
description="description",
process_graph={"scale_minmax_1": node})
examples = [
ProcessExample(title="Simple example",
description="Simple example",
process_graph=graph)
]
pd = ProcessDescription(
id=PROCESS_NAME,
description=
"Scales the image values between specified min and max values.",
summary="Rescale raster data based on interval",
parameters={
"data": p_data,
"min": p_min,
"max": p_max
},
returns=rv,
examples=examples)
return json.loads(pd.to_json())
def create_process_description():
p_data = Parameter(
description="Any openEO process object that returns raster datasets "
"or a space-time raster dataset",
schema={
"type": "object",
"subtype": "raster-cube"
},
optional=False)
p_mask = Parameter(
description="Any openEO process object that returns raster datasets "
"or a space-time raster dataset",
schema={
"type": "object",
"subtype": "raster-cube"
},
optional=False)
rv = ReturnValue(description="Masked EO data.",
schema={
"type": "object",
"subtype": "raster-cube"
})
# Example
arguments = {
"data": {
"from_node": "get_strds_data"
},
"mask": {
"from_node": "get_mask_data"
},
}
node = ProcessGraphNode(process_id=PROCESS_NAME, arguments=arguments)
graph = ProcessGraph(title="title",
description="description",
process_graph={"apply_mask_1": node})
examples = [
ProcessExample(title="Simple example",
description="Simple example",
process_graph=graph)
]
pd = ProcessDescription(
id=PROCESS_NAME,
description="Applies a mask to an EO dataset. "
"Each pixel that is 0 or nodata in the mask is set to nodata. "
"See also multilayer_mask.",
summary="Apply a mask to an EO dataset.",
parameters={
"data": p_data,
"mask": p_mask
},
returns=rv,
examples=examples)
return json.loads(pd.to_json())
def create_process_description():
p_data = Parameter(description="An array of numbers.",
schema={
"type": "array",
"items": {
"type": [
"number",
"null"
]
}
})
p_nodata = Parameter(
description="Indicates whether no-data values are ignored or not.",
schema={
"type": "boolean"},
default=True,
optional=True)
rv = ReturnValue(description="The computed arithmetic mean.",
schema={
"type": [
"number",
"null"
],
})
# Example
arguments = {
"data": [
1,
0,
3,
2
]
}
node = ProcessGraphNode(process_id=PROCESS_NAME, arguments=arguments)
graph = ProcessGraph(
title="title",
description="description",
process_graph={
"mean_1": node})
examples = [
ProcessExample(
title="Simple example",
description="Simple example",
process_graph=graph)]
pd = ProcessDescription(
id=PROCESS_NAME,
description="The arithmetic mean of an array of numbers is the quantity commonly called the average.",
summary="Arithmetic mean (average)",
parameters={
"data": p_data,
"ignore_nodata": p_nodata},
returns=rv,
examples=examples)
return json.loads(pd.to_json())
def create_process_description():
p_data = Parameter(description="Raster data cube",
schema={
"type": "object",
"subtype": "raster-cube"
},
optional=False)
p_uprocess = Parameter(
description=
"Applies a unary process to each pixel value in the data cube. "
"A unary process takes a single value and returns a single value.",
schema={
"type":
"object",
"subtype":
"process-graph",
"parameters": [{
"name": "x",
"description": "The value to process.",
"schema": {
"description": "Any data type."
}
}]
},
optional=False)
rv = ReturnValue(description="Processed EO data.",
schema={
"type": "object",
"subtype": "raster-cube"
})
# Example
arguments = {"data": {"from_node": "get_strds_data"}, "process": "null"}
node = ProcessGraphNode(process_id=PROCESS_NAME, arguments=arguments)
graph = ProcessGraph(title="title",
description="description",
process_graph={"apply1": node})
examples = [
ProcessExample(title="Simple example",
description="Simple example",
process_graph=graph)
]
pd = ProcessDescription(
id=PROCESS_NAME,
description="Applies a **unary** process which takes a single value "
"such as `abs` or `sqrt` to each pixel value and returns "
"a single new value for each pixel",
summary="Applies a unary process to each pixel",
parameters={
"data": p_data,
"process": p_uprocess
},
returns=rv,
examples=examples)
return json.loads(pd.to_json())
def create_process_description():
p_data = Parameter(description="An array of numbers.",
schema={
"type": "array",
"items": {
"type": [
"number",
"null"
]
}
})
p_nodata = Parameter(
description="Indicates whether no-data values are ignored or not.",
schema={
"type": "boolean"},
default=True,
optional=True)
rv = ReturnValue(
description="The computed sum of the sequence of numbers.",
schema={
"type": [
"number",
"null"],
})
# Example
arguments = {
"data": [
-2,
4,
2.5
]
}
node = ProcessGraphNode(process_id=PROCESS_NAME, arguments=arguments)
graph = ProcessGraph(
title="title",
description="description",
process_graph={
"sum_1": node})
examples = [
ProcessExample(
title="Simple example",
description="Simple example",
process_graph=graph)]
pd = ProcessDescription(
id=PROCESS_NAME,
description="Sums up all elements in a sequential array of numbers and returns the computed sum.",
summary="Compute the sum by adding up numbers",
parameters={
"data": p_data,
"ignore_nodata": p_nodata},
returns=rv,
examples=examples)
return json.loads(pd.to_json())
def create_process_description():
p_data = Parameter(description="An array",
schema={
"type": "array",
"items": {
"description": "Any data type is allowed."
}})
p_index = Parameter(
description="The zero-based index of the element to retrieve.",
schema={
"type": "integer"},
optional=True)
p_label = Parameter(description="The label of the element to retrieve.",
schema=[
{
"type": "number"
},
{
"type": "string"
}
],
optional=True)
rv = ReturnValue(description="The value of the requested element.",
schema={
"description": "Any data type is allowed."})
# Example
arguments = {
"data": {"from_node": "get_data_1"},
"index": 0,
"label": 0
}
node = ProcessGraphNode(process_id=PROCESS_NAME, arguments=arguments)
graph = ProcessGraph(
title="title",
description="description",
process_graph={
"array_element_1": node})
examples = [
ProcessExample(
title="Simple example",
description="Simple example",
process_graph=graph)]
pd = ProcessDescription(
id=PROCESS_NAME,
description="Returns the element with the specified index or label from the array.",
summary="Get an element from an array",
parameters={
"data": p_data,
"index": p_index,
"label": p_label},
returns=rv,
examples=examples)
return json.loads(pd.to_json())
def create_process_description():
p_data = Parameter(description="An array of numbers.",
schema={
"type": "array",
"items": {
"type": [
"number",
"null"
]
}
})
p_nodata = Parameter(
description="Indicates whether no-data values are ignored or not.",
schema={
"type": "boolean"},
default=True,
optional=True)
rv = ReturnValue(description="The computed sample variance.",
schema={
"type": [
"number",
"null"
],
})
# Example
arguments = {
"data": [
-1,
1,
3
]
}
node = ProcessGraphNode(process_id=PROCESS_NAME, arguments=arguments)
graph = ProcessGraph(
title="title",
description="description",
process_graph={
"variance_1": node})
examples = [
ProcessExample(
title="Simple example",
description="Simple example",
process_graph=graph)]
pd = ProcessDescription(
id=PROCESS_NAME,
description="Computes the sample variance of an array of numbers by calculating the square of the standard deviation (see ``sd()``).",
summary="Variance",
parameters={
"data": p_data,
"ignore_nodata": p_nodata},
returns=rv,
examples=examples)
return json.loads(pd.to_json())
def create_process_description():
p_data = Parameter(
description="A raster data cube with two bands that have the common names red and nir assigned.",
schema={
"type": "object",
"subtype": "raster-cube"},
optional=False)
p_nir = Parameter(
description="The name of the NIR band. Defaults to the band that has the common name `nir` assigned.",
schema={
"type": "string",
"subtype": "band-name"},
optional=True)
p_red = Parameter(
description="The name of the red band. Defaults to the band that has the common name `red` assigned.",
schema={
"type": "string",
"subtype": "band-name"},
optional=True)
rv = ReturnValue(description="Processed EO data.",
schema={"type": "object", "subtype": "raster-cube"})
# Example
arguments = {
"data": {"from_node": "get_data"},
"nir": "S2_8",
"red": "S2_4"
}
node = ProcessGraphNode(process_id=PROCESS_NAME, arguments=arguments)
graph = ProcessGraph(
title="title",
description="description",
process_graph={
"ndvi_1": node})
examples = [
ProcessExample(
title="Simple example",
description="Simple example",
process_graph=graph)]
pd = ProcessDescription(
id=PROCESS_NAME,
description="The data parameter expects a raster data cube with two bands "
"that have the common names red and nir assigned. The process returns "
"a raster data cube with two bands being replaced with a new band "
"that holds the computed values. ",
summary="Computes the Normalized Difference Vegetation Index (NDVI). "
"The NDVI is computed as (nir - red) / (nir + red).",
parameters={
"data": p_data,
"nir": p_nir,
"red": p_red},
returns=rv,
examples=examples)
return json.loads(pd.to_json())
def create_process_description():
p_data = Parameter(
description="Any openEO process object that returns raster datasets "
"or space-time raster dataset",
schema={
"type": "object",
"subtype": "raster-cube"
},
optional=False)
p_polygons = Parameter(
description="URL to a publicly accessible polygon file readable by OGR",
schema={"type": "string"},
optional=False)
rv = ReturnValue(description="Processed EO data.",
schema={
"type": "object",
"subtype": "raster-cube"
})
# Example
arguments = {
"data": {
"from_node": "get_b08_data"
},
"polygons":
"https://storage.googleapis.com/graas-geodata/roi_openeo_use_case_2.geojson"
}
node = ProcessGraphNode(process_id=PROCESS_NAME, arguments=arguments)
graph = ProcessGraph(title="title",
description="description",
process_graph={"zonal_statistics_1": node})
examples = [
ProcessExample(title="Simple example",
description="Simple example",
process_graph=graph)
]
pd = ProcessDescription(
id=PROCESS_NAME,
description=
"Compute the zonal statistics of a time series using a vector polygon. "
"The following parameters are computed: "
"mean, min, max, mean_of_abs, stddev, variance, "
"coeff_var, sum, null_cells, cells",
summary=
"Compute the zonal statistics of a time series using a vector polygon.",
parameters={
"data": p_data,
"polygons": p_polygons
},
returns=rv,
examples=examples)
return json.loads(pd.to_json())
def create_process_description():
p_red = Parameter(
description="Any openEO process object that returns a single space-time raster datasets "
"that contains the RED band for EVI computation.", schema={
"type": "object", "subtype": "raster-cube"}, optional=False)
p_nir = Parameter(
description="Any openEO process object that returns a single space-time raster datasets "
"that contains the NIR band for EVI computation.", schema={
"type": "object", "subtype": "raster-cube"}, optional=False)
p_blue = Parameter(
description="Any openEO process object that returns a single space-time raster datasets "
"that contains the BLUE band for EVI computation.", schema={
"type": "object", "subtype": "raster-cube"}, optional=False)
p_scale = Parameter(description="Scale factor to convert band values",
schema={"type": "object", "subtype": "float"},
optional=True)
rv = ReturnValue(description="Processed EO data.",
schema={"type": "object", "subtype": "raster-cube"})
# Example
arguments = {
"red": {"from_node": "get_red_data"},
"nir": {"from_node": "get_nir_data"},
"blue": {"from_node": "get_blue_data"},
}
node = ProcessGraphNode(process_id=PROCESS_NAME, arguments=arguments)
graph = ProcessGraph(
title="title",
description="description",
process_graph={
"evi_1": node})
examples = [
ProcessExample(
title="Simple example",
description="Simple example",
process_graph=graph)]
pd = ProcessDescription(
id=PROCESS_NAME,
description="Compute the EVI based on the red, nir, and blue bands of the input datasets.",
summary="Compute the EVI based on the red, nir, and blue bands of the input datasets.",
parameters={
"red": p_red,
"nir": p_nir,
"blue": p_blue,
"scale": p_scale},
returns=rv,
examples=examples)
return json.loads(pd.to_json())
def create_process_description():
p_value = Parameter(description="A boolean value.",
schema={
"type": [
"boolean",
"null"
]
})
p_accept = Parameter(
description="A value that is returned if the boolean value is `true`.",
schema={
"description": "Any data type is allowed."})
p_reject = Parameter(
description="A value that is returned if the boolean value is **not** `true`. Defaults to `null`.",
schema={
"description": "Any data type is allowed."},
default=None,
optional=True)
rv = ReturnValue(
description="Either the `accept` or `reject` argument depending on the given boolean value.",
schema={
"description": "Any data type is allowed."})
# Example
arguments = {
"value": True,
"accept": "A",
"reject": "B"
}
node = ProcessGraphNode(process_id=PROCESS_NAME, arguments=arguments)
graph = ProcessGraph(
title="title",
description="description",
process_graph={
"if_1": node})
examples = [
ProcessExample(
title="Simple example",
description="Simple example",
process_graph=graph)]
pd = ProcessDescription(
id=PROCESS_NAME,
description="If the value passed is `true`, returns the value of the `accept` parameter, otherwise returns the value of the `reject` parameter.",
summary="If-Then-Else conditional",
parameters={
"value": p_value,
"accept": p_accept,
"reject": p_reject},
returns=rv,
examples=examples)
return json.loads(pd.to_json())
def create_process_description():
p_x = Parameter(description="The minuend",
schema={
"type": [
"number",
"null"
]
})
p_y = Parameter(description="The subtrahend",
schema={
"type": [
"number",
"null"
]
})
rv = ReturnValue(description="The computed result.",
schema={
"type": [
"number",
"null"
],
})
# Example
arguments = {
"x": 5,
"y": 2.5
}
node = ProcessGraphNode(process_id=PROCESS_NAME, arguments=arguments)
graph = ProcessGraph(
title="title",
description="description",
process_graph={
"subract_1": node})
examples = [
ProcessExample(
title="Simple example",
description="Simple example",
process_graph=graph)]
pd = ProcessDescription(
id=PROCESS_NAME,
description="Subtracts argument `y` from the argument `x` (*x - y*) and returns the computed result.",
summary="Subtraction of two numbers",
parameters={
"x": p_x,
"y": p_y},
returns=rv,
examples=examples)
return json.loads(pd.to_json())
def create_process_description():
p_x = Parameter(description="The numerical base.",
schema={
"type": [
"number",
"null"
]
})
p_y = Parameter(description="The numerical exponent.",
schema={
"type": [
"number",
"null"
]
})
rv = ReturnValue(
description="The computed value for `base` raised to the power of `p`.",
schema={
"type": [
"number",
"null"],
})
# Example
arguments = {
"x": 5,
"y": 2.5
}
node = ProcessGraphNode(process_id=PROCESS_NAME, arguments=arguments)
graph = ProcessGraph(
title="title",
description="description",
process_graph={
"power_1": node})
examples = [
ProcessExample(
title="Simple example",
description="Simple example",
process_graph=graph)]
pd = ProcessDescription(
id=PROCESS_NAME,
description="Computes the exponentiation for the base `base` raised to the power of `p`.",
summary="Exponentiation",
parameters={
"base": p_x,
"p": p_y},
returns=rv,
examples=examples)
return json.loads(pd.to_json())
def create_process_description():
p_x = Parameter(description="First operand.",
schema={"description": "Any data type is allowed."})
p_y = Parameter(description="Second operand.",
schema={"description": "Any data type is allowed."})
p_delta = Parameter(
description="Only applicable for comparing two numbers.",
schema={
"type": ["number", "null"],
},
default=None,
optional=True)
p_case = Parameter(
description="Only applicable for comparing two strings.",
schema={"type": "boolean"},
default=None,
optional=True)
rv = ReturnValue(
description=
"Returns `true` if `x` is equal to `y`, `null` if any operand is `null`, otherwise `false`.",
schema={"type": ["boolean", "null"]})
# Example
arguments = {"x": 1, "y": None}
node = ProcessGraphNode(process_id=PROCESS_NAME, arguments=arguments)
graph = ProcessGraph(title="title",
description="description",
process_graph={"eq_1": node})
examples = [
ProcessExample(title="Simple example",
description="Simple example",
process_graph=graph)
]
pd = ProcessDescription(
id=PROCESS_NAME,
description="Compares whether `x` is strictly equal to `y`.",
summary="Equal to comparison",
parameters={
"x": p_x,
"y": p_y,
"delta": p_delta,
"case_sensitive": p_case
},
returns=rv,
examples=examples)
return json.loads(pd.to_json())
def create_process_description():
p_data = Parameter(
description="Any openEO process object that returns raster datasets "
"or space-time raster dataset",
schema={
"type": "object",
"subtype": "raster-cube"
},
optional=False)
p_percentile = Parameter(description="The percentile to get from a "
"space-time raster dataset",
schema={
"type": "object",
"subtype": "float"
},
optional=False)
rv = ReturnValue(description="Processed EO data.",
schema={
"type": "object",
"subtype": "raster-cube"
})
# Example
arguments = {"data": {"from_node": "get_strds_data"}, "percentile": "5"}
node = ProcessGraphNode(process_id=PROCESS_NAME, arguments=arguments)
graph = ProcessGraph(title="title",
description="description",
process_graph={"percentile_time_1": node})
examples = [
ProcessExample(title="Simple example",
description="Simple example",
process_graph=graph)
]
pd = ProcessDescription(
id=PROCESS_NAME,
description="Reduce the time dimension of a space-time raster dataset "
"by getting the percentile.",
summary="Reduce the time dimension of a space-time raster dataset.",
parameters={
"data": p_data,
"percentile": p_percentile
},
returns=rv,
examples=examples)
return json.loads(pd.to_json())
def create_process_description():
p_red = Parameter(
description="Any openEO process object that returns raster dataset that should be used as "
"the red channel in the resulting GRB image.", schema={
"type": "object", "subtype": "raster-cube"}, optional=False)
p_green = Parameter(
description="Any openEO process object that returns raster dataset that should be used as "
"the green channel in the resulting GRB image.", schema={
"type": "object", "subtype": "raster-cube"}, optional=False)
p_blue = Parameter(
description="Any openEO process object that returns raster dataset that should be used as "
"the blue channel in the resulting GRB image.", schema={
"type": "object", "subtype": "raster-cube"}, optional=False)
rv = ReturnValue(description="Processed EO data.",
schema={"type": "object", "subtype": "raster-cube"})
# Example
arguments = {"red": {"from_node": "get_red_data"},
"green": {"from_node": "get_green_data"},
"blue": {"from_node": "get_blue_data"}}
node = ProcessGraphNode(process_id=PROCESS_NAME, arguments=arguments)
graph = ProcessGraph(
title="title",
description="description",
process_graph={
"rgb_raster_exporter_1": node})
examples = [
ProcessExample(
title="Simple example",
description="Simple example",
process_graph=graph)]
pd = ProcessDescription(
id=PROCESS_NAME,
description="This process exports three raster map layers as a single RGB image "
"using the region specified upstream.",
summary="Exports three RGB raster map layers using the region specified upstream.",
parameters={
"red": p_red,
"green": p_green,
"blur": p_blue},
returns=rv,
examples=examples)
return json.loads(pd.to_json())
def create_process_description():
p_data = Parameter(description="An array of numbers.",
schema={
"type": "array",
"items": {
"type": ["number", "null"]
}
})
p_nodata = Parameter(
description="Indicates whether no-data values are ignored or not.",
schema={"type": "boolean"},
default=True,
optional=True)
rv = ReturnValue(description="The computed statistical median.",
schema={
"type": ["number", "null"],
})
# Example
arguments = {"data": [1, 3, 3, 6, 7, 8, 9]}
node = ProcessGraphNode(process_id=PROCESS_NAME, arguments=arguments)
graph = ProcessGraph(title="title",
description="description",
process_graph={"median_1": node})
examples = [
ProcessExample(title="Simple example",
description="Simple example",
process_graph=graph)
]
pd = ProcessDescription(
id=PROCESS_NAME,
description=
"The statistical median of an array of numbers is the value separating the higher half from the lower half of the sorted data.",
summary="Statistical median",
parameters={
"data": p_data,
"ignore_nodata": p_nodata
},
returns=rv,
examples=examples)
return json.loads(pd.to_json())
def create_process_description():
p_data = Parameter(
description="Any openEO process object that returns raster datasets "
"or space-time raster dataset",
schema={
"type": "object",
"subtype": "raster-cube"},
optional=False)
p_format = Parameter(
description="The format of the export. Default is GeotTiff format.",
schema={
"type": "string",
"default": "GTiff"},
optional=True)
rv = ReturnValue(description="Processed EO data.",
schema={"type": "object", "subtype": "raster-cube"})
# Example
arguments = {"data": {"from_node": "get_b08_data"},
"format": "GTiff"}
node = ProcessGraphNode(process_id=PROCESS_NAME, arguments=arguments)
graph = ProcessGraph(
title="title",
description="description",
process_graph={
"raster_exporter_1": node})
examples = [
ProcessExample(
title="Simple example",
description="Simple example",
process_graph=graph)]
pd = ProcessDescription(
id=PROCESS_NAME,
description="This process exports an arbitrary number of raster map layers "
"using the region specified upstream.",
summary="Exports raster map layers using the region specified upstream.",
parameters={
"data": p_data,
"format": p_format},
returns=rv,
examples=examples)
return json.loads(pd.to_json())
def create_process_description():
p_data = Parameter(description="A number.",
schema={"type": ["number", "null"]})
p_min = Parameter(
description=
"Minimum value. If the value is lower than this value, the process will return the value of this parameter.",
schema={"type": ["number", "null"]})
p_max = Parameter(
description=
"Maximum value. If the value is greater than this value, the process will return the value of this parameter.",
schema={"type": ["number", "null"]})
rv = ReturnValue(description="The value clipped to the specified range.",
schema={
"type": ["number", "null"],
})
# Example
arguments = {"x": -5, "min": -1, "max": 1}
node = ProcessGraphNode(process_id=PROCESS_NAME, arguments=arguments)
graph = ProcessGraph(title="title",
description="description",
process_graph={"clip_1": node})
examples = [
ProcessExample(title="Simple example",
description="Simple example",
process_graph=graph)
]
pd = ProcessDescription(
id=PROCESS_NAME,
description=
"Clips a number between specified minimum and maximum values.",
summary="Clip a value between a minimum and a maximum",
parameters={
"x": p_data,
"min": p_min,
"max": p_max
},
returns=rv,
examples=examples)
return json.loads(pd.to_json())
def create_process_description():
p_data = Parameter(
description="Any openEO process object that returns raster datasets",
schema={
"type": "object",
"subtype": "raster-cube"
},
optional=False)
rv = ReturnValue(description="Processed EO data.",
schema={
"type": "object",
"subtype": "raster-cube"
})
# Example
arguments = {
"data": {
"from_node": "get_data_1"
},
}
node = ProcessGraphNode(process_id=PROCESS_NAME, arguments=arguments)
graph = ProcessGraph(title="title",
description="description",
process_graph={"bbox_from_raster_1": node})
examples = [
ProcessExample(title="Simple example",
description="Simple example",
process_graph=graph)
]
pd = ProcessDescription(
id=PROCESS_NAME,
description="Sets the computational bounding box for "
"downstream computation from raster layer.",
summary="Sets the computational bounding box for "
"downstream computation from raster layer.",
parameters={"data": p_data},
returns=rv,
examples=examples)
return json.loads(pd.to_json())
def create_process_description():
p_data = Parameter(
description="Any openEO process object that returns raster datasets "
"or a space-time raster dataset",
schema={
"type": "object",
"subtype": "raster-cube"
},
optional=False)
rv = ReturnValue(description="Multilayer mask as EO data.",
schema={
"type": "object",
"subtype": "raster-cube"
})
# Example
arguments = {"data": {"from_node": "get_strds_data"}}
node = ProcessGraphNode(process_id=PROCESS_NAME, arguments=arguments)
graph = ProcessGraph(title="title",
description="description",
process_graph={"multilayer_mask_1": node})
examples = [
ProcessExample(title="Simple example",
description="Simple example",
process_graph=graph)
]
pd = ProcessDescription(
id=PROCESS_NAME,
description="Creates a mask using several bands of an EO dataset. "
"Each pixel that has nodata or invalid value in any of "
"the layers/bands gets value 1, pixels that have valid "
"values in all layers/bands get value 0.",
summary="Create a multilayer mask from several raster datasets.",
parameters={"data": p_data},
returns=rv,
examples=examples)
return json.loads(pd.to_json())
