├── .github ├── ISSUE_TEMPLATE │ ├── config.yml │ ├── other.md │ ├── issue-or-clarification-for-existing-process.md │ ├── new-process-parameter.md │ └── new-process-proposal.md └── workflows │ ├── tests.yml │ └── docs.yml ├── tests ├── .gitignore ├── testConfig.json ├── .words ├── package.json └── README.md ├── .editorconfig ├── constant.json ├── create_data_cube.json ├── pi.json ├── e.json ├── array_labels.json ├── trim_cube.json ├── proposals ├── nan.json ├── is_infinite.json ├── array_find_label.json ├── array_create_labeled.json ├── load_url.json ├── vector_buffer.json ├── inspect.json ├── load_uploaded_files.json ├── load_geojson.json ├── run_udf_externally.json ├── filter_vector.json ├── cumsum.json ├── cummax.json ├── cummin.json ├── unflatten_dimension.json ├── vector_to_regular_points.json ├── flatten_dimensions.json ├── cumproduct.json └── vector_reproject.json ├── sin.json ├── cos.json ├── sinh.json ├── cosh.json ├── tan.json ├── arcsin.json ├── not.json ├── arccos.json ├── arctan.json ├── arsinh.json ├── tanh.json ├── arcosh.json ├── artanh.json ├── dimension_labels.json ├── is_nodata.json ├── ceil.json ├── is_nan.json ├── drop_dimension.json ├── int.json ├── rename_dimension.json ├── floor.json ├── exp.json ├── arctan2.json ├── is_valid.json ├── sqrt.json ├── array_append.json ├── add_dimension.json ├── subtract.json ├── last.json ├── first.json ├── ln.json ├── divide.json ├── log.json ├── power.json ├── array_concat.json ├── absolute.json ├── or.json ├── and.json ├── add.json ├── min.json ├── array_interpolate_linear.json ├── max.json ├── if.json ├── normalized_difference.json ├── multiply.json ├── text_contains.json ├── text_ends.json ├── array_create.json ├── text_begins.json ├── apply.json ├── lt.json ├── mod.json ├── gt.json ├── sgn.json ├── save_result.json ├── rearrange.json ├── clip.json ├── text_concat.json ├── mask.json ├── round.json ├── sum.json ├── product.json ├── sd.json ├── extrema.json └── xor.json /.github/ISSUE_TEMPLATE/config.yml: -------------------------------------------------------------------------------- 1 | blank_issues_enabled: false -------------------------------------------------------------------------------- /tests/.gitignore: -------------------------------------------------------------------------------- 1 | /node_modules/ 2 | /package-lock.json 3 | /processes.json 4 | -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE/other.md: -------------------------------------------------------------------------------- 1 | --- 2 | name: Other issues or proposals 3 | about: Use this if no other option suits your needs and you want to fill a "normal" issue. 4 | title: '' 5 | labels: '' 6 | assignees: '' 7 | 8 | --- 9 | -------------------------------------------------------------------------------- /.editorconfig: -------------------------------------------------------------------------------- 1 | # EditorConfig is awesome: https://EditorConfig.org 2 | 3 | [*.json] 4 | charset = utf-8 5 | end_of_line = crlf 6 | indent_style = spaces 7 | indent_size = 4 8 | insert_final_newline = true 9 | trim_trailing_whitespace = true 10 | -------------------------------------------------------------------------------- /tests/testConfig.json: -------------------------------------------------------------------------------- 1 | { 2 | "folder": "../", 3 | "proposalsFolder": "../proposals/", 4 | "ignoredWords": ".words", 5 | "anyOfRequired": [ 6 | "array_element", 7 | "quantiles" 8 | ], 9 | "subtypeSchemas": "../meta/subtype-schemas.json", 10 | "checkSubtypeSchemas": true, 11 | "forbidDeprecatedTypes": false, 12 | "checkProcessLinks": true, 13 | "verbose": false 14 | } 15 | -------------------------------------------------------------------------------- /.github/workflows/tests.yml: -------------------------------------------------------------------------------- 1 | name: Test Processes 2 | on: [push, pull_request] 3 | jobs: 4 | deploy: 5 | runs-on: ubuntu-latest 6 | steps: 7 | - uses: actions/setup-node@v3 8 | with: 9 | node-version: 'lts/*' 10 | - uses: actions/checkout@v3 11 | - name: Run tests 12 | run: | 13 | npm install 14 | npm run test 15 | working-directory: tests -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE/issue-or-clarification-for-existing-process.md: -------------------------------------------------------------------------------- 1 | --- 2 | name: Issue or clarification for existing process 3 | about: Report an issue or clarification for an existing process. 4 | title: "[process id]: [issue summary]" 5 | labels: bug, patch 6 | assignees: '' 7 | 8 | --- 9 | 10 | **Process ID:** ... 11 | 12 | **Describe the issue:** 13 | A clear and concise description of what needs to be fixed or clarified. 14 | 15 | **Proposed solution:** 16 | A potential solution you'd propose. 17 | 18 | **Additional context:** 19 | Add any other context about the problem here. 20 | -------------------------------------------------------------------------------- /constant.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "constant", 3 | "summary": "Define a constant value", 4 | "description": "Defines a constant value that can be reused in multiple places of a process.", 5 | "categories": [ 6 | "math > constants" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "x", 11 | "description": "The value of the constant.", 12 | "schema": { 13 | "description": "Any data type." 14 | } 15 | } 16 | ], 17 | "returns": { 18 | "description": "The value of the constant.", 19 | "schema": { 20 | "description": "Any data type." 21 | } 22 | } 23 | } -------------------------------------------------------------------------------- /tests/.words: -------------------------------------------------------------------------------- 1 | 0-to-9 2 | 1-to-0 3 | anno 4 | behavior 5 | boolean 6 | center 7 | centers 8 | dekad 9 | DEM-based 10 | Domini 11 | gamma0 12 | GeoJSON 13 | FeatureCollections 14 | labeled 15 | MathWorld 16 | n-ary 17 | neighbor 18 | neighborhood 19 | neighborhoods 20 | openEO 21 | orthorectification 22 | orthorectified 23 | radiometrically 24 | reflectances 25 | reproject 26 | Reprojects 27 | resample 28 | resampled 29 | resamples 30 | Resamples 31 | resampling 32 | Sentinel-2 33 | Sentinel-2A 34 | Sentinel-2B 35 | signum 36 | STAC 37 | catalog 38 | Catalog 39 | summand 40 | UDFs 41 | gdalwarp 42 | Lanczos 43 | sinc 44 | interpolants 45 | Breiman 46 | Hyndman 47 | date1 48 | date2 49 | favor 50 | -------------------------------------------------------------------------------- /create_data_cube.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "create_data_cube", 3 | "summary": "Create an empty data cube", 4 | "description": "Creates a new data cube without dimensions. Dimensions can be added with ``add_dimension()``.", 5 | "categories": [ 6 | "cubes" 7 | ], 8 | "parameters": [], 9 | "returns": { 10 | "description": "An empty data cube with no dimensions.", 11 | "schema": { 12 | "type": "object", 13 | "subtype": "datacube" 14 | } 15 | }, 16 | "links": [ 17 | { 18 | "href": "https://openeo.org/documentation/1.0/datacubes.html", 19 | "rel": "about", 20 | "title": "Data Cubes explained in the openEO documentation" 21 | } 22 | ] 23 | } 24 | -------------------------------------------------------------------------------- /pi.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "pi", 3 | "summary": "Pi (π)", 4 | "description": "The real number Pi (π) is a mathematical constant that is the ratio of the circumference of a circle to its diameter. The numerical value is approximately *3.14159*.", 5 | "categories": [ 6 | "math > constants", 7 | "math > trigonometric" 8 | ], 9 | "parameters": [], 10 | "returns": { 11 | "description": "The numerical value of Pi.", 12 | "schema": { 13 | "type": "number" 14 | } 15 | }, 16 | "links": [ 17 | { 18 | "rel": "about", 19 | "href": "http://mathworld.wolfram.com/Pi.html", 20 | "title": "Mathematical constant Pi explained by Wolfram MathWorld" 21 | } 22 | ] 23 | } -------------------------------------------------------------------------------- /e.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "e", 3 | "summary": "Euler's number (e)", 4 | "description": "The real number *e* is a mathematical constant that is the base of the natural logarithm such that *`ln(e) = 1`*. The numerical value is approximately *2.71828*.", 5 | "categories": [ 6 | "math > constants", 7 | "math > exponential & logarithmic" 8 | ], 9 | "parameters": [], 10 | "returns": { 11 | "description": "The numerical value of Euler's number.", 12 | "schema": { 13 | "type": "number" 14 | } 15 | }, 16 | "links": [ 17 | { 18 | "rel": "about", 19 | "href": "http://mathworld.wolfram.com/e.html", 20 | "title": "Mathematical constant e explained by Wolfram MathWorld" 21 | } 22 | ] 23 | } -------------------------------------------------------------------------------- /array_labels.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "array_labels", 3 | "summary": "Get the labels for an array", 4 | "description": "Gives all labels for a labeled array or gives all indices for an array without labels. If the array is not labeled, an array with the zero-based indices is returned. The labels or indices have the same order as in the array.", 5 | "categories": [ 6 | "arrays" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "data", 11 | "description": "An array.", 12 | "schema": { 13 | "type": "array" 14 | } 15 | } 16 | ], 17 | "returns": { 18 | "description": "The labels or indices as array.", 19 | "schema": { 20 | "type": "array", 21 | "items": { 22 | "type": [ 23 | "number", 24 | "string" 25 | ] 26 | } 27 | } 28 | } 29 | } -------------------------------------------------------------------------------- /trim_cube.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "trim_cube", 3 | "summary": "Remove dimension labels with no-data values", 4 | "description": "Removes dimension labels solely containing no-data values. If the dimension is irregular categorical then dimension labels in the middle can be removed.", 5 | "categories": [ 6 | "cubes" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "data", 11 | "description": "A data cube to trim.", 12 | "schema": { 13 | "type": "object", 14 | "subtype": "datacube" 15 | } 16 | } 17 | ], 18 | "returns": { 19 | "description": "A trimmed data cube with the same dimensions. The dimension properties name, type, reference system and resolution remain unchanged. The number of dimension labels may decrease.", 20 | "schema": { 21 | "type": "object", 22 | "subtype": "datacube" 23 | } 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /tests/package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "@openeo/processes", 3 | "version": "2.0.0", 4 | "author": "openEO Consortium", 5 | "contributors": [ 6 | { 7 | "name": "Matthias Mohr" 8 | } 9 | ], 10 | "license": "Apache-2.0", 11 | "description": "Validates the processes specified in this repository.", 12 | "homepage": "http://openeo.org", 13 | "bugs": { 14 | "url": "https://github.com/Open-EO/openeo-processes/issues" 15 | }, 16 | "repository": { 17 | "type": "git", 18 | "url": "git+https://github.com/Open-EO/openeo-processes.git" 19 | }, 20 | "devDependencies": { 21 | "@openeo/processes-lint": "^0.1.5", 22 | "concat-json-files": "^1.1.0", 23 | "http-server": "^14.1.1" 24 | }, 25 | "scripts": { 26 | "test": "openeo-processes-lint testConfig.json", 27 | "generate": "concat-json-files \"../{*,proposals/*}.json\" -t \"processes.json\"", 28 | "start": "npm run generate && http-server -p 9876 -o docs.html -c-1" 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE/new-process-parameter.md: -------------------------------------------------------------------------------- 1 | --- 2 | name: New process parameter 3 | about: Propose a new process parameter 4 | title: "[process id]: [parameter summary]" 5 | labels: enhancement, minor 6 | assignees: '' 7 | 8 | --- 9 | 10 | **Proposed Process ID:** ... (alphanumeric + underscore only) 11 | **Proposed Parameter Name:** ... (alphanumeric + underscore only) 12 | **Optional:** yes, default: ... 13 | 14 | ## Context 15 | Give some context and an introduction of what this parameter is needed for, e.g. use cases. 16 | 17 | ## Description 18 | ... (Markdown allowed) 19 | 20 | ## Data Type 21 | boolean/number/string/array/object/null 22 | ... (include additional constraints, e.g. min/max values for numbers or a list of allowed values for strings) 23 | 24 | ## Additional changes 25 | If required describe any additional changes that are required for the parameter, e.g. an additional data type for the return value, an additional example, an additional link to explain the parameter, etc. 26 | -------------------------------------------------------------------------------- /proposals/nan.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "nan", 3 | "summary": "Not a Number (NaN)", 4 | "description": "`NaN` (not a number) is a symbolic floating-point representation which is neither a signed infinity nor a finite number.", 5 | "categories": [ 6 | "math > constants" 7 | ], 8 | "experimental": true, 9 | "parameters": [], 10 | "returns": { 11 | "description": "Returns `NaN`.", 12 | "schema": { 13 | "description": "JSON Schema can't represent `NaN` and thus a schema can't be specified." 14 | } 15 | }, 16 | "links": [ 17 | { 18 | "rel": "about", 19 | "href": "https://ieeexplore.ieee.org/document/4610935", 20 | "title": "IEEE Standard 754-2008 for Floating-Point Arithmetic" 21 | }, 22 | { 23 | "rel": "about", 24 | "href": "http://mathworld.wolfram.com/NaN.html", 25 | "title": "NaN explained by Wolfram MathWorld" 26 | } 27 | ] 28 | } -------------------------------------------------------------------------------- /sin.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "sin", 3 | "summary": "Sine", 4 | "description": "Computes the sine of `x`.\n\nWorks on radians only.\nThe no-data value `null` is passed through and therefore gets propagated.", 5 | "categories": [ 6 | "math > trigonometric" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "x", 11 | "description": "An angle in radians.", 12 | "schema": { 13 | "type": [ 14 | "number", 15 | "null" 16 | ] 17 | } 18 | } 19 | ], 20 | "returns": { 21 | "description": "The computed sine of `x`.", 22 | "schema": { 23 | "type": [ 24 | "number", 25 | "null" 26 | ] 27 | } 28 | }, 29 | "examples": [ 30 | { 31 | "arguments": { 32 | "x": 0 33 | }, 34 | "returns": 0 35 | } 36 | ], 37 | "links": [ 38 | { 39 | "rel": "about", 40 | "href": "http://mathworld.wolfram.com/Sine.html", 41 | "title": "Sine explained by Wolfram MathWorld" 42 | } 43 | ] 44 | } -------------------------------------------------------------------------------- /cos.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "cos", 3 | "summary": "Cosine", 4 | "description": "Computes the cosine of `x`.\n\nWorks on radians only.\nThe no-data value `null` is passed through and therefore gets propagated.", 5 | "categories": [ 6 | "math > trigonometric" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "x", 11 | "description": "An angle in radians.", 12 | "schema": { 13 | "type": [ 14 | "number", 15 | "null" 16 | ] 17 | } 18 | } 19 | ], 20 | "returns": { 21 | "description": "The computed cosine of `x`.", 22 | "schema": { 23 | "type": [ 24 | "number", 25 | "null" 26 | ] 27 | } 28 | }, 29 | "examples": [ 30 | { 31 | "arguments": { 32 | "x": 0 33 | }, 34 | "returns": 1 35 | } 36 | ], 37 | "links": [ 38 | { 39 | "rel": "about", 40 | "href": "http://mathworld.wolfram.com/Cosine.html", 41 | "title": "Cosine explained by Wolfram MathWorld" 42 | } 43 | ] 44 | } -------------------------------------------------------------------------------- /sinh.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "sinh", 3 | "summary": "Hyperbolic sine", 4 | "description": "Computes the hyperbolic sine of `x`.\n\nWorks on radians only.\nThe no-data value `null` is passed through and therefore gets propagated.", 5 | "categories": [ 6 | "math > trigonometric" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "x", 11 | "description": "An angle in radians.", 12 | "schema": { 13 | "type": [ 14 | "number", 15 | "null" 16 | ] 17 | } 18 | } 19 | ], 20 | "returns": { 21 | "description": "The computed hyperbolic sine of `x`.", 22 | "schema": { 23 | "type": [ 24 | "number", 25 | "null" 26 | ] 27 | } 28 | }, 29 | "examples": [ 30 | { 31 | "arguments": { 32 | "x": 0 33 | }, 34 | "returns": 0 35 | } 36 | ], 37 | "links": [ 38 | { 39 | "rel": "about", 40 | "href": "http://mathworld.wolfram.com/HyperbolicSine.html", 41 | "title": "Hyperbolic sine explained by Wolfram MathWorld" 42 | } 43 | ] 44 | } -------------------------------------------------------------------------------- /proposals/is_infinite.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "is_infinite", 3 | "summary": "Value is an infinite number", 4 | "description": "Checks whether the specified value `x` is an infinite number. The definition of infinite numbers follows the [IEEE Standard 754](https://ieeexplore.ieee.org/document/4610935). The special numerical value `NaN` (not a number) as defined by the [IEEE Standard 754](https://ieeexplore.ieee.org/document/4610935) is not an infinite number and must return `false`.", 5 | "categories": [ 6 | "comparison" 7 | ], 8 | "experimental": true, 9 | "parameters": [ 10 | { 11 | "name": "x", 12 | "description": "The data to check.", 13 | "schema": { 14 | "description": "Any data type is allowed." 15 | } 16 | } 17 | ], 18 | "returns": { 19 | "description": "`true` if the data is an infinite number, otherwise `false`.", 20 | "schema": { 21 | "type": "boolean" 22 | } 23 | }, 24 | "links": [ 25 | { 26 | "rel": "about", 27 | "href": "https://ieeexplore.ieee.org/document/4610935", 28 | "title": "IEEE Standard 754-2008 for Floating-Point Arithmetic" 29 | } 30 | ] 31 | } -------------------------------------------------------------------------------- /cosh.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "cosh", 3 | "summary": "Hyperbolic cosine", 4 | "description": "Computes the hyperbolic cosine of `x`.\n\nWorks on radians only.\nThe no-data value `null` is passed through and therefore gets propagated.", 5 | "categories": [ 6 | "math > trigonometric" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "x", 11 | "description": "An angle in radians.", 12 | "schema": { 13 | "type": [ 14 | "number", 15 | "null" 16 | ] 17 | } 18 | } 19 | ], 20 | "returns": { 21 | "description": "The computed hyperbolic cosine of `x`.", 22 | "schema": { 23 | "type": [ 24 | "number", 25 | "null" 26 | ] 27 | } 28 | }, 29 | "examples": [ 30 | { 31 | "arguments": { 32 | "x": 0 33 | }, 34 | "returns": 1 35 | } 36 | ], 37 | "links": [ 38 | { 39 | "rel": "about", 40 | "href": "http://mathworld.wolfram.com/HyperbolicCosine.html", 41 | "title": "Hyperbolic cosine explained by Wolfram MathWorld" 42 | } 43 | ] 44 | } -------------------------------------------------------------------------------- /tan.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "tan", 3 | "summary": "Tangent", 4 | "description": "Computes the tangent of `x`. The tangent is defined to be the sine of x divided by the cosine of x.\n\nWorks on radians only.\nThe no-data value `null` is passed through and therefore gets propagated.", 5 | "categories": [ 6 | "math > trigonometric" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "x", 11 | "description": "An angle in radians.", 12 | "schema": { 13 | "type": [ 14 | "number", 15 | "null" 16 | ] 17 | } 18 | } 19 | ], 20 | "returns": { 21 | "description": "The computed tangent of `x`.", 22 | "schema": { 23 | "type": [ 24 | "number", 25 | "null" 26 | ] 27 | } 28 | }, 29 | "examples": [ 30 | { 31 | "arguments": { 32 | "x": 0 33 | }, 34 | "returns": 0 35 | } 36 | ], 37 | "links": [ 38 | { 39 | "rel": "about", 40 | "href": "http://mathworld.wolfram.com/Tangent.html", 41 | "title": "Tangent explained by Wolfram MathWorld" 42 | } 43 | ] 44 | } -------------------------------------------------------------------------------- /arcsin.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "arcsin", 3 | "summary": "Inverse sine", 4 | "description": "Computes the arc sine of `x`. The arc sine is the inverse function of the sine so that *`arcsin(sin(x)) = x`*.\n\nWorks on radians only.\nThe no-data value `null` is passed through and therefore gets propagated.", 5 | "categories": [ 6 | "math > trigonometric" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "x", 11 | "description": "A number.", 12 | "schema": { 13 | "type": [ 14 | "number", 15 | "null" 16 | ] 17 | } 18 | } 19 | ], 20 | "returns": { 21 | "description": "The computed angle in radians.", 22 | "schema": { 23 | "type": [ 24 | "number", 25 | "null" 26 | ] 27 | } 28 | }, 29 | "examples": [ 30 | { 31 | "arguments": { 32 | "x": 0 33 | }, 34 | "returns": 0 35 | } 36 | ], 37 | "links": [ 38 | { 39 | "rel": "about", 40 | "href": "http://mathworld.wolfram.com/InverseSine.html", 41 | "title": "Inverse sine explained by Wolfram MathWorld" 42 | } 43 | ] 44 | } -------------------------------------------------------------------------------- /not.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "not", 3 | "summary": "Inverting a boolean", 4 | "description": "Inverts a single boolean so that `true` gets `false` and `false` gets `true`.\n\nThe no-data value `null` is passed through and therefore gets propagated.", 5 | "categories": [ 6 | "logic" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "x", 11 | "description": "Boolean value to invert.", 12 | "schema": { 13 | "type": [ 14 | "boolean", 15 | "null" 16 | ] 17 | } 18 | } 19 | ], 20 | "returns": { 21 | "description": "Inverted boolean value.", 22 | "schema": { 23 | "type": [ 24 | "boolean", 25 | "null" 26 | ] 27 | } 28 | }, 29 | "examples": [ 30 | { 31 | "arguments": { 32 | "x": null 33 | }, 34 | "returns": null 35 | }, 36 | { 37 | "arguments": { 38 | "x": false 39 | }, 40 | "returns": true 41 | }, 42 | { 43 | "arguments": { 44 | "x": true 45 | }, 46 | "returns": false 47 | } 48 | ] 49 | } -------------------------------------------------------------------------------- /arccos.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "arccos", 3 | "summary": "Inverse cosine", 4 | "description": "Computes the arc cosine of `x`. The arc cosine is the inverse function of the cosine so that *`arccos(cos(x)) = x`*.\n\nWorks on radians only.\nThe no-data value `null` is passed through and therefore gets propagated.", 5 | "categories": [ 6 | "math > trigonometric" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "x", 11 | "description": "A number.", 12 | "schema": { 13 | "type": [ 14 | "number", 15 | "null" 16 | ] 17 | } 18 | } 19 | ], 20 | "returns": { 21 | "description": "The computed angle in radians.", 22 | "schema": { 23 | "type": [ 24 | "number", 25 | "null" 26 | ] 27 | } 28 | }, 29 | "examples": [ 30 | { 31 | "arguments": { 32 | "x": 1 33 | }, 34 | "returns": 0 35 | } 36 | ], 37 | "links": [ 38 | { 39 | "rel": "about", 40 | "href": "http://mathworld.wolfram.com/InverseCosine.html", 41 | "title": "Inverse cosine explained by Wolfram MathWorld" 42 | } 43 | ] 44 | } -------------------------------------------------------------------------------- /arctan.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "arctan", 3 | "summary": "Inverse tangent", 4 | "description": "Computes the arc tangent of `x`. The arc tangent is the inverse function of the tangent so that *`arctan(tan(x)) = x`*.\n\nWorks on radians only.\nThe no-data value `null` is passed through and therefore gets propagated.", 5 | "categories": [ 6 | "math > trigonometric" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "x", 11 | "description": "A number.", 12 | "schema": { 13 | "type": [ 14 | "number", 15 | "null" 16 | ] 17 | } 18 | } 19 | ], 20 | "returns": { 21 | "description": "The computed angle in radians.", 22 | "schema": { 23 | "type": [ 24 | "number", 25 | "null" 26 | ] 27 | } 28 | }, 29 | "examples": [ 30 | { 31 | "arguments": { 32 | "x": 0 33 | }, 34 | "returns": 0 35 | } 36 | ], 37 | "links": [ 38 | { 39 | "rel": "about", 40 | "href": "http://mathworld.wolfram.com/InverseTangent.html", 41 | "title": "Inverse tangent explained by Wolfram MathWorld" 42 | } 43 | ] 44 | } -------------------------------------------------------------------------------- /arsinh.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "arsinh", 3 | "summary": "Inverse hyperbolic sine", 4 | "description": "Computes the inverse hyperbolic sine of `x`. It is the inverse function of the hyperbolic sine so that *`arsinh(sinh(x)) = x`*.\n\nWorks on radians only.\nThe no-data value `null` is passed through and therefore gets propagated.", 5 | "categories": [ 6 | "math > trigonometric" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "x", 11 | "description": "A number.", 12 | "schema": { 13 | "type": [ 14 | "number", 15 | "null" 16 | ] 17 | } 18 | } 19 | ], 20 | "returns": { 21 | "description": "The computed angle in radians.", 22 | "schema": { 23 | "type": [ 24 | "number", 25 | "null" 26 | ] 27 | } 28 | }, 29 | "examples": [ 30 | { 31 | "arguments": { 32 | "x": 0 33 | }, 34 | "returns": 0 35 | } 36 | ], 37 | "links": [ 38 | { 39 | "rel": "about", 40 | "href": "http://mathworld.wolfram.com/InverseHyperbolicSine.html", 41 | "title": "Inverse hyperbolic sine explained by Wolfram MathWorld" 42 | } 43 | ] 44 | } -------------------------------------------------------------------------------- /tanh.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "tanh", 3 | "summary": "Hyperbolic tangent", 4 | "description": "Computes the hyperbolic tangent of `x`. The tangent is defined to be the hyperbolic sine of x divided by the hyperbolic cosine of x.\n\nWorks on radians only.\nThe no-data value `null` is passed through and therefore gets propagated.", 5 | "categories": [ 6 | "math > trigonometric" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "x", 11 | "description": "An angle in radians.", 12 | "schema": { 13 | "type": [ 14 | "number", 15 | "null" 16 | ] 17 | } 18 | } 19 | ], 20 | "returns": { 21 | "description": "The computed hyperbolic tangent of `x`.", 22 | "schema": { 23 | "type": [ 24 | "number", 25 | "null" 26 | ] 27 | } 28 | }, 29 | "examples": [ 30 | { 31 | "arguments": { 32 | "x": 0 33 | }, 34 | "returns": 0 35 | } 36 | ], 37 | "links": [ 38 | { 39 | "rel": "about", 40 | "href": "http://mathworld.wolfram.com/HyperbolicTangent.html", 41 | "title": "Hyperbolic tangent explained by Wolfram MathWorld" 42 | } 43 | ] 44 | } -------------------------------------------------------------------------------- /arcosh.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "arcosh", 3 | "summary": "Inverse hyperbolic cosine", 4 | "description": "Computes the inverse hyperbolic cosine of `x`. It is the inverse function of the hyperbolic cosine so that *`arcosh(cosh(x)) = x`*.\n\nWorks on radians only.\nThe no-data value `null` is passed through and therefore gets propagated.", 5 | "categories": [ 6 | "math > trigonometric" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "x", 11 | "description": "A number.", 12 | "schema": { 13 | "type": [ 14 | "number", 15 | "null" 16 | ] 17 | } 18 | } 19 | ], 20 | "returns": { 21 | "description": "The computed angle in radians.", 22 | "schema": { 23 | "type": [ 24 | "number", 25 | "null" 26 | ] 27 | } 28 | }, 29 | "examples": [ 30 | { 31 | "arguments": { 32 | "x": 1 33 | }, 34 | "returns": 0 35 | } 36 | ], 37 | "links": [ 38 | { 39 | "rel": "about", 40 | "href": "http://mathworld.wolfram.com/InverseHyperbolicCosine.html", 41 | "title": "Inverse hyperbolic cosine explained by Wolfram MathWorld" 42 | } 43 | ] 44 | } -------------------------------------------------------------------------------- /artanh.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "artanh", 3 | "summary": "Inverse hyperbolic tangent", 4 | "description": "Computes the inverse hyperbolic tangent of `x`. It is the inverse function of the hyperbolic tangent so that *`artanh(tanh(x)) = x`*.\n\nWorks on radians only.\nThe no-data value `null` is passed through and therefore gets propagated.", 5 | "categories": [ 6 | "math > trigonometric" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "x", 11 | "description": "A number.", 12 | "schema": { 13 | "type": [ 14 | "number", 15 | "null" 16 | ] 17 | } 18 | } 19 | ], 20 | "returns": { 21 | "description": "The computed angle in radians.", 22 | "schema": { 23 | "type": [ 24 | "number", 25 | "null" 26 | ] 27 | } 28 | }, 29 | "examples": [ 30 | { 31 | "arguments": { 32 | "x": 0 33 | }, 34 | "returns": 0 35 | } 36 | ], 37 | "links": [ 38 | { 39 | "rel": "about", 40 | "href": "http://mathworld.wolfram.com/InverseHyperbolicTangent.html", 41 | "title": "Inverse hyperbolic tangent explained by Wolfram MathWorld" 42 | } 43 | ] 44 | } -------------------------------------------------------------------------------- /dimension_labels.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "dimension_labels", 3 | "summary": "Get the dimension labels", 4 | "description": "Gives all labels for a dimension in the data cube. The labels have the same order as in the data cube.\n\nIf a dimension with the specified name does not exist, the process fails with a `DimensionNotAvailable` exception.", 5 | "categories": [ 6 | "cubes" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "data", 11 | "description": "The data cube.", 12 | "schema": { 13 | "type": "object", 14 | "subtype": "datacube" 15 | } 16 | }, 17 | { 18 | "name": "dimension", 19 | "description": "The name of the dimension to get the labels for.", 20 | "schema": { 21 | "type": "string" 22 | } 23 | } 24 | ], 25 | "returns": { 26 | "description": "The labels as an array.", 27 | "schema": { 28 | "type": "array", 29 | "items": { 30 | "type": [ 31 | "number", 32 | "string" 33 | ] 34 | } 35 | } 36 | }, 37 | "exceptions": { 38 | "DimensionNotAvailable": { 39 | "message": "A dimension with the specified name does not exist." 40 | } 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /is_nodata.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "is_nodata", 3 | "summary": "Value is a no-data value", 4 | "description": "Checks whether the specified data is missing data, i.e. equals to `null` or any of the no-data values specified in the metadata.\n\nThe special numerical value `NaN` (not a number) as defined by the [IEEE Standard 754](https://ieeexplore.ieee.org/document/4610935) is only considered as no-data value if specified as no-data value in the metadata.", 5 | "categories": [ 6 | "comparison" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "x", 11 | "description": "The data to check.", 12 | "schema": { 13 | "description": "Any data type is allowed." 14 | } 15 | } 16 | ], 17 | "returns": { 18 | "description": "`true` if the data is a no-data value, otherwise `false`.", 19 | "schema": { 20 | "type": "boolean" 21 | } 22 | }, 23 | "examples": [ 24 | { 25 | "arguments": { 26 | "x": 1 27 | }, 28 | "returns": false 29 | }, 30 | { 31 | "arguments": { 32 | "x": "Test" 33 | }, 34 | "returns": false 35 | }, 36 | { 37 | "arguments": { 38 | "x": null 39 | }, 40 | "returns": true 41 | }, 42 | { 43 | "arguments": { 44 | "x": [ 45 | null, 46 | null 47 | ] 48 | }, 49 | "returns": false 50 | } 51 | ] 52 | } 53 | -------------------------------------------------------------------------------- /proposals/array_find_label.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "array_find_label", 3 | "summary": "Get the index for a label in a labeled array", 4 | "description": "Checks whether the labeled array specified for `data` has the label specified in `label` and returns the zero-based index for it. If there's no match as either the label doesn't exist or the array is not labeled, `null` is returned.\n\nUse ``array_find()`` to find the index for a given value in the array.", 5 | "categories": [ 6 | "arrays", 7 | "reducer" 8 | ], 9 | "experimental": true, 10 | "parameters": [ 11 | { 12 | "name": "data", 13 | "description": "List to find the label in.", 14 | "schema": { 15 | "type": "array", 16 | "items": { 17 | "description": "Any data type is allowed." 18 | } 19 | } 20 | }, 21 | { 22 | "name": "label", 23 | "description": "Label to find in `data`.", 24 | "schema": [ 25 | { 26 | "type": "number" 27 | }, 28 | { 29 | "type": "string" 30 | } 31 | ] 32 | } 33 | ], 34 | "returns": { 35 | "description": "The index of the element with the specified label assigned. If no such label was found, `null` is returned.", 36 | "schema": [ 37 | { 38 | "type": "null" 39 | }, 40 | { 41 | "type": "integer", 42 | "minimum": 0 43 | } 44 | ] 45 | } 46 | } -------------------------------------------------------------------------------- /ceil.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "ceil", 3 | "summary": "Round fractions up", 4 | "description": "The least integer greater than or equal to the number `x`.\n\nThe no-data value `null` is passed through and therefore gets propagated.", 5 | "categories": [ 6 | "math > rounding" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "x", 11 | "description": "A number to round up.", 12 | "schema": { 13 | "type": [ 14 | "number", 15 | "null" 16 | ] 17 | } 18 | } 19 | ], 20 | "returns": { 21 | "description": "The number rounded up.", 22 | "schema": { 23 | "type": [ 24 | "integer", 25 | "null" 26 | ] 27 | } 28 | }, 29 | "examples": [ 30 | { 31 | "arguments": { 32 | "x": 0 33 | }, 34 | "returns": 0 35 | }, 36 | { 37 | "arguments": { 38 | "x": 3.5 39 | }, 40 | "returns": 4 41 | }, 42 | { 43 | "arguments": { 44 | "x": -0.4 45 | }, 46 | "returns": 0 47 | }, 48 | { 49 | "arguments": { 50 | "x": -3.5 51 | }, 52 | "returns": -3 53 | } 54 | ], 55 | "links": [ 56 | { 57 | "rel": "about", 58 | "href": "http://mathworld.wolfram.com/CeilingFunction.html", 59 | "title": "Ceiling explained by Wolfram MathWorld" 60 | } 61 | ] 62 | } -------------------------------------------------------------------------------- /is_nan.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "is_nan", 3 | "summary": "Value is not a number", 4 | "description": "Checks whether the specified value `x` is *not* a number. Numbers are all integers and floating-point numbers, except for the special value `NaN` as defined by the [IEEE Standard 754](https://ieeexplore.ieee.org/document/4610935).", 5 | "categories": [ 6 | "comparison", 7 | "math > constants" 8 | ], 9 | "parameters": [ 10 | { 11 | "name": "x", 12 | "description": "The data to check.", 13 | "schema": { 14 | "description": "Any data type is allowed." 15 | } 16 | } 17 | ], 18 | "returns": { 19 | "description": "Returns `true` for `NaN` and all non-numeric data types, otherwise returns `false`.", 20 | "schema": { 21 | "type": "boolean" 22 | } 23 | }, 24 | "examples": [ 25 | { 26 | "arguments": { 27 | "x": 1 28 | }, 29 | "returns": false 30 | }, 31 | { 32 | "arguments": { 33 | "x": "Test" 34 | }, 35 | "returns": true 36 | }, 37 | { 38 | "arguments": { 39 | "x": null 40 | }, 41 | "returns": true 42 | } 43 | ], 44 | "links": [ 45 | { 46 | "rel": "about", 47 | "href": "https://ieeexplore.ieee.org/document/4610935", 48 | "title": "IEEE Standard 754-2008 for Floating-Point Arithmetic" 49 | }, 50 | { 51 | "rel": "about", 52 | "href": "http://mathworld.wolfram.com/NaN.html", 53 | "title": "NaN explained by Wolfram MathWorld" 54 | } 55 | ] 56 | } 57 | -------------------------------------------------------------------------------- /proposals/array_create_labeled.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "array_create_labeled", 3 | "summary": "Create a labeled array", 4 | "description": "Creates a new labeled array by using the values from the `labels` array as labels and the values from the `data` array as the corresponding values.\n\nThe exception `ArrayLengthMismatch` is thrown, if the number of the values in the given arrays don't match exactly.\n\nThe primary use case here is to be able to transmit labeled arrays from the client to the server as JSON doesn't support this data type.", 5 | "categories": [ 6 | "arrays" 7 | ], 8 | "experimental": true, 9 | "parameters": [ 10 | { 11 | "name": "data", 12 | "description": "An array of values to be used.", 13 | "schema": { 14 | "description": "Any data type is allowed." 15 | } 16 | }, 17 | { 18 | "name": "labels", 19 | "description": "An array of labels to be used.", 20 | "schema": { 21 | "type": "array", 22 | "items": { 23 | "type": [ 24 | "number", 25 | "string" 26 | ] 27 | } 28 | } 29 | } 30 | ], 31 | "returns": { 32 | "description": "The newly created labeled array.", 33 | "schema": { 34 | "type": "array", 35 | "subtype": "labeled-array", 36 | "items": { 37 | "description": "Any data type is allowed." 38 | } 39 | } 40 | }, 41 | "exceptions": { 42 | "ArrayLengthMismatch": { 43 | "message": "The number of values in the parameters `data` and `labels` don't match." 44 | } 45 | } 46 | } -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE/new-process-proposal.md: -------------------------------------------------------------------------------- 1 | --- 2 | name: New process proposal 3 | about: Propose a new process with detailed specifics (name, description, parameters, 4 | return value etc.). To just pitch an idea without a lot of details, please fill 5 | a "normal" issue. 6 | title: '' 7 | labels: new process 8 | assignees: '' 9 | 10 | --- 11 | 12 | **Proposed Process ID:** ... (alphanumeric + underscore only) 13 | 14 | ## Context 15 | Give some context and an introduction of what this process is needed for, e.g. use cases. 16 | 17 | ## Summary 18 | ... (max. 60 chars) 19 | 20 | ## Description 21 | ... (min. 55 chars, Markdown allowed) 22 | 23 | ## Parameters 24 | 25 | ### `param1` (name of first parameter, alphanumeric + underscore only) 26 | 27 | **Optional:** no/yes, default: ... (default value only required for "yes") 28 | 29 | #### Description 30 | ... (Markdown allowed) 31 | 32 | #### Data Type 33 | boolean/number/string/array/object/null 34 | ... (include additional constraints, e.g. min/max values for numbers or a list of allowed values for strings) 35 | 36 | ### `param2` (name of second parameter, copy this template for additional parameters) 37 | 38 | **Optional:** no/yes, default: ... (default value only required for "yes") 39 | 40 | #### Description 41 | ... 42 | 43 | #### Data Type 44 | ... 45 | 46 | ## Return Value 47 | ### Description 48 | ... (Markdown allowed) 49 | 50 | ### Data Type 51 | boolean/number/string/array/object/null 52 | ... (include additional constraints, e.g. min/max values for numbers or a list of allowed values for strings) 53 | 54 | ## Categories (optional) 55 | * ... 56 | * ... 57 | 58 | ## Links to additional resources (optional) 59 | * https://... 60 | 61 | ## Examples (optional) 62 | * ... 63 | 64 | ## Details about exceptions mentioned in the description (optional) 65 | * ... 66 | -------------------------------------------------------------------------------- /drop_dimension.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "drop_dimension", 3 | "summary": "Remove a dimension", 4 | "description": "Drops a dimension from the data cube.\n\nDropping a dimension only works on dimensions with a single dimension label left, otherwise the process fails with a `DimensionLabelCountMismatch` exception. Dimension values can be reduced to a single value with a filter such as ``filter_bands()`` or the ``reduce_dimension()`` process. If a dimension with the specified name does not exist, the process fails with a `DimensionNotAvailable` exception.", 5 | "categories": [ 6 | "cubes" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "data", 11 | "description": "The data cube to drop a dimension from.", 12 | "schema": { 13 | "type": "object", 14 | "subtype": "datacube" 15 | } 16 | }, 17 | { 18 | "name": "name", 19 | "description": "Name of the dimension to drop.", 20 | "schema": { 21 | "type": "string" 22 | } 23 | } 24 | ], 25 | "returns": { 26 | "description": "A data cube without the specified dimension. The number of dimensions decreases by one, but the dimension properties (name, type, labels, reference system and resolution) for all other dimensions remain unchanged.", 27 | "schema": { 28 | "type": "object", 29 | "subtype": "datacube" 30 | } 31 | }, 32 | "exceptions": { 33 | "DimensionLabelCountMismatch": { 34 | "message": "The number of dimension labels exceeds one, which requires a reducer." 35 | }, 36 | "DimensionNotAvailable": { 37 | "message": "A dimension with the specified name does not exist." 38 | } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /int.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "int", 3 | "summary": "Integer part of a number", 4 | "description": "The integer part of the real number `x`.\n\nThis process is *not* an alias for the ``floor()`` process as defined by some mathematicians, see the examples for negative numbers in both processes for differences.\n\nThe no-data value `null` is passed through and therefore gets propagated.", 5 | "categories": [ 6 | "math", 7 | "math > rounding" 8 | ], 9 | "parameters": [ 10 | { 11 | "name": "x", 12 | "description": "A number.", 13 | "schema": { 14 | "type": [ 15 | "number", 16 | "null" 17 | ] 18 | } 19 | } 20 | ], 21 | "returns": { 22 | "description": "Integer part of the number.", 23 | "schema": { 24 | "type": [ 25 | "integer", 26 | "null" 27 | ] 28 | } 29 | }, 30 | "examples": [ 31 | { 32 | "arguments": { 33 | "x": 0 34 | }, 35 | "returns": 0 36 | }, 37 | { 38 | "arguments": { 39 | "x": 3.5 40 | }, 41 | "returns": 3 42 | }, 43 | { 44 | "arguments": { 45 | "x": -0.4 46 | }, 47 | "returns": 0 48 | }, 49 | { 50 | "arguments": { 51 | "x": -3.5 52 | }, 53 | "returns": -3 54 | } 55 | ], 56 | "links": [ 57 | { 58 | "rel": "about", 59 | "href": "http://mathworld.wolfram.com/IntegerPart.html", 60 | "title": "Integer Part explained by Wolfram MathWorld" 61 | } 62 | ] 63 | } -------------------------------------------------------------------------------- /rename_dimension.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "rename_dimension", 3 | "summary": "Rename a dimension", 4 | "description": "Renames a dimension in the data cube while preserving all other properties.", 5 | "categories": [ 6 | "cubes" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "data", 11 | "description": "The data cube.", 12 | "schema": { 13 | "type": "object", 14 | "subtype": "datacube" 15 | } 16 | }, 17 | { 18 | "name": "source", 19 | "description": "The current name of the dimension. Fails with a `DimensionNotAvailable` exception if the specified dimension does not exist.", 20 | "schema": { 21 | "type": "string" 22 | } 23 | }, 24 | { 25 | "name": "target", 26 | "description": "A new Name for the dimension. Fails with a `DimensionExists` exception if a dimension with the specified name exists.", 27 | "schema": { 28 | "type": "string" 29 | } 30 | } 31 | ], 32 | "returns": { 33 | "description": "A data cube with the same dimensions, but the name of one of the dimensions changes. The old name can not be referred to any longer. The dimension properties (name, type, labels, reference system and resolution) remain unchanged.", 34 | "schema": { 35 | "type": "object", 36 | "subtype": "datacube" 37 | } 38 | }, 39 | "exceptions": { 40 | "DimensionNotAvailable": { 41 | "message": "A dimension with the specified name does not exist." 42 | }, 43 | "DimensionExists": { 44 | "message": "A dimension with the specified name already exists." 45 | } 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /floor.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "floor", 3 | "summary": "Round fractions down", 4 | "description": "The greatest integer less than or equal to the number `x`.\n\nThis process is *not* an alias for the ``int()`` process as defined by some mathematicians, see the examples for negative numbers in both processes for differences.\n\nThe no-data value `null` is passed through and therefore gets propagated.", 5 | "categories": [ 6 | "math > rounding" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "x", 11 | "description": "A number to round down.", 12 | "schema": { 13 | "type": [ 14 | "number", 15 | "null" 16 | ] 17 | } 18 | } 19 | ], 20 | "returns": { 21 | "description": "The number rounded down.", 22 | "schema": { 23 | "type": [ 24 | "integer", 25 | "null" 26 | ] 27 | } 28 | }, 29 | "examples": [ 30 | { 31 | "arguments": { 32 | "x": 0 33 | }, 34 | "returns": 0 35 | }, 36 | { 37 | "arguments": { 38 | "x": 3.5 39 | }, 40 | "returns": 3 41 | }, 42 | { 43 | "arguments": { 44 | "x": -0.4 45 | }, 46 | "returns": -1 47 | }, 48 | { 49 | "arguments": { 50 | "x": -3.5 51 | }, 52 | "returns": -4 53 | } 54 | ], 55 | "links": [ 56 | { 57 | "rel": "about", 58 | "href": "http://mathworld.wolfram.com/FloorFunction.html", 59 | "title": "Floor explained by Wolfram MathWorld" 60 | } 61 | ] 62 | } -------------------------------------------------------------------------------- /exp.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "exp", 3 | "summary": "Exponentiation to the base e", 4 | "description": "Exponential function to the base *e* raised to the power of `p`.\n\nThe no-data value `null` is passed through and therefore gets propagated.", 5 | "categories": [ 6 | "math > exponential & logarithmic" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "p", 11 | "description": "The numerical exponent.", 12 | "schema": { 13 | "type": [ 14 | "number", 15 | "null" 16 | ] 17 | } 18 | } 19 | ], 20 | "returns": { 21 | "description": "The computed value for *e* raised to the power of `p`.", 22 | "schema": { 23 | "type": [ 24 | "number", 25 | "null" 26 | ] 27 | } 28 | }, 29 | "examples": [ 30 | { 31 | "arguments": { 32 | "p": 0 33 | }, 34 | "returns": 1 35 | }, 36 | { 37 | "arguments": { 38 | "p": null 39 | }, 40 | "returns": null 41 | } 42 | ], 43 | "links": [ 44 | { 45 | "rel": "about", 46 | "href": "http://mathworld.wolfram.com/ExponentialFunction.html", 47 | "title": "Exponential function explained by Wolfram MathWorld" 48 | } 49 | ], 50 | "process_graph": { 51 | "e": { 52 | "process_id": "e", 53 | "arguments": {} 54 | }, 55 | "power": { 56 | "process_id": "power", 57 | "arguments": { 58 | "base": { 59 | "from_node": "e" 60 | }, 61 | "p": { 62 | "from_parameter": "p" 63 | } 64 | }, 65 | "result": true 66 | } 67 | } 68 | } -------------------------------------------------------------------------------- /arctan2.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "arctan2", 3 | "summary": "Inverse tangent of two numbers", 4 | "description": "Computes the arc tangent of two numbers `x` and `y`. It is similar to calculating the arc tangent of *`y / x`*, except that the signs of both arguments are used to determine the quadrant of the result.\n\nWorks on radians only.\nThe no-data value `null` is passed through and therefore gets propagated if any of the arguments is `null`.", 5 | "categories": [ 6 | "math > trigonometric" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "y", 11 | "description": "A number to be used as the dividend.", 12 | "schema": { 13 | "type": [ 14 | "number", 15 | "null" 16 | ] 17 | } 18 | }, 19 | { 20 | "name": "x", 21 | "description": "A number to be used as the divisor.", 22 | "schema": { 23 | "type": [ 24 | "number", 25 | "null" 26 | ] 27 | } 28 | } 29 | ], 30 | "returns": { 31 | "description": "The computed angle in radians.", 32 | "schema": { 33 | "type": [ 34 | "number", 35 | "null" 36 | ] 37 | } 38 | }, 39 | "examples": [ 40 | { 41 | "arguments": { 42 | "y": 0, 43 | "x": 0 44 | }, 45 | "returns": 0 46 | }, 47 | { 48 | "arguments": { 49 | "y": null, 50 | "x": 1.5 51 | }, 52 | "returns": null 53 | } 54 | ], 55 | "links": [ 56 | { 57 | "rel": "about", 58 | "href": "https://en.wikipedia.org/wiki/Atan2", 59 | "title": "Two-argument inverse tangent explained by Wikipedia" 60 | } 61 | ] 62 | } -------------------------------------------------------------------------------- /tests/README.md: -------------------------------------------------------------------------------- 1 | # Tests for openEO Processes 2 | 3 | To run the tests follow these steps: 4 | 5 | 1. Install [node and npm](https://nodejs.org) - should run with any recent version 6 | 2. Run `npm install` in this folder to install the dependencies 7 | 3. Run the tests with `npm test`. This will also lint the files and verify it follows best practices. 8 | 4. To show the files nicely formatted in a web browser, run `npm start`. It starts a server and opens the corresponding page in a web browser. 9 | 10 | ## Development processes 11 | 12 | All new processes must be added to the `proposals` folder. Each process must be declared to be `experimental`. 13 | Processes must comply to best practices, which ensure a certain degree of consistency. 14 | `npm test` will validate and lint the processes and also ensure the best practices are applied. 15 | 16 | The linting checks that the files are named correctly, that the content is correctly formatted and indented (JSON and embedded CommonMark). 17 | The best practices ensure that for examples the fields are not too short and also not too long for example. 18 | 19 | A spell check is also checking the texts. It may report names and rarely used technical words as errors. 20 | If you are sure that these are correct, you can add them to the `.words` file to exclude the word from being reported as an error. 21 | The file must contain one word per line. 22 | 23 | New processes should be added via GitHub Pull Requests. 24 | 25 | ## Subtype schemas 26 | 27 | Sometimes it is useful to define a new "data type" on top of the JSON types (number, string, array, object, ...). 28 | For example, a client could make a select box with all collections available by adding a subtype `collection-id` to the JSON type `string`. 29 | If you think a new subype should be added, you need to add it to the `meta/subtype-schemas.json` file. 30 | It must be a valid JSON Schema. The tests mentioned above will also verify to a certain degree that the subtypes are defined correctly. 31 | -------------------------------------------------------------------------------- /is_valid.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "is_valid", 3 | "summary": "Value is valid data", 4 | "description": "Checks whether the specified value `x` is valid. The following values are considered valid:\n\n* Any finite numerical value (integers and floating-point numbers). The definition of finite numbers follows the [IEEE Standard 754](https://ieeexplore.ieee.org/document/4610935) and excludes the special value `NaN` (not a number).\n* Any other value that is not a no-data value according to ``is_nodata()``. Thus all arrays, objects and strings are valid, regardless of their content.", 5 | "categories": [ 6 | "comparison" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "x", 11 | "description": "The data to check.", 12 | "schema": { 13 | "description": "Any data type is allowed." 14 | } 15 | } 16 | ], 17 | "returns": { 18 | "description": "`true` if the data is valid, otherwise `false`.", 19 | "schema": { 20 | "type": "boolean" 21 | } 22 | }, 23 | "examples": [ 24 | { 25 | "arguments": { 26 | "x": 1 27 | }, 28 | "returns": true 29 | }, 30 | { 31 | "arguments": { 32 | "x": "Test" 33 | }, 34 | "returns": true 35 | }, 36 | { 37 | "arguments": { 38 | "x": null 39 | }, 40 | "returns": false 41 | }, 42 | { 43 | "arguments": { 44 | "x": [ 45 | null, 46 | null 47 | ] 48 | }, 49 | "returns": true 50 | } 51 | ], 52 | "links": [ 53 | { 54 | "rel": "about", 55 | "href": "https://ieeexplore.ieee.org/document/4610935", 56 | "title": "IEEE Standard 754-2008 for Floating-Point Arithmetic" 57 | } 58 | ] 59 | } 60 | -------------------------------------------------------------------------------- /.github/workflows/docs.yml: -------------------------------------------------------------------------------- 1 | name: Deploy Documentation 2 | on: 3 | release: 4 | types: [published] 5 | push: 6 | branches: 7 | - draft 8 | - draft-2.0 9 | - master 10 | jobs: 11 | deploy: 12 | runs-on: ubuntu-latest 13 | steps: 14 | - name: Inject env variables 15 | uses: rlespinasse/github-slug-action@v3.x 16 | - uses: actions/setup-node@v3 17 | with: 18 | node-version: 'lts/*' 19 | - uses: actions/checkout@v3 20 | - run: | 21 | npm install 22 | npm run generate 23 | working-directory: tests 24 | - name: clone gh-pages and clean-up 25 | if: ${{ env.GITHUB_REF_SLUG == 'master' }} 26 | run: | 27 | git clone --branch gh-pages https://github.com/Open-EO/openeo-processes.git gh-pages 28 | find gh-pages -maxdepth 1 -type f -delete 29 | rm -rf gh-pages/meta/ 30 | rm -rf gh-pages/proposals/ 31 | - name: create empty gh-pages folder 32 | if: ${{ env.GITHUB_REF_SLUG != 'master' }} 33 | run: mkdir gh-pages 34 | - run: | 35 | cp tests/docs.html index.html 36 | cp tests/processes.json processes.json 37 | rsync -vrm --include='*.json' --include='*.html' --include='meta/***' --include='proposals/***' --exclude='*' . gh-pages 38 | - name: deploy to root (master) 39 | uses: peaceiris/actions-gh-pages@v3 40 | if: ${{ env.GITHUB_REF_SLUG == 'master' }} 41 | with: 42 | github_token: ${{ secrets.GITHUB_TOKEN }} 43 | publish_dir: gh-pages 44 | user_name: 'openEO CI' 45 | user_email: openeo.ci@uni-muenster.de 46 | cname: processes.openeo.org 47 | - name: deploy to ${{ env.GITHUB_REF_SLUG }} 48 | uses: peaceiris/actions-gh-pages@v3 49 | if: ${{ env.GITHUB_REF_SLUG != 'master' }} 50 | with: 51 | github_token: ${{ secrets.GITHUB_TOKEN }} 52 | publish_dir: gh-pages 53 | destination_dir: ${{ env.GITHUB_REF_SLUG }} 54 | user_name: 'openEO CI' 55 | user_email: openeo.ci@uni-muenster.de -------------------------------------------------------------------------------- /sqrt.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "sqrt", 3 | "summary": "Square root", 4 | "description": "Computes the square root of a real number `x`, which is equal to calculating `x` to the power of *0.5*.\n\nA square root of x is a number a such that *`a² = x`*. Therefore, the square root is the inverse function of a to the power of 2, but only for *a >= 0*.\n\nThe no-data value `null` is passed through and therefore gets propagated.", 5 | "categories": [ 6 | "math", 7 | "math > exponential & logarithmic" 8 | ], 9 | "parameters": [ 10 | { 11 | "name": "x", 12 | "description": "A number.", 13 | "schema": { 14 | "type": [ 15 | "number", 16 | "null" 17 | ] 18 | } 19 | } 20 | ], 21 | "returns": { 22 | "description": "The computed square root.", 23 | "schema": { 24 | "type": [ 25 | "number", 26 | "null" 27 | ] 28 | } 29 | }, 30 | "examples": [ 31 | { 32 | "arguments": { 33 | "x": 0 34 | }, 35 | "returns": 0 36 | }, 37 | { 38 | "arguments": { 39 | "x": 1 40 | }, 41 | "returns": 1 42 | }, 43 | { 44 | "arguments": { 45 | "x": 9 46 | }, 47 | "returns": 3 48 | }, 49 | { 50 | "arguments": { 51 | "x": null 52 | }, 53 | "returns": null 54 | } 55 | ], 56 | "links": [ 57 | { 58 | "rel": "about", 59 | "href": "http://mathworld.wolfram.com/SquareRoot.html", 60 | "title": "Square root explained by Wolfram MathWorld" 61 | } 62 | ], 63 | "process_graph": { 64 | "power": { 65 | "process_id": "power", 66 | "arguments": { 67 | "base": { 68 | "from_parameter": "x" 69 | }, 70 | "p": 0.5 71 | }, 72 | "result": true 73 | } 74 | } 75 | } -------------------------------------------------------------------------------- /array_append.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "array_append", 3 | "summary": "Append a value to an array", 4 | "description": "Appends a new value to the end of the array, which may also include a new label for labeled arrays.", 5 | "categories": [ 6 | "arrays" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "data", 11 | "description": "An array.", 12 | "schema": { 13 | "type": "array", 14 | "items": { 15 | "description": "Any data type is allowed." 16 | } 17 | } 18 | }, 19 | { 20 | "name": "value", 21 | "description": "Value to append to the array.", 22 | "schema": { 23 | "description": "Any data type is allowed." 24 | } 25 | }, 26 | { 27 | "name": "label", 28 | "description": "If the given array is a labeled array, a new label for the new value should be given. If not given or `null`, the array index as string is used as the label. If in any case the label exists, a `LabelExists` exception is thrown.", 29 | "optional": true, 30 | "default": null, 31 | "schema": { 32 | "type": [ 33 | "string", 34 | "null" 35 | ] 36 | } 37 | } 38 | ], 39 | "returns": { 40 | "description": "The new array with the value being appended.", 41 | "schema": { 42 | "type": "array", 43 | "items": { 44 | "description": "Any data type is allowed." 45 | } 46 | } 47 | }, 48 | "exceptions": { 49 | "LabelExists": { 50 | "message": "An array element with the specified label already exists." 51 | } 52 | }, 53 | "examples": [ 54 | { 55 | "arguments": { 56 | "data": [ 57 | 1, 58 | 2 59 | ], 60 | "value": 3 61 | }, 62 | "returns": [ 63 | 1, 64 | 2, 65 | 3 66 | ] 67 | } 68 | ] 69 | } 70 | -------------------------------------------------------------------------------- /proposals/load_url.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "load_url", 3 | "summary": "Load data from a URL", 4 | "description": "Loads a file from a URL (supported protocols: HTTP and HTTPS).", 5 | "categories": [ 6 | "cubes", 7 | "import" 8 | ], 9 | "experimental": true, 10 | "parameters": [ 11 | { 12 | "name": "url", 13 | "description": "The URL to read from. Authentication details such as API keys or tokens may need to be included in the URL.", 14 | "schema": { 15 | "title": "URL", 16 | "type": "string", 17 | "format": "uri", 18 | "subtype": "uri", 19 | "pattern": "^https?://" 20 | } 21 | }, 22 | { 23 | "name": "format", 24 | "description": "The file format to use when loading the data. It must be one of the values that the server reports as supported input file formats, which usually correspond to the short GDAL/OGR codes. If the format is not suitable for loading the data, a `FormatUnsuitable` exception will be thrown. This parameter is *case insensitive*.", 25 | "schema": { 26 | "type": "string", 27 | "subtype": "input-format" 28 | } 29 | }, 30 | { 31 | "name": "options", 32 | "description": "The file format parameters to use when reading the data. Must correspond to the parameters that the server reports as supported parameters for the chosen `format`. The parameter names and valid values usually correspond to the GDAL/OGR format options.", 33 | "schema": { 34 | "type": "object", 35 | "subtype": "input-format-options" 36 | }, 37 | "default": {}, 38 | "optional": true 39 | } 40 | ], 41 | "returns": { 42 | "description": "A data cube for further processing.", 43 | "schema": { 44 | "type": "object", 45 | "subtype": "datacube" 46 | } 47 | }, 48 | "exceptions": { 49 | "FormatUnsuitable": { 50 | "message": "Data can't be loaded with the requested input format." 51 | } 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /add_dimension.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "add_dimension", 3 | "summary": "Add a new dimension", 4 | "description": "Adds a new named dimension to the data cube.\n\nAfterwards, the dimension can be referred to with the specified `name`. If a dimension with the specified name exists, the process fails with a `DimensionExists` exception. The dimension label of the dimension is set to the specified `label`.", 5 | "categories": [ 6 | "cubes" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "data", 11 | "description": "A data cube to add the dimension to.", 12 | "schema": { 13 | "type": "object", 14 | "subtype": "datacube" 15 | } 16 | }, 17 | { 18 | "name": "name", 19 | "description": "Name for the dimension.", 20 | "schema": { 21 | "type": "string" 22 | } 23 | }, 24 | { 25 | "name": "label", 26 | "description": "A dimension label.", 27 | "schema": [ 28 | { 29 | "type": "number" 30 | }, 31 | { 32 | "type": "string" 33 | } 34 | ] 35 | }, 36 | { 37 | "name": "type", 38 | "description": "The type of dimension, defaults to `other`.", 39 | "schema": { 40 | "type": "string", 41 | "enum": [ 42 | "bands", 43 | "geometry", 44 | "spatial", 45 | "temporal", 46 | "other" 47 | ] 48 | }, 49 | "default": "other", 50 | "optional": true 51 | } 52 | ], 53 | "returns": { 54 | "description": "The data cube with a newly added dimension. The new dimension has exactly one dimension label. All other dimensions remain unchanged.", 55 | "schema": { 56 | "type": "object", 57 | "subtype": "datacube" 58 | } 59 | }, 60 | "exceptions": { 61 | "DimensionExists": { 62 | "message": "A dimension with the specified name already exists." 63 | } 64 | } 65 | } 66 | -------------------------------------------------------------------------------- /subtract.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "subtract", 3 | "summary": "Subtraction of two numbers", 4 | "description": "Subtracts argument `y` from the argument `x` (*`x - y`*) and returns the computed result.\n\nNo-data values are taken into account so that `null` is returned if any element is such a value.\n\nThe computations follow [IEEE Standard 754](https://ieeexplore.ieee.org/document/8766229) whenever the processing environment supports it.", 5 | "categories": [ 6 | "math" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "x", 11 | "description": "The minuend.", 12 | "schema": { 13 | "type": [ 14 | "number", 15 | "null" 16 | ] 17 | } 18 | }, 19 | { 20 | "name": "y", 21 | "description": "The subtrahend.", 22 | "schema": { 23 | "type": [ 24 | "number", 25 | "null" 26 | ] 27 | } 28 | } 29 | ], 30 | "returns": { 31 | "description": "The computed result.", 32 | "schema": { 33 | "type": [ 34 | "number", 35 | "null" 36 | ] 37 | } 38 | }, 39 | "examples": [ 40 | { 41 | "arguments": { 42 | "x": 5, 43 | "y": 2.5 44 | }, 45 | "returns": 2.5 46 | }, 47 | { 48 | "arguments": { 49 | "x": -2, 50 | "y": 4 51 | }, 52 | "returns": -6 53 | }, 54 | { 55 | "arguments": { 56 | "x": 1, 57 | "y": null 58 | }, 59 | "returns": null 60 | } 61 | ], 62 | "links": [ 63 | { 64 | "rel": "about", 65 | "href": "http://mathworld.wolfram.com/Subtraction.html", 66 | "title": "Subtraction explained by Wolfram MathWorld" 67 | }, 68 | { 69 | "rel": "about", 70 | "href": "https://ieeexplore.ieee.org/document/8766229", 71 | "title": "IEEE Standard 754-2019 for Floating-Point Arithmetic" 72 | } 73 | ] 74 | } -------------------------------------------------------------------------------- /proposals/vector_buffer.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "vector_buffer", 3 | "summary": "Buffer geometries by distance", 4 | "description": "Buffers each input geometry by a given distance, which can either expand (dilate) or a shrink (erode) the geometry. Buffers can be applied to points, lines and polygons, but the results are always polygons. Empty geometries are passed through and negative buffers may result in empty geometries. Multi-part types (e.g. `MultiPoint`) are also allowed.", 5 | "categories": [ 6 | "vector" 7 | ], 8 | "experimental": true, 9 | "parameters": [ 10 | { 11 | "name": "geometries", 12 | "description": "Geometries to apply the buffer on. Feature properties are preserved.", 13 | "schema": { 14 | "type": "object", 15 | "subtype": "datacube", 16 | "dimensions": [ 17 | { 18 | "type": "geometry" 19 | } 20 | ] 21 | } 22 | }, 23 | { 24 | "name": "distance", 25 | "description": "The distance of the buffer in meters. A positive distance expands the geometries, resulting in outward buffering (dilation), while a negative distance shrinks the geometries, resulting in inward buffering (erosion).\n\nIf the unit of the spatial reference system is not meters, a `UnitMismatch` error is thrown. Use ``vector_reproject()`` to convert the geometries to a suitable spatial reference system.", 26 | "schema": { 27 | "type": "number", 28 | "not": { 29 | "const": 0 30 | } 31 | } 32 | } 33 | ], 34 | "returns": { 35 | "description": "Returns a vector data cube with the computed new geometries of which some may be empty.", 36 | "schema": { 37 | "type": "object", 38 | "subtype": "datacube", 39 | "dimensions": [ 40 | { 41 | "type": "geometry" 42 | } 43 | ] 44 | } 45 | }, 46 | "exceptions": { 47 | "UnitMismatch": { 48 | "message": "The unit of the spatial reference system is not meters, but the given distance is in meters." 49 | } 50 | } 51 | } 52 | -------------------------------------------------------------------------------- /last.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "last", 3 | "summary": "Last element", 4 | "description": "Gives the last element of an array.\n\nAn array without non-`null` elements resolves always with `null`.", 5 | "categories": [ 6 | "arrays", 7 | "reducer" 8 | ], 9 | "parameters": [ 10 | { 11 | "name": "data", 12 | "description": "An array with elements of any data type.", 13 | "schema": { 14 | "type": "array", 15 | "items": { 16 | "description": "Any data type is allowed." 17 | } 18 | } 19 | }, 20 | { 21 | "name": "ignore_nodata", 22 | "description": "Indicates whether no-data values are ignored or not. Ignores them by default. Setting this flag to `false` considers no-data values so that `null` is returned if the last value is such a value.", 23 | "schema": { 24 | "type": "boolean" 25 | }, 26 | "default": true, 27 | "optional": true 28 | } 29 | ], 30 | "returns": { 31 | "description": "The last element of the input array.", 32 | "schema": { 33 | "description": "Any data type is allowed." 34 | } 35 | }, 36 | "examples": [ 37 | { 38 | "arguments": { 39 | "data": [ 40 | 1, 41 | 0, 42 | 3, 43 | 2 44 | ] 45 | }, 46 | "returns": 2 47 | }, 48 | { 49 | "arguments": { 50 | "data": [ 51 | "A", 52 | "B", 53 | null 54 | ] 55 | }, 56 | "returns": "B" 57 | }, 58 | { 59 | "arguments": { 60 | "data": [ 61 | 0, 62 | 1, 63 | null 64 | ], 65 | "ignore_nodata": false 66 | }, 67 | "returns": null 68 | }, 69 | { 70 | "description": "The input array is empty: return `null`.", 71 | "arguments": { 72 | "data": [] 73 | }, 74 | "returns": null 75 | } 76 | ] 77 | } -------------------------------------------------------------------------------- /first.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "first", 3 | "summary": "First element", 4 | "description": "Gives the first element of an array.\n\nAn array without non-`null` elements resolves always with `null`.", 5 | "categories": [ 6 | "arrays", 7 | "reducer" 8 | ], 9 | "parameters": [ 10 | { 11 | "name": "data", 12 | "description": "An array with elements of any data type.", 13 | "schema": { 14 | "type": "array", 15 | "items": { 16 | "description": "Any data type is allowed." 17 | } 18 | } 19 | }, 20 | { 21 | "name": "ignore_nodata", 22 | "description": "Indicates whether no-data values are ignored or not. Ignores them by default. Setting this flag to `false` considers no-data values so that `null` is returned if the first value is such a value.", 23 | "schema": { 24 | "type": "boolean" 25 | }, 26 | "default": true, 27 | "optional": true 28 | } 29 | ], 30 | "returns": { 31 | "description": "The first element of the input array.", 32 | "schema": { 33 | "description": "Any data type is allowed." 34 | } 35 | }, 36 | "examples": [ 37 | { 38 | "arguments": { 39 | "data": [ 40 | 1, 41 | 0, 42 | 3, 43 | 2 44 | ] 45 | }, 46 | "returns": 1 47 | }, 48 | { 49 | "arguments": { 50 | "data": [ 51 | null, 52 | "A", 53 | "B" 54 | ] 55 | }, 56 | "returns": "A" 57 | }, 58 | { 59 | "arguments": { 60 | "data": [ 61 | null, 62 | 2, 63 | 3 64 | ], 65 | "ignore_nodata": false 66 | }, 67 | "returns": null 68 | }, 69 | { 70 | "description": "The input array is empty: return `null`.", 71 | "arguments": { 72 | "data": [] 73 | }, 74 | "returns": null 75 | } 76 | ] 77 | } -------------------------------------------------------------------------------- /ln.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "ln", 3 | "summary": "Natural logarithm", 4 | "description": "The natural logarithm is the logarithm to the base *e* of the number `x`, which equals to using the *log* process with the base set to *e*. The natural logarithm is the inverse function of taking *e* to the power x.\n\nThe no-data value `null` is passed through.\n\nThe computations follow [IEEE Standard 754](https://ieeexplore.ieee.org/document/8766229) whenever the processing environment supports it. Therefore, *`ln(0)`* results in ±infinity if the processing environment supports it or otherwise an exception is thrown.", 5 | "categories": [ 6 | "math > exponential & logarithmic" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "x", 11 | "description": "A number to compute the natural logarithm for.", 12 | "schema": { 13 | "type": [ 14 | "number", 15 | "null" 16 | ] 17 | } 18 | } 19 | ], 20 | "returns": { 21 | "description": "The computed natural logarithm.", 22 | "schema": { 23 | "type": [ 24 | "number", 25 | "null" 26 | ] 27 | } 28 | }, 29 | "examples": [ 30 | { 31 | "arguments": { 32 | "x": 1 33 | }, 34 | "returns": 0 35 | } 36 | ], 37 | "links": [ 38 | { 39 | "rel": "about", 40 | "href": "http://mathworld.wolfram.com/NaturalLogarithm.html", 41 | "title": "Natural logarithm explained by Wolfram MathWorld" 42 | }, 43 | { 44 | "rel": "about", 45 | "href": "https://ieeexplore.ieee.org/document/8766229", 46 | "title": "IEEE Standard 754-2019 for Floating-Point Arithmetic" 47 | } 48 | ], 49 | "process_graph": { 50 | "e": { 51 | "process_id": "e", 52 | "arguments": {} 53 | }, 54 | "log": { 55 | "process_id": "log", 56 | "arguments": { 57 | "x": { 58 | "from_parameter": "x" 59 | }, 60 | "base": { 61 | "from_node": "e" 62 | } 63 | }, 64 | "result": true 65 | } 66 | } 67 | } -------------------------------------------------------------------------------- /proposals/inspect.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "inspect", 3 | "summary": "Add information to the logs", 4 | "description": "This process can be used to add runtime information to the logs, e.g. for debugging purposes. This process should be used with caution and it is recommended to remove the process in production workflows. For example, logging each value or array individually in a process such as ``apply()`` or ``reduce_dimension()`` could lead to a (too) large number of log entries. Several data structures (e.g. data cubes) are too large to log and will only return summaries of their contents.\n\nThe data provided in the parameter `data` is returned without changes.", 5 | "categories": [ 6 | "development" 7 | ], 8 | "experimental": true, 9 | "parameters": [ 10 | { 11 | "name": "data", 12 | "description": "Data to log.", 13 | "schema": { 14 | "description": "Any data type is allowed." 15 | } 16 | }, 17 | { 18 | "name": "message", 19 | "description": "A message to send in addition to the data.", 20 | "schema": { 21 | "type": "string" 22 | }, 23 | "default": "", 24 | "optional": true 25 | }, 26 | { 27 | "name": "code", 28 | "description": "A label to help identify one or more log entries originating from this process in the list of all log entries. It can help to group or filter log entries and is usually not unique.", 29 | "schema": { 30 | "type": "string" 31 | }, 32 | "default": "User", 33 | "optional": true 34 | }, 35 | { 36 | "name": "level", 37 | "description": "The severity level of this message, defaults to `info`.", 38 | "schema": { 39 | "type": "string", 40 | "enum": [ 41 | "error", 42 | "warning", 43 | "info", 44 | "debug" 45 | ] 46 | }, 47 | "default": "info", 48 | "optional": true 49 | } 50 | ], 51 | "returns": { 52 | "description": "The data as passed to the `data` parameter without any modification.", 53 | "schema": { 54 | "description": "Any data type is allowed." 55 | } 56 | } 57 | } 58 | -------------------------------------------------------------------------------- /proposals/load_uploaded_files.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "load_uploaded_files", 3 | "summary": "Load files from the user workspace", 4 | "description": "Loads one or more user-uploaded files from the server-side workspace of the authenticated user and returns them as a single data cube. The files must have been stored by the authenticated user on the back-end currently connected to.", 5 | "categories": [ 6 | "cubes", 7 | "import" 8 | ], 9 | "experimental": true, 10 | "parameters": [ 11 | { 12 | "name": "paths", 13 | "description": "The files to read. Folders can't be specified, specify all files instead. An exception is thrown if a file can't be read.", 14 | "schema": { 15 | "type": "array", 16 | "subtype": "file-paths", 17 | "items": { 18 | "type": "string", 19 | "subtype": "file-path", 20 | "pattern": "^[^\r\n\\:'\"]+$" 21 | } 22 | } 23 | }, 24 | { 25 | "name": "format", 26 | "description": "The file format to read from. It must be one of the values that the server reports as supported input file formats, which usually correspond to the short GDAL/OGR codes. If the format is not suitable for loading the data, a `FormatUnsuitable` exception will be thrown. This parameter is *case insensitive*.", 27 | "schema": { 28 | "type": "string", 29 | "subtype": "input-format" 30 | } 31 | }, 32 | { 33 | "name": "options", 34 | "description": "The file format parameters to be used to read the files. Must correspond to the parameters that the server reports as supported parameters for the chosen `format`. The parameter names and valid values usually correspond to the GDAL/OGR format options.", 35 | "schema": { 36 | "type": "object", 37 | "subtype": "input-format-options" 38 | }, 39 | "default": {}, 40 | "optional": true 41 | } 42 | ], 43 | "returns": { 44 | "description": "A data cube for further processing.", 45 | "schema": { 46 | "type": "object", 47 | "subtype": "datacube" 48 | } 49 | }, 50 | "exceptions": { 51 | "FormatUnsuitable": { 52 | "message": "Data can't be loaded with the requested input format." 53 | } 54 | } 55 | } 56 | -------------------------------------------------------------------------------- /divide.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "divide", 3 | "summary": "Division of two numbers", 4 | "description": "Divides argument `x` by the argument `y` (*`x / y`*) and returns the computed result.\n\nNo-data values are taken into account so that `null` is returned if any element is such a value.\n\nThe computations follow [IEEE Standard 754](https://ieeexplore.ieee.org/document/8766229) whenever the processing environment supports it. Therefore, a division by zero results in ±infinity if the processing environment supports it. Otherwise, a `DivisionByZero` exception must the thrown.", 5 | "categories": [ 6 | "math" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "x", 11 | "description": "The dividend.", 12 | "schema": { 13 | "type": [ 14 | "number", 15 | "null" 16 | ] 17 | } 18 | }, 19 | { 20 | "name": "y", 21 | "description": "The divisor.", 22 | "schema": { 23 | "type": [ 24 | "number", 25 | "null" 26 | ] 27 | } 28 | } 29 | ], 30 | "returns": { 31 | "description": "The computed result.", 32 | "schema": { 33 | "type": [ 34 | "number", 35 | "null" 36 | ] 37 | } 38 | }, 39 | "exceptions": { 40 | "DivisionByZero": { 41 | "message": "Division by zero is not supported." 42 | } 43 | }, 44 | "examples": [ 45 | { 46 | "arguments": { 47 | "x": 5, 48 | "y": 2.5 49 | }, 50 | "returns": 2 51 | }, 52 | { 53 | "arguments": { 54 | "x": -2, 55 | "y": 4 56 | }, 57 | "returns": -0.5 58 | }, 59 | { 60 | "arguments": { 61 | "x": 1, 62 | "y": null 63 | }, 64 | "returns": null 65 | } 66 | ], 67 | "links": [ 68 | { 69 | "rel": "about", 70 | "href": "http://mathworld.wolfram.com/Division.html", 71 | "title": "Division explained by Wolfram MathWorld" 72 | }, 73 | { 74 | "rel": "about", 75 | "href": "https://ieeexplore.ieee.org/document/8766229", 76 | "title": "IEEE Standard 754-2019 for Floating-Point Arithmetic" 77 | } 78 | ] 79 | } -------------------------------------------------------------------------------- /log.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "log", 3 | "summary": "Logarithm to a base", 4 | "description": "Logarithm to the base `base` of the number `x` is defined to be the inverse function of taking b to the power of x.\n\nThe no-data value `null` is passed through and therefore gets propagated if any of the arguments is `null`.\n\nThe computations follow [IEEE Standard 754](https://ieeexplore.ieee.org/document/8766229) whenever the processing environment supports it. Therefore, `log(0, 2)` results in ±infinity if the processing environment supports it or otherwise an exception is thrown.", 5 | "categories": [ 6 | "math > exponential & logarithmic" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "x", 11 | "description": "A number to compute the logarithm for.", 12 | "schema": { 13 | "type": [ 14 | "number", 15 | "null" 16 | ] 17 | } 18 | }, 19 | { 20 | "name": "base", 21 | "description": "The numerical base.", 22 | "schema": { 23 | "type": [ 24 | "number", 25 | "null" 26 | ] 27 | } 28 | } 29 | ], 30 | "returns": { 31 | "description": "The computed logarithm.", 32 | "schema": { 33 | "type": [ 34 | "number", 35 | "null" 36 | ] 37 | } 38 | }, 39 | "examples": [ 40 | { 41 | "arguments": { 42 | "x": 10, 43 | "base": 10 44 | }, 45 | "returns": 1 46 | }, 47 | { 48 | "arguments": { 49 | "x": 2, 50 | "base": 2 51 | }, 52 | "returns": 1 53 | }, 54 | { 55 | "arguments": { 56 | "x": 4, 57 | "base": 2 58 | }, 59 | "returns": 2 60 | }, 61 | { 62 | "arguments": { 63 | "x": 1, 64 | "base": 16 65 | }, 66 | "returns": 0 67 | } 68 | ], 69 | "links": [ 70 | { 71 | "rel": "about", 72 | "href": "http://mathworld.wolfram.com/Logarithm.html", 73 | "title": "Logarithm explained by Wolfram MathWorld" 74 | }, 75 | { 76 | "rel": "about", 77 | "href": "https://ieeexplore.ieee.org/document/8766229", 78 | "title": "IEEE Standard 754-2019 for Floating-Point Arithmetic" 79 | } 80 | ] 81 | } -------------------------------------------------------------------------------- /power.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "power", 3 | "summary": "Exponentiation", 4 | "description": "Computes the exponentiation for the base `base` raised to the power of `p`.\n\nThe no-data value `null` is passed through and therefore gets propagated if any of the arguments is `null`.", 5 | "categories": [ 6 | "math", 7 | "math > exponential & logarithmic" 8 | ], 9 | "parameters": [ 10 | { 11 | "name": "base", 12 | "description": "The numerical base.", 13 | "schema": { 14 | "type": [ 15 | "number", 16 | "null" 17 | ] 18 | } 19 | }, 20 | { 21 | "name": "p", 22 | "description": "The numerical exponent.", 23 | "schema": { 24 | "type": [ 25 | "number", 26 | "null" 27 | ] 28 | } 29 | } 30 | ], 31 | "returns": { 32 | "description": "The computed value for `base` raised to the power of `p`.", 33 | "schema": { 34 | "type": [ 35 | "number", 36 | "null" 37 | ] 38 | } 39 | }, 40 | "examples": [ 41 | { 42 | "arguments": { 43 | "base": 0, 44 | "p": 2 45 | }, 46 | "returns": 0 47 | }, 48 | { 49 | "arguments": { 50 | "base": 2.5, 51 | "p": 0 52 | }, 53 | "returns": 1 54 | }, 55 | { 56 | "arguments": { 57 | "base": 3, 58 | "p": 3 59 | }, 60 | "returns": 27 61 | }, 62 | { 63 | "arguments": { 64 | "base": 5, 65 | "p": -1 66 | }, 67 | "returns": 0.2 68 | }, 69 | { 70 | "arguments": { 71 | "base": 1, 72 | "p": 0.5 73 | }, 74 | "returns": 1 75 | }, 76 | { 77 | "arguments": { 78 | "base": 1, 79 | "p": null 80 | }, 81 | "returns": null 82 | }, 83 | { 84 | "arguments": { 85 | "base": null, 86 | "p": 2 87 | }, 88 | "returns": null 89 | } 90 | ], 91 | "links": [ 92 | { 93 | "rel": "about", 94 | "href": "http://mathworld.wolfram.com/Power.html", 95 | "title": "Power explained by Wolfram MathWorld" 96 | } 97 | ] 98 | } -------------------------------------------------------------------------------- /array_concat.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "array_concat", 3 | "summary": "Merge two arrays", 4 | "description": "Concatenates two arrays into a single array by appending the second array to the first array.\n\nArray labels are kept only if both given arrays are labeled. Otherwise, the labels get discarded from both arrays. The process fails with an `ArrayLabelConflict` exception if a label is present in both arrays. Conflicts must be resolved beforehand.", 5 | "categories": [ 6 | "arrays" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "array1", 11 | "description": "The first array.", 12 | "schema": { 13 | "type": "array", 14 | "items": { 15 | "description": "Any data type is allowed." 16 | } 17 | } 18 | }, 19 | { 20 | "name": "array2", 21 | "description": "The second array.", 22 | "schema": { 23 | "type": "array", 24 | "items": { 25 | "description": "Any data type is allowed." 26 | } 27 | } 28 | } 29 | ], 30 | "returns": { 31 | "description": "The merged array.", 32 | "schema": { 33 | "type": "array", 34 | "items": { 35 | "description": "Any data type is allowed." 36 | } 37 | } 38 | }, 39 | "exceptions": { 40 | "ArrayLabelConflict": { 41 | "message": "At least one label exists in both arrays and the conflict must be resolved before." 42 | } 43 | }, 44 | "examples": [ 45 | { 46 | "description": "Concatenates two numerical arrays.", 47 | "arguments": { 48 | "array1": [ 49 | 1.5, 50 | 2.5 51 | ], 52 | "array2": [ 53 | 5 54 | ] 55 | }, 56 | "returns": [ 57 | 1.5, 58 | 2.5, 59 | 5 60 | ] 61 | }, 62 | { 63 | "description": "Concatenates two arrays containing different data type, may not always be supported.", 64 | "arguments": { 65 | "array1": [ 66 | "a", 67 | "b" 68 | ], 69 | "array2": [ 70 | 1, 71 | 2 72 | ] 73 | }, 74 | "returns": [ 75 | "a", 76 | "b", 77 | 1, 78 | 2 79 | ] 80 | } 81 | ] 82 | } 83 | -------------------------------------------------------------------------------- /absolute.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "absolute", 3 | "summary": "Absolute value", 4 | "description": "Computes the absolute value of a real number `x`, which is the \"unsigned\" portion of x and often denoted as *|x|*.\n\nThe no-data value `null` is passed through and therefore gets propagated.", 5 | "categories": [ 6 | "math" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "x", 11 | "description": "A number.", 12 | "schema": { 13 | "type": [ 14 | "number", 15 | "null" 16 | ] 17 | } 18 | } 19 | ], 20 | "returns": { 21 | "description": "The computed absolute value.", 22 | "schema": { 23 | "type": [ 24 | "number", 25 | "null" 26 | ], 27 | "minimum": 0 28 | } 29 | }, 30 | "examples": [ 31 | { 32 | "arguments": { 33 | "x": 0 34 | }, 35 | "returns": 0 36 | }, 37 | { 38 | "arguments": { 39 | "x": 3.5 40 | }, 41 | "returns": 3.5 42 | }, 43 | { 44 | "arguments": { 45 | "x": -0.4 46 | }, 47 | "returns": 0.4 48 | }, 49 | { 50 | "arguments": { 51 | "x": -3.5 52 | }, 53 | "returns": 3.5 54 | } 55 | ], 56 | "links": [ 57 | { 58 | "rel": "about", 59 | "href": "http://mathworld.wolfram.com/AbsoluteValue.html", 60 | "title": "Absolute value explained by Wolfram MathWorld" 61 | } 62 | ], 63 | "process_graph": { 64 | "lt": { 65 | "process_id": "lt", 66 | "arguments": { 67 | "x": { 68 | "from_parameter": "x" 69 | }, 70 | "y": 0 71 | } 72 | }, 73 | "multiply": { 74 | "process_id": "multiply", 75 | "arguments": { 76 | "x": { 77 | "from_parameter": "x" 78 | }, 79 | "y": -1 80 | } 81 | }, 82 | "if": { 83 | "process_id": "if", 84 | "arguments": { 85 | "value": { 86 | "from_node": "lt" 87 | }, 88 | "accept": { 89 | "from_node": "multiply" 90 | }, 91 | "reject": { 92 | "from_parameter": "x" 93 | } 94 | }, 95 | "result": true 96 | } 97 | } 98 | } -------------------------------------------------------------------------------- /or.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "or", 3 | "summary": "Logical OR", 4 | "description": "Checks if **at least one** of the values is true. Evaluates parameter `x` before `y` and stops once the outcome is unambiguous. If a component is `null`, the result will be `null` if the outcome is ambiguous.\n\n**Truth table:**\n\n```\na \\ b || null | false | true\n----- || ---- | ----- | ----\nnull || null | null | true\nfalse || null | false | true\ntrue || true | true | true\n```", 5 | "categories": [ 6 | "logic" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "x", 11 | "description": "A boolean value.", 12 | "schema": { 13 | "type": [ 14 | "boolean", 15 | "null" 16 | ] 17 | } 18 | }, 19 | { 20 | "name": "y", 21 | "description": "A boolean value.", 22 | "schema": { 23 | "type": [ 24 | "boolean", 25 | "null" 26 | ] 27 | } 28 | } 29 | ], 30 | "returns": { 31 | "description": "Boolean result of the logical OR.", 32 | "schema": { 33 | "type": [ 34 | "boolean", 35 | "null" 36 | ] 37 | } 38 | }, 39 | "examples": [ 40 | { 41 | "arguments": { 42 | "x": true, 43 | "y": true 44 | }, 45 | "returns": true 46 | }, 47 | { 48 | "arguments": { 49 | "x": false, 50 | "y": false 51 | }, 52 | "returns": false 53 | }, 54 | { 55 | "arguments": { 56 | "x": true, 57 | "y": null 58 | }, 59 | "returns": true 60 | }, 61 | { 62 | "arguments": { 63 | "x": null, 64 | "y": true 65 | }, 66 | "returns": true 67 | }, 68 | { 69 | "arguments": { 70 | "x": false, 71 | "y": null 72 | }, 73 | "returns": null 74 | } 75 | ], 76 | "process_graph": { 77 | "any": { 78 | "process_id": "any", 79 | "arguments": { 80 | "data": [ 81 | { 82 | "from_parameter": "x" 83 | }, 84 | { 85 | "from_parameter": "y" 86 | } 87 | ], 88 | "ignore_nodata": false 89 | }, 90 | "result": true 91 | } 92 | } 93 | } -------------------------------------------------------------------------------- /and.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "and", 3 | "summary": "Logical AND", 4 | "description": "Checks if **both** values are true.\n\nEvaluates parameter `x` before `y` and stops once the outcome is unambiguous. If any argument is `null`, the result will be `null` if the outcome is ambiguous.\n\n**Truth table:**\n\n```\na \\ b || null | false | true\n----- || ----- | ----- | -----\nnull || null | false | null\nfalse || false | false | false\ntrue || null | false | true\n```", 5 | "categories": [ 6 | "logic" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "x", 11 | "description": "A boolean value.", 12 | "schema": { 13 | "type": [ 14 | "boolean", 15 | "null" 16 | ] 17 | } 18 | }, 19 | { 20 | "name": "y", 21 | "description": "A boolean value.", 22 | "schema": { 23 | "type": [ 24 | "boolean", 25 | "null" 26 | ] 27 | } 28 | } 29 | ], 30 | "returns": { 31 | "description": "Boolean result of the logical AND.", 32 | "schema": { 33 | "type": [ 34 | "boolean", 35 | "null" 36 | ] 37 | } 38 | }, 39 | "examples": [ 40 | { 41 | "arguments": { 42 | "x": true, 43 | "y": true 44 | }, 45 | "returns": true 46 | }, 47 | { 48 | "arguments": { 49 | "x": true, 50 | "y": false 51 | }, 52 | "returns": false 53 | }, 54 | { 55 | "arguments": { 56 | "x": false, 57 | "y": false 58 | }, 59 | "returns": false 60 | }, 61 | { 62 | "arguments": { 63 | "x": false, 64 | "y": null 65 | }, 66 | "returns": false 67 | }, 68 | { 69 | "arguments": { 70 | "x": true, 71 | "y": null 72 | }, 73 | "returns": null 74 | } 75 | ], 76 | "process_graph": { 77 | "all": { 78 | "process_id": "all", 79 | "arguments": { 80 | "data": [ 81 | { 82 | "from_parameter": "x" 83 | }, 84 | { 85 | "from_parameter": "y" 86 | } 87 | ], 88 | "ignore_nodata": false 89 | }, 90 | "result": true 91 | } 92 | } 93 | } -------------------------------------------------------------------------------- /proposals/load_geojson.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "load_geojson", 3 | "summary": "Converts GeoJSON into a vector data cube", 4 | "description": "Converts GeoJSON data as defined by [RFC 7946](https://www.rfc-editor.org/rfc/rfc7946.html) into a vector data cube. Feature properties are preserved.", 5 | "categories": [ 6 | "import", 7 | "vector" 8 | ], 9 | "experimental": true, 10 | "parameters": [ 11 | { 12 | "name": "data", 13 | "description": "A GeoJSON object to convert into a vector data cube. The GeoJSON type `GeometryCollection` is not supported. Each geometry in the GeoJSON data results in a dimension label in the `geometries` dimension.", 14 | "schema": { 15 | "type": "object", 16 | "subtype": "geojson" 17 | } 18 | }, 19 | { 20 | "name": "properties", 21 | "description": "A list of properties from the GeoJSON file to construct an additional dimension from. A new dimension with the name `properties` and type `other` is created if at least one property is provided. Only applies for GeoJSON Features and FeatureCollections. Missing values are generally set to no-data (`null`).\n\nDepending on the number of properties provided, the process creates the dimension differently:\n\n- Single property with scalar values: A single dimension label with the name of the property and a single value per geometry.\n- Single property of type array: The dimension labels correspond to the array indices. There are as many values and labels per geometry as there are for the largest array.\n- Multiple properties with scalar values: The dimension labels correspond to the property names. There are as many values and labels per geometry as there are properties provided here.", 22 | "schema": { 23 | "type": "array", 24 | "uniqueItems": true, 25 | "items": { 26 | "type": "string" 27 | } 28 | }, 29 | "default": [], 30 | "optional": true 31 | } 32 | ], 33 | "returns": { 34 | "description": "A vector data cube containing the geometries, either one or two dimensional.", 35 | "schema": { 36 | "type": "object", 37 | "subtype": "datacube", 38 | "dimensions": [ 39 | { 40 | "type": "geometry" 41 | } 42 | ] 43 | } 44 | }, 45 | "links": [ 46 | { 47 | "href": "https://www.rfc-editor.org/rfc/rfc7946.html", 48 | "title": "RFC 7946: The GeoJSON Format", 49 | "type": "text/html", 50 | "rel": "about" 51 | } 52 | ] 53 | } 54 | -------------------------------------------------------------------------------- /add.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "add", 3 | "summary": "Addition of two numbers", 4 | "description": "Sums up the two numbers `x` and `y` (*`x + y`*) and returns the computed sum.\n\nNo-data values are taken into account so that `null` is returned if any element is such a value.\n\nThe computations follow [IEEE Standard 754](https://ieeexplore.ieee.org/document/8766229) whenever the processing environment supports it.", 5 | "categories": [ 6 | "math" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "x", 11 | "description": "The first summand.", 12 | "schema": { 13 | "type": [ 14 | "number", 15 | "null" 16 | ] 17 | } 18 | }, 19 | { 20 | "name": "y", 21 | "description": "The second summand.", 22 | "schema": { 23 | "type": [ 24 | "number", 25 | "null" 26 | ] 27 | } 28 | } 29 | ], 30 | "returns": { 31 | "description": "The computed sum of the two numbers.", 32 | "schema": { 33 | "type": [ 34 | "number", 35 | "null" 36 | ] 37 | } 38 | }, 39 | "examples": [ 40 | { 41 | "arguments": { 42 | "x": 5, 43 | "y": 2.5 44 | }, 45 | "returns": 7.5 46 | }, 47 | { 48 | "arguments": { 49 | "x": -2, 50 | "y": -4 51 | }, 52 | "returns": -6 53 | }, 54 | { 55 | "arguments": { 56 | "x": 1, 57 | "y": null 58 | }, 59 | "returns": null 60 | } 61 | ], 62 | "links": [ 63 | { 64 | "rel": "about", 65 | "href": "http://mathworld.wolfram.com/Sum.html", 66 | "title": "Sum explained by Wolfram MathWorld" 67 | }, 68 | { 69 | "rel": "about", 70 | "href": "https://ieeexplore.ieee.org/document/8766229", 71 | "title": "IEEE Standard 754-2019 for Floating-Point Arithmetic" 72 | } 73 | ], 74 | "process_graph": { 75 | "sum": { 76 | "process_id": "sum", 77 | "arguments": { 78 | "data": [ 79 | { 80 | "from_parameter": "x" 81 | }, 82 | { 83 | "from_parameter": "y" 84 | } 85 | ], 86 | "ignore_nodata": false 87 | }, 88 | "result": true 89 | } 90 | } 91 | } -------------------------------------------------------------------------------- /min.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "min", 3 | "summary": "Minimum value", 4 | "description": "Computes the smallest value of an array of numbers, which is equal to the last element of a sorted (i.e., ordered) version of the array.\n\nAn array without non-`null` elements resolves always with `null`.", 5 | "categories": [ 6 | "math", 7 | "math > statistics", 8 | "reducer" 9 | ], 10 | "parameters": [ 11 | { 12 | "name": "data", 13 | "description": "An array of numbers.", 14 | "schema": { 15 | "type": "array", 16 | "items": { 17 | "type": [ 18 | "number", 19 | "null" 20 | ] 21 | } 22 | } 23 | }, 24 | { 25 | "name": "ignore_nodata", 26 | "description": "Indicates whether no-data values are ignored or not. Ignores them by default. Setting this flag to `false` considers no-data values so that `null` is returned if any value is such a value.", 27 | "schema": { 28 | "type": "boolean" 29 | }, 30 | "default": true, 31 | "optional": true 32 | } 33 | ], 34 | "returns": { 35 | "description": "The minimum value.", 36 | "schema": { 37 | "type": [ 38 | "number", 39 | "null" 40 | ] 41 | } 42 | }, 43 | "examples": [ 44 | { 45 | "arguments": { 46 | "data": [ 47 | 1, 48 | 0, 49 | 3, 50 | 2 51 | ] 52 | }, 53 | "returns": 0 54 | }, 55 | { 56 | "arguments": { 57 | "data": [ 58 | 5, 59 | 2.5, 60 | null, 61 | -0.7 62 | ] 63 | }, 64 | "returns": -0.7 65 | }, 66 | { 67 | "arguments": { 68 | "data": [ 69 | 1, 70 | 0, 71 | 3, 72 | null, 73 | 2 74 | ], 75 | "ignore_nodata": false 76 | }, 77 | "returns": null 78 | }, 79 | { 80 | "arguments": { 81 | "data": [] 82 | }, 83 | "returns": null 84 | } 85 | ], 86 | "links": [ 87 | { 88 | "rel": "about", 89 | "href": "http://mathworld.wolfram.com/Minimum.html", 90 | "title": "Minimum explained by Wolfram MathWorld" 91 | } 92 | ] 93 | } -------------------------------------------------------------------------------- /array_interpolate_linear.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "array_interpolate_linear", 3 | "summary": "One-dimensional linear interpolation for arrays", 4 | "description": "Performs a linear interpolation for each of the no-data values (`null`) in the array given, except for leading and trailing no-data values.\n\nThe linear interpolants are defined by the array indices or labels (x) and the values in the array (y).", 5 | "categories": [ 6 | "arrays", 7 | "math", 8 | "math > interpolation" 9 | ], 10 | "parameters": [ 11 | { 12 | "name": "data", 13 | "description": "An array of numbers and no-data values.\n\nIf the given array is a labeled array, the labels must have a natural/inherent label order and the process expects the labels to be sorted accordingly. This is the default behavior in openEO for spatial and temporal dimensions.", 14 | "schema": { 15 | "type": "array", 16 | "items": { 17 | "type": [ 18 | "number", 19 | "null" 20 | ] 21 | } 22 | } 23 | } 24 | ], 25 | "returns": { 26 | "description": "An array with no-data values being replaced with interpolated values. If not at least 2 numerical values are available in the array, the array stays the same.", 27 | "schema": { 28 | "type": "array", 29 | "items": { 30 | "type": [ 31 | "number", 32 | "null" 33 | ] 34 | } 35 | } 36 | }, 37 | "examples": [ 38 | { 39 | "arguments": { 40 | "data": [ 41 | null, 42 | 1, 43 | null, 44 | 6, 45 | null, 46 | -8 47 | ] 48 | }, 49 | "returns": [ 50 | null, 51 | 1, 52 | 3.5, 53 | 6, 54 | -1, 55 | -8 56 | ] 57 | }, 58 | { 59 | "arguments": { 60 | "data": [ 61 | null, 62 | 1, 63 | null, 64 | null 65 | ] 66 | }, 67 | "returns": [ 68 | null, 69 | 1, 70 | null, 71 | null 72 | ] 73 | } 74 | ], 75 | "links": [ 76 | { 77 | "rel": "about", 78 | "href": "https://en.wikipedia.org/wiki/Linear_interpolation", 79 | "title": "Linear interpolation explained by Wikipedia" 80 | } 81 | ] 82 | } 83 | -------------------------------------------------------------------------------- /max.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "max", 3 | "summary": "Maximum value", 4 | "description": "Computes the largest value of an array of numbers, which is equal to the first element of a sorted (i.e., ordered) version of the array.\n\nAn array without non-`null` elements resolves always with `null`.", 5 | "categories": [ 6 | "math", 7 | "math > statistics", 8 | "reducer" 9 | ], 10 | "parameters": [ 11 | { 12 | "name": "data", 13 | "description": "An array of numbers.", 14 | "schema": { 15 | "type": "array", 16 | "items": { 17 | "type": [ 18 | "number", 19 | "null" 20 | ] 21 | } 22 | } 23 | }, 24 | { 25 | "name": "ignore_nodata", 26 | "description": "Indicates whether no-data values are ignored or not. Ignores them by default. Setting this flag to `false` considers no-data values so that `null` is returned if any value is such a value.", 27 | "schema": { 28 | "type": "boolean" 29 | }, 30 | "default": true, 31 | "optional": true 32 | } 33 | ], 34 | "returns": { 35 | "description": "The maximum value.", 36 | "schema": { 37 | "type": [ 38 | "number", 39 | "null" 40 | ] 41 | } 42 | }, 43 | "examples": [ 44 | { 45 | "arguments": { 46 | "data": [ 47 | 1, 48 | 0, 49 | 3, 50 | 2 51 | ] 52 | }, 53 | "returns": 3 54 | }, 55 | { 56 | "arguments": { 57 | "data": [ 58 | 5, 59 | 2.5, 60 | null, 61 | -0.7 62 | ] 63 | }, 64 | "returns": 5 65 | }, 66 | { 67 | "arguments": { 68 | "data": [ 69 | 1, 70 | 0, 71 | 3, 72 | null, 73 | 2 74 | ], 75 | "ignore_nodata": false 76 | }, 77 | "returns": null 78 | }, 79 | { 80 | "description": "The input array is empty: return `null`.", 81 | "arguments": { 82 | "data": [] 83 | }, 84 | "returns": null 85 | } 86 | ], 87 | "links": [ 88 | { 89 | "rel": "about", 90 | "href": "http://mathworld.wolfram.com/Maximum.html", 91 | "title": "Maximum explained by Wolfram MathWorld" 92 | } 93 | ] 94 | } -------------------------------------------------------------------------------- /proposals/run_udf_externally.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "run_udf_externally", 3 | "summary": "Run an externally hosted UDF container", 4 | "description": "Runs a compatible UDF container that is either externally hosted by a service provider or running on a local machine of the user. The UDF container must follow the [openEO UDF specification](https://openeo.org/documentation/1.0/udfs.html).\n\nThe referenced UDF service can be executed in several processes such as ``aggregate_spatial()``, ``apply()``, ``apply_dimension()`` and ``reduce_dimension()``. In this case, an array is passed instead of a data cube. The user must ensure that the data is given in a way that the UDF code can make sense of it.", 5 | "categories": [ 6 | "cubes", 7 | "import", 8 | "udf" 9 | ], 10 | "experimental": true, 11 | "parameters": [ 12 | { 13 | "name": "data", 14 | "description": "The data to be passed to the UDF.", 15 | "schema": [ 16 | { 17 | "title": "Array", 18 | "type": "array", 19 | "minItems": 1, 20 | "items": { 21 | "description": "Any data type." 22 | } 23 | }, 24 | { 25 | "title": "Single Value", 26 | "description": "A single value of any data type." 27 | } 28 | ] 29 | }, 30 | { 31 | "name": "url", 32 | "description": "Absolute URL to a remote UDF service.", 33 | "schema": { 34 | "type": "string", 35 | "format": "uri", 36 | "subtype": "uri", 37 | "pattern": "^https?://" 38 | } 39 | }, 40 | { 41 | "name": "context", 42 | "description": "Additional data such as configuration options to be passed to the UDF.", 43 | "schema": { 44 | "type": "object" 45 | }, 46 | "default": {}, 47 | "optional": true 48 | } 49 | ], 50 | "returns": { 51 | "description": "The data processed by the UDF. The returned value can in principle be of any data type, but it depends on what is returned by the UDF code. Please see the implemented UDF interface for details.", 52 | "schema": { 53 | "title": "Any", 54 | "description": "Any data type." 55 | } 56 | }, 57 | "links": [ 58 | { 59 | "rel": "about", 60 | "href": "https://openeo.org/documentation/1.0/udfs.html", 61 | "title": "openEO UDF specification" 62 | }, 63 | { 64 | "rel": "about", 65 | "href": "https://github.com/Open-EO/openeo-udf", 66 | "title": "openEO UDF repository" 67 | } 68 | ] 69 | } 70 | -------------------------------------------------------------------------------- /if.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "if", 3 | "summary": "If-Then-Else conditional", 4 | "description": "If the value passed is `true`, returns the value of the `accept` parameter, otherwise returns the value of the `reject` parameter.\n\nThis is basically an if-then-else construct as in other programming languages.", 5 | "categories": [ 6 | "logic", 7 | "comparison", 8 | "masks" 9 | ], 10 | "parameters": [ 11 | { 12 | "name": "value", 13 | "description": "A boolean value.", 14 | "schema": { 15 | "type": [ 16 | "boolean", 17 | "null" 18 | ] 19 | } 20 | }, 21 | { 22 | "name": "accept", 23 | "description": "A value that is returned if the boolean value is `true`.", 24 | "schema": { 25 | "description": "Any data type is allowed." 26 | } 27 | }, 28 | { 29 | "name": "reject", 30 | "description": "A value that is returned if the boolean value is **not** `true`. Defaults to `null`.", 31 | "schema": { 32 | "description": "Any data type is allowed." 33 | }, 34 | "default": null, 35 | "optional": true 36 | } 37 | ], 38 | "returns": { 39 | "description": "Either the `accept` or `reject` argument depending on the given boolean value.", 40 | "schema": { 41 | "description": "Any data type is allowed." 42 | } 43 | }, 44 | "examples": [ 45 | { 46 | "arguments": { 47 | "value": true, 48 | "accept": "A", 49 | "reject": "B" 50 | }, 51 | "returns": "A" 52 | }, 53 | { 54 | "arguments": { 55 | "value": null, 56 | "accept": "A", 57 | "reject": "B" 58 | }, 59 | "returns": "B" 60 | }, 61 | { 62 | "arguments": { 63 | "value": false, 64 | "accept": [ 65 | 1, 66 | 2, 67 | 3 68 | ], 69 | "reject": [ 70 | 4, 71 | 5, 72 | 6 73 | ] 74 | }, 75 | "returns": [ 76 | 4, 77 | 5, 78 | 6 79 | ] 80 | }, 81 | { 82 | "arguments": { 83 | "value": true, 84 | "accept": 123 85 | }, 86 | "returns": 123 87 | }, 88 | { 89 | "arguments": { 90 | "value": false, 91 | "accept": 1 92 | }, 93 | "returns": null 94 | } 95 | ] 96 | } -------------------------------------------------------------------------------- /normalized_difference.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "normalized_difference", 3 | "summary": "Normalized difference", 4 | "description": "Computes the normalized difference for two bands. The normalized difference is computed as *`(x - y) / (x + y)`*.\n\nThis process could be used for a number of remote sensing indices such as:\n\n* [NDVI](https://eos.com/ndvi/): `x` = NIR band, `y` = red band\n* [NDWI](https://eos.com/ndwi/): `x` = NIR band, `y` = SWIR band\n* [NDSI](https://eos.com/ndsi/): `x` = green band, `y` = SWIR band\n\nSome back-ends may have native processes such as ``ndvi()`` available for convenience.", 5 | "categories": [ 6 | "math > indices", 7 | "vegetation indices" 8 | ], 9 | "parameters": [ 10 | { 11 | "name": "x", 12 | "description": "The value for the first band.", 13 | "schema": { 14 | "type": "number" 15 | } 16 | }, 17 | { 18 | "name": "y", 19 | "description": "The value for the second band.", 20 | "schema": { 21 | "type": "number" 22 | } 23 | } 24 | ], 25 | "returns": { 26 | "description": "The computed normalized difference.", 27 | "schema": { 28 | "type": "number", 29 | "minimum": -1, 30 | "maximum": 1 31 | } 32 | }, 33 | "links": [ 34 | { 35 | "rel": "related", 36 | "href": "https://eos.com/ndvi/", 37 | "title": "NDVI explained by EOS" 38 | }, 39 | { 40 | "rel": "related", 41 | "href": "https://eos.com/ndwi/", 42 | "title": "NDWI explained by EOS" 43 | }, 44 | { 45 | "rel": "related", 46 | "href": "https://eos.com/ndsi/", 47 | "title": "NDSI explained by EOS" 48 | } 49 | ], 50 | "process_graph": { 51 | "subtract": { 52 | "process_id": "subtract", 53 | "arguments": { 54 | "x": { 55 | "from_parameter": "x" 56 | }, 57 | "y": { 58 | "from_parameter": "y" 59 | } 60 | } 61 | }, 62 | "add": { 63 | "process_id": "add", 64 | "arguments": { 65 | "x": { 66 | "from_parameter": "x" 67 | }, 68 | "y": { 69 | "from_parameter": "y" 70 | } 71 | } 72 | }, 73 | "divide": { 74 | "process_id": "divide", 75 | "arguments": { 76 | "x": { 77 | "from_node": "subtract" 78 | }, 79 | "y": { 80 | "from_node": "add" 81 | } 82 | }, 83 | "result": true 84 | } 85 | } 86 | } -------------------------------------------------------------------------------- /multiply.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "multiply", 3 | "summary": "Multiplication of two numbers", 4 | "description": "Multiplies the two numbers `x` and `y` (*`x * y`*) and returns the computed product.\n\nNo-data values are taken into account so that `null` is returned if any element is such a value.\n\nThe computations follow [IEEE Standard 754](https://ieeexplore.ieee.org/document/8766229) whenever the processing environment supports it.", 5 | "categories": [ 6 | "math" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "x", 11 | "description": "The multiplier.", 12 | "schema": { 13 | "type": [ 14 | "number", 15 | "null" 16 | ] 17 | } 18 | }, 19 | { 20 | "name": "y", 21 | "description": "The multiplicand.", 22 | "schema": { 23 | "type": [ 24 | "number", 25 | "null" 26 | ] 27 | } 28 | } 29 | ], 30 | "returns": { 31 | "description": "The computed product of the two numbers.", 32 | "schema": { 33 | "type": [ 34 | "number", 35 | "null" 36 | ] 37 | } 38 | }, 39 | "exceptions": { 40 | "MultiplicandMissing": { 41 | "message": "Multiplication requires at least two numbers." 42 | } 43 | }, 44 | "examples": [ 45 | { 46 | "arguments": { 47 | "x": 5, 48 | "y": 2.5 49 | }, 50 | "returns": 12.5 51 | }, 52 | { 53 | "arguments": { 54 | "x": -2, 55 | "y": -4 56 | }, 57 | "returns": 8 58 | }, 59 | { 60 | "arguments": { 61 | "x": 1, 62 | "y": null 63 | }, 64 | "returns": null 65 | } 66 | ], 67 | "links": [ 68 | { 69 | "rel": "about", 70 | "href": "http://mathworld.wolfram.com/Product.html", 71 | "title": "Product explained by Wolfram MathWorld" 72 | }, 73 | { 74 | "rel": "about", 75 | "href": "https://ieeexplore.ieee.org/document/8766229", 76 | "title": "IEEE Standard 754-2019 for Floating-Point Arithmetic" 77 | } 78 | ], 79 | "process_graph": { 80 | "product": { 81 | "process_id": "product", 82 | "arguments": { 83 | "data": [ 84 | { 85 | "from_parameter": "x" 86 | }, 87 | { 88 | "from_parameter": "y" 89 | } 90 | ], 91 | "ignore_nodata": false 92 | }, 93 | "result": true 94 | } 95 | } 96 | } -------------------------------------------------------------------------------- /text_contains.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "text_contains", 3 | "summary": "Text contains another text", 4 | "description": "Checks whether the text (also known as *string*) specified for `data` contains the text specified for `pattern`. Both are expected to be encoded in UTF-8 by default. The no-data value `null` is passed through and therefore gets propagated.", 5 | "categories": [ 6 | "texts", 7 | "comparison" 8 | ], 9 | "parameters": [ 10 | { 11 | "name": "data", 12 | "description": "Text in which to find something in.", 13 | "schema": { 14 | "type": [ 15 | "string", 16 | "null" 17 | ] 18 | } 19 | }, 20 | { 21 | "name": "pattern", 22 | "description": "Text to find in `data`. Regular expressions are not supported.", 23 | "schema": { 24 | "type": "string" 25 | } 26 | }, 27 | { 28 | "name": "case_sensitive", 29 | "description": "Case sensitive comparison can be disabled by setting this parameter to `false`.", 30 | "schema": { 31 | "type": "boolean" 32 | }, 33 | "default": true, 34 | "optional": true 35 | } 36 | ], 37 | "returns": { 38 | "description": "`true` if `data` contains the `pattern`, false` otherwise.", 39 | "schema": { 40 | "type": [ 41 | "boolean", 42 | "null" 43 | ] 44 | } 45 | }, 46 | "examples": [ 47 | { 48 | "arguments": { 49 | "data": "Lorem ipsum dolor sit amet", 50 | "pattern": "openEO" 51 | }, 52 | "returns": false 53 | }, 54 | { 55 | "arguments": { 56 | "data": "Lorem ipsum dolor sit amet", 57 | "pattern": "ipsum dolor" 58 | }, 59 | "returns": true 60 | }, 61 | { 62 | "arguments": { 63 | "data": "Lorem ipsum dolor sit amet", 64 | "pattern": "Ipsum Dolor" 65 | }, 66 | "returns": false 67 | }, 68 | { 69 | "arguments": { 70 | "data": "Lorem ipsum dolor sit amet", 71 | "pattern": "SIT", 72 | "case_sensitive": false 73 | }, 74 | "returns": true 75 | }, 76 | { 77 | "arguments": { 78 | "data": "ÄÖÜ", 79 | "pattern": "ö", 80 | "case_sensitive": false 81 | }, 82 | "returns": true 83 | }, 84 | { 85 | "arguments": { 86 | "data": null, 87 | "pattern": "null" 88 | }, 89 | "returns": null 90 | } 91 | ] 92 | } 93 | -------------------------------------------------------------------------------- /text_ends.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "text_ends", 3 | "summary": "Text ends with another text", 4 | "description": "Checks whether the text (also known as *string*) specified for `data` contains the text specified for `pattern` at the end. Both are expected to be encoded in UTF-8 by default. The no-data value `null` is passed through and therefore gets propagated.", 5 | "categories": [ 6 | "texts", 7 | "comparison" 8 | ], 9 | "parameters": [ 10 | { 11 | "name": "data", 12 | "description": "Text in which to find something at the end.", 13 | "schema": { 14 | "type": [ 15 | "string", 16 | "null" 17 | ] 18 | } 19 | }, 20 | { 21 | "name": "pattern", 22 | "description": "Text to find at the end of `data`. Regular expressions are not supported.", 23 | "schema": { 24 | "type": "string" 25 | } 26 | }, 27 | { 28 | "name": "case_sensitive", 29 | "description": "Case sensitive comparison can be disabled by setting this parameter to `false`.", 30 | "schema": { 31 | "type": "boolean" 32 | }, 33 | "default": true, 34 | "optional": true 35 | } 36 | ], 37 | "returns": { 38 | "description": "`true` if `data` ends with `pattern`, false` otherwise.", 39 | "schema": { 40 | "type": [ 41 | "boolean", 42 | "null" 43 | ] 44 | } 45 | }, 46 | "examples": [ 47 | { 48 | "arguments": { 49 | "data": "Lorem ipsum dolor sit amet", 50 | "pattern": "amet" 51 | }, 52 | "returns": true 53 | }, 54 | { 55 | "arguments": { 56 | "data": "Lorem ipsum dolor sit amet", 57 | "pattern": "AMET" 58 | }, 59 | "returns": false 60 | }, 61 | { 62 | "arguments": { 63 | "data": "Lorem ipsum dolor sit amet", 64 | "pattern": "Lorem" 65 | }, 66 | "returns": false 67 | }, 68 | { 69 | "arguments": { 70 | "data": "Lorem ipsum dolor sit amet", 71 | "pattern": "AMET", 72 | "case_sensitive": false 73 | }, 74 | "returns": true 75 | }, 76 | { 77 | "arguments": { 78 | "data": "Ä", 79 | "pattern": "ä", 80 | "case_sensitive": false 81 | }, 82 | "returns": true 83 | }, 84 | { 85 | "arguments": { 86 | "data": null, 87 | "pattern": "null" 88 | }, 89 | "returns": null 90 | } 91 | ] 92 | } 93 | -------------------------------------------------------------------------------- /array_create.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "array_create", 3 | "summary": "Create an array", 4 | "description": "Creates a new array, which by default is empty.\n\nThe second parameter `repeat` allows to add the given array multiple times to the new array.\n\nIn most cases you can simply pass a (native) array to processes directly, but this process is especially useful to create a new array that is getting returned by a child process, for example in ``apply_dimension()``.", 5 | "categories": [ 6 | "arrays" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "data", 11 | "description": "A (native) array to fill the newly created array with. Defaults to an empty array.", 12 | "optional": true, 13 | "default": [], 14 | "schema": { 15 | "type": "array", 16 | "items": { 17 | "description": "Any data type is allowed." 18 | } 19 | } 20 | }, 21 | { 22 | "name": "repeat", 23 | "description": "The number of times the (native) array specified in `data` is repeatedly added after each other to the new array being created. Defaults to `1`.", 24 | "optional": true, 25 | "default": 1, 26 | "schema": { 27 | "type": "integer", 28 | "minimum": 1 29 | } 30 | } 31 | ], 32 | "returns": { 33 | "description": "The newly created array.", 34 | "schema": { 35 | "type": "array", 36 | "items": { 37 | "description": "Any data type is allowed." 38 | } 39 | } 40 | }, 41 | "examples": [ 42 | { 43 | "arguments": {}, 44 | "returns": [] 45 | }, 46 | { 47 | "arguments": { 48 | "data": [ 49 | "this", 50 | "is", 51 | "a", 52 | "test" 53 | ] 54 | }, 55 | "returns": [ 56 | "this", 57 | "is", 58 | "a", 59 | "test" 60 | ] 61 | }, 62 | { 63 | "arguments": { 64 | "data": [ 65 | null 66 | ], 67 | "repeat": 3 68 | }, 69 | "returns": [ 70 | null, 71 | null, 72 | null 73 | ] 74 | }, 75 | { 76 | "arguments": { 77 | "data": [ 78 | 1, 79 | 2, 80 | 3 81 | ], 82 | "repeat": 2 83 | }, 84 | "returns": [ 85 | 1, 86 | 2, 87 | 3, 88 | 1, 89 | 2, 90 | 3 91 | ] 92 | } 93 | ] 94 | } 95 | -------------------------------------------------------------------------------- /text_begins.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "text_begins", 3 | "summary": "Text begins with another text", 4 | "description": "Checks whether the text (also known as *string*) specified for `data` contains the text specified for `pattern` at the beginning. Both are expected to be encoded in UTF-8 by default. The no-data value `null` is passed through and therefore gets propagated.", 5 | "categories": [ 6 | "texts", 7 | "comparison" 8 | ], 9 | "parameters": [ 10 | { 11 | "name": "data", 12 | "description": "Text in which to find something at the beginning.", 13 | "schema": { 14 | "type": [ 15 | "string", 16 | "null" 17 | ] 18 | } 19 | }, 20 | { 21 | "name": "pattern", 22 | "description": "Text to find at the beginning of `data`. Regular expressions are not supported.", 23 | "schema": { 24 | "type": "string" 25 | } 26 | }, 27 | { 28 | "name": "case_sensitive", 29 | "description": "Case sensitive comparison can be disabled by setting this parameter to `false`.", 30 | "schema": { 31 | "type": "boolean" 32 | }, 33 | "default": true, 34 | "optional": true 35 | } 36 | ], 37 | "returns": { 38 | "description": "`true` if `data` begins with `pattern`, false` otherwise.", 39 | "schema": { 40 | "type": [ 41 | "boolean", 42 | "null" 43 | ] 44 | } 45 | }, 46 | "examples": [ 47 | { 48 | "arguments": { 49 | "data": "Lorem ipsum dolor sit amet", 50 | "pattern": "amet" 51 | }, 52 | "returns": false 53 | }, 54 | { 55 | "arguments": { 56 | "data": "Lorem ipsum dolor sit amet", 57 | "pattern": "Lorem" 58 | }, 59 | "returns": true 60 | }, 61 | { 62 | "arguments": { 63 | "data": "Lorem ipsum dolor sit amet", 64 | "pattern": "lorem" 65 | }, 66 | "returns": false 67 | }, 68 | { 69 | "arguments": { 70 | "data": "Lorem ipsum dolor sit amet", 71 | "pattern": "lorem", 72 | "case_sensitive": false 73 | }, 74 | "returns": true 75 | }, 76 | { 77 | "arguments": { 78 | "data": "Ä", 79 | "pattern": "ä", 80 | "case_sensitive": false 81 | }, 82 | "returns": true 83 | }, 84 | { 85 | "arguments": { 86 | "data": null, 87 | "pattern": "null" 88 | }, 89 | "returns": null 90 | } 91 | ] 92 | } 93 | -------------------------------------------------------------------------------- /apply.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "apply", 3 | "summary": "Apply a process to each value", 4 | "description": "Applies a process to each value in the data cube (i.e. a local operation). In contrast, the process ``apply_dimension()`` applies a process to all values along a particular dimension.", 5 | "categories": [ 6 | "cubes" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "data", 11 | "description": "A data cube.", 12 | "schema": { 13 | "type": "object", 14 | "subtype": "datacube" 15 | } 16 | }, 17 | { 18 | "name": "process", 19 | "description": "A process that accepts and returns a single value and is applied on each individual value in the data cube. The process may consist of multiple sub-processes and could, for example, consist of processes such as ``absolute()`` or ``linear_scale_range()``.", 20 | "schema": { 21 | "type": "object", 22 | "subtype": "process-graph", 23 | "parameters": [ 24 | { 25 | "name": "x", 26 | "description": "The value to process.", 27 | "schema": { 28 | "description": "Any data type." 29 | } 30 | }, 31 | { 32 | "name": "context", 33 | "description": "Additional data passed by the user.", 34 | "schema": { 35 | "description": "Any data type." 36 | }, 37 | "optional": true, 38 | "default": null 39 | } 40 | ], 41 | "returns": { 42 | "description": "The value to be set in the new data cube.", 43 | "schema": { 44 | "description": "Any data type." 45 | } 46 | } 47 | } 48 | }, 49 | { 50 | "name": "context", 51 | "description": "Additional data to be passed to the process.", 52 | "schema": { 53 | "description": "Any data type." 54 | }, 55 | "optional": true, 56 | "default": null 57 | } 58 | ], 59 | "returns": { 60 | "description": "A data cube with the newly computed values and the same dimensions. The dimension properties (name, type, labels, reference system and resolution) remain unchanged.", 61 | "schema": { 62 | "type": "object", 63 | "subtype": "datacube" 64 | } 65 | }, 66 | "links": [ 67 | { 68 | "href": "https://openeo.org/documentation/1.0/datacubes.html#apply", 69 | "rel": "about", 70 | "title": "Apply explained in the openEO documentation" 71 | } 72 | ] 73 | } 74 | -------------------------------------------------------------------------------- /lt.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "lt", 3 | "summary": "Less than comparison", 4 | "description": "Compares whether `x` is strictly less than `y`.\n\n**Remarks:**\n\n* If any operand is `null`, the return value is `null`.\n* If any operand is not a `number`, the process returns `false`.\n* Temporal strings are normal strings. To compare temporal strings as dates/times, use ``date_difference()``.", 5 | "categories": [ 6 | "comparison" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "x", 11 | "description": "First operand.", 12 | "schema": { 13 | "type": [ 14 | "number", 15 | "boolean", 16 | "string", 17 | "null" 18 | ] 19 | } 20 | }, 21 | { 22 | "name": "y", 23 | "description": "Second operand.", 24 | "schema": { 25 | "type": [ 26 | "number", 27 | "boolean", 28 | "string", 29 | "null" 30 | ] 31 | } 32 | } 33 | ], 34 | "returns": { 35 | "description": "`true` if `x` is strictly less than `y`, `null` if any operand is `null`, otherwise `false`.", 36 | "schema": { 37 | "type": [ 38 | "boolean", 39 | "null" 40 | ] 41 | } 42 | }, 43 | "examples": [ 44 | { 45 | "arguments": { 46 | "x": 1, 47 | "y": null 48 | }, 49 | "returns": null 50 | }, 51 | { 52 | "arguments": { 53 | "x": 0, 54 | "y": 0 55 | }, 56 | "returns": false 57 | }, 58 | { 59 | "arguments": { 60 | "x": 1, 61 | "y": 2 62 | }, 63 | "returns": true 64 | }, 65 | { 66 | "arguments": { 67 | "x": -0.5, 68 | "y": -0.6 69 | }, 70 | "returns": false 71 | }, 72 | { 73 | "arguments": { 74 | "x": "2018-01-01T00:00:00Z", 75 | "y": "2018-01-02T00:00:00Z" 76 | }, 77 | "returns": false 78 | }, 79 | { 80 | "arguments": { 81 | "x": 0, 82 | "y": true 83 | }, 84 | "returns": false 85 | }, 86 | { 87 | "arguments": { 88 | "x": false, 89 | "y": true 90 | }, 91 | "returns": false 92 | }, 93 | { 94 | "arguments": { 95 | "x": null, 96 | "y": null 97 | }, 98 | "returns": null 99 | } 100 | ] 101 | } 102 | -------------------------------------------------------------------------------- /mod.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "mod", 3 | "summary": "Modulo", 4 | "description": "Remainder after a division of `x` by `y` for both integers and floating-point numbers.\n\nThe result of a modulo operation has the sign of the divisor. The handling regarding the sign of the result [differs between programming languages](https://en.wikipedia.org/wiki/Modulo_operation#In_programming_languages) and needs careful consideration to avoid unexpected results.\n\nThe no-data value `null` is passed through and therefore gets propagated if any of the arguments is `null`. A modulo by zero results in ±infinity if the processing environment supports it. Otherwise, a `DivisionByZero` exception must the thrown.", 5 | "categories": [ 6 | "math" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "x", 11 | "description": "A number to be used as the dividend.", 12 | "schema": { 13 | "type": [ 14 | "number", 15 | "null" 16 | ] 17 | } 18 | }, 19 | { 20 | "name": "y", 21 | "description": "A number to be used as the divisor.", 22 | "schema": { 23 | "type": [ 24 | "number", 25 | "null" 26 | ] 27 | } 28 | } 29 | ], 30 | "returns": { 31 | "description": "The remainder after division.", 32 | "schema": { 33 | "type": [ 34 | "number", 35 | "null" 36 | ] 37 | } 38 | }, 39 | "exceptions": { 40 | "DivisionByZero": { 41 | "message": "Division by zero is not supported." 42 | } 43 | }, 44 | "examples": [ 45 | { 46 | "arguments": { 47 | "x": 27, 48 | "y": 5 49 | }, 50 | "returns": 2 51 | }, 52 | { 53 | "arguments": { 54 | "x": -27, 55 | "y": 5 56 | }, 57 | "returns": 3 58 | }, 59 | { 60 | "arguments": { 61 | "x": 3.14, 62 | "y": -2 63 | }, 64 | "returns": -0.86 65 | }, 66 | { 67 | "arguments": { 68 | "x": -27, 69 | "y": -5 70 | }, 71 | "returns": -2 72 | }, 73 | { 74 | "arguments": { 75 | "x": 27, 76 | "y": null 77 | }, 78 | "returns": null 79 | }, 80 | { 81 | "arguments": { 82 | "x": null, 83 | "y": 5 84 | }, 85 | "returns": null 86 | } 87 | ], 88 | "links": [ 89 | { 90 | "rel": "about", 91 | "href": "https://en.wikipedia.org/wiki/Modulo_operation", 92 | "title": "Modulo explained by Wikipedia" 93 | } 94 | ] 95 | } -------------------------------------------------------------------------------- /gt.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "gt", 3 | "summary": "Greater than comparison", 4 | "description": "Compares whether `x` is strictly greater than `y`.\n\n**Remarks:**\n\n* If any operand is `null`, the return value is `null`.\n* If any operand is not a `number`, the process returns `false`.\n* Temporal strings are normal strings. To compare temporal strings as dates/times, use ``date_difference()``.", 5 | "categories": [ 6 | "comparison" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "x", 11 | "description": "First operand.", 12 | "schema": { 13 | "type": [ 14 | "number", 15 | "boolean", 16 | "string", 17 | "null" 18 | ] 19 | } 20 | }, 21 | { 22 | "name": "y", 23 | "description": "Second operand.", 24 | "schema": { 25 | "type": [ 26 | "number", 27 | "boolean", 28 | "string", 29 | "null" 30 | ] 31 | } 32 | } 33 | ], 34 | "returns": { 35 | "description": "`true` if `x` is strictly greater than `y` or `null` if any operand is `null`, otherwise `false`.", 36 | "schema": { 37 | "type": [ 38 | "boolean", 39 | "null" 40 | ] 41 | } 42 | }, 43 | "examples": [ 44 | { 45 | "arguments": { 46 | "x": 1, 47 | "y": null 48 | }, 49 | "returns": null 50 | }, 51 | { 52 | "arguments": { 53 | "x": 0, 54 | "y": 0 55 | }, 56 | "returns": false 57 | }, 58 | { 59 | "arguments": { 60 | "x": 2, 61 | "y": 1 62 | }, 63 | "returns": true 64 | }, 65 | { 66 | "arguments": { 67 | "x": -0.5, 68 | "y": -0.6 69 | }, 70 | "returns": true 71 | }, 72 | { 73 | "arguments": { 74 | "x": "2018-01-02T00:00:00Z", 75 | "y": "2018-01-01T00:00:00Z" 76 | }, 77 | "returns": false 78 | }, 79 | { 80 | "arguments": { 81 | "x": true, 82 | "y": 0 83 | }, 84 | "returns": false 85 | }, 86 | { 87 | "arguments": { 88 | "x": true, 89 | "y": false 90 | }, 91 | "returns": false 92 | }, 93 | { 94 | "arguments": { 95 | "x": null, 96 | "y": null 97 | }, 98 | "returns": null 99 | } 100 | ] 101 | } 102 | -------------------------------------------------------------------------------- /sgn.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "sgn", 3 | "summary": "Signum", 4 | "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*\n\nThe no-data value `null` is passed through and therefore gets propagated.", 5 | "categories": [ 6 | "math" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "x", 11 | "description": "A number.", 12 | "schema": { 13 | "type": [ 14 | "number", 15 | "null" 16 | ] 17 | } 18 | } 19 | ], 20 | "returns": { 21 | "description": "The computed signum value of `x`.", 22 | "schema": { 23 | "type": [ 24 | "number", 25 | "null" 26 | ] 27 | } 28 | }, 29 | "examples": [ 30 | { 31 | "arguments": { 32 | "x": -2 33 | }, 34 | "returns": -1 35 | }, 36 | { 37 | "arguments": { 38 | "x": 3.5 39 | }, 40 | "returns": 1 41 | }, 42 | { 43 | "arguments": { 44 | "x": 0 45 | }, 46 | "returns": 0 47 | }, 48 | { 49 | "arguments": { 50 | "x": null 51 | }, 52 | "returns": null 53 | } 54 | ], 55 | "links": [ 56 | { 57 | "rel": "about", 58 | "href": "http://mathworld.wolfram.com/Sign.html", 59 | "title": "Sign explained by Wolfram MathWorld" 60 | } 61 | ], 62 | "process_graph": { 63 | "gt0": { 64 | "process_id": "gt", 65 | "arguments": { 66 | "x": { 67 | "from_parameter": "x" 68 | }, 69 | "y": 0 70 | } 71 | }, 72 | "lt0": { 73 | "process_id": "lt", 74 | "arguments": { 75 | "x": { 76 | "from_parameter": "x" 77 | }, 78 | "y": 0 79 | } 80 | }, 81 | "if_gt0": { 82 | "process_id": "if", 83 | "arguments": { 84 | "value": { 85 | "from_node": "gt0" 86 | }, 87 | "accept": 1, 88 | "reject": { 89 | "from_parameter": "x" 90 | } 91 | } 92 | }, 93 | "if_lt0": { 94 | "process_id": "if", 95 | "arguments": { 96 | "value": { 97 | "from_node": "lt0" 98 | }, 99 | "accept": -1, 100 | "reject": { 101 | "from_node": "if_gt0" 102 | } 103 | }, 104 | "result": true 105 | } 106 | } 107 | } -------------------------------------------------------------------------------- /proposals/filter_vector.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "filter_vector", 3 | "summary": "Spatial vector filter using geometries", 4 | "description": "Limits the vector data cube to the specified geometries. The process works on geometries as defined in the Simple Features standard by the OGC. All geometries that were empty or become empty will be removed from the data cube. Alternatively, use ``filter_bbox()`` to filter by bounding box.", 5 | "categories": [ 6 | "cubes", 7 | "filter", 8 | "vector" 9 | ], 10 | "experimental": true, 11 | "parameters": [ 12 | { 13 | "name": "data", 14 | "description": "A vector data cube with the candidate geometries.", 15 | "schema": { 16 | "type": "object", 17 | "subtype": "datacube", 18 | "dimensions": [ 19 | { 20 | "type": "geometry" 21 | } 22 | ] 23 | } 24 | }, 25 | { 26 | "name": "geometries", 27 | "description": "One or more base geometries used for filtering, given as vector data cube. If multiple base geometries are provided, the union of them is used.", 28 | "schema": { 29 | "type": "object", 30 | "subtype": "datacube", 31 | "dimensions": [ 32 | { 33 | "type": "geometry" 34 | } 35 | ] 36 | } 37 | }, 38 | { 39 | "name": "relation", 40 | "description": "The spatial filter predicate for comparing the geometries provided through (a) `geometries` (base geometries) and (b) `data` (candidate geometries).", 41 | "schema": { 42 | "type": "string", 43 | "enum": [ 44 | "intersects", 45 | "disjoint", 46 | "equals", 47 | "touches", 48 | "crosses", 49 | "overlaps", 50 | "contains", 51 | "within" 52 | ] 53 | }, 54 | "optional": true, 55 | "default": "intersects" 56 | } 57 | ], 58 | "returns": { 59 | "description": "A vector data cube restricted to the specified geometries. The dimensions and dimension properties (name, type, labels, reference system and resolution) remain unchanged, except that the geometries dimension has less (or the same) dimension labels.", 60 | "schema": { 61 | "type": "object", 62 | "subtype": "datacube", 63 | "dimensions": [ 64 | { 65 | "type": "geometry" 66 | } 67 | ] 68 | } 69 | }, 70 | "links": [ 71 | { 72 | "href": "https://openeo.org/documentation/1.0/datacubes.html#filter", 73 | "rel": "about", 74 | "title": "Filters explained in the openEO documentation" 75 | }, 76 | { 77 | "href": "http://www.opengeospatial.org/standards/sfa", 78 | "rel": "about", 79 | "title": "Simple Features standard by the OGC" 80 | } 81 | ] 82 | } 83 | -------------------------------------------------------------------------------- /proposals/cumsum.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "cumsum", 3 | "summary": "Cumulative sums", 4 | "description": "Computes cumulative sums of an array of numbers. Every computed element is equal to the sum of current and all previous values. The returned array and the input array have always the same length.\n\nBy default, no-data values are skipped, but stay in the result. Setting the `ignore_nodata` flag to `true` makes that once a no-data value (`null`) is reached all following elements are set to `null` in the result.", 5 | "categories": [ 6 | "math > cumulative" 7 | ], 8 | "experimental": true, 9 | "parameters": [ 10 | { 11 | "name": "data", 12 | "description": "An array of numbers.", 13 | "schema": { 14 | "type": "array", 15 | "items": { 16 | "type": [ 17 | "number", 18 | "null" 19 | ] 20 | } 21 | } 22 | }, 23 | { 24 | "name": "ignore_nodata", 25 | "description": "Indicates whether no-data values are ignored or not and ignores them by default. Setting this flag to `false` considers no-data values so that `null` is set for all the following elements.", 26 | "schema": { 27 | "type": "boolean" 28 | }, 29 | "default": true, 30 | "optional": true 31 | } 32 | ], 33 | "returns": { 34 | "description": "An array with the computed cumulative sums.", 35 | "schema": { 36 | "type": "array", 37 | "items": { 38 | "type": [ 39 | "number", 40 | "null" 41 | ] 42 | } 43 | } 44 | }, 45 | "examples": [ 46 | { 47 | "arguments": { 48 | "data": [ 49 | 1, 50 | 3, 51 | 5, 52 | 3, 53 | 1 54 | ] 55 | }, 56 | "returns": [ 57 | 1, 58 | 4, 59 | 9, 60 | 12, 61 | 13 62 | ] 63 | }, 64 | { 65 | "arguments": { 66 | "data": [ 67 | 1, 68 | 3, 69 | null, 70 | 3, 71 | 1 72 | ] 73 | }, 74 | "returns": [ 75 | 1, 76 | 4, 77 | null, 78 | 7, 79 | 8 80 | ] 81 | }, 82 | { 83 | "arguments": { 84 | "data": [ 85 | 1, 86 | 3, 87 | null, 88 | 3, 89 | 1 90 | ], 91 | "ignore_nodata": false 92 | }, 93 | "returns": [ 94 | 1, 95 | 4, 96 | null, 97 | null, 98 | null 99 | ] 100 | } 101 | ] 102 | } -------------------------------------------------------------------------------- /save_result.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "save_result", 3 | "summary": "Save processed data", 4 | "description": "Makes the processed data available in the given file format to the corresponding medium that is relevant for the context this processes is applied in:\n\n* For **batch jobs** the data is stored on the back-end. STAC-compatible metadata is usually made available with the processed data.\n* For **synchronous processing** the data is sent to the client as a direct response to the request.\n* **Secondary web services** are provided with the processed data so that it can make use of it (e.g., visualize it). Web service may require the data in a certain format. Please refer to the documentation of the individual service types for details.", 5 | "categories": [ 6 | "cubes", 7 | "export" 8 | ], 9 | "parameters": [ 10 | { 11 | "name": "data", 12 | "description": "The data to deliver in the given file format.", 13 | "schema": { 14 | "type": "object", 15 | "subtype": "datacube" 16 | } 17 | }, 18 | { 19 | "name": "format", 20 | "description": "The file format to use. It must be one of the values that the server reports as supported output file formats, which usually correspond to the short GDAL/OGR codes. This parameter is *case insensitive*.\n\n* If the data cube is empty and the file format can't store empty data cubes, a `DataCubeEmpty` exception is thrown.\n* If the file format is otherwise not suitable for storing the underlying data structure, a `FormatUnsuitable` exception is thrown.", 21 | "schema": { 22 | "type": "string", 23 | "subtype": "output-format" 24 | } 25 | }, 26 | { 27 | "name": "options", 28 | "description": "The file format parameters to be used to create the file(s). Must correspond to the parameters that the server reports as supported parameters for the chosen `format`. The parameter names and valid values usually correspond to the GDAL/OGR format options.", 29 | "schema": { 30 | "type": "object", 31 | "subtype": "output-format-options" 32 | }, 33 | "default": {}, 34 | "optional": true 35 | } 36 | ], 37 | "returns": { 38 | "description": "Always returns `true` as in case of an error an exception is thrown which aborts the execution of the process.", 39 | "schema": { 40 | "type": "boolean", 41 | "const": true 42 | } 43 | }, 44 | "exceptions": { 45 | "FormatUnsuitable": { 46 | "message": "Data can't be transformed into the requested output format." 47 | }, 48 | "DataCubeEmpty": { 49 | "message": "The file format doesn't support storing empty data cubes." 50 | } 51 | }, 52 | "links": [ 53 | { 54 | "rel": "about", 55 | "href": "https://gdal.org/drivers/raster/index.html", 56 | "title": "GDAL Raster Formats" 57 | }, 58 | { 59 | "rel": "about", 60 | "href": "https://gdal.org/drivers/vector/index.html", 61 | "title": "OGR Vector Formats" 62 | } 63 | ] 64 | } 65 | -------------------------------------------------------------------------------- /proposals/cummax.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "cummax", 3 | "summary": "Cumulative maxima", 4 | "description": "Finds cumulative maxima of an array of numbers. Every computed element is equal to the bigger one between the current element and the previously computed element. The returned array and the input array have always the same length.\n\nBy default, no-data values are skipped, but stay in the result. Setting the `ignore_nodata` flag to `true` makes that once a no-data value (`null`) is reached all following elements are set to `null` in the result.", 5 | "categories": [ 6 | "math > cumulative" 7 | ], 8 | "experimental": true, 9 | "parameters": [ 10 | { 11 | "name": "data", 12 | "description": "An array of numbers.", 13 | "schema": { 14 | "type": "array", 15 | "items": { 16 | "type": [ 17 | "number", 18 | "null" 19 | ] 20 | } 21 | } 22 | }, 23 | { 24 | "name": "ignore_nodata", 25 | "description": "Indicates whether no-data values are ignored or not and ignores them by default. Setting this flag to `false` considers no-data values so that `null` is set for all the following elements.", 26 | "schema": { 27 | "type": "boolean" 28 | }, 29 | "default": true, 30 | "optional": true 31 | } 32 | ], 33 | "returns": { 34 | "description": "An array with the computed cumulative maxima.", 35 | "schema": { 36 | "type": "array", 37 | "items": { 38 | "type": [ 39 | "number", 40 | "null" 41 | ] 42 | } 43 | } 44 | }, 45 | "examples": [ 46 | { 47 | "arguments": { 48 | "data": [ 49 | 1, 50 | 3, 51 | 5, 52 | 3, 53 | 1 54 | ] 55 | }, 56 | "returns": [ 57 | 1, 58 | 3, 59 | 5, 60 | 5, 61 | 5 62 | ] 63 | }, 64 | { 65 | "arguments": { 66 | "data": [ 67 | 1, 68 | 3, 69 | null, 70 | 5, 71 | 1 72 | ] 73 | }, 74 | "returns": [ 75 | 1, 76 | 3, 77 | null, 78 | 5, 79 | 5 80 | ] 81 | }, 82 | { 83 | "arguments": { 84 | "data": [ 85 | 1, 86 | 3, 87 | null, 88 | 5, 89 | 1 90 | ], 91 | "ignore_nodata": false 92 | }, 93 | "returns": [ 94 | 1, 95 | 3, 96 | null, 97 | null, 98 | null 99 | ] 100 | } 101 | ] 102 | } -------------------------------------------------------------------------------- /proposals/cummin.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "cummin", 3 | "summary": "Cumulative minima", 4 | "description": "Finds cumulative minima of an array of numbers. Every computed element is equal to the smaller one between the current element and the previously computed element. The returned array and the input array have always the same length.\n\nBy default, no-data values are skipped, but stay in the result. Setting the `ignore_nodata` flag to `true` makes that once a no-data value (`null`) is reached all following elements are set to `null` in the result.", 5 | "categories": [ 6 | "math > cumulative" 7 | ], 8 | "experimental": true, 9 | "parameters": [ 10 | { 11 | "name": "data", 12 | "description": "An array of numbers.", 13 | "schema": { 14 | "type": "array", 15 | "items": { 16 | "type": [ 17 | "number", 18 | "null" 19 | ] 20 | } 21 | } 22 | }, 23 | { 24 | "name": "ignore_nodata", 25 | "description": "Indicates whether no-data values are ignored or not and ignores them by default. Setting this flag to `false` considers no-data values so that `null` is set for all the following elements.", 26 | "schema": { 27 | "type": "boolean" 28 | }, 29 | "default": true, 30 | "optional": true 31 | } 32 | ], 33 | "returns": { 34 | "description": "An array with the computed cumulative minima.", 35 | "schema": { 36 | "type": "array", 37 | "items": { 38 | "type": [ 39 | "number", 40 | "null" 41 | ] 42 | } 43 | } 44 | }, 45 | "examples": [ 46 | { 47 | "arguments": { 48 | "data": [ 49 | 5, 50 | 3, 51 | 1, 52 | 3, 53 | 5 54 | ] 55 | }, 56 | "returns": [ 57 | 5, 58 | 3, 59 | 1, 60 | 1, 61 | 1 62 | ] 63 | }, 64 | { 65 | "arguments": { 66 | "data": [ 67 | 5, 68 | 3, 69 | null, 70 | 1, 71 | 5 72 | ] 73 | }, 74 | "returns": [ 75 | 5, 76 | 3, 77 | null, 78 | 1, 79 | 1 80 | ] 81 | }, 82 | { 83 | "arguments": { 84 | "data": [ 85 | 5, 86 | 3, 87 | null, 88 | 1, 89 | 5 90 | ], 91 | "ignore_nodata": false 92 | }, 93 | "returns": [ 94 | 5, 95 | 3, 96 | null, 97 | null, 98 | null 99 | ] 100 | } 101 | ] 102 | } -------------------------------------------------------------------------------- /rearrange.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "rearrange", 3 | "summary": "Sort an array based on a permutation", 4 | "description": "Rearranges an array based on a ranked list of element positions in the original list (i.e., a permutation). The positions must be zero-based. The process ``order()`` can compute such a permutation.", 5 | "categories": [ 6 | "arrays", 7 | "sorting" 8 | ], 9 | "parameters": [ 10 | { 11 | "name": "data", 12 | "description": "The array to rearrange.", 13 | "schema": { 14 | "type": "array", 15 | "items": { 16 | "description": "Any data type is allowed." 17 | } 18 | } 19 | }, 20 | { 21 | "name": "order", 22 | "description": "The permutation used for rearranging.", 23 | "schema": { 24 | "type": "array", 25 | "items": { 26 | "type": "integer", 27 | "minimum": 0 28 | } 29 | } 30 | } 31 | ], 32 | "returns": { 33 | "description": "The rearranged array.", 34 | "schema": { 35 | "type": "array", 36 | "items": { 37 | "description": "Any data type is allowed." 38 | } 39 | } 40 | }, 41 | "examples": [ 42 | { 43 | "title": "Reverse a list", 44 | "arguments": { 45 | "data": [ 46 | 5, 47 | 4, 48 | 3 49 | ], 50 | "order": [ 51 | 2, 52 | 1, 53 | 0 54 | ] 55 | }, 56 | "returns": [ 57 | 3, 58 | 4, 59 | 5 60 | ] 61 | }, 62 | { 63 | "title": "Remove two elements", 64 | "arguments": { 65 | "data": [ 66 | 5, 67 | 4, 68 | 3, 69 | 2 70 | ], 71 | "order": [ 72 | 1, 73 | 3 74 | ] 75 | }, 76 | "returns": [ 77 | 4, 78 | 2 79 | ] 80 | }, 81 | { 82 | "title": "Swap two elements", 83 | "arguments": { 84 | "data": [ 85 | 5, 86 | 4, 87 | 3, 88 | 2 89 | ], 90 | "order": [ 91 | 0, 92 | 2, 93 | 1, 94 | 3 95 | ] 96 | }, 97 | "returns": [ 98 | 5, 99 | 3, 100 | 4, 101 | 2 102 | ] 103 | } 104 | ], 105 | "links": [ 106 | { 107 | "rel": "about", 108 | "href": "http://mathworld.wolfram.com/Permutation.html", 109 | "title": "Permutation explained by Wolfram MathWorld" 110 | } 111 | ] 112 | } 113 | -------------------------------------------------------------------------------- /clip.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "clip", 3 | "summary": "Clip a value between a minimum and a maximum", 4 | "description": "Clips a number between specified minimum and maximum values. A value larger than the maximum value is set to the maximum value, a value lower than the minimum value is set to the minimum value.\n\nThe no-data value `null` is passed through and therefore gets propagated.", 5 | "categories": [ 6 | "math" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "x", 11 | "description": "A number.", 12 | "schema": { 13 | "type": [ 14 | "number", 15 | "null" 16 | ] 17 | } 18 | }, 19 | { 20 | "name": "min", 21 | "description": "Minimum value. If the value is lower than this value, the process will return the value of this parameter.", 22 | "schema": { 23 | "type": "number" 24 | } 25 | }, 26 | { 27 | "name": "max", 28 | "description": "Maximum value. If the value is greater than this value, the process will return the value of this parameter.", 29 | "schema": { 30 | "type": "number" 31 | } 32 | } 33 | ], 34 | "returns": { 35 | "description": "The value clipped to the specified range.", 36 | "schema": { 37 | "type": [ 38 | "number", 39 | "null" 40 | ] 41 | } 42 | }, 43 | "examples": [ 44 | { 45 | "arguments": { 46 | "x": -5, 47 | "min": -1, 48 | "max": 1 49 | }, 50 | "returns": -1 51 | }, 52 | { 53 | "arguments": { 54 | "x": 10.001, 55 | "min": 1, 56 | "max": 10 57 | }, 58 | "returns": 10 59 | }, 60 | { 61 | "arguments": { 62 | "x": 0.000001, 63 | "min": 0, 64 | "max": 0.02 65 | }, 66 | "returns": 0.000001 67 | }, 68 | { 69 | "arguments": { 70 | "x": null, 71 | "min": 0, 72 | "max": 1 73 | }, 74 | "returns": null 75 | } 76 | ], 77 | "process_graph": { 78 | "min": { 79 | "process_id": "min", 80 | "arguments": { 81 | "data": [ 82 | { 83 | "from_parameter": "max" 84 | }, 85 | { 86 | "from_parameter": "x" 87 | } 88 | ] 89 | } 90 | }, 91 | "max": { 92 | "process_id": "max", 93 | "arguments": { 94 | "data": [ 95 | { 96 | "from_parameter": "min" 97 | }, 98 | { 99 | "from_node": "min" 100 | } 101 | ] 102 | }, 103 | "result": true 104 | } 105 | } 106 | } -------------------------------------------------------------------------------- /proposals/unflatten_dimension.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "unflatten_dimension", 3 | "summary": "Split a single dimensions into multiple dimensions", 4 | "description": "Splits a single dimension into multiple dimensions by systematically extracting values and splitting the dimension labels by the given `label_separator`. This process is the opposite of the process ``flatten_dimensions()`` but executing both processes subsequently doesn't necessarily create a data cube that is equal to the original data cube.\n\nExample: Executing the process with a data cube with one dimension `X` (labels: `2020~B1`, `2020~B2`, `2021~B1` and `2021~B2`) and the data `[1,2,3,4]` and the parameters `dimension` = `X` and `target_dimensions` = `[A,B]` will result in a data cube with two dimensions `A` (labels: `2020` and `2021`) and B (labels: `B1` and `B2`) and the data `[[1,2],[3,4]]`.", 5 | "categories": [ 6 | "cubes" 7 | ], 8 | "experimental": true, 9 | "parameters": [ 10 | { 11 | "name": "data", 12 | "description": "A data cube that is consistently structured so that operation can execute flawlessly (e.g. the dimension labels need to contain the `label_separator` exactly 1 time for two target dimensions, 2 times for three target dimensions etc.).", 13 | "schema": { 14 | "type": "object", 15 | "subtype": "datacube" 16 | } 17 | }, 18 | { 19 | "name": "dimension", 20 | "description": "The name of the dimension to split.", 21 | "schema": { 22 | "type": "string" 23 | } 24 | }, 25 | { 26 | "name": "target_dimensions", 27 | "description": "The names of the new target dimensions. New dimensions will be created with the given names and type `other` (see ``add_dimension()``). Fails with a `TargetDimensionExists` exception if any of the dimensions exists.\n\nThe order of the array defines the order in which the dimensions and dimension labels are added to the data cube (see the example in the process description).", 28 | "schema": { 29 | "type": "array", 30 | "minItems": 2, 31 | "items": { 32 | "type": "string" 33 | } 34 | } 35 | }, 36 | { 37 | "name": "label_separator", 38 | "description": "The string that will be used as a separator to split the dimension labels.", 39 | "optional": true, 40 | "default": "~", 41 | "schema": { 42 | "type": "string", 43 | "minLength": 1 44 | } 45 | } 46 | ], 47 | "returns": { 48 | "description": "A data cube with the new shape. The dimension properties (name, type, labels, reference system and resolution) for all other dimensions remain unchanged.", 49 | "schema": { 50 | "type": "object", 51 | "subtype": "datacube" 52 | } 53 | }, 54 | "exceptions": { 55 | "DimensionNotAvailable": { 56 | "message": "A dimension with the specified name does not exist." 57 | }, 58 | "TargetDimensionExists": { 59 | "message": "A dimension with the specified target dimension name already exists." 60 | } 61 | } 62 | } 63 | -------------------------------------------------------------------------------- /proposals/vector_to_regular_points.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "vector_to_regular_points", 3 | "summary": "Sample regular points from geometries", 4 | "description": "Generate a vector data cube of points by sampling regularly-spaced points from input geometries. Empty geometries are passed through without any points assigned. Feature properties are preserved.", 5 | "categories": [ 6 | "cubes", 7 | "vector" 8 | ], 9 | "experimental": true, 10 | "parameters": [ 11 | { 12 | "name": "data", 13 | "description": "Input geometries for sample extraction.", 14 | "schema": { 15 | "type": "object", 16 | "subtype": "datacube", 17 | "dimensions": [ 18 | { 19 | "type": "geometry" 20 | } 21 | ] 22 | } 23 | }, 24 | { 25 | "name": "distance", 26 | "description": "Defines the minimum distance in meters that is required between two samples generated *inside* a single geometry. If the unit of the spatial reference system is not meters, a `UnitMismatch` error is thrown. Use ``vector_reproject()`` to convert the geometries to a suitable spatial reference system.\n\n- For **polygons**, the distance defines the cell sizes of a regular grid that starts at the upper-left bound of each polygon. The centroid of each cell is then a sample point. If the centroid is not enclosed in the polygon, no point is sampled. If no point can be sampled for the geometry at all, the first coordinate of the geometry is returned as point.\n- For **lines** (line strings), the sampling starts with a point at the first coordinate of the line and then walks along the line and samples a new point each time the distance to the previous point has been reached again.\n- For **points**, the point is returned as given.", 27 | "schema": { 28 | "type": "number", 29 | "minimumExclusive": 0 30 | } 31 | }, 32 | { 33 | "name": "group", 34 | "description": "Specifies whether the sampled points should be grouped by input geometry (default) or be generated as independent points.\n\n* If the sampled points are grouped, the process generates a `MultiPoint` per geometry given which keeps the original identifier if present.\n* Otherwise, each sampled point is generated as a distinct `Point` geometry without identifier.", 35 | "optional": true, 36 | "default": true, 37 | "schema": { 38 | "type": "boolean" 39 | } 40 | } 41 | ], 42 | "returns": { 43 | "description": "Returns a vector data cube with the sampled points.", 44 | "schema": { 45 | "type": "object", 46 | "subtype": "datacube", 47 | "dimensions": [ 48 | { 49 | "type": "geometry", 50 | "geometry_type": [ 51 | "Point", 52 | "MultiPoint" 53 | ] 54 | } 55 | ] 56 | } 57 | }, 58 | "exceptions": { 59 | "UnitMismatch": { 60 | "message": "The unit of the spatial reference system is not meters, but the given distance is in meters." 61 | } 62 | } 63 | } 64 | -------------------------------------------------------------------------------- /text_concat.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "text_concat", 3 | "summary": "Concatenate elements to a single text", 4 | "description": "Merges text representations (also known as *string*) of a set of elements to a single text, having the separator between each element.", 5 | "categories": [ 6 | "texts" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "data", 11 | "description": "A set of elements. Numbers, boolean values and null values get converted to their (lower case) string representation. For example: `1` (integer), `-1.5` (number), `true` / `false` (boolean values)", 12 | "schema": { 13 | "type": "array", 14 | "items": { 15 | "type": [ 16 | "string", 17 | "number", 18 | "boolean", 19 | "null" 20 | ] 21 | } 22 | } 23 | }, 24 | { 25 | "name": "separator", 26 | "description": "A separator to put between each of the individual texts. Defaults to an empty string.", 27 | "schema": { 28 | "type": [ 29 | "string", 30 | "number", 31 | "boolean", 32 | "null" 33 | ] 34 | }, 35 | "default": "", 36 | "optional": true 37 | } 38 | ], 39 | "returns": { 40 | "description": "A string containing a string representation of all the array elements in the same order, with the separator between each element.", 41 | "schema": { 42 | "type": "string" 43 | } 44 | }, 45 | "examples": [ 46 | { 47 | "arguments": { 48 | "data": [ 49 | "Hello", 50 | "World" 51 | ], 52 | "separator": " " 53 | }, 54 | "returns": "Hello World" 55 | }, 56 | { 57 | "arguments": { 58 | "data": [ 59 | 1, 60 | 2, 61 | 3, 62 | 4, 63 | 5, 64 | 6, 65 | 7, 66 | 8, 67 | 9, 68 | 0 69 | ] 70 | }, 71 | "returns": "1234567890" 72 | }, 73 | { 74 | "arguments": { 75 | "data": [ 76 | null, 77 | true, 78 | false, 79 | 1, 80 | -1.5, 81 | "ß" 82 | ], 83 | "separator": "\n" 84 | }, 85 | "returns": "null\ntrue\nfalse\n1\n-1.5\nß" 86 | }, 87 | { 88 | "arguments": { 89 | "data": [ 90 | 2, 91 | 0 92 | ], 93 | "separator": 1 94 | }, 95 | "returns": "210" 96 | }, 97 | { 98 | "arguments": { 99 | "data": [] 100 | }, 101 | "returns": "" 102 | } 103 | ] 104 | } 105 | -------------------------------------------------------------------------------- /proposals/flatten_dimensions.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "flatten_dimensions", 3 | "summary": "Combine multiple dimensions into a single dimension", 4 | "description": "Combines multiple given dimensions into a single dimension by flattening the values and merging the dimension labels with the given `label_separator`. Non-string dimension labels will be converted to strings. This process is the opposite of the process ``unflatten_dimension()`` but executing both processes subsequently doesn't necessarily create a data cube that is equal to the original data cube.\n\nExample: Executing the process with a data cube with two dimensions `A` (labels: `2020` and `2021`) and `B` (labels: `B1` and `B2`) and the data `[[1,2],[3,4]]` and the parameters `dimensions` = `[A,B]` and `target_dimension` = `X` will result in a data cube with one dimension `X` (labels: `2020~B1`, `2020~B2`, `2021~B1` and `2021~B2`) and the data `[1,2,3,4]`.", 5 | "categories": [ 6 | "cubes" 7 | ], 8 | "experimental": true, 9 | "parameters": [ 10 | { 11 | "name": "data", 12 | "description": "A data cube.", 13 | "schema": { 14 | "type": "object", 15 | "subtype": "datacube" 16 | } 17 | }, 18 | { 19 | "name": "dimensions", 20 | "description": "The names of the dimension to combine. The order of the array defines the order in which the dimension labels and values are combined (see the example in the process description). Fails with a `DimensionNotAvailable` exception if at least one of the specified dimensions does not exist.", 21 | "schema": { 22 | "type": "array", 23 | "items": { 24 | "type": "string" 25 | } 26 | } 27 | }, 28 | { 29 | "name": "target_dimension", 30 | "description": "The name of the new target dimension. A new dimensions will be created with the given names and type `other` (see ``add_dimension()``). Fails with a `TargetDimensionExists` exception if a dimension with the specified name exists.", 31 | "schema": { 32 | "type": "string" 33 | } 34 | }, 35 | { 36 | "name": "label_separator", 37 | "description": "The string that will be used as a separator for the concatenated dimension labels.\n\nTo unambiguously revert the dimension labels with the process ``unflatten_dimension()``, the given string must not be contained in any of the dimension labels.", 38 | "optional": true, 39 | "default": "~", 40 | "schema": { 41 | "type": "string", 42 | "minLength": 1 43 | } 44 | } 45 | ], 46 | "returns": { 47 | "description": "A data cube with the new shape. The dimension properties (name, type, labels, reference system and resolution) for all other dimensions remain unchanged.", 48 | "schema": { 49 | "type": "object", 50 | "subtype": "datacube" 51 | } 52 | }, 53 | "exceptions": { 54 | "DimensionNotAvailable": { 55 | "message": "A dimension with the specified name does not exist." 56 | }, 57 | "TargetDimensionExists": { 58 | "message": "A dimension with the specified target dimension name already exists." 59 | } 60 | } 61 | } 62 | -------------------------------------------------------------------------------- /proposals/cumproduct.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "cumproduct", 3 | "summary": "Cumulative products", 4 | "description": "Computes cumulative products of an array of numbers. Every computed element is equal to the product of the current and all previous values. The returned array and the input array have always the same length.\n\nBy default, no-data values are skipped, but stay in the result. Setting the `ignore_nodata` flag to `true` makes that once a no-data value (`null`) is reached all following elements are set to `null` in the result.", 5 | "categories": [ 6 | "math > cumulative" 7 | ], 8 | "experimental": true, 9 | "parameters": [ 10 | { 11 | "name": "data", 12 | "description": "An array of numbers.", 13 | "schema": { 14 | "type": "array", 15 | "items": { 16 | "type": [ 17 | "number", 18 | "null" 19 | ] 20 | } 21 | } 22 | }, 23 | { 24 | "name": "ignore_nodata", 25 | "description": "Indicates whether no-data values are ignored or not and ignores them by default. Setting this flag to `false` considers no-data values so that `null` is set for all the following elements.", 26 | "schema": { 27 | "type": "boolean" 28 | }, 29 | "default": true, 30 | "optional": true 31 | } 32 | ], 33 | "returns": { 34 | "description": "An array with the computed cumulative products.", 35 | "schema": { 36 | "type": "array", 37 | "items": { 38 | "type": [ 39 | "number", 40 | "null" 41 | ] 42 | } 43 | } 44 | }, 45 | "examples": [ 46 | { 47 | "arguments": { 48 | "data": [ 49 | 1, 50 | 3, 51 | 5, 52 | 3, 53 | 1 54 | ] 55 | }, 56 | "returns": [ 57 | 1, 58 | 3, 59 | 15, 60 | 45, 61 | 45 62 | ] 63 | }, 64 | { 65 | "arguments": { 66 | "data": [ 67 | 1, 68 | 2, 69 | 3, 70 | null, 71 | 3, 72 | 1 73 | ] 74 | }, 75 | "returns": [ 76 | 1, 77 | 2, 78 | 6, 79 | null, 80 | 18, 81 | 18 82 | ] 83 | }, 84 | { 85 | "arguments": { 86 | "data": [ 87 | 1, 88 | 2, 89 | 3, 90 | null, 91 | 3, 92 | 1 93 | ], 94 | "ignore_nodata": false 95 | }, 96 | "returns": [ 97 | 1, 98 | 2, 99 | 6, 100 | null, 101 | null, 102 | null 103 | ] 104 | } 105 | ] 106 | } -------------------------------------------------------------------------------- /mask.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "mask", 3 | "summary": "Apply a raster mask", 4 | "description": "Applies a mask to a raster data cube. To apply a polygon as a mask, use ``mask_polygon()``.\n\nA mask is a raster data cube for which corresponding pixels among `data` and `mask` are compared and those pixels in `data` are replaced whose pixels in `mask` are non-zero (for numbers) or `true` (for boolean values). The pixel values are replaced with the value specified for `replacement`, which defaults to `null` (no data).\n\nThe data cubes have to be compatible except that the horizontal spatial dimensions (axes `x` and `y`) will be aligned implicitly by ``resample_cube_spatial()``. `data` is the target data cube for resampling and the default parameters of ``resample_cube_spatial()`` apply. All other dimensions in the mask must also be available in the raster data cube with the same name, type, reference system, resolution and labels. Dimensions can be missing in the mask with the result that the mask is applied to each label of the dimension in `data` that is missing in the data cube of the mask. The process fails if there's an incompatibility found between the raster data cube and the mask.", 5 | "categories": [ 6 | "cubes", 7 | "masks" 8 | ], 9 | "parameters": [ 10 | { 11 | "name": "data", 12 | "description": "A raster data cube.", 13 | "schema": { 14 | "type": "object", 15 | "subtype": "datacube", 16 | "dimensions": [ 17 | { 18 | "type": "spatial", 19 | "axis": [ 20 | "x", 21 | "y" 22 | ] 23 | } 24 | ] 25 | } 26 | }, 27 | { 28 | "name": "mask", 29 | "description": "A mask as a raster data cube. Every pixel in `data` must have a corresponding element in `mask`.", 30 | "schema": { 31 | "type": "object", 32 | "subtype": "datacube", 33 | "dimensions": [ 34 | { 35 | "type": "spatial", 36 | "axis": [ 37 | "x", 38 | "y" 39 | ] 40 | } 41 | ] 42 | } 43 | }, 44 | { 45 | "name": "replacement", 46 | "description": "The value used to replace masked values with.", 47 | "schema": { 48 | "type": [ 49 | "number", 50 | "boolean", 51 | "string", 52 | "null" 53 | ] 54 | }, 55 | "default": null, 56 | "optional": true 57 | } 58 | ], 59 | "returns": { 60 | "description": "A masked raster data cube with the same dimensions. The dimension properties (name, type, labels, reference system and resolution) remain unchanged.", 61 | "schema": { 62 | "type": "object", 63 | "subtype": "datacube", 64 | "dimensions": [ 65 | { 66 | "type": "spatial", 67 | "axis": [ 68 | "x", 69 | "y" 70 | ] 71 | } 72 | ] 73 | } 74 | } 75 | } 76 | -------------------------------------------------------------------------------- /round.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "round", 3 | "summary": "Round to a specified precision", 4 | "description": "Rounds a real number `x` to specified precision `p`.\n\nIf `x` is halfway between closest numbers of precision `p`, it is rounded to the closest even number of precision `p`.\nThis behavior follows [IEEE Standard 754](https://ieeexplore.ieee.org/document/8766229) and is often called \"round to nearest (even)\" or \"banker's rounding\". It minimizes rounding errors that result from consistently rounding a midpoint value in a single direction.\n\nThe no-data value `null` is passed through and therefore gets propagated.", 5 | "categories": [ 6 | "math > rounding" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "x", 11 | "description": "A number to round.", 12 | "schema": { 13 | "type": [ 14 | "number", 15 | "null" 16 | ] 17 | } 18 | }, 19 | { 20 | "name": "p", 21 | "description": "A positive number specifies the number of digits after the decimal point to round to. A negative number means rounding to a power of ten, so for example *-2* rounds to the nearest hundred. Defaults to *0*.", 22 | "schema": { 23 | "type": "integer" 24 | }, 25 | "default": 0, 26 | "optional": true 27 | } 28 | ], 29 | "returns": { 30 | "description": "The rounded number.", 31 | "schema": { 32 | "type": [ 33 | "number", 34 | "null" 35 | ] 36 | } 37 | }, 38 | "examples": [ 39 | { 40 | "arguments": { 41 | "x": 0 42 | }, 43 | "returns": 0 44 | }, 45 | { 46 | "arguments": { 47 | "x": 3.56, 48 | "p": 1 49 | }, 50 | "returns": 3.6 51 | }, 52 | { 53 | "arguments": { 54 | "x": -0.4444444, 55 | "p": 2 56 | }, 57 | "returns": -0.44 58 | }, 59 | { 60 | "arguments": { 61 | "x": -2.5 62 | }, 63 | "returns": -2 64 | }, 65 | { 66 | "arguments": { 67 | "x": -3.5 68 | }, 69 | "returns": -4 70 | }, 71 | { 72 | "arguments": { 73 | "x": 0.25, 74 | "p": 1 75 | }, 76 | "returns": 0.2 77 | }, 78 | { 79 | "arguments": { 80 | "x": 0.35, 81 | "p": 1 82 | }, 83 | "returns": 0.4 84 | }, 85 | { 86 | "arguments": { 87 | "x": 1234.5, 88 | "p": -2 89 | }, 90 | "returns": 1200 91 | } 92 | ], 93 | "links": [ 94 | { 95 | "rel": "about", 96 | "href": "http://mathworld.wolfram.com/AbsoluteValue.html", 97 | "title": "Absolute value explained by Wolfram MathWorld" 98 | }, 99 | { 100 | "rel": "about", 101 | "href": "https://ieeexplore.ieee.org/document/8766229", 102 | "title": "IEEE Standard 754-2019 for Floating-Point Arithmetic" 103 | } 104 | ] 105 | } 106 | -------------------------------------------------------------------------------- /sum.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "sum", 3 | "summary": "Compute the sum by adding up numbers", 4 | "description": "Sums up all elements in a sequential array of numbers and returns the computed sum.\n\nBy default no-data values are ignored. Setting `ignore_nodata` to `false` considers no-data values so that `null` is returned if any element is such a value.\n\nThe computations follow [IEEE Standard 754](https://ieeexplore.ieee.org/document/8766229) whenever the processing environment supports it.", 5 | "categories": [ 6 | "math", 7 | "reducer" 8 | ], 9 | "parameters": [ 10 | { 11 | "name": "data", 12 | "description": "An array of numbers.", 13 | "schema": { 14 | "type": "array", 15 | "items": { 16 | "type": [ 17 | "number", 18 | "null" 19 | ] 20 | } 21 | } 22 | }, 23 | { 24 | "name": "ignore_nodata", 25 | "description": "Indicates whether no-data values are ignored or not. Ignores them by default. Setting this flag to `false` considers no-data values so that `null` is returned if any value is such a value.", 26 | "schema": { 27 | "type": "boolean" 28 | }, 29 | "default": true, 30 | "optional": true 31 | } 32 | ], 33 | "returns": { 34 | "description": "The computed sum of the sequence of numbers.", 35 | "schema": { 36 | "type": [ 37 | "number", 38 | "null" 39 | ] 40 | } 41 | }, 42 | "examples": [ 43 | { 44 | "arguments": { 45 | "data": [ 46 | 5, 47 | 1 48 | ] 49 | }, 50 | "returns": 6 51 | }, 52 | { 53 | "arguments": { 54 | "data": [ 55 | -2, 56 | 4, 57 | 2.5 58 | ] 59 | }, 60 | "returns": 4.5 61 | }, 62 | { 63 | "arguments": { 64 | "data": [ 65 | 1, 66 | null 67 | ], 68 | "ignore_nodata": false 69 | }, 70 | "returns": null 71 | }, 72 | { 73 | "arguments": { 74 | "data": [ 75 | 100 76 | ] 77 | }, 78 | "returns": 100 79 | }, 80 | { 81 | "arguments": { 82 | "data": [ 83 | null 84 | ], 85 | "ignore_nodata": false 86 | }, 87 | "returns": null 88 | }, 89 | { 90 | "arguments": { 91 | "data": [] 92 | }, 93 | "returns": null 94 | } 95 | ], 96 | "links": [ 97 | { 98 | "rel": "about", 99 | "href": "http://mathworld.wolfram.com/Sum.html", 100 | "title": "Sum explained by Wolfram MathWorld" 101 | }, 102 | { 103 | "rel": "about", 104 | "href": "https://ieeexplore.ieee.org/document/8766229", 105 | "title": "IEEE Standard 754-2019 for Floating-Point Arithmetic" 106 | } 107 | ] 108 | } -------------------------------------------------------------------------------- /product.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "product", 3 | "summary": "Compute the product by multiplying numbers", 4 | "description": "Multiplies all elements in a sequential array of numbers and returns the computed product.\n\nBy default no-data values are ignored. Setting `ignore_nodata` to `false` considers no-data values so that `null` is returned if any element is such a value.\n\nThe computations follow [IEEE Standard 754](https://ieeexplore.ieee.org/document/8766229) whenever the processing environment supports it.", 5 | "categories": [ 6 | "math", 7 | "reducer" 8 | ], 9 | "parameters": [ 10 | { 11 | "name": "data", 12 | "description": "An array of numbers.", 13 | "schema": { 14 | "type": "array", 15 | "items": { 16 | "type": [ 17 | "number", 18 | "null" 19 | ] 20 | } 21 | } 22 | }, 23 | { 24 | "name": "ignore_nodata", 25 | "description": "Indicates whether no-data values are ignored or not. Ignores them by default. Setting this flag to `false` considers no-data values so that `null` is returned if any value is such a value.", 26 | "schema": { 27 | "type": "boolean" 28 | }, 29 | "default": true, 30 | "optional": true 31 | } 32 | ], 33 | "returns": { 34 | "description": "The computed product of the sequence of numbers.", 35 | "schema": { 36 | "type": [ 37 | "number", 38 | "null" 39 | ] 40 | } 41 | }, 42 | "examples": [ 43 | { 44 | "arguments": { 45 | "data": [ 46 | 5, 47 | 0 48 | ] 49 | }, 50 | "returns": 0 51 | }, 52 | { 53 | "arguments": { 54 | "data": [ 55 | -2, 56 | 4, 57 | 2.5 58 | ] 59 | }, 60 | "returns": -20 61 | }, 62 | { 63 | "arguments": { 64 | "data": [ 65 | 1, 66 | null 67 | ], 68 | "ignore_nodata": false 69 | }, 70 | "returns": null 71 | }, 72 | { 73 | "arguments": { 74 | "data": [ 75 | -1 76 | ] 77 | }, 78 | "returns": -1 79 | }, 80 | { 81 | "arguments": { 82 | "data": [ 83 | null 84 | ], 85 | "ignore_nodata": false 86 | }, 87 | "returns": null 88 | }, 89 | { 90 | "arguments": { 91 | "data": [] 92 | }, 93 | "returns": null 94 | } 95 | ], 96 | "links": [ 97 | { 98 | "rel": "about", 99 | "href": "http://mathworld.wolfram.com/Product.html", 100 | "title": "Product explained by Wolfram MathWorld" 101 | }, 102 | { 103 | "rel": "about", 104 | "href": "https://ieeexplore.ieee.org/document/8766229", 105 | "title": "IEEE Standard 754-2019 for Floating-Point Arithmetic" 106 | } 107 | ] 108 | } -------------------------------------------------------------------------------- /sd.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "sd", 3 | "summary": "Standard deviation", 4 | "description": "Computes the sample standard deviation, which quantifies the amount of variation of an array of numbers. It is defined to be the square root of the corresponding variance (see ``variance()``).\n\nA low standard deviation indicates that the values tend to be close to the expected value, while a high standard deviation indicates that the values are spread out over a wider range.\n\nAn array without non-`null` elements resolves always with `null`.", 5 | "categories": [ 6 | "math > statistics", 7 | "reducer" 8 | ], 9 | "parameters": [ 10 | { 11 | "name": "data", 12 | "description": "An array of numbers.", 13 | "schema": { 14 | "type": "array", 15 | "items": { 16 | "type": [ 17 | "number", 18 | "null" 19 | ] 20 | } 21 | } 22 | }, 23 | { 24 | "name": "ignore_nodata", 25 | "description": "Indicates whether no-data values are ignored or not. Ignores them by default. Setting this flag to `false` considers no-data values so that `null` is returned if any value is such a value.", 26 | "schema": { 27 | "type": "boolean" 28 | }, 29 | "default": true, 30 | "optional": true 31 | } 32 | ], 33 | "returns": { 34 | "description": "The computed sample standard deviation.", 35 | "schema": { 36 | "type": [ 37 | "number", 38 | "null" 39 | ] 40 | } 41 | }, 42 | "examples": [ 43 | { 44 | "arguments": { 45 | "data": [ 46 | -1, 47 | 1, 48 | 3, 49 | null 50 | ] 51 | }, 52 | "returns": 2 53 | }, 54 | { 55 | "arguments": { 56 | "data": [ 57 | -1, 58 | 1, 59 | 3, 60 | null 61 | ], 62 | "ignore_nodata": false 63 | }, 64 | "returns": null 65 | }, 66 | { 67 | "description": "The input array is empty: return `null`.", 68 | "arguments": { 69 | "data": [] 70 | }, 71 | "returns": null 72 | } 73 | ], 74 | "links": [ 75 | { 76 | "rel": "about", 77 | "href": "http://mathworld.wolfram.com/StandardDeviation.html", 78 | "title": "Standard deviation explained by Wolfram MathWorld" 79 | } 80 | ], 81 | "process_graph": { 82 | "variance": { 83 | "process_id": "variance", 84 | "arguments": { 85 | "data": { 86 | "from_parameter": "data" 87 | }, 88 | "ignore_nodata": { 89 | "from_parameter": "ignore_nodata" 90 | } 91 | } 92 | }, 93 | "power": { 94 | "process_id": "power", 95 | "arguments": { 96 | "base": { 97 | "from_node": "variance" 98 | }, 99 | "p": 0.5 100 | }, 101 | "result": true 102 | } 103 | } 104 | } -------------------------------------------------------------------------------- /extrema.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "extrema", 3 | "summary": "Minimum and maximum values", 4 | "description": "Two element array containing the minimum and the maximum values of `data`.\n\nThis process is basically an alias for calling both ``min()`` and ``max()``, but may be implemented more performant by back-ends as it only needs to iterate over the data once instead of twice.", 5 | "categories": [ 6 | "math > statistics" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "data", 11 | "description": "An array of numbers.", 12 | "schema": { 13 | "type": "array", 14 | "items": { 15 | "type": [ 16 | "number", 17 | "null" 18 | ] 19 | } 20 | } 21 | }, 22 | { 23 | "name": "ignore_nodata", 24 | "description": "Indicates whether no-data values are ignored or not. Ignores them by default. Setting this flag to `false` considers no-data values so that an array with two `null` values is returned if any value is such a value.", 25 | "schema": { 26 | "type": "boolean" 27 | }, 28 | "default": true, 29 | "optional": true 30 | } 31 | ], 32 | "returns": { 33 | "description": "An array containing the minimum and maximum values for the specified numbers. The first element is the minimum, the second element is the maximum. If the input array is empty both elements are set to `null`.", 34 | "schema": [ 35 | { 36 | "type": "array", 37 | "minItems": 2, 38 | "maxItems": 2, 39 | "items": { 40 | "type": "number" 41 | } 42 | }, 43 | { 44 | "type": "array", 45 | "minItems": 2, 46 | "maxItems": 2, 47 | "items": { 48 | "type": "null" 49 | } 50 | } 51 | ] 52 | }, 53 | "examples": [ 54 | { 55 | "arguments": { 56 | "data": [ 57 | 1, 58 | 0, 59 | 3, 60 | 2 61 | ] 62 | }, 63 | "returns": [ 64 | 0, 65 | 3 66 | ] 67 | }, 68 | { 69 | "arguments": { 70 | "data": [ 71 | 5, 72 | 2.5, 73 | null, 74 | -0.7 75 | ] 76 | }, 77 | "returns": [ 78 | -0.7, 79 | 5 80 | ] 81 | }, 82 | { 83 | "arguments": { 84 | "data": [ 85 | 1, 86 | 0, 87 | 3, 88 | null, 89 | 2 90 | ], 91 | "ignore_nodata": false 92 | }, 93 | "returns": [ 94 | null, 95 | null 96 | ] 97 | }, 98 | { 99 | "description": "The input array is empty: return two `null` values.", 100 | "arguments": { 101 | "data": [] 102 | }, 103 | "returns": [ 104 | null, 105 | null 106 | ] 107 | } 108 | ] 109 | } -------------------------------------------------------------------------------- /proposals/vector_reproject.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "vector_reproject", 3 | "summary": "Reprojects the geometry dimension", 4 | "description": "Converts the geometries stored in a geometry dimension to a different coordinate reference system.", 5 | "categories": [ 6 | "cubes", 7 | "reproject", 8 | "vector" 9 | ], 10 | "experimental": true, 11 | "parameters": [ 12 | { 13 | "name": "data", 14 | "description": "A vector data cube.", 15 | "schema": { 16 | "type": "object", 17 | "subtype": "datacube", 18 | "dimensions": [ 19 | { 20 | "type": "geometry" 21 | } 22 | ] 23 | } 24 | }, 25 | { 26 | "name": "projection", 27 | "description": "Coordinate reference system to reproject to. Specified as an [EPSG code](http://www.epsg-registry.org/) or [WKT2 CRS string](http://docs.opengeospatial.org/is/18-010r7/18-010r7.html).", 28 | "schema": [ 29 | { 30 | "title": "EPSG Code", 31 | "type": "integer", 32 | "subtype": "epsg-code", 33 | "minimum": 1000, 34 | "examples": [ 35 | 3857 36 | ] 37 | }, 38 | { 39 | "title": "WKT2", 40 | "type": "string", 41 | "subtype": "wkt2-definition" 42 | } 43 | ] 44 | }, 45 | { 46 | "name": "dimension", 47 | "description": "The name of the geometry dimension to reproject. If no specific dimension is specified, the filter applies to all geometry dimensions. Fails with a `DimensionNotAvailable` exception if the specified dimension does not exist.", 48 | "schema": { 49 | "type": [ 50 | "string", 51 | "null" 52 | ] 53 | }, 54 | "default": null, 55 | "optional": true 56 | } 57 | ], 58 | "returns": { 59 | "description": "A vector data cube with geometries projected to the new coordinate reference system. The reference system of the geometry dimension changes, all other dimensions and properties remain unchanged.", 60 | "schema": { 61 | "type": "object", 62 | "subtype": "datacube", 63 | "dimensions": [ 64 | { 65 | "type": "geometry" 66 | } 67 | ] 68 | } 69 | }, 70 | "exceptions": { 71 | "DimensionNotAvailable": { 72 | "message": "A dimension with the specified name does not exist." 73 | } 74 | }, 75 | "links": [ 76 | { 77 | "href": "https://openeo.org/documentation/1.0/datacubes.html#resample", 78 | "rel": "about", 79 | "title": "Resampling explained in the openEO documentation" 80 | }, 81 | { 82 | "rel": "about", 83 | "href": "https://proj.org/usage/projections.html", 84 | "title": "PROJ parameters for cartographic projections" 85 | }, 86 | { 87 | "rel": "about", 88 | "href": "http://www.epsg-registry.org", 89 | "title": "Official EPSG code registry" 90 | }, 91 | { 92 | "rel": "about", 93 | "href": "http://www.epsg.io", 94 | "title": "Unofficial EPSG code database" 95 | } 96 | ] 97 | } 98 | -------------------------------------------------------------------------------- /xor.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "xor", 3 | "summary": "Logical XOR (exclusive or)", 4 | "description": "Checks if **exactly one** of the values is true. If a component is `null`, the result will be `null` if the outcome is ambiguous.\n\n**Truth table:**\n\n```\na \\ b || null | false | true\n----- || ---- | ----- | -----\nnull || null | null | null\nfalse || null | false | true\ntrue || null | true | false\n```", 5 | "categories": [ 6 | "logic" 7 | ], 8 | "parameters": [ 9 | { 10 | "name": "x", 11 | "description": "A boolean value.", 12 | "schema": { 13 | "type": [ 14 | "boolean", 15 | "null" 16 | ] 17 | } 18 | }, 19 | { 20 | "name": "y", 21 | "description": "A boolean value.", 22 | "schema": { 23 | "type": [ 24 | "boolean", 25 | "null" 26 | ] 27 | } 28 | } 29 | ], 30 | "returns": { 31 | "description": "Boolean result of the logical XOR.", 32 | "schema": { 33 | "type": [ 34 | "boolean", 35 | "null" 36 | ] 37 | } 38 | }, 39 | "examples": [ 40 | { 41 | "arguments": { 42 | "x": true, 43 | "y": true 44 | }, 45 | "returns": false 46 | }, 47 | { 48 | "arguments": { 49 | "x": false, 50 | "y": false 51 | }, 52 | "returns": false 53 | }, 54 | { 55 | "arguments": { 56 | "x": true, 57 | "y": false 58 | }, 59 | "returns": true 60 | }, 61 | { 62 | "arguments": { 63 | "x": true, 64 | "y": null 65 | }, 66 | "returns": null 67 | }, 68 | { 69 | "arguments": { 70 | "x": false, 71 | "y": null 72 | }, 73 | "returns": null 74 | } 75 | ], 76 | "process_graph": { 77 | "not_x": { 78 | "process_id": "not", 79 | "arguments": { 80 | "x": { 81 | "from_parameter": "x" 82 | } 83 | } 84 | }, 85 | "not_y": { 86 | "process_id": "not", 87 | "arguments": { 88 | "x": { 89 | "from_parameter": "y" 90 | } 91 | } 92 | }, 93 | "and1": { 94 | "process_id": "and", 95 | "arguments": { 96 | "x": { 97 | "from_node": "not_x" 98 | }, 99 | "y": { 100 | "from_parameter": "y" 101 | } 102 | } 103 | }, 104 | "and2": { 105 | "process_id": "and", 106 | "arguments": { 107 | "x": { 108 | "from_parameter": "x" 109 | }, 110 | "y": { 111 | "from_node": "not_y" 112 | } 113 | } 114 | }, 115 | "or": { 116 | "process_id": "or", 117 | "arguments": { 118 | "x": { 119 | "from_node": "and1" 120 | }, 121 | "y": { 122 | "from_node": "and2" 123 | } 124 | }, 125 | "result": true 126 | } 127 | } 128 | } --------------------------------------------------------------------------------