Skip to content

Instantly share code, notes, and snippets.

@donmccurdy

donmccurdy/algorithms.json

Last active April 2, 2019 18:35
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save donmccurdy/1e7e15e019e6c60c87b57170882b8ad0 to your computer and use it in GitHub Desktop.
Save donmccurdy/1e7e15e019e6c60c87b57170882b8ad0 to your computer and use it in GitHub Desktop.
Download ZIP
Generate JSDoc from Earth Engine algorithm descriptors.
Display the source blob
Display the rendered blob
Raw
algorithms.json
{
"data": {
"Filter.greaterThanOrEquals": {
"args": [
{
"default": null,
"description": "A selector for the left operand. Should not be specified if leftValue is specified.",
"name": "leftField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the right operand. Should not be specified if rightField is specified.",
"name": "rightValue",
"optional": true,
"type": "Object"
},
{
"default": null,
"description": "A selector for the right operand. Should not be specified if rightValue is specified.",
"name": "rightField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the left operand. Should not be specified if leftField is specified.",
"name": "leftValue",
"optional": true,
"type": "Object"
}
],
"description": "Creates a unary or binary filter that passes unless the left operand is less than the right operand.",
"returns": "Filter",
"type": "Algorithm",
"hidden": false
},
"Annotation.text": {
"args": [
{
"description": "The x-axis coordinate for the start of the text.",
"name": "x",
"type": "Float"
},
{
"description": "The y-axis coordinate for the start of the text.",
"name": "y",
"type": "Float"
},
{
"description": "The text to render.",
"name": "text",
"type": "String"
},
{
"default": null,
"description": "The size of the font to use in rendering the text (in pixels).",
"name": "fontSize",
"optional": true,
"type": "Float"
}
],
"description": "Creates a text annotation.",
"returns": "Annotation",
"type": "Algorithm",
"hidden": false
},
"ImageCollection.reduce": {
"args": [
{
"description": "The image collection to reduce.",
"name": "collection",
"type": "ImageCollection"
},
{
"description": "The reducer to apply to the given collection.",
"name": "reducer",
"type": "Reducer"
},
{
"default": 1.0,
"description": "A scaling factor used to limit memory use; using a larger parallelScale (e.g. 2 or 4) may enable computations that run out of memory with the default.",
"name": "parallelScale",
"optional": true,
"type": "Float"
}
],
"description": "Applies a reducer across all of the images in a collection.\nIf the reducer has a single input, it will be applied separately to each band of the collection; otherwise it must have the same number of inputs as the collection has bands.\nThe reducer output names determine the names of the output bands: reducers with multiple inputs will use the output names directly, while reducers with a single input will prefix the output name with the input band name (e.g. '10_mean', '20_mean', etc.).",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"String": {
"args": [
{
"description": "The object to convert.",
"name": "input",
"type": "Object"
}
],
"description": "Converts the input to a string.",
"returns": "String",
"type": "Algorithm",
"hidden": false
},
"Fail.allocateMemory": {
"args": [
{
"description": "Size of allocation in bytes.",
"name": "size",
"type": "Long"
}
],
"description": "Temporarily allocates the specified amount of memory, in the view of Earth Engine memorytracking. Does not affect the actual Java heap.\n\nReturns its argument so as to have a value to return.",
"returns": "Long",
"type": "Algorithm",
"hidden": false
},
"Collection.errorMatrix": {
"args": [
{
"description": "The input collection.",
"name": "collection",
"type": "FeatureCollection"
},
{
"description": "The name of the property containing the actual value.",
"name": "actual",
"type": "String"
},
{
"description": "The name of the property containing the predicted value.",
"name": "predicted",
"type": "String"
},
{
"default": null,
"description": "A list of the expected values. If this argument is not specified, the values are assumed to be contiguous and span the range 0 to maxValue. If specified, only values matching this list are used, and the matrix will have dimensions and order matching the this list.",
"name": "order",
"optional": true,
"type": "List<Integer>"
}
],
"description": "Computes a 2D error matrix for a collection by comparing two columns of a collection: one containing the actual values, and one containing predicted values.The values are expected to be small contiguous integers, starting from 0. Axis 0 (the rows) of the matrix correspond to the actual values, and Axis 1 (the columns) to the predicted values.",
"returns": "ConfusionMatrix",
"type": "Algorithm",
"hidden": false
},
"Classifier.minimumDistance": {
"args": [
{
"default": "euclidean",
"description": "The distance metric to use. Options are:\n 'euclidean' - euclidean distance from the unnormalized class mean.\n 'cosine' - spectral angle from the unnormalized class mean.\n 'mahalanobis' - Mahalanobis distance from the class mean.",
"name": "metric",
"optional": true,
"type": "String"
}
],
"description": "Creates a minimum distance classifier for the given distance metric.",
"returns": "Classifier",
"type": "Algorithm",
"hidden": false
},
"Image.min": {
"args": [
{
"description": "The image from which the left operand bands are taken.",
"name": "image1",
"type": "Image<unknown bands>"
},
{
"description": "The image from which the right operand bands are taken.",
"name": "image2",
"type": "Image<unknown bands>"
}
],
"description": "Selects the minimum of the first and second values for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is the union of the input types.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Filter.isContained": {
"args": [
{
"default": null,
"description": "A selector for the left operand. Should not be specified if leftValue is specified.",
"name": "leftField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the right operand. Should not be specified if rightField is specified.",
"name": "rightValue",
"optional": true,
"type": "Object"
},
{
"default": null,
"description": "A selector for the right operand. Should not be specified if rightValue is specified.",
"name": "rightField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the left operand. Should not be specified if leftField is specified.",
"name": "leftValue",
"optional": true,
"type": "Object"
},
{
"default": {
"type": "ErrorMargin",
"unit": "meters",
"value": 0.1
},
"description": "The maximum reprojection error allowed during filter application.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
}
],
"description": "Creates a unary or binary filter that passes if the right geometry contains the left geometry (empty geometries are not contained in anything).",
"returns": "Filter",
"type": "Algorithm",
"hidden": false
},
"Image.bitwiseXor": {
"args": [
{
"description": "The image from which the left operand bands are taken.",
"name": "image1",
"type": "Image<unknown bands>"
},
{
"description": "The image from which the right operand bands are taken.",
"name": "image2",
"type": "Image<unknown bands>"
}
],
"description": "Calculates the bitwise XOR of the input values for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is the union of the input types.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"List.equals": {
"args": [
{
"name": "list",
"type": "List<Object>"
},
{
"name": "other",
"type": "List<Object>"
}
],
"description": "Returns true if list contains the same elements as other, in the same order.",
"returns": "Boolean",
"type": "Algorithm",
"hidden": false
},
"List.length": {
"args": [
{
"name": "list",
"type": "List<Object>"
}
],
"description": "Returns the number of elements in list.",
"returns": "Integer",
"type": "Algorithm",
"hidden": false
},
"Date.update": {
"args": [
{
"name": "date",
"type": "Date"
},
{
"default": null,
"name": "year",
"optional": true,
"type": "Integer"
},
{
"default": null,
"name": "month",
"optional": true,
"type": "Integer"
},
{
"default": null,
"name": "day",
"optional": true,
"type": "Integer"
},
{
"default": null,
"name": "hour",
"optional": true,
"type": "Integer"
},
{
"default": null,
"name": "minute",
"optional": true,
"type": "Integer"
},
{
"default": null,
"name": "second",
"optional": true,
"type": "Integer"
},
{
"default": null,
"description": "The time zone (e.g. 'America/Los_Angeles'); defaults to UTC.",
"name": "timeZone",
"optional": true,
"type": "String"
}
],
"description": "Create a new Date by setting one or more of the units of the given Date to a new value. If a timeZone is given the new value(s) is interpreted in that zone.",
"returns": "Date",
"type": "Algorithm",
"hidden": false
},
"Number.first_nonzero": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Number"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Number"
}
],
"description": "Selects the first value if it is non-zero, and the second value otherwise.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Array.int64": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, casts the input value to a signed 64-bit integer.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Kernel.manhattan": {
"args": [
{
"description": "The radius of the kernel to generate.",
"name": "radius",
"type": "Float"
},
{
"default": "pixels",
"description": "The system of measurement for the kernel ('pixels' or 'meters'). If the kernel is specified in meters, it will resize when the zoom-level is changed.",
"name": "units",
"optional": true,
"type": "String"
},
{
"default": false,
"description": "Normalize the kernel values to sum to 1.",
"name": "normalize",
"optional": true,
"type": "Boolean"
},
{
"default": 1.0,
"description": "Scale each value by this amount.",
"name": "magnitude",
"optional": true,
"type": "Float"
}
],
"description": "Generates a distance kernel based on rectilinear (city-block) distance.",
"returns": "Kernel",
"type": "Algorithm",
"hidden": false
},
"Dictionary.set": {
"args": [
{
"name": "dictionary",
"type": "Dictionary<Object>"
},
{
"name": "key",
"type": "String"
},
{
"name": "value",
"type": "Object"
}
],
"description": "Set a value in a dictionary.",
"returns": "Object",
"type": "Algorithm",
"hidden": false
},
"Reducer.forEach": {
"args": [
{
"name": "reducer",
"type": "Reducer"
},
{
"name": "outputNames",
"type": "List<String>"
}
],
"description": "Creates a Reducer by combining a copy of the given reducer for each output name in the given list. If the reducer has a single output, the output names are used as-is; otherwise they are prefixed to the original output names.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Filter.eq": {
"args": [
{
"default": null,
"description": "A selector for the left operand. Should not be specified if leftValue is specified.",
"name": "leftField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the right operand. Should not be specified if rightField is specified.",
"name": "rightValue",
"optional": true,
"type": "Object"
},
{
"default": null,
"description": "A selector for the right operand. Should not be specified if rightValue is specified.",
"name": "rightField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the left operand. Should not be specified if leftField is specified.",
"name": "leftValue",
"optional": true,
"type": "Object"
}
],
"description": "Creates a unary or binary filter that passes if the two operands are equals.",
"returns": "Filter",
"type": "Algorithm",
"hidden": false
},
"String.toUpperCase": {
"args": [
{
"description": "The string to convert to upper case.",
"name": "string",
"type": "String"
}
],
"description": "Converts all of the characters in a string to upper case.",
"returns": "String",
"type": "Algorithm",
"hidden": false
},
"PixelType.float": {
"args": [],
"description": "Returns the 32-bit floating point pixel type.",
"returns": "PixelType",
"type": "Algorithm",
"hidden": false
},
"Number.hypot": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Number"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Number"
}
],
"description": "Calculates the magnitude of the 2D vector [x, y].",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"GeometryConstructors.Point": {
"args": [
{
"description": "The coordinates of this Point in x,y order.",
"name": "coordinates",
"type": "List<Number>"
},
{
"default": null,
"description": "The coordinate reference system of the coordinates. The default is the projection of the inputs, where Numbers are assumed to be EPSG:4326.",
"name": "crs",
"optional": true,
"type": "Projection"
}
],
"description": "Constructs a new Point from the given x,y coordinates.",
"returns": "Geometry",
"type": "Algorithm",
"hidden": false
},
"DateRange.intersection": {
"args": [
{
"name": "dateRange",
"type": "DateRange"
},
{
"name": "other",
"type": "DateRange"
}
],
"description": "Returns a DateRange that contains all points in the intersection of this DateRange and another.",
"returns": "DateRange",
"type": "Algorithm",
"hidden": false
},
"DateRange.end": {
"args": [
{
"name": "dateRange",
"type": "DateRange"
}
],
"description": "Returns the (exclusive) end of this DateRange.",
"returns": "Date",
"type": "Algorithm",
"hidden": false
},
"Image.Segmentation.seedGrid": {
"args": [
{
"default": 5,
"description": "The superpixel seed location spacing, in pixels.",
"name": "size",
"optional": true,
"type": "Integer"
},
{
"default": "square",
"description": "Type of grid. One of 'square' or 'hex'.",
"name": "gridType",
"optional": true,
"type": "String"
}
],
"description": "Selects seed pixels for clustering.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"ConfusionMatrix.kappa": {
"args": [
{
"name": "confusionMatrix",
"type": "ConfusionMatrix"
}
],
"description": "Computes the Kappa statistic for the confusion matrix.",
"returns": "Float",
"type": "Algorithm",
"hidden": false
},
"Array.matrixMultiply": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Array"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Array"
}
],
"description": "Returns the matrix multiplication A*B.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Number.acos": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Computes the arc cosine in radians of the input.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Array.digamma": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, computes the digamma function of the input.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Image.paint": {
"args": [
{
"description": "The image on which the collection is painted.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"description": "The collection painted onto the image.",
"name": "featureCollection",
"type": "FeatureCollection"
},
{
"default": 0,
"description": "Either the name of a color property or a number.",
"name": "color",
"optional": true,
"type": "Object"
},
{
"default": null,
"description": "Either the name of a line-width property or a number.",
"name": "width",
"optional": true,
"type": "Object"
}
],
"description": "Paints the geometries of a collection onto an image.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Array.int32": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, casts the input value to a signed 32-bit integer.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Array.ceil": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, computes the smallest integer greater than or equal to the input.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Image.acos": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Computes the arc cosine in radians of the input.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Array.byte": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, casts the input value to an unsigned 8-bit integer.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"ImageCollection.merge": {
"args": [
{
"description": "The first collection to merge.",
"name": "collection1",
"type": "ImageCollection"
},
{
"description": "The second collection to merge.",
"name": "collection2",
"type": "ImageCollection"
}
],
"description": "Merges two image collections into one. The result has all the images that were in either collection.",
"returns": "ImageCollection",
"type": "Algorithm",
"hidden": false
},
"WrappedFeatureCollection.AggregationContainer": {
"args": [
{
"name": "collection",
"type": "FeatureCollection"
}
],
"description": "INTERNAL",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": true
},
"DateRange.contains": {
"args": [
{
"name": "dateRange",
"type": "DateRange"
},
{
"name": "other",
"type": "Object"
}
],
"description": "Returns true if the given Date or DateRange is within this DateRange.",
"returns": "Boolean",
"type": "Algorithm",
"hidden": false
},
"Geometry.geometries": {
"args": [
{
"name": "geometry",
"type": "Geometry"
}
],
"description": "Returns the list of geometries in a GeometryCollection, or a singleton list of the geometry for single geometries.",
"returns": "List<Geometry>",
"type": "Algorithm",
"hidden": false
},
"Number.log": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Computes the natural logarithm of the input.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Join.saveAll": {
"args": [
{
"description": "The property name used to save the matches list.",
"name": "matchesKey",
"type": "String"
},
{
"default": null,
"description": "The property on which to sort the matches list.",
"name": "ordering",
"optional": true,
"type": "String"
},
{
"default": true,
"description": "Whether the ordering is ascending.",
"name": "ascending",
"optional": true,
"type": "Boolean"
},
{
"default": null,
"description": "An optional property name used to save the measure of the join condition on each match.",
"name": "measureKey",
"optional": true,
"type": "String"
}
],
"description": "Returns a join that pairs each element from the first collection with a group of matching elements from the second collection. The list of matches is added to each result as an additional property. If measureKey is specified, each match has the value of its join measure attached. Join measures are produced when withinDistance or maxDifference filters are used as the join condition.",
"returns": "Join",
"type": "Algorithm",
"hidden": false
},
"Image.toLong": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Casts the input value to a signed 64-bit integer.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Geometry.disjoint": {
"args": [
{
"description": "The geometry used as the left operand of the operation.",
"name": "left",
"type": "Geometry"
},
{
"description": "The geometry used as the right operand of the operation.",
"name": "right",
"type": "Geometry"
},
{
"default": null,
"description": "The maximum amount of error tolerated when performing any necessary reprojection.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
},
{
"default": null,
"description": "The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.",
"name": "proj",
"optional": true,
"type": "Projection"
}
],
"description": "Returns true iff the geometries are disjoint.",
"returns": "Boolean",
"type": "Algorithm",
"hidden": false
},
"Image.medialAxis": {
"args": [
{
"description": "The input image.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"default": 256,
"description": "Neighborhood size in pixels.",
"name": "neighborhood",
"optional": true,
"type": "Integer"
},
{
"default": "pixels",
"description": "The units of the neighborhood, currently only 'pixels' are supported.",
"name": "units",
"optional": true,
"type": "String"
}
],
"description": "Computes the discrete medial axis of the zero valued pixels of the first band of the input. Outputs 4 bands:\n medial - the medial axis points, scaled by the distance.\n coverage - the number of points supporting each medial axis point.\n xlabel - the horizontal distance to the power point for each pixel.\n ylabel - the vertical distance to the power point for each pixel.\n",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Landsat.pathRowLimit": {
"args": [
{
"description": "The Landsat ImageCollection to limit.",
"name": "collection",
"type": "ImageCollection"
},
{
"default": 25,
"description": "The max number of scenes to return per path/row.",
"name": "maxScenesPerPathRow",
"optional": true,
"type": "Integer"
},
{
"default": 100,
"description": "The max number of scenes to return per request total.",
"name": "maxScenesTotal",
"optional": true,
"type": "Integer"
}
],
"description": "Limits requests to an ImageCollection of Landsat scenes to return a controllable number of the best scenes for each request. This is intended for use with statistical algorithms like median composites that need a certain amount of good data to perform well, but that do not benefit substantially from additional data beyond that while becoming needlessly expensive. The default arguments select approximately one year's worth of good data.\n\nNote that in rare circumstances, when the tile boundary aligns with a Landsat WRS cell bounadry, queries for adjacent tiles may yield conflicting results. This is why it is important that this algorithm only be used with statistical methods that can tolerate these inconsistencies.",
"returns": "ImageCollection",
"type": "Algorithm",
"hidden": false
},
"SampleImage.AggregationContainer": {
"args": [
{
"name": "image",
"type": "Image<unknown bands>"
},
{
"name": "proj",
"type": "Projection"
},
{
"name": "region",
"type": "Geometry"
},
{
"name": "factor",
"type": "Float"
},
{
"name": "seed",
"type": "Long"
},
{
"name": "dropNulls",
"type": "Boolean"
},
{
"name": "tileScale",
"type": "Float"
}
],
"description": "INTERNAL",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": true
},
"Image.geometry": {
"args": [
{
"description": "The feature from which the geometry is taken.",
"name": "feature",
"type": "Element"
},
{
"default": null,
"description": "The maximum amount of error tolerated when performing any necessary reprojection.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
},
{
"default": null,
"description": "If specified, the geometry will be in this projection. If unspecified, the geometry will be in its default projection.",
"name": "proj",
"optional": true,
"type": "Projection"
},
{
"default": null,
"description": "If true, the geometry will have geodesic edges. If false, it will have edges as straight lines in the specified projection. If null, the edge interpretation will be the same as the original geometry. This argument is ignored if proj is not specified.",
"name": "geodesics",
"optional": true,
"type": "Boolean"
}
],
"description": "Returns the geometry of a given feature in a given projection.",
"returns": "Geometry",
"type": "Algorithm",
"hidden": false,
"deprecated": "Use Element.geometry()"
},
"List.iterate": {
"args": [
{
"name": "list",
"type": "List<Object>"
},
{
"name": "function",
"type": "Algorithm"
},
{
"name": "first",
"type": "Object"
}
],
"description": "Iterate an algorithm over a list. The algorithm is expected to take two objects, the current list item, and the result from the previous iteration or the value of first for the first iteration.",
"returns": "Object",
"type": "Algorithm",
"hidden": false
},
"FMask.matchClouds": {
"args": [
{
"description": "The scene for which to compute cloud and shadow masks.",
"name": "input",
"type": "Image<unknown bands>"
},
{
"description": "Potential cloud mask image. Expected to contain 1s for cloudy pixels and masked pixels everywhere else.",
"name": "cloud",
"type": "Image<unknown bands>"
},
{
"description": "Potential shadow mask image. Expected to contain 1s for shadow pixels and masked pixels everywhere else.",
"name": "shadow",
"type": "Image<unknown bands>"
},
{
"description": "Brightness temperature image, in Celsius.",
"name": "btemp",
"type": "Image<unknown bands>"
},
{
"description": "The 0.175 percentile brightness temperature of the scene.",
"name": "sceneLow",
"type": "Float"
},
{
"description": "The 0.825 percentile brightness temperature of the scene.",
"name": "sceneHigh",
"type": "Float"
},
{
"default": 50,
"description": "The neighborhood to pad around each tile.",
"name": "neighborhood",
"optional": true,
"type": "Integer"
}
],
"description": "Runs the FMask cloud and shadow matching. Outputs a single band ('csm'), containing the computed cloud and shadow masks.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.pixelCoordinates": {
"args": [
{
"description": "The projection in which to provide pixel.",
"name": "projection",
"type": "Projection"
}
],
"description": "Creates a two band image containing the x and y coordinates of each pixel in the given projection.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.hypot": {
"args": [
{
"description": "The image from which the left operand bands are taken.",
"name": "image1",
"type": "Image<unknown bands>"
},
{
"description": "The image from which the right operand bands are taken.",
"name": "image2",
"type": "Image<unknown bands>"
}
],
"description": "Calculates the magnitude of the 2D vector [x, y] for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is float.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.gradient": {
"args": [
{
"description": "The input image.",
"name": "input",
"type": "Image<unknown bands>"
}
],
"description": "Calculates the x and y gradient.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Annotation.ellipse": {
"args": [
{
"description": "The x-axis coordinate of the center of the ellipse.",
"name": "cx",
"type": "Float"
},
{
"description": "The y-axis coordinate of the center of the ellipse.",
"name": "cy",
"type": "Float"
},
{
"description": "The x-axis radius of the ellipse.",
"name": "rx",
"type": "Float"
},
{
"description": "The y-axis radius of the ellipse.",
"name": "ry",
"type": "Float"
}
],
"description": "Creates an ellipse annotation.",
"returns": "Annotation",
"type": "Algorithm",
"hidden": false
},
"Array.log": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, computes the natural logarithm of the input.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Kernel.roberts": {
"args": [
{
"default": 1.0,
"description": "Scale each value by this amount.",
"name": "magnitude",
"optional": true,
"type": "Float"
},
{
"default": false,
"description": "Normalize the kernel values to sum to 1.",
"name": "normalize",
"optional": true,
"type": "Boolean"
}
],
"description": "Generates a 2x2 Roberts edge-detection kernel.",
"returns": "Kernel",
"type": "Algorithm",
"hidden": false
},
"DateRange.isUnbounded": {
"args": [
{
"name": "dateRange",
"type": "DateRange"
}
],
"description": "Returns true if this DateRange contains all dates.",
"returns": "Boolean",
"type": "Algorithm",
"hidden": false
},
"Date.fromYMD": {
"args": [
{
"name": "year",
"type": "Integer"
},
{
"name": "month",
"type": "Integer"
},
{
"name": "day",
"type": "Integer"
},
{
"default": null,
"description": "The time zone (e.g. 'America/Los_Angeles'); defaults to UTC.",
"name": "timeZone",
"optional": true,
"type": "String"
}
],
"description": "Returns a Date given year, month, day.",
"returns": "Date",
"type": "Algorithm",
"hidden": false
},
"List.lastIndexOfSubList": {
"args": [
{
"name": "list",
"type": "List<Object>"
},
{
"name": "target",
"type": "List<Object>"
}
],
"description": "Returns the starting position of the last occurrence of target within list, or -1 if there is no such occurrence.",
"returns": "Integer",
"type": "Algorithm",
"hidden": false
},
"Number.log10": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Computes the base-10 logarithm of the input.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Array.int16": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, casts the input value to a signed 16-bit integer.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Image.unitScale": {
"args": [
{
"description": "The image to scale.",
"name": "input",
"type": "Image<unknown bands>"
},
{
"description": "The value mapped to 0.",
"name": "low",
"type": "Float"
},
{
"description": "The value mapped to 1.",
"name": "high",
"type": "Float"
}
],
"description": "Scales the input so that the range of input values [low, high] becomes [0, 1]. Values outside the range are NOT clamped. This algorithm always produces floating point pixels.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Number.subtract": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Number"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Number"
}
],
"description": "Subtracts the second value from the first.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Image.log10": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Computes the base-10 logarithm of the input.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"GeometryConstructors.LineString": {
"args": [
{
"description": "The list of Points or pairs of Numbers in x,y order.",
"name": "coordinates",
"type": "List<Object>"
},
{
"default": null,
"description": "The coordinate reference system of the coordinates. The default is the projection of the inputs, where Numbers are assumed to be EPSG:4326.",
"name": "crs",
"optional": true,
"type": "Projection"
},
{
"default": null,
"description": "If false, edges are straight in the projection. If true, edges are curved to follow the shortest path on the surface of the Earth. The default is the geodesic state of the inputs, or true if the inputs are numbers.",
"name": "geodesic",
"optional": true,
"type": "Boolean"
}
],
"description": "Constructs a LineString from the given coordinates.",
"returns": "Geometry",
"type": "Algorithm",
"hidden": false
},
"Image.lanczos": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Computes the Lanczos approximation of the input.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Filter.contains": {
"args": [
{
"default": null,
"description": "A selector for the left operand. Should not be specified if leftValue is specified.",
"name": "leftField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the right operand. Should not be specified if rightField is specified.",
"name": "rightValue",
"optional": true,
"type": "Object"
},
{
"default": null,
"description": "A selector for the right operand. Should not be specified if rightValue is specified.",
"name": "rightField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the left operand. Should not be specified if leftField is specified.",
"name": "leftValue",
"optional": true,
"type": "Object"
},
{
"default": {
"type": "ErrorMargin",
"unit": "meters",
"value": 0.1
},
"description": "The maximum reprojection error allowed during filter application.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
}
],
"description": "Creates a unary or binary filter that passes if the left geometry contains the right geometry (empty geometries are not contained in anything).",
"returns": "Filter",
"type": "Algorithm",
"hidden": false
},
"Image.Segmentation.SNIC": {
"args": [
{
"description": "The input image for clustering.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"default": 5,
"description": "The superpixel seed location spacing, in pixels. If 'seeds' image is provided, no grid is produced.",
"name": "size",
"optional": true,
"type": "Integer"
},
{
"default": 1.0,
"description": "Compactness factor. Larger values cause clusters to be more compact (square). Setting this to 0 disables spatial distance weighting.",
"name": "compactness",
"optional": true,
"type": "Float"
},
{
"default": 8,
"description": "Connectivity. Either 4 or 8.",
"name": "connectivity",
"optional": true,
"type": "Integer"
},
{
"default": null,
"description": "Tile neighborhood size (to avoid tile boundary artifacts). Defaults to 2 * size.",
"name": "neighborhoodSize",
"optional": true,
"type": "Integer"
},
{
"default": null,
"description": "If provided, any non-zero valued pixels are used as seed locations. Pixels that touch (as specified by 'connectivity') are considered to belong to the same cluster.",
"name": "seeds",
"optional": true,
"type": "Image<unknown bands>"
}
],
"description": "Superpixel clustering based on SNIC (Simple Non-Iterative Clustering). Outputs a band of cluster IDs and the per-cluster averages for each of the input bands. If the 'seeds' image isn't provided as input, the output will include a 'seeds' band containing the generated seed locations. See: Achanta, Radhakrishna and Susstrunk, Sabine, 'Superpixels and Polygons using Simple Non-Iterative Clustering', CVPR, 2017.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"FeatureCollection.classify": {
"args": [
{
"description": "The collection of features to classify. Each feature must contain all the properties in the classifier's schema.",
"name": "features",
"type": "FeatureCollection"
},
{
"description": "The classifier to use.",
"name": "classifier",
"type": "Object"
},
{
"default": "classification",
"description": "The name of the output property to be added.",
"name": "outputName",
"optional": true,
"type": "String"
}
],
"description": "Classifies each feature in a collection.",
"returns": "FeatureCollection",
"type": "Algorithm",
"hidden": false
},
"Array.toList": {
"args": [
{
"description": "Array to convert.",
"name": "array",
"type": "Array"
}
],
"description": "Turns an Array into a list of lists of numbers.",
"returns": "List<Object>",
"type": "Algorithm",
"hidden": false
},
"Image.toInt8": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Casts the input value to a signed 8-bit integer.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.retile": {
"args": [
{
"description": "Input image. The result will have the same bands and properties.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"description": "Edge length in pixels of the tile grid to use; must be between 1 and 256.",
"name": "size",
"type": "Integer"
}
],
"description": "Change the size of tiles in which the input image is calculated.\n\nWhen pixels of this image are needed, they are computed in tiles of the specified size. This allows a memory-intensive image computation, such as one involving large array bands, to be broken up into smaller pieces that will fit into memory where larger ones will not.\n\nCurrently, if the image is used in a reduce operation, the tileScale parameter should be used instead of retile(). retile() will also have no or detrimental effect in an Export.video task.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Number.bitwiseXor": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Number"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Number"
}
],
"description": "Calculates the bitwise XOR of the input values.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Reducer.product": {
"args": [],
"description": "Returns a Reducer that computes the product of its inputs.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Reducer.lastNonNull": {
"args": [],
"description": "Returns a Reducer that returns the last of its non-null inputs.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Date.millis": {
"args": [
{
"name": "date",
"type": "Date"
}
],
"description": "The number of milliseconds since 1970-01-01T00:00:00Z.",
"returns": "Long",
"type": "Algorithm",
"hidden": false
},
"Geometry.convexHull": {
"args": [
{
"description": "Calculates the convex hull of this geometry.",
"name": "geometry",
"type": "Geometry"
},
{
"default": null,
"description": "The maximum amount of error tolerated when performing any necessary reprojection.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
},
{
"default": null,
"description": "The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.",
"name": "proj",
"optional": true,
"type": "Projection"
}
],
"description": "Returns the convex hull of the given geometry. The convex hull of a single point is the point itself, the convex hull of collinear points is a line, and the convex hull of everything else is a polygon. Note that a degenerate polygon with all vertices on the same line will result in a line segment.",
"returns": "Geometry",
"type": "Algorithm",
"hidden": false
},
"Image.reduceRegion": {
"args": [
{
"description": "The image to reduce.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"description": "The reducer to apply.",
"name": "reducer",
"type": "Reducer"
},
{
"default": null,
"description": "The region over which to reduce data. Defaults to the footprint of the image's first band.",
"name": "geometry",
"optional": true,
"type": "Geometry"
},
{
"default": null,
"description": "A nominal scale in meters of the projection to work in.",
"name": "scale",
"optional": true,
"type": "Float"
},
{
"default": null,
"description": "The projection to work in. If unspecified, the projection of the image's first band is used. If specified in addition to scale, rescaled to the specified scale.",
"name": "crs",
"optional": true,
"type": "Projection"
},
{
"default": null,
"description": "The list of CRS transform values. This is a row-major ordering of the 3x2 transform matrix. This option is mutually exclusive with 'scale', and replaces any transform already set on the projection.",
"name": "crsTransform",
"optional": true,
"type": "List<Float>"
},
{
"default": false,
"description": "If the polygon would contain too many pixels at the given scale, compute and use a larger scale which would allow the operation to succeed.",
"name": "bestEffort",
"optional": true,
"type": "Boolean"
},
{
"default": 10000000,
"description": "The maximum number of pixels to reduce.",
"name": "maxPixels",
"optional": true,
"type": "Long"
},
{
"default": 1.0,
"description": "A scaling factor used to reduce aggregation tile size; using a larger tileScale (e.g. 2 or 4) may enable computations that run out of memory with the default.",
"name": "tileScale",
"optional": true,
"type": "Float"
}
],
"description": "Apply a reducer to all the pixels in a specific region.\nEither the reducer must have the same number of inputs as the input image has bands, or it must have a single input and will be repeated for each band.\nReturns a dictionary of the reducer's outputs.",
"returns": "Dictionary<Object>",
"type": "Algorithm",
"hidden": false
},
"Image.reduceResolution": {
"args": [
{
"description": "The input image.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"description": "The reducer to apply to be used for combining pixels.",
"name": "reducer",
"type": "Reducer"
},
{
"default": false,
"description": "If using the input at its default resolution would require too many pixels, start with already-reduced input pixels from a pyramid level that allows the operation to succeed.",
"name": "bestEffort",
"optional": true,
"type": "Boolean"
},
{
"default": 64,
"description": "The maximum number of input pixels to combine for each output pixel. Setting this too large will cause out-of-memory problems.",
"name": "maxPixels",
"optional": true,
"type": "Integer"
}
],
"description": "Enables reprojection using the given reducer to combine all input pixels corresponding to each output pixel. If the reducer has a single input, it will be applied separately to each band of the collection; otherwise it must have the same number of inputs as the input image has bands.\nThe reducer output names determine the names of the output bands: reducers with multiple inputs will use the output names directly, reducers with a single input and single output will preserve the input band names, and reducers with a single input and multiple outputs will prefix the output name with the input band name (e.g. '10_mean', '10_stdDev', '20_mean', '20_stdDev', etc.).\nReducer input weights will be the product of the input mask and the fraction of the output pixel covered by the input pixel.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.matrixTranspose": {
"args": [
{
"description": "Input image.",
"name": "input",
"type": "Image<unknown bands>"
},
{
"default": 0,
"description": "First axis to swap.",
"name": "axis1",
"optional": true,
"type": "Integer"
},
{
"default": 1,
"description": "Second axis to swap.",
"name": "axis2",
"optional": true,
"type": "Integer"
}
],
"description": "Transposes two dimensions of each array pixel.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.updateMask": {
"args": [
{
"description": "Input image.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"description": "New mask for the image, as a floating-point value in the range [0, 1] (invalid = 0, valid = 1). If this image has a single band, it is used for all bands in the input image; otherwise, must have the same number of bands as the input image.",
"name": "mask",
"type": "Image<unknown bands>"
}
],
"description": "Updates an image's mask at all positions where the existing mask is not zero. The output image retains the metadata and footprint of the input image.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.toDouble": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Casts the input value to a 64-bit float.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.matrixLUDecomposition": {
"args": [
{
"description": "Image of 2-D matrices to be decomposed.",
"name": "image",
"type": "Image<unknown bands>"
}
],
"description": "Calculates the LU matrix decomposition such that P×input=L×U, where L is lower triangular (with unit diagonal terms), U is upper triangular and P is a partial pivot permutation matrix. The input matrix must be square. Returns an image with bands named 'L', 'U' and 'P'.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Geometry.projection": {
"args": [
{
"name": "geometry",
"type": "Geometry"
}
],
"description": "Returns the projection of the geometry.",
"returns": "Projection",
"type": "Algorithm",
"hidden": false
},
"Image.rename": {
"args": [
{
"description": "The image to select bands from.",
"name": "input",
"type": "Image<unknown bands>"
},
{
"description": "New names for the image's bands. Must exactly match the number of bands in input.",
"name": "names",
"type": "List<String>"
}
],
"description": "Renames the bands of an image.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Number.lte": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Number"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Number"
}
],
"description": "Returns 1 iff the first value is less than or equal to the second.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Classifier.continuousNaiveBayes": {
"args": [
{
"default": 0.001,
"description": "A smoothing lambda. Used to avoid assigning zero probability to classes not seen during training, instead using lambda / (lambda * nFeatures).",
"name": "lambda",
"optional": true,
"type": "Float"
}
],
"description": "Creates an empty Continuous Naive Bayes classifier.",
"returns": "Classifier",
"type": "Algorithm",
"hidden": false,
"deprecated": "Deprecated; will be removed eventually."
},
"List.repeat": {
"args": [
{
"name": "value",
"type": "Object"
},
{
"name": "count",
"type": "Integer"
}
],
"description": "Returns a new list containing value repeated count times.",
"returns": "List<Object>",
"type": "Algorithm",
"hidden": false
},
"Number.ceil": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Computes the smallest integer greater than or equal to the input.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Image.arrayReduce": {
"args": [
{
"description": "Input image.",
"name": "input",
"type": "Image<unknown bands>"
},
{
"description": "The reducer to apply",
"name": "reducer",
"type": "Reducer"
},
{
"description": "The list of array axes to reduce in each pixel. The output will have a length of 1 in all these axes.",
"name": "axes",
"type": "List<Integer>"
},
{
"default": null,
"description": "The axis for the reducer's input and output fields. Only required if the reducer has multiple inputs or outputs.",
"name": "fieldAxis",
"optional": true,
"type": "Integer"
}
],
"description": "Reduces elements of each array pixel.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Array.bitsToArray": {
"args": [
{
"name": "input",
"type": "Number"
}
],
"description": "Convert the bits of an integer to an Array. The array has as many elements as the position of the highest set bit, or a single 0 for a value of 0.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Collection.fromColumns": {
"args": [
{
"description": "A list of values for each property; must have the same length as propertyNames.",
"name": "columns",
"type": "List<List<Object>>"
},
{
"description": "The property names for features in this collection.",
"name": "propertyNames",
"type": "List<String>"
},
{
"default": null,
"description": "The type of each property; if present, must have the same length as propertyNames.",
"name": "propertyTypes",
"optional": true,
"type": "List<Object>"
}
],
"description": "Creates a FeatureCollection, given a list of values for each property.",
"returns": "FeatureCollection",
"type": "Algorithm",
"hidden": true
},
"Image.mod": {
"args": [
{
"description": "The image from which the left operand bands are taken.",
"name": "image1",
"type": "Image<unknown bands>"
},
{
"description": "The image from which the right operand bands are taken.",
"name": "image2",
"type": "Image<unknown bands>"
}
],
"description": "Calculates the remainder of the first value divided by the second for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is the union of the input types.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Number.byte": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Casts the input value to an unsigned 8-bit integer.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"List.set": {
"args": [
{
"name": "list",
"type": "List<Object>"
},
{
"name": "index",
"type": "Integer"
},
{
"name": "element",
"type": "Object"
}
],
"description": "Replaces the value at the specified position in list with element. A negative index counts backwards from the end of the list.",
"returns": "List<Object>",
"type": "Algorithm",
"hidden": false
},
"Dictionary.rename": {
"args": [
{
"name": "dictionary",
"type": "Dictionary<Object>"
},
{
"description": "A list of keys to be renamed.",
"name": "from",
"type": "List<String>"
},
{
"description": "A list of the new names for the keys listed in the 'from' parameter. Must have the same length as the 'from' list.",
"name": "to",
"type": "List<String>"
},
{
"default": false,
"description": "Allow overwriting existing properties with the same name.",
"name": "overwrite",
"optional": true,
"type": "Boolean"
}
],
"description": "Rename elements in a dictionary.",
"returns": "Dictionary<Object>",
"type": "Algorithm",
"hidden": false
},
"Image.copyProperties": {
"args": [
{
"default": null,
"description": "The object whose properties to override.",
"name": "destination",
"optional": true,
"type": "Element"
},
{
"default": null,
"description": "The object from which to copy the properties.",
"name": "source",
"optional": true,
"type": "Element"
},
{
"default": null,
"description": "The properties to copy. If omitted, all ordinary (i.e. non-system) properties are copied.",
"name": "properties",
"optional": true,
"type": "List<String>"
},
{
"default": null,
"description": "The list of properties to exclude when copying all properties. Must not be specified if properties is.",
"name": "exclude",
"optional": true,
"type": "List<String>"
}
],
"description": "Copies metadata properties from one element to another.",
"returns": "Element",
"type": "Algorithm",
"hidden": false,
"deprecated": "Use Element.copyProperties()"
},
"Array.toUint8": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, casts the input value to an unsigned 8-bit integer.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Join.saveBest": {
"args": [
{
"description": "The key used to save the match.",
"name": "matchKey",
"type": "String"
},
{
"description": "The key used to save the measure of the join condition on the match.",
"name": "measureKey",
"type": "String"
}
],
"description": "Returns a join that pairs each element from the first collection with a matching element from the second collection. The match with the best join measure is added to each result as an additional property. Join measures are produced when withinDistance or maxDifference filters are used as the join condition.",
"returns": "Join",
"type": "Algorithm",
"hidden": false
},
"Array.lte": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Array"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Array"
}
],
"description": "On an element-wise basis, returns 1 iff the first value is less than or equal to the second.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"FeatureCollection.inverseDistance": {
"args": [
{
"description": "Feature collection to use as source data for the estimation.",
"name": "collection",
"type": "FeatureCollection"
},
{
"description": "Size of the interpolation window (in meters).",
"name": "range",
"type": "Float"
},
{
"description": "Name of the numeric property to be estimated.",
"name": "propertyName",
"type": "String"
},
{
"description": "Global expected mean.",
"name": "mean",
"type": "Float"
},
{
"description": "Global standard deviation.",
"name": "stdDev",
"type": "Float"
},
{
"default": 1.0,
"description": "Determines how quickly the estimates tend towards the global mean.",
"name": "gamma",
"optional": true,
"type": "Float"
},
{
"default": null,
"description": "Reducer used to collapse the 'propertyName' value of overlapping points into a single value.",
"name": "reducer",
"optional": true,
"type": "Reducer"
}
],
"description": "Returns an inverse-distance weighted estimate of the value at each pixel.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Number.int64": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Casts the input value to a signed 64-bit integer.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Reducer.toCollection": {
"args": [
{
"description": "The property names that will be defined on each output feature; determines the number of reducer inputs.",
"name": "propertyNames",
"type": "List<String>"
},
{
"default": 0,
"description": "The last numOptional inputs will be considered optional; the other inputs must be non-null or the input tuple will be dropped.",
"name": "numOptional",
"optional": true,
"type": "Integer"
}
],
"description": "Returns a reducer that collects its inputs into a FeatureCollection.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"reduce.mean": {
"args": [
{
"description": "The image collection to reduce.",
"name": "collection",
"type": "ImageCollection"
}
],
"description": "Reduces an image collection by calculating the mean of all values at each pixel across the stack of all matching bands. Bands are matched by name.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Array.matrixQRDecomposition": {
"args": [
{
"description": "The array to decompose.",
"name": "array",
"type": "Array"
}
],
"description": "Calculates the QR-decomposition of a matrix into two matrices Q and R such that input = QR, where Q is orthogonal, and R is upper triangular. Returns a dictionary with entries named 'Q' and 'R'.",
"returns": "Dictionary<Object>",
"type": "Algorithm",
"hidden": false
},
"Image.erfc": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Computes the complementary error function of the input.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Array.bitwise_and": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Array"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Array"
}
],
"description": "On an element-wise basis, calculates the bitwise AND of the input values.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Collection.cache": {
"args": [
{
"description": "The collection to cache.",
"name": "collection",
"type": "FeatureCollection"
}
],
"description": "Caches the given collection.",
"returns": "FeatureCollection",
"type": "Algorithm",
"hidden": true
},
"List.reduce": {
"args": [
{
"name": "list",
"type": "List<Object>"
},
{
"name": "reducer",
"type": "Reducer"
}
],
"description": "Apply a reducer to a list. If the reducer takes more than 1 input, then each element in the list is assumed to be a list of inputs. If the reducer returns a single output, it is returned directly, otherwise returns a dictionary containing the named reducer outputs.",
"returns": "Object",
"type": "Algorithm",
"hidden": false
},
"Array.toDouble": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, casts the input value to a 64-bit float.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Array.toByte": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, casts the input value to an unsigned 8-bit integer.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Image.matrixFnorm": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Computes the Frobenius norm of the matrix.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"CannyEdgeDetector": {
"args": [
{
"description": "The image on which to apply edge detection.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"description": "Threshold value. The pixel is only considered for edge detection if the gradient magnitude is higher than this threshold.",
"name": "threshold",
"type": "Float"
},
{
"default": 1.0,
"description": "Sigma value for a gaussian filter applied before edge detection. 0 means apply no filtering.",
"name": "sigma",
"optional": true,
"type": "Float"
}
],
"description": "Applies the Canny edge detection algorithm to an image. The output is an image whose bands have the same names as the input bands, and in which non-zero values indicate edges, and the magnitude of the value is the gradient magnitude.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"DateRange.isEmpty": {
"args": [
{
"name": "dateRange",
"type": "DateRange"
}
],
"description": "Returns true if this DateRange contains no dates (i.e. start >= end).",
"returns": "Boolean",
"type": "Algorithm",
"hidden": false
},
"Geometry.coveringGrid": {
"args": [
{
"description": "The result is the grid cells that intersect with this region.",
"name": "geometry",
"type": "Geometry"
},
{
"description": "The projection in which to construct the grid. A feature is generated for each grid cell that intersects 'geometry', where cell corners are at integer-valued positions in the projection. If the projection is scaled in meters, the points will be on a grid of that size at the point of true scale.",
"name": "proj",
"type": "Projection"
},
{
"default": null,
"description": "Overrides the scale of the projection, if provided. May be required if the projection isn't already scaled.",
"name": "scale",
"optional": true,
"type": "Float"
}
],
"description": "Returns a collection of features that cover this geometry, where each feature is a rectangle in the grid defined by the given projection.",
"returns": "FeatureCollection",
"type": "Algorithm",
"hidden": false
},
"Join.apply": {
"args": [
{
"description": "The join to apply; determines how the the results are constructed.",
"name": "join",
"type": "Join"
},
{
"description": "The primary collection.",
"name": "primary",
"type": "FeatureCollection"
},
{
"description": "The secondary collection.",
"name": "secondary",
"type": "FeatureCollection"
},
{
"description": "The join condition used to select the matches from the two collections.",
"name": "condition",
"type": "Filter"
}
],
"description": "Joins two collections.",
"returns": "FeatureCollection",
"type": "Algorithm",
"hidden": false
},
"Array.matrixInverse": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "Computes the inverse of the matrix.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Array.trigamma": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, computes the trigamma function of the input.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Array.right_shift": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Array"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Array"
}
],
"description": "On an element-wise basis, calculates the signed right shift of v1 by v2 bits.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Filter.stringContains": {
"args": [
{
"default": null,
"description": "A selector for the left operand. Should not be specified if leftValue is specified.",
"name": "leftField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the right operand. Should not be specified if rightField is specified.",
"name": "rightValue",
"optional": true,
"type": "Object"
},
{
"default": null,
"description": "A selector for the right operand. Should not be specified if rightValue is specified.",
"name": "rightField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the left operand. Should not be specified if leftField is specified.",
"name": "leftValue",
"optional": true,
"type": "Object"
}
],
"description": "Creates a unary or binary filter that passes if the left operand, a string, contains the right operand, also a string.",
"returns": "Filter",
"type": "Algorithm",
"hidden": false
},
"List.size": {
"args": [
{
"name": "list",
"type": "List<Object>"
}
],
"description": "Returns the number of elements in list.",
"returns": "Integer",
"type": "Algorithm",
"hidden": false
},
"Dictionary.contains": {
"args": [
{
"name": "dictionary",
"type": "Dictionary<Object>"
},
{
"default": null,
"name": "key",
"optional": true,
"type": "String"
}
],
"description": "Returns true if the dictionary contains the given key.",
"returns": "Boolean",
"type": "Algorithm",
"hidden": false
},
"Filter.dayOfYear": {
"args": [
{
"description": "The start of the desired day range, inclusive.",
"name": "start",
"type": "Integer"
},
{
"description": "The end of the desired day range, exclusive.",
"name": "end",
"type": "Integer"
}
],
"description": "Returns a filter that passes if the object's timestamp falls within the given day-of-year range.",
"returns": "Filter",
"type": "Algorithm",
"hidden": false
},
"PixelType.uint8": {
"args": [],
"description": "Returns the 8-bit unsigned integer pixel type.",
"returns": "PixelType",
"type": "Algorithm",
"hidden": false
},
"Feature.setGeometry": {
"args": [
{
"description": "The feature on which to set the geometry.",
"name": "feature",
"type": "Element"
},
{
"default": null,
"description": "The geometry to set.",
"name": "geometry",
"optional": true,
"type": "Geometry"
}
],
"description": "Returns the feature, with the geometry replaced by the specified geometry.",
"returns": "Element",
"type": "Algorithm",
"hidden": false
},
"Number.toInt8": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Casts the input value to a signed 8-bit integer.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Filter.greaterThan": {
"args": [
{
"default": null,
"description": "A selector for the left operand. Should not be specified if leftValue is specified.",
"name": "leftField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the right operand. Should not be specified if rightField is specified.",
"name": "rightValue",
"optional": true,
"type": "Object"
},
{
"default": null,
"description": "A selector for the right operand. Should not be specified if rightValue is specified.",
"name": "rightField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the left operand. Should not be specified if leftField is specified.",
"name": "leftValue",
"optional": true,
"type": "Object"
}
],
"description": "Creates a unary or binary filter that passes if the left operand is greater than the right operand.",
"returns": "Filter",
"type": "Algorithm",
"hidden": false
},
"String.trim": {
"args": [
{
"description": "The string to trim.",
"name": "string",
"type": "String"
}
],
"description": "Returns a string whose value is the original string, with any leading and trailing whitespace removed.",
"returns": "String",
"type": "Algorithm",
"hidden": false
},
"Filter.or": {
"args": [
{
"description": "The filters to disjunct.",
"name": "filters",
"type": "List<Filter>"
}
],
"description": "Returns a filter that passes if any of the component filters pass.",
"returns": "Filter",
"type": "Algorithm",
"hidden": false
},
"Image.arrayRepeat": {
"args": [
{
"description": "Image of array pixels to be repeated.",
"name": "input",
"type": "Image<unknown bands>"
},
{
"description": "Axis along which to repeat each pixel's array.",
"name": "axis",
"type": "Integer"
},
{
"description": "Number of copies of each pixel.",
"name": "copies",
"type": "Image<unknown bands>"
}
],
"description": "Repeats each array pixel along the given axis. Each output pixel will have the shape of the input pixel, except length along the repeated axis, which will be multiplied by the number of copies.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.matrixIdentity": {
"args": [
{
"description": "The length of each axis.",
"name": "size",
"type": "Integer"
}
],
"description": "Creates an image where each pixel is a 2D identity matrix of the given size.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Date.getFraction": {
"args": [
{
"name": "date",
"type": "Date"
},
{
"description": "One of 'year', 'month' 'week', 'day', 'hour', 'minute', or 'second'.",
"name": "unit",
"type": "String"
},
{
"default": null,
"description": "The time zone (e.g. 'America/Los_Angeles'); defaults to UTC.",
"name": "timeZone",
"optional": true,
"type": "String"
}
],
"description": "Returns this date's elapsed fraction of the specified unit (between 0 and 1).",
"returns": "Float",
"type": "Algorithm",
"hidden": false
},
"Geometry.dissolve": {
"args": [
{
"description": "The geometry to union.",
"name": "geometry",
"type": "Geometry"
},
{
"default": null,
"description": "The maximum amount of error tolerated when performing any necessary reprojection.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
},
{
"default": null,
"description": "If specified, the union will be performed in this projection. Otherwise it will be performed in a spherical coordinate system.",
"name": "proj",
"optional": true,
"type": "Projection"
}
],
"description": "Returns the union of the geometry. This leaves single geometries untouched, and unions multi geometries.",
"returns": "Geometry",
"type": "Algorithm",
"hidden": false
},
"green_mosaic/com.google.earthengine.examples.greenmosaic.GreenMosaic": {
"args": [
{
"description": "The MCD43A4 collection to mosaic.",
"name": "inputs",
"type": "ImageCollection"
},
{
"name": "ndviStartPercentile",
"type": "Float"
},
{
"name": "ndviEndPercentile",
"type": "Float"
}
],
"description": "Mosaicks an MCD43A4 image collection by taking the top fraction graded by NDVI, then selecting the geometric mediod.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": true
},
"Array.bitwiseOr": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Array"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Array"
}
],
"description": "On an element-wise basis, calculates the bitwise OR of the input values.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Number.erfc": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Computes the complementary error function of the input.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Array.firstNonZero": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Array"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Array"
}
],
"description": "On an element-wise basis, selects the first value if it is non-zero, and the second value otherwise.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Image.int64": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Casts the input value to a signed 64-bit integer.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Projection.atScale": {
"args": [
{
"name": "projection",
"type": "Projection"
},
{
"name": "meters",
"type": "Float"
}
],
"description": "Returns the projection scaled such that its units have the given scale in linear meters, as measured at the point of true scale.",
"returns": "Projection",
"type": "Algorithm",
"hidden": false
},
"Projection.scale": {
"args": [
{
"name": "projection",
"type": "Projection"
},
{
"name": "x",
"type": "Float"
},
{
"name": "y",
"type": "Float"
}
],
"description": "Returns the projection scaled by the given amount in each axis.",
"returns": "Projection",
"type": "Algorithm",
"hidden": false
},
"Image.blend": {
"args": [
{
"description": "The bottom image.",
"name": "bottom",
"type": "Image<unknown bands>"
},
{
"description": "The top image.",
"name": "top",
"type": "Image<unknown bands>"
}
],
"description": "Overlays one image on top of another. The images are blended together using the masks as opacity. If either of images has only 1 band, it is replicated to match the number of bands in the other image.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Reducer.variance": {
"args": [],
"description": "Returns a Reducer that computes the variance of its inputs.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Number.pow": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Number"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Number"
}
],
"description": "Raises the first value to the power of the second.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"ConfusionMatrix.accuracy": {
"args": [
{
"name": "confusionMatrix",
"type": "ConfusionMatrix"
}
],
"description": "Computes the overall accuracy of a confusion matrix defined as correct / total.",
"returns": "Float",
"type": "Algorithm",
"hidden": false
},
"Image.max": {
"args": [
{
"description": "The image from which the left operand bands are taken.",
"name": "image1",
"type": "Image<unknown bands>"
},
{
"description": "The image from which the right operand bands are taken.",
"name": "image2",
"type": "Image<unknown bands>"
}
],
"description": "Selects the maximum of the first and second values for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is the union of the input types.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"ImageCollection.fromImages": {
"args": [
{
"description": "The images to include in the collection.",
"name": "images",
"type": "List<Image<unknown bands>>"
}
],
"description": "Returns the image collection containing the given images.",
"returns": "ImageCollection",
"type": "Algorithm",
"hidden": false
},
"Feature.cutLines": {
"args": [
{
"description": "Cuts the lines of this feature's default geometry.",
"name": "feature",
"type": "Element"
},
{
"description": "Distances along each LineString to cut the line into separate pieces, measured in units of the given proj, or meters if proj is unspecified.",
"name": "distances",
"type": "List<Float>"
},
{
"default": null,
"description": "The maximum amount of error tolerated when performing any necessary reprojection.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
},
{
"default": null,
"description": "Projection of the result and distance measurements, or WGS84 if unspecified.",
"name": "proj",
"optional": true,
"type": "Projection"
}
],
"description": "Converts LineStrings into a MultiLineString by cutting it in two at each distance along the length of the LineString.",
"returns": "Feature",
"type": "Algorithm",
"hidden": false
},
"If": {
"args": [
{
"default": null,
"description": "The condition that determines which result is returned. If this is not a boolean, it is interpreted as a boolean by the following rules:\n - Numbers that are equal to 0 or a NaN are false.\n - Empty strings, lists and dictionaries are false.\n - Null is false.\n - Everything else is true.",
"name": "condition",
"optional": true,
"type": "Object"
},
{
"default": null,
"description": "The result to return if the condition is true.",
"name": "trueCase",
"optional": true,
"type": "Object"
},
{
"default": null,
"description": "The result to return if the condition is false.",
"name": "falseCase",
"optional": true,
"type": "Object"
}
],
"description": "Selects one of its inputs based on a condition, similar to an if-then-else construct.",
"returns": "Object",
"type": "Algorithm",
"hidden": false
},
"Forma.points": {
"args": [],
"description": "Loads a collection of points from a FORMA CSV file.",
"returns": "FeatureCollection",
"type": "Algorithm",
"hidden": true
},
"Projection.nominalScale": {
"args": [
{
"name": "proj",
"type": "Projection"
}
],
"description": "Returns the linear scale in meters of the units of this projection, as measured at the point of true scale.",
"returns": "Float",
"type": "Algorithm",
"hidden": false
},
"Image.int32": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Casts the input value to a signed 32-bit integer.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"ImageCollection.formaTrend": {
"args": [
{
"description": "Collection from which to extract trends.",
"name": "timeSeries",
"type": "ImageCollection"
},
{
"default": null,
"description": "Cofactors to use in the trend analysis.",
"name": "covariates",
"optional": true,
"type": "ImageCollection"
},
{
"default": 6,
"description": "Short term trend analysis window size, in images.",
"name": "windowSize",
"optional": true,
"type": "Integer"
}
],
"description": "Computes the long and short term trends of a time series or optionally, the trends of the ratio of the time series and a covariate. The long term trend is estimated from the linear term of a regression on the full time series. The short term trend is computed as the windowed minimum over the time series.\nThe time series and covariate series are expected to contain a single band each, and the time series is expected to be evenly spaced in time. The output is 4 float bands: the long and short term trends, the t-test of the long term trend against the time series, and the Bruce Hansen test of parameter stability.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.bitCount": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Calculates the number of one-bits in the 64-bit two's complement binary representation of the input.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"String.compareTo": {
"args": [
{
"description": "The string to compare.",
"name": "string1",
"type": "String"
},
{
"description": "The string to be compared.",
"name": "string2",
"type": "String"
}
],
"description": "Compares two strings lexicographically. Returns: the value 0 if the two strings are lexicographically equal; a value less than 0 if string1 is less than string2; and a value greater than 0 if string1 is lexicographically greater than string2. ",
"returns": "Integer",
"type": "Algorithm",
"hidden": false
},
"Array.uint16": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, casts the input value to an unsigned 16-bit integer.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Number.erfcInv": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Computes the inverse complementary error function of the input.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Array.dotProduct": {
"args": [
{
"description": "The first 1-D array.",
"name": "array1",
"type": "Array"
},
{
"description": "The second 1-D array.",
"name": "array2",
"type": "Array"
}
],
"description": "Compute the dot product between two 1-D arrays.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Fail.hang": {
"args": [],
"description": "Never returns. For triggering timeouts cheaply.",
"returns": "Object",
"type": "Algorithm",
"hidden": false
},
"Classifier.confusionMatrix": {
"args": [
{
"description": "The classifier to use.",
"name": "classifier",
"type": "Classifier"
}
],
"description": "Computes a 2D confusion matrix for a classifier based on its training data (ie: resubstitution error). Axis 0 of the matrix correspond to the input classes, and axis 1 to the output classes. The rows and columns start at class 0 and increase sequentially up to the maximum class value, so some rows or columns might be empty if the input classes aren't 0-based or sequential.",
"returns": "ConfusionMatrix",
"type": "Algorithm",
"hidden": false
},
"Feature.contains": {
"args": [
{
"description": "The feature containing the geometry used as the left operand of the operation.",
"name": "left",
"type": "Element"
},
{
"description": "The feature containing the geometry used as the right operand of the operation.",
"name": "right",
"type": "Element"
},
{
"default": null,
"description": "The maximum amount of error tolerated when performing any necessary reprojection.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
},
{
"default": null,
"description": "The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.",
"name": "proj",
"optional": true,
"type": "Projection"
}
],
"description": "Returns true iff the geometry of one feature contains the geometry of another.",
"returns": "Boolean",
"type": "Algorithm",
"hidden": false
},
"FeatureCollection.trainClassifier": {
"args": [
{
"description": "A collection of classified features to use for supervised classification.",
"name": "collection",
"type": "FeatureCollection"
},
{
"default": null,
"description": "The list of properties in each element of training_features to include in the training input.",
"name": "property_list",
"optional": true,
"type": "List<String>"
},
{
"default": "classification",
"description": "The name of the property in each element of training_features containing its class number.",
"name": "class_property",
"optional": true,
"type": "String"
},
{
"default": "FastNaiveBayes",
"description": "The name of the Abe classifier to use. Currently supported values are FastNaiveBayes, GmoMaxEnt, Winnow, MultiClassPerceptron, Pegasos, Cart, RifleSerialClassifier, IKPamir, VotingSvm, MarginSvm, ContinuousNaiveBayes. Ignored if a classifier argument is provided.",
"name": "classifier_name",
"optional": true,
"type": "String"
},
{
"default": "",
"description": "The Abe classifier parameters. Ignored if a classifier argument is provided.",
"name": "classifier_parameters",
"optional": true,
"type": "String"
},
{
"default": "classification",
"description": "The classifier mode. Accepted values are 'classification', 'regression' and 'probability'. Ignored if a classifier argument is provided.",
"name": "classifier_mode",
"optional": true,
"type": "String"
},
{
"default": 1,
"description": "The number of subsamples to use for cross-validation or bagging. If 1, no cross-validation or bagging is performed. Ignored if a classifier argument is provided.",
"name": "num_subsamples",
"optional": true,
"type": "Integer"
},
{
"default": null,
"description": "The bootstrap subsampling factor. Ignored if a classifier argument is provided.",
"name": "bootstrap_subsampling",
"optional": true,
"type": "Float"
},
{
"default": null,
"description": "The bootstrap aggregator. Ignored if a classifier argument is provided.",
"name": "bootstrap_aggregator",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "A pre-built classifier to use.",
"name": "classifier",
"optional": true,
"type": "OldClassifier"
}
],
"description": "Trains a classifier from features in a collection, using the specified numeric properties of each feature as training data.\n\nThe input data is specified with the collection and property_list arguments. The input is generated by extracting the specified properties from each feature in the collection. The list of properties should not include the class_property, as it is handled separately. The classifier will expect future inputs to be classified to be in the same order.\n\nTo use the classifier library, specify the classifier_name, classifier_parameters, and classifier_mode arguments.\n\nTo enable cross-validation or bagging, set the num_subsamples argument. When bagging, set the bootstrap_subsampling factor and the bootstrap_aggregator as well.\n\nTo use a custom classifier, specify it using the classifier parameter.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": true,
"deprecated": "Use Classifier.train()."
},
"Window.median": {
"args": [
{
"description": "The image to which to apply the operations.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"default": 1.5,
"description": "The radius of the kernel to use.",
"name": "radius",
"optional": true,
"type": "Float"
},
{
"default": "circle",
"description": "The type of kernel to use. Options include: 'circle', 'square', 'cross', 'plus', octagon' and 'diamond'.",
"name": "kernelType",
"optional": true,
"type": "String"
},
{
"default": "pixels",
"description": "If a kernel is not specified, this determines whether the kernel is in meters or pixels.",
"name": "units",
"optional": true,
"type": "String"
},
{
"default": 1,
"description": "The number of times to apply the given kernel.",
"name": "iterations",
"optional": true,
"type": "Integer"
},
{
"default": null,
"description": "A custom kernel. If used, kernelType and radius are ignored.",
"name": "kernel",
"optional": true,
"type": "Kernel"
}
],
"description": "Applies a morphological reducer() filter to each band of an image using a named or custom kernel.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Array.bitwise_xor": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Array"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Array"
}
],
"description": "On an element-wise basis, calculates the bitwise XOR of the input values.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Image.projection": {
"args": [
{
"description": "The image from which to get the projection.",
"name": "image",
"type": "Image<unknown bands>"
}
],
"description": "Returns the default projection of an Image. Throws an error if the bands of the image don't all have the same projection.",
"returns": "Projection",
"type": "Algorithm",
"hidden": false
},
"Reducer.pearsonsCorrelation": {
"args": [],
"description": "Creates a two-input reducer that computes Pearson's product-moment correlation coefficient and the 2-sided p-value test for correlation = 0.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Filter.lt": {
"args": [
{
"default": null,
"description": "A selector for the left operand. Should not be specified if leftValue is specified.",
"name": "leftField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the right operand. Should not be specified if rightField is specified.",
"name": "rightValue",
"optional": true,
"type": "Object"
},
{
"default": null,
"description": "A selector for the right operand. Should not be specified if rightValue is specified.",
"name": "rightField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the left operand. Should not be specified if leftField is specified.",
"name": "leftValue",
"optional": true,
"type": "Object"
}
],
"description": "Creates a unary or binary filter that passes if the left operand is less than the right operand.",
"returns": "Filter",
"type": "Algorithm",
"hidden": false
},
"Number.exp": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Computes the Euler's number e raised to the power of the input.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Reducer.fixedHistogram": {
"args": [
{
"description": "The lower (inclusive) bound of the first bucket.",
"name": "min",
"type": "Float"
},
{
"description": "The upper (exclusive) bound of the last bucket.",
"name": "max",
"type": "Float"
},
{
"description": "The number of buckets to use.",
"name": "steps",
"type": "Integer"
}
],
"description": "Creates a reducer that will compute a histogram of the inputs using a fixed number of fixed width bins. Values outside of the [min, max) range are ignored. The output is a Nx2 array of bucket lower edges and counts and is suitable for use per-pixel.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Array.hypot": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Array"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Array"
}
],
"description": "On an element-wise basis, calculates the magnitude of the 2D vector [x, y].",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Array.double": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, casts the input value to a 64-bit float.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Test.Clustering.SpatialConsistency": {
"args": [
{
"description": "The input image for clustering.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"default": 256,
"description": "Maximum object size.",
"name": "maxObjectSize",
"optional": true,
"type": "Integer"
},
{
"default": true,
"description": "Use centroid to search for corresponding cluster.",
"name": "useCentroid",
"optional": true,
"type": "Boolean"
},
{
"default": true,
"description": "Treat corner cases.",
"name": "cornerCases",
"optional": true,
"type": "Boolean"
}
],
"description": "Performs clustering on the input image in a consistent way across tiles. The algorithm works as follows: first, renumber the current tile clusters based on an offset; then, for each cluster that touches the left or the top edge, look at the adjacent tile and find that tile's cluster label. Assign this label, added to that tile's offset, to the current cluster and continue. Ambiguities can be resolved either by number of pixels touching the current pixel, or by closest mean. Corner cases can be resolved by looking at the northwest tile. Note that not all cases can be resolved.\nInput should be an image where one of the bands is named 'clusters' and represents the cluster labels. The remaining bands are spectral data.\nThe output is an INT32 image in which each value is the cluster to which he pixel belongs.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": true
},
"Image.erfInv": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Computes the inverse error function of the input.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Array.cosh": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, computes the hyperbolic cosine of the input.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Reducer.timesat": {
"args": [
{
"description": "The local function to be used to fit the data: [AsymmetricGaussian, Fourier1, Fourier2, Fourier3]",
"name": "function",
"type": "String"
},
{
"default": false,
"description": "Apply a second pass fit after adjusting the weights to fit the upper envelope of the data more closely.",
"name": "envelope",
"optional": true,
"type": "Boolean"
}
],
"description": "Creates a reducer that computes a nonlinear regression using the TIMESAT algorithm by Jonsson and Eklundh. TIMESAT fits a function in neighborhoods around local extrema and merges the local fits together to create a global fit. An asymmetric Gaussian or low-order Fourier series can be used for the local function.\nEach input tuple will have a (weighted) value for the independent and dependent variable.\nThe first output is a two-dimensional array describing the resulting fit, with the local fits along the first axis, and the parameters of each fit along the second axis. To evaluate the fit, use timesatValue(). The second output is the root mean square of the residuals.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Array.uint32": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, casts the input value to an unsigned 32-bit integer.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Test.Clustering.RegionGrow": {
"args": [
{
"description": "The input image for clustering.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"description": "The distance threshold. As a cluster grows, a distance measure is computed between the starting point's value and the new point's value. If it is greater than the threshold, the pixel is not included in the cluster.",
"name": "threshold",
"type": "Float"
},
{
"default": true,
"description": "Whether to use cosine distance instead of euclidean distance.",
"name": "useCosine",
"optional": true,
"type": "Boolean"
},
{
"default": true,
"description": "Whether to apply a second pass of clustering.",
"name": "secondPass",
"optional": true,
"type": "Boolean"
},
{
"default": 256,
"description": "Maximum object size.",
"name": "maxObjectSize",
"optional": true,
"type": "Integer"
}
],
"description": "An algorithm that performs clustering on the input image by region growing. It performs a flood fill like procedure based on either the euclidean or the cosine distance between the value of the starting growth point of the cluster and the neighboring points. The cluster grows until this distance is above the threshold; at this point, a new cluster starts to grow. The algorithm works independently on cells of a grid. This grid is defined by maxObjectSize and can be different from the tile size. Per-cell clusters are unrelated. A cluster that spans a cell boundary may receive two different labels in the two cells. The output is an INT32 image in which each value is the cluster to which the pixel belongs. A pixel in the output band is only defined (i.e. has a non-zero mask) if all the inputs are defined.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": true
},
"List.rotate": {
"args": [
{
"name": "list",
"type": "List<Object>"
},
{
"name": "distance",
"type": "Integer"
}
],
"description": "Rotates the elements of the list by the specified distance.",
"returns": "List<Object>",
"type": "Algorithm",
"hidden": false
},
"PixelType.uint32": {
"args": [],
"description": "Returns the 32-bit unsigned integer pixel type.",
"returns": "PixelType",
"type": "Algorithm",
"hidden": false
},
"Array.bitwiseNot": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, calculates the bitwise NOT of the input, in the smallest signed integer type that can hold the input.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Image.matrixDeterminant": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Computes the determinant of the matrix.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Reducer.minMax": {
"args": [],
"description": "Returns a Reducer that computes the minimum and maximum of its inputs.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Image.distance": {
"args": [
{
"description": "The input image.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"default": null,
"description": "The distance kernel.",
"name": "kernel",
"optional": true,
"type": "Kernel"
},
{
"default": true,
"description": "Mask output pixels if the corresponding input pixel is masked.",
"name": "skipMasked",
"optional": true,
"type": "Boolean"
}
],
"description": "Computes the distance to the nearest non-zero pixel in each band, using the specified distance kernel.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Array.bitwise_or": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Array"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Array"
}
],
"description": "On an element-wise basis, calculates the bitwise OR of the input values.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Kernel.kirsch": {
"args": [
{
"default": 1.0,
"description": "Scale each value by this amount.",
"name": "magnitude",
"optional": true,
"type": "Float"
},
{
"default": false,
"description": "Normalize the kernel values to sum to 1.",
"name": "normalize",
"optional": true,
"type": "Boolean"
}
],
"description": "Generates a 3x3 Kirsch's Compass edge-detection kernel.",
"returns": "Kernel",
"type": "Algorithm",
"hidden": false
},
"Number.not": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Returns 0 if the input is non-zero, and 1 otherwise.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"TemporalSegmentation.LandTrendr": {
"args": [
{
"description": "Yearly time-series from which to extract breakpoints. The first band is usedto find breakpoints, and all subsequent bands are fitted using those breakpoints.",
"name": "timeSeries",
"type": "ImageCollection"
},
{
"description": "Maximum number of segments to be fitted on the time series.",
"name": "maxSegments",
"type": "Integer"
},
{
"default": 0.9,
"description": "Threshold for dampening the spikes (1.0 means no dampening).",
"name": "spikeThreshold",
"optional": true,
"type": "Float"
},
{
"default": 3,
"description": "The initial model can overshoot the maxSegments + 1 vertices by this amount. Later, it will be pruned down to maxSegments + 1.",
"name": "vertexCountOvershoot",
"optional": true,
"type": "Integer"
},
{
"default": false,
"description": "Prevent segments that represent one year recoveries.",
"name": "preventOneYearRecovery",
"optional": true,
"type": "Boolean"
},
{
"default": 0.25,
"description": "If a segment has a recovery rate faster than 1/recoveryThreshold (in years), then the segment is disallowed.",
"name": "recoveryThreshold",
"optional": true,
"type": "Float"
},
{
"default": 0.1,
"description": "If the p-value of the fitted model exceeds this threshold, then the current model is discarded and another one is fitted using the Levenberg-Marquardt optimizer.",
"name": "pvalThreshold",
"optional": true,
"type": "Float"
},
{
"default": 1.25,
"description": "Takes the model with most vertices that has a p-value that is at most this proportion away from the model with lowest p-value.",
"name": "bestModelProportion",
"optional": true,
"type": "Float"
},
{
"default": 6,
"description": "Min observations needed to perform output fitting.",
"name": "minObservationsNeeded",
"optional": true,
"type": "Integer"
}
],
"description": "Landsat-based detection of Trends in Disturbance and Recovery: temporally segments a time-series of images by extracting the spectral trajectories of change over time. The first band of each image is used to find breakpoints, and those breakpoints are used to perform fitting on all subsequent bands. The breakpoints are returned as a 2-D matrix of 4 rows and as many columns as images. The first two rows are the original X and Y values. The third row contains the Y values fitted to the estimated segments, and the 4th row contains a 1 if the corresponding point was used as a segment vertex or 0 if not. Any additional fitted bands are appended as rows in the output. Breakpoint fitting assumes that increasing values represent disturbance and decreasing values represent recovery.\nSee: Kennedy, R.E., Yang, Z. and Cohen, W.B., 2010. Detecting trends in forest disturbance and recovery using yearly Landsat time series: 1. LandTrendr - Temporal segmentation algorithms. Remote Sensing of Environment, 114(12), pp.2897-2910.\n",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"PixelType.int8": {
"args": [],
"description": "Returns the 8-bit signed integer pixel type.",
"returns": "PixelType",
"type": "Algorithm",
"hidden": false
},
"Landsat.calibratedRadiance": {
"args": [
{
"description": "The input Landsat image.",
"name": "image",
"type": "Image<unknown bands>"
}
],
"description": "Calibrates each band of an image by applying linear transformation with slope RADIANCE_MULT_BAND_N and y-intercept RADIANCE_ADD_BAND_N; these values are extracted from the image metadata.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"PixelType.double": {
"args": [],
"description": "Returns the 64-bit floating point pixel type.",
"returns": "PixelType",
"type": "Algorithm",
"hidden": false
},
"Image.arrayFlatten": {
"args": [
{
"description": "Image of multidimensional pixels to flatten.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"description": "Name of each position along each axis. For example, 2x2 arrays with axes meaning 'day' and 'color' could have labels like [['monday', 'tuesday'], ['red', 'green']], resulting in band names'monday_red', 'monday_green', 'tuesday_red', and 'tuesday_green'.",
"name": "coordinateLabels",
"type": "List<List<String>>"
},
{
"default": "_",
"description": "Separator between array labels in each band name.",
"name": "separator",
"optional": true,
"type": "String"
}
],
"description": "Converts a single band image of equal-shape multidimensional pixels to an image of scalar pixels, with one band for each element of the array.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Test.Clustering.HashedConsistency": {
"args": [
{
"description": "The input image for clustering.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"default": 256,
"description": "Maximum object size.",
"name": "maxObjectSize",
"optional": true,
"type": "Integer"
},
{
"default": 100.0,
"description": "Bin size for quantization.",
"name": "binSize",
"optional": true,
"type": "Float"
}
],
"description": "Perform consistent clustering across tiles by binning per-tile clustered labels into slots according to the cluster means. Input should be an image where one of the bands is named 'clusters' and represents the cluster labels. The remaining bands are spectral data.\nWorks better when dealing with a small number of clusters. The output is an INT32 image in which each value is the cluster to which the pixel belongs.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": true
},
"Array.first_nonzero": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Array"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Array"
}
],
"description": "On an element-wise basis, selects the first value if it is non-zero, and the second value otherwise.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Array.left_shift": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Array"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Array"
}
],
"description": "On an element-wise basis, calculates the left shift of v1 by v2 bits.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Clusterer.wekaKMeans": {
"args": [
{
"description": "Number of clusters.",
"name": "nClusters",
"type": "Integer"
},
{
"default": 0,
"description": "Initialization method to use.0 = random, 1 = k-means++, 2 = canopy, 3 = farthest first.",
"name": "init",
"optional": true,
"type": "Integer"
},
{
"default": false,
"description": "Use canopies to reduce the number of distance calculations.",
"name": "canopies",
"optional": true,
"type": "Boolean"
},
{
"default": 100,
"description": "Maximum number of candidate canopies to retain in memory at any one time when using canopy clustering. T2 distance plus, data characteristics, will determine how many candidate canopies are formed before periodic and final pruning are performed, which might result in exceess memory consumption. This setting avoids large numbers of candidate canopies consuming memory.",
"name": "maxCandidates",
"optional": true,
"type": "Integer"
},
{
"default": 10000,
"description": "How often to prune low density canopies when using canopy clustering.",
"name": "periodicPruning",
"optional": true,
"type": "Integer"
},
{
"default": 2,
"description": "Minimum canopy density, when using canopy clustering, below which a canopy will be pruned during periodic pruning.",
"name": "minDensity",
"optional": true,
"type": "Integer"
},
{
"default": -1.5,
"description": "The T1 distance to use when using canopy clustering. A value < 0 is taken as a positive multiplier for T2.",
"name": "t1",
"optional": true,
"type": "Float"
},
{
"default": -1.0,
"description": "The T2 distance to use when using canopy clustering. Values < 0 cause a heuristic based on attribute std. deviation to be used.",
"name": "t2",
"optional": true,
"type": "Float"
},
{
"default": "Euclidean",
"description": "Distance function to use. Options are: Euclidean & Manhattan",
"name": "distanceFunction",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "Maximum number of iterations.",
"name": "maxIterations",
"optional": true,
"type": "Integer"
},
{
"default": false,
"description": "Preserve order of instances.",
"name": "preserveOrder",
"optional": true,
"type": "Boolean"
},
{
"default": false,
"description": "Enables faster distance calculations, using cut-off values. Disables the calculation/output of squared errors/distances",
"name": "fast",
"optional": true,
"type": "Boolean"
},
{
"default": 10,
"description": "The randomization seed.",
"name": "seed",
"optional": true,
"type": "Integer"
}
],
"description": "Cluster data using the k means algorithm. Can use either the Euclidean distance (default) or the Manhattan distance. If the Manhattan distance is used, then centroids are computed as the component-wise median rather than mean. For more information see:\nD. Arthur, S. Vassilvitskii: k-means++: the advantages of carefull seeding. In: Proceedings of the eighteenth annual ACM-SIAM symposium on Discrete algorithms, 1027-1035, 2007.",
"returns": "Clusterer",
"type": "Algorithm",
"hidden": false
},
"SelectorSet.Object": {
"args": [
{
"name": "map",
"type": "Dictionary<SelectorSet>"
}
],
"description": "Returns a SelectorSet for a given set of property paths.",
"returns": "SelectorSet",
"type": "Algorithm",
"hidden": true
},
"Array.divide": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Array"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Array"
}
],
"description": "On an element-wise basis, divides the first value by the second, returning 0 for division by 0.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Number.toLong": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Casts the input value to a signed 64-bit integer.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"List.indexOf": {
"args": [
{
"name": "list",
"type": "List<Object>"
},
{
"name": "element",
"type": "Object"
}
],
"description": "Returns the position of the first occurrence of target in list, or -1 if list does not contain target.",
"returns": "Integer",
"type": "Algorithm",
"hidden": false
},
"Image.neighborhoodToArray": {
"args": [
{
"description": "The image to get pixels from; must be scalar-valued.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"description": "The kernel specifying the shape of the neighborhood. Only fixed, square and rectangle kernels are supported. Weights are ignored; only the shape of the kernel is used.",
"name": "kernel",
"type": "Kernel"
},
{
"default": 0.0,
"description": "The value to use in the output arrays to replace the invalid (masked) pixels of the input. If the band type is integral, the fractional part of this value is discarded; in all cases, the value is clamped to the value range of the band.",
"name": "defaultValue",
"optional": true,
"type": "Float"
}
],
"description": "Turns the neighborhood of each pixel in a scalar image into a 2D array. Axes 0 and 1 of the output array correspond to Y and X axes of the image, respectively. The output image will have as many bands as the input; each output band has the same mask as the corresponding input band. The footprint and metadata of the input image are preserved.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Array.sin": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, computes the sine of the input in radians.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"DateRange": {
"args": [
{
"name": "start",
"type": "Object"
},
{
"default": null,
"name": "end",
"optional": true,
"type": "Object"
},
{
"default": null,
"description": "If start and/or end are provided as strings, the time zone in which to interpret them; defaults to UTC.",
"name": "timeZone",
"optional": true,
"type": "String"
}
],
"description": "Creates a DateRange with the given start (inclusive) and end (exclusive), which may be Dates, numbers (interpreted as milliseconds since 1970-01-01T00:00:00Z), or strings (such as '1996-01-01T08:00'). If 'end' is not specified, a 1-millisecond range starting at 'start' is created.",
"returns": "DateRange",
"type": "Algorithm",
"hidden": false
},
"Geometry.perimeter": {
"args": [
{
"description": "The input geometry.",
"name": "geometry",
"type": "Geometry"
},
{
"default": null,
"description": "The maximum amount of error tolerated when performing any necessary reprojection.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
},
{
"default": null,
"description": "If specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in meters.",
"name": "proj",
"optional": true,
"type": "Projection"
}
],
"description": "Returns the length of the perimeter of the polygonal parts of the geometry. The perimeter of multi geometries is the sum of the perimeters of their components.",
"returns": "Float",
"type": "Algorithm",
"hidden": false
},
"Array.leftShift": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Array"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Array"
}
],
"description": "On an element-wise basis, calculates the left shift of v1 by v2 bits.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Reducer.sampleVariance": {
"args": [],
"description": "Returns a Reducer that computes the sample variance of its inputs.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Image.rightShift": {
"args": [
{
"description": "The image from which the left operand bands are taken.",
"name": "image1",
"type": "Image<unknown bands>"
},
{
"description": "The image from which the right operand bands are taken.",
"name": "image2",
"type": "Image<unknown bands>"
}
],
"description": "Calculates the signed right shift of v1 by v2 bits for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is the union of the input types.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Feature.bounds": {
"args": [
{
"description": "The feature the bound of which is being calculated.",
"name": "feature",
"type": "Element"
},
{
"default": null,
"description": "The maximum amount of error tolerated when performing any necessary reprojection.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
},
{
"default": null,
"description": "If specified, the result will be in this projection. Otherwise it will be in WGS84.",
"name": "proj",
"optional": true,
"type": "Projection"
}
],
"description": "Returns a feature containing the bounding box of the geometry of a given feature.",
"returns": "Feature",
"type": "Algorithm",
"hidden": false
},
"Geometry.simplify": {
"args": [
{
"description": "The geometry to simplify.",
"name": "geometry",
"type": "Geometry"
},
{
"description": "The maximum amount of error by which the result may differ from the input.",
"name": "maxError",
"type": "ErrorMargin"
},
{
"default": null,
"description": "If specified, the result will be in this projection. Otherwise it will be in the same projection as the input. If the error margin is in projected units, the margin will be interpreted as units of this projection",
"name": "proj",
"optional": true,
"type": "Projection"
}
],
"description": "Simplifies the geometry to within a given error margin. Note that this does not respect the error margin requested by the consumer of this algorithm, unless maxError is explicitly specified to be null.\nThis overrides the default Earth Engine policy for propagating error margins, so regardless of the geometry accuracy requested from the output, the inputs will be requested with the error margin specified in the arguments to this algorithm. This results in consistent rendering at all zoom levels of a rendered vector map, but at lower zoom levels (i.e. zoomed out), the geometry won't be simplified, which may harm performance.",
"returns": "Geometry",
"type": "Algorithm",
"hidden": false
},
"Classifier.ikpamir": {
"args": [
{
"default": 10,
"description": "The number of histogram bins per dimension.",
"name": "numBins",
"optional": true,
"type": "Integer"
},
{
"default": 0.1,
"description": "The rate of learning from each example.",
"name": "learningRate",
"optional": true,
"type": "Float"
},
{
"default": 5,
"description": "The maximum number of epochs.",
"name": "epochs",
"optional": true,
"type": "Integer"
}
],
"description": "Creates an IKPAMIR (Intersection Kernel Passive-Aggressive Method for Information Retrieval) classifier. See:\n \"Classification using Intersection Kernel Support Vector Machinesis Efficient\"\n S. Maji, A. Berg, J. Malik",
"returns": "Classifier",
"type": "Algorithm",
"hidden": false,
"deprecated": "Deprecated; will be removed eventually."
},
"Reducer.repeat": {
"args": [
{
"name": "reducer",
"type": "Reducer"
},
{
"name": "count",
"type": "Integer"
}
],
"description": "Creates a Reducer by combining the specified number of copies of the given reducer. Output names are the same as the given reducer, but each is a list of the corresponding output from each of the reducers.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Join.inverted": {
"args": [],
"description": "Returns a join that produces the elements of the primary collection that match no elements of the secondary collection. No properties are added to the results.",
"returns": "Join",
"type": "Algorithm",
"hidden": false
},
"Array.atan": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, computes the arc tangent in radians of the input.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Filter.gt": {
"args": [
{
"default": null,
"description": "A selector for the left operand. Should not be specified if leftValue is specified.",
"name": "leftField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the right operand. Should not be specified if rightField is specified.",
"name": "rightValue",
"optional": true,
"type": "Object"
},
{
"default": null,
"description": "A selector for the right operand. Should not be specified if rightValue is specified.",
"name": "rightField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the left operand. Should not be specified if leftField is specified.",
"name": "leftValue",
"optional": true,
"type": "Object"
}
],
"description": "Creates a unary or binary filter that passes if the left operand is greater than the right operand.",
"returns": "Filter",
"type": "Algorithm",
"hidden": false
},
"IsEqual": {
"args": [
{
"default": null,
"name": "left",
"optional": true,
"type": "Object"
},
{
"default": null,
"name": "right",
"optional": true,
"type": "Object"
}
],
"description": "Returns whether two objects are equal.",
"returns": "Boolean",
"type": "Algorithm",
"hidden": false
},
"Array": {
"args": [
{
"description": "An existing array to cast, or a number/list of numbers/nested list of numbers of any depth to create an array from. For nested lists, all inner arrays at the same depth must have the same length, and numbers may only be present at the deepest level.",
"name": "values",
"type": "Object"
},
{
"default": null,
"description": "The type of each number in the values argument. If the pixel type is not provided, it will be inferred from the numbers in 'values'. If there aren't any numbers in 'values', this type must be provided.",
"name": "pixelType",
"optional": true,
"type": "PixelType"
}
],
"description": "Returns an array with the given coordinates.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Reducer.linearRegression": {
"args": [
{
"description": "The number of input dimensions.",
"name": "numX",
"type": "Integer"
},
{
"default": 1,
"description": "The number of output dimensions.",
"name": "numY",
"optional": true,
"type": "Integer"
}
],
"description": "Creates a reducer that computes a linear least squares regression with numX independent variables and numY dependent variables.\nEach input tuple will have values for the independent variables followed by the dependent variables.\nThe first output is a coefficients array with dimensions (numX, numY); each column contains the coefficients for the corresponding dependent variable. The second output is a vector of the root mean square of the residuals of each dependent variable. Both outputs are null if the system is underdetermined, e.g. the number of inputs is less than or equal to numX.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Reducer.splitWeights": {
"args": [
{
"name": "reducer",
"type": "Reducer"
}
],
"description": "Returns a Reducer with the same outputs as the given Reducer, but with each weighted input replaced by two unweighted inputs.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"FeatureCollection.randomPoints": {
"args": [
{
"description": "The region to generate points for.",
"name": "region",
"type": "Geometry"
},
{
"default": 1000,
"description": "The number of points to generate.",
"name": "points",
"optional": true,
"type": "Integer"
},
{
"default": 0,
"description": "A seed for the random number generator.",
"name": "seed",
"optional": true,
"type": "Long"
},
{
"default": {
"type": "ErrorMargin",
"unit": "meters",
"value": 100.0
},
"description": "The maximum amount of error tolerated when performing any necessary reprojection.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
}
],
"description": "Generates points that are uniformly random on the sphere, and within the given region.",
"returns": "FeatureCollection",
"type": "Algorithm",
"hidden": false
},
"TrainFeatureClassifier.AggregationContainer": {
"args": [
{
"name": "collection",
"type": "FeatureCollection"
},
{
"default": null,
"name": "classifierName",
"optional": true,
"type": "String"
},
{
"default": null,
"name": "classifierParameters",
"optional": true,
"type": "String"
},
{
"default": null,
"name": "classifierMode",
"optional": true,
"type": "String"
},
{
"default": 0,
"name": "numSubsamples",
"optional": true,
"type": "Integer"
},
{
"default": null,
"name": "bootstrapSubsampling",
"optional": true,
"type": "Float"
},
{
"default": null,
"name": "bootstrapAggregator",
"optional": true,
"type": "String"
},
{
"default": null,
"name": "classifier",
"optional": true,
"type": "OldClassifier"
},
{
"default": null,
"name": "propertyList",
"optional": true,
"type": "List<String>"
},
{
"default": "classification",
"name": "classProperty",
"optional": true,
"type": "String"
},
{
"default": 0,
"name": "maxClass",
"optional": true,
"type": "Integer"
}
],
"description": "INTERNAL",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": true
},
"Number.bitwise_xor": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Number"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Number"
}
],
"description": "Calculates the bitwise XOR of the input values.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"ConfusionMatrix.order": {
"args": [
{
"name": "confusionMatrix",
"type": "ConfusionMatrix"
}
],
"description": "Returns the name and order of the rows and columns of the matrix.",
"returns": "List<Integer>",
"type": "Algorithm",
"hidden": false
},
"Classifier.randomForest": {
"args": [
{
"default": 1,
"description": "The number of Rifle decision trees to create per class.",
"name": "numberOfTrees",
"optional": true,
"type": "Integer"
},
{
"default": 0,
"description": "The number of variables per split. If set to 0 (default), defaults to the square root of the number of variables.",
"name": "variablesPerSplit",
"optional": true,
"type": "Integer"
},
{
"default": 1,
"description": "The minimum size of a terminal node.",
"name": "minLeafPopulation",
"optional": true,
"type": "Integer"
},
{
"default": 0.5,
"description": "The fraction of input to bag per tree.",
"name": "bagFraction",
"optional": true,
"type": "Float"
},
{
"default": false,
"description": "Whether the classifier should run in out-of-bag mode.",
"name": "outOfBagMode",
"optional": true,
"type": "Boolean"
},
{
"default": 0,
"description": "Random seed.",
"name": "seed",
"optional": true,
"type": "Integer"
}
],
"description": "Creates an empty Rifle Serial classifier, which uses the Random Forest algorithm.",
"returns": "Classifier",
"type": "Algorithm",
"hidden": false
},
"Collection.iterate": {
"args": [
{
"description": "The collection to which the algorithm is applied.",
"name": "collection",
"type": "FeatureCollection"
},
{
"description": "The function to apply to each element. Must take two arguments: an element of the collection and the value from the previous iteration.",
"name": "function",
"type": "Algorithm"
},
{
"default": null,
"description": "The initial state.",
"name": "first",
"optional": true,
"type": "Object"
}
],
"description": "Applies a user-supplied function to each element of a collection. The user-supplied function is given two arguments: the current element, and the value returned by the previous call to iterate() or the first argument, for the first iteration. The result is the value returned by the final call to the user-supplied function.",
"returns": "Object",
"type": "Algorithm",
"hidden": false
},
"Reducer.and": {
"args": [],
"description": "Returns a Reducer that returns 1 if all of its inputs are non-zero, 0 otherwise.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false,
"deprecated": "Use Reducer.allNonZero()."
},
"Feature": {
"args": [
{
"default": null,
"description": "The geometry of the feature.",
"name": "geometry",
"optional": true,
"type": "Geometry"
},
{
"default": {},
"description": "The properties of the feature.",
"name": "metadata",
"optional": true,
"type": "Dictionary<Object>"
},
{
"default": null,
"description": "Obsolete; has no effect.",
"name": "geometryKey",
"optional": true,
"type": "String"
}
],
"description": "Returns a Feature composed of the given geometry and metadata.",
"returns": "Feature",
"type": "Algorithm",
"hidden": false
},
"String.replace": {
"args": [
{
"description": "The string in which to search.",
"name": "input",
"type": "String"
},
{
"description": "The regular expression to match.",
"name": "regex",
"type": "String"
},
{
"description": "The string that replaces the matched substring.",
"name": "replacement",
"type": "String"
},
{
"default": "",
"description": "A string specifying a combination of regular expression flags, specifically one or more of: 'g' (global match) or 'i' (ignore case)",
"name": "flags",
"optional": true,
"type": "String"
}
],
"description": "Returns a new string with some or all matches of a pattern replaced.",
"returns": "String",
"type": "Algorithm",
"hidden": false
},
"Array.project": {
"args": [
{
"description": "Array to project.",
"name": "array",
"type": "Array"
},
{
"description": "The axes to project onto. Other axes will be discarded, and must be at most length 1.",
"name": "axes",
"type": "List<Integer>"
}
],
"description": "Projects an array to a lower dimensional space by specifying the axes to retain. Dropped axes must be at most length 1.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Image.digamma": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Computes the digamma function of the input.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Number.trigamma": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Computes the trigamma function of the input.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"WHRC.CombinePoints": {
"args": [
{
"description": "The collection to combine.",
"name": "collection",
"type": "FeatureCollection"
},
{
"description": "The minimum number of intersecting points.",
"name": "intersections",
"type": "Integer"
},
{
"description": "Pixel size",
"name": "pixelSize",
"type": "Float"
}
],
"description": "Averaged values of observations in a pixel if the number of observations exceeds a threshold.",
"returns": "FeatureCollection",
"type": "Algorithm",
"hidden": true
},
"Geometry.difference": {
"args": [
{
"description": "The geometry used as the left operand of the operation.",
"name": "left",
"type": "Geometry"
},
{
"description": "The geometry used as the right operand of the operation.",
"name": "right",
"type": "Geometry"
},
{
"default": null,
"description": "The maximum amount of error tolerated when performing any necessary reprojection.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
},
{
"default": null,
"description": "The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.",
"name": "proj",
"optional": true,
"type": "Projection"
}
],
"description": "Returns the result of subtracting the 'right' geometry from the 'left' geometry.",
"returns": "Geometry",
"type": "Algorithm",
"hidden": false
},
"Image.matrixToDiag": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Computes a square diagonal matrix from a single column matrix.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Array.neq": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Array"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Array"
}
],
"description": "On an element-wise basis, returns 1 iff the first value is not equal to the second.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Image.requestBoundary": {
"args": [
{
"default": 0,
"description": "Number of pixels to inset the lines from the boundary.",
"name": "inset",
"optional": true,
"type": "Integer"
}
],
"description": "An image in which the edges of the region actually computed are marked by line segments. In a tiled map, the effect will be to draw crosshairs on the corner points where tiles meet.\n\nThe image has only a mask. Use visualization parameters to change the displayed color.\n\nIntended for use in debugging tile boundary artifacts only.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Geometry.geodesic": {
"args": [
{
"name": "geometry",
"type": "Geometry"
}
],
"description": "If false, edges are straight in the projection. If true, edges are curved to follow the shortest path on the surface of the Earth.",
"returns": "Boolean",
"type": "Algorithm",
"hidden": false
},
"Reducer.covariance": {
"args": [],
"description": "Creates a reducer that reduces some number of 1-D arrays of the same length N to a covariance matrix of shape NxN. This reducer uses the one-pass covariance formula from Sandia National Laboratories Technical Report SAND2008-6212, which can lose accuracy if the values span a large range.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Image.gt": {
"args": [
{
"description": "The image from which the left operand bands are taken.",
"name": "image1",
"type": "Image<unknown bands>"
},
{
"description": "The image from which the right operand bands are taken.",
"name": "image2",
"type": "Image<unknown bands>"
}
],
"description": "Returns 1 iff the first value is greater than the second for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is boolean.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"String.length": {
"args": [
{
"description": "The string from which to get the length.",
"name": "string",
"type": "String"
}
],
"description": "Returns the length of a string.",
"returns": "Integer",
"type": "Algorithm",
"hidden": false
},
"Array.cos": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, computes the cosine of the input in radians.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Image.convolve": {
"args": [
{
"description": "The image to convolve.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"description": "The kernel to convolve with.",
"name": "kernel",
"type": "Kernel"
}
],
"description": "Convolves each band of an image with the given kernel.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.spectralGradient": {
"args": [
{
"description": "The input image.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"default": "sam",
"description": "The spectral distance metric to use. One of 'sam' (spectral angle mapper), 'sid' (spectral information divergence), 'sed' (squared euclidean distance), or 'emd' (earth movers distance).",
"name": "metric",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "Connectedness kernel. Defaults to a square of radius 1 (8-way connected).",
"name": "kernel",
"optional": true,
"type": "Kernel"
},
{
"default": false,
"description": "If true, distances are computed from the mean of all pixels under the kernel instead of the kernel's center pixel.",
"name": "useCentroid",
"optional": true,
"type": "Boolean"
}
],
"description": "Computes the spectral gradient over all bands of an image (or the first band if the image is Array typed) by computing the per-pixel difference between the spectral erosion and dilation with a given structuring kernel and distance metric. See: Plaza, Antonio, et al. 'Spatial/spectral endmember extraction by multidimensional morphological operations.' IEEE transactions on geoscience and remote sensing 40.9 (2002): 2025-2041.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.regexpRename": {
"args": [
{
"description": "The image containing the bands to rename.",
"name": "input",
"type": "Image<unknown bands>"
},
{
"description": "A regular expression to match in each band name.",
"name": "regex",
"type": "String"
},
{
"description": "The text with which to replace each match. Supports $n syntax for captured values.",
"name": "replacement",
"type": "String"
},
{
"default": true,
"description": "If true, all matches in a given string will be replaced. Otherwise, only the first match in each string will be replaced.",
"name": "all",
"optional": true,
"type": "Boolean"
}
],
"description": "Renames the bands of an image by applying a regular expression replacement to the current band names. Any bands not matched by the regex will be copied over without renaming.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"ImageCollection.getRegion": {
"args": [
{
"description": "The image collection to extract data from.",
"name": "collection",
"type": "ImageCollection"
},
{
"description": "The region over which to extract data.",
"name": "geometry",
"type": "Geometry"
},
{
"default": null,
"description": "A nominal scale in meters of the projection to work in.",
"name": "scale",
"optional": true,
"type": "Float"
},
{
"default": {
"crs": "EPSG:4326",
"transform": [
1.0,
0.0,
0.0,
0.0,
1.0,
0.0
],
"type": "Projection"
},
"description": "The projection to work in. If unspecified, defaults to EPSG:4326. If specified in addition to scale, the projection is rescaled to the specified scale.",
"name": "crs",
"optional": true,
"type": "Projection"
},
{
"default": null,
"description": "The array of CRS transform values. This is a row-major ordering of a 3x2 affine transform. This option is mutually exclusive with the scale option, and will replace any transform already set on the given projection.",
"name": "crsTransform",
"optional": true,
"type": "List<Float>"
}
],
"description": "Output an array of values for each [pixel, band, image] tuple in an ImageCollection. The output contains rows of id, lon, lat, time, and all bands for each image that intersects each pixel in the given region.",
"returns": "List<Object>",
"type": "Algorithm",
"hidden": false
},
"Image.toUint16": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Casts the input value to an unsigned 16-bit integer.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.uint16": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Casts the input value to an unsigned 16-bit integer.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Array.matrixTranspose": {
"args": [
{
"description": "Array to transpose.",
"name": "array",
"type": "Array"
},
{
"default": 0,
"description": "First axis to swap.",
"name": "axis1",
"optional": true,
"type": "Integer"
},
{
"default": 1,
"description": "Second axis to swap.",
"name": "axis2",
"optional": true,
"type": "Integer"
}
],
"description": "Transposes two dimensions of an array.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Array.matrixToDiag": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "Computes a square diagonal matrix from a single column matrix.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Landsat.TOA": {
"args": [
{
"description": "The Landsat image to process.",
"name": "input",
"type": "Image<unknown bands>"
}
],
"description": "Calibrates Landsat DN to TOA reflectance and brightness temperature for Landsat and similar data. For recently-acquired scenes calibration coefficients are extracted from the image metadata; for older scenes the coefficients are derived from:\n Chander, Gyanesh, Brian L. Markham, and Dennis L. Helder. \"Summary of current radiometric calibration coefficients for Landsat MSS, TM, ETM+, and EO-1 ALI sensors.\" Remote sensing of environment 113.5 (2009): 893-903.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.id": {
"args": [
{
"description": "The element from which the ID is taken.",
"name": "element",
"type": "Element"
}
],
"description": "Returns the ID of a given element within a collection. Objects outside collections are not guaranteed to have IDs.",
"returns": "String",
"type": "Algorithm",
"hidden": false
},
"Number.erf": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Computes the error function of the input.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"reduce.and": {
"args": [
{
"description": "The image collection to reduce.",
"name": "collection",
"type": "ImageCollection"
}
],
"description": "Reduces an image collection by setting each pixel to 1 iff all the non-masked values at that pixel are non-zero across the stack of all matching bands. Bands are matched by name.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Fail.outOfMemory": {
"args": [
{
"default": true,
"name": "isUserQuota",
"optional": true,
"type": "Boolean"
}
],
"description": "Fakes an out-of-memory error. Does not actually allocate.",
"returns": "Object",
"type": "Algorithm",
"hidden": false
},
"Array.toUint16": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, casts the input value to an unsigned 16-bit integer.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Number.multiply": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Number"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Number"
}
],
"description": "Multiplies the first value by the second.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"List.flatten": {
"args": [
{
"name": "list",
"type": "List<Object>"
}
],
"description": "Flattens any sublists into a single list.",
"returns": "List<Object>",
"type": "Algorithm",
"hidden": false
},
"Number.toFloat": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Casts the input value to a 32-bit float.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Image.addBands": {
"args": [
{
"description": "An image into which to copy bands.",
"name": "dstImg",
"type": "Image<unknown bands>"
},
{
"description": "An image containing bands to copy.",
"name": "srcImg",
"type": "Image<unknown bands>"
},
{
"default": null,
"description": "Optional list of band names to copy. If names is omitted, all bands from srcImg will be copied over.",
"name": "names",
"optional": true,
"type": "List<String>"
},
{
"default": false,
"description": "If true, bands from srcImg will override bands with the same names in dstImg. Otherwise the new band will be renamed with a numerical suffix ('foo' to 'foo_1' unless 'foo_1' exists, then 'foo_2' unless it exists, etc).",
"name": "overwrite",
"optional": true,
"type": "Boolean"
}
],
"description": "Returns an image containing all bands copied from the first input and selected bands from the second input, optionally overwriting bands in the first image with the same name. The new image has the metadata and footprint from the first input image.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Terrain.slope": {
"args": [
{
"description": "An elevation image, in meters.",
"name": "input",
"type": "Image<unknown bands>"
}
],
"description": "Calculates slope in degrees from a terrain DEM.\n\nThe local gradient is computed using the 4-connected neighbors of each pixel, so missing values will occur around the edges of an image.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Number.bitCount": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Calculates the number of one-bits in the 64-bit two's complement binary representation of the input.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Reducer.getOutputs": {
"args": [
{
"name": "reducer",
"type": "Reducer"
}
],
"description": "Returns a list of the output names of the given reducer.",
"returns": "List<Object>",
"type": "Algorithm",
"hidden": false
},
"Array.mask": {
"args": [
{
"description": "Array to mask.",
"name": "input",
"type": "Array"
},
{
"description": "Mask array.",
"name": "mask",
"type": "Array"
}
],
"description": "Creates a subarray by slicing out each position in an input array that is parallel to a non-zero element of the given mask array.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Array.erf": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, computes the error function of the input.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Image.setDefaultProjection": {
"args": [
{
"description": "The Image to reproject.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"description": "The CRS to project the image to.",
"name": "crs",
"type": "Projection"
},
{
"default": null,
"description": "The list of CRS transform values. This is a row-major ordering of the 3x2 transform matrix. This option is mutually exclusive with the scale option, and replaces any transform already on the projection.",
"name": "crsTransform",
"optional": true,
"type": "List<Float>"
},
{
"default": null,
"description": "If scale is specified, then the projection is scaled by dividing the specified scale value by the nominal size of a meter in the specified projection. If scale is not specified, then the scale of the given projection will be used.",
"name": "scale",
"optional": true,
"type": "Float"
}
],
"description": "Set a default projection to be applied to this image. The projection's resolution may be overridden by later operations.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"PixelType.uint16": {
"args": [],
"description": "Returns the 16-bit unsigned integer pixel type.",
"returns": "PixelType",
"type": "Algorithm",
"hidden": false
},
"Join.saveFirst": {
"args": [
{
"description": "The property name used to save the match.",
"name": "matchKey",
"type": "String"
},
{
"default": null,
"description": "The property on which to sort the matches before selecting the first.",
"name": "ordering",
"optional": true,
"type": "String"
},
{
"default": true,
"description": "Whether the ordering is ascending.",
"name": "ascending",
"optional": true,
"type": "Boolean"
},
{
"default": null,
"description": "An optional property name used to save the measure of the join condition on the match.",
"name": "measureKey",
"optional": true,
"type": "String"
}
],
"description": "Returns a join that pairs each element from the first collection with a matching element from the second collection. The first match is added to the result as an additional property.",
"returns": "Join",
"type": "Algorithm",
"hidden": false
},
"Describe": {
"args": [
{
"description": "The object to describe.",
"name": "input",
"type": "Object"
}
],
"description": "Describes an object using a simple JSON-compatible structure.",
"returns": "Object",
"type": "Algorithm",
"hidden": false
},
"FeatureCollection.kriging": {
"args": [
{
"description": "Feature collection to use as source data for the estimation.",
"name": "collection",
"type": "FeatureCollection"
},
{
"description": "Property to be estimated (must be numeric).",
"name": "propertyName",
"type": "String"
},
{
"description": "Semivariogram shape (one of {exponential, gaussian, spherical}).",
"name": "shape",
"type": "String"
},
{
"description": "Semivariogram range.",
"name": "range",
"type": "Float"
},
{
"description": "Semivariogram sill.",
"name": "sill",
"type": "Float"
},
{
"description": "Semivariogram nugget.",
"name": "nugget",
"type": "Float"
},
{
"default": null,
"description": "Radius which determines which features are included in each pixel's computation. Defaults to the semivariogram's range.",
"name": "maxDistance",
"optional": true,
"type": "Float"
},
{
"default": null,
"description": "Reducer used to collapse the 'propertyName' value of overlapping points into a single value.",
"name": "reducer",
"optional": true,
"type": "Reducer"
}
],
"description": "Returns the results of sampling a Kriging estimator at each pixel.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.toUint32": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Casts the input value to an unsigned 32-bit integer.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.matrixCholeskyDecomposition": {
"args": [
{
"description": "Image of 2-D matrices to be decomposed.",
"name": "image",
"type": "Image<unknown bands>"
}
],
"description": "Calculates the Cholesky decomposition of a matrix. The Cholesky decomposition is a decomposition into the form L*L' where L is a lower triangular matrix. The input must be a symmetric positive-definite matrix. Returns an image with 1 band named 'L'.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.atan": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Computes the arc tangent in radians of the input.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"ImageCollection.toBands": {
"args": [
{
"description": "The input collection.",
"name": "collection",
"type": "ImageCollection"
}
],
"description": "Converts a collection to a single multi-band image containing all of the bands of every image in the collection. Output bands are named by prefixing the existing band names with the image id from which it came (e.g.: 'image1_band1')",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Classifier.pegasosGaussian": {
"args": [
{
"default": 1.0,
"description": "The gamma value of the Gaussian kernel.",
"name": "rbfGamma",
"optional": true,
"type": "Float"
},
{
"default": "HingeSum",
"description": "The loss function to use. Valid values are: 'HingeSum', 'HingeMax', 'LogSum' and 'LogMax'",
"name": "lossFunction",
"optional": true,
"type": "String"
},
{
"default": 0.001,
"description": "The regularization parameter of SVM (lambda).",
"name": "lambda",
"optional": true,
"type": "Float"
},
{
"default": 0,
"description": "The number of iterations (T). When set to 0 (default), the number of training iterations is automatically set to 5 * training data size (~5 epochs).",
"name": "iterations",
"optional": true,
"type": "Integer"
},
{
"default": 1,
"description": "The subset size (k), i.e. the number of random samples to process on each iteration.",
"name": "subsetSize",
"optional": true,
"type": "Integer"
},
{
"default": 1.0,
"description": "The norm of w for regularization.",
"name": "regularizationNorm",
"optional": true,
"type": "Float"
},
{
"default": 0.01,
"description": "The gamma value for the loss function in multi-class classification.",
"name": "multiGamma",
"optional": true,
"type": "Float"
}
],
"description": "Creates an empty gaussian Pegasos classifier. See:\n \"Pegasos (Primal Estimated sub-GrAdient SOlver for SVM)\"\n S. Shalev-Shwartz, Y. Singer, N. Srebro, A. Cotter",
"returns": "Classifier",
"type": "Algorithm",
"hidden": false,
"deprecated": "Deprecated; will be removed eventually."
},
"List.distinct": {
"args": [
{
"name": "list",
"type": "List<Object>"
}
],
"description": "Returns a copy of list without duplicate elements.",
"returns": "List<Object>",
"type": "Algorithm",
"hidden": false
},
"Image.uint32": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Casts the input value to an unsigned 32-bit integer.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.entropy": {
"args": [
{
"description": "The image for which to compute the entropy.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"description": "A kernel specifying the window in which to compute.",
"name": "kernel",
"type": "Kernel"
}
],
"description": "Computes the windowed entropy for each band using the specified kernel centered on each input pixel.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Number.gte": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Number"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Number"
}
],
"description": "Returns 1 iff the first value is greater than or equal to the second.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Classifier.svm": {
"args": [
{
"default": "Voting",
"description": "The decision procedure to use for classification. Either 'Voting' or 'Margin'. Not used for regression.",
"name": "decisionProcedure",
"optional": true,
"type": "String"
},
{
"default": "C_SVC",
"description": "The SVM type. One of C_SVC, NU_SVC, ONE_CLASS, EPSILON_SVR or NU_SVR.",
"name": "svmType",
"optional": true,
"type": "String"
},
{
"default": "LINEAR",
"description": "The kernel type. One of LINEAR (u′×v), POLY ((γ×u′×v + coef₀)ᵈᵉᵍʳᵉᵉ), RBF (exp(-γ×|u-v|²)) or SIGMOID (tanh(γ×u′×v + coef₀)).",
"name": "kernelType",
"optional": true,
"type": "String"
},
{
"default": true,
"description": "Whether to use shrinking heuristics.",
"name": "shrinking",
"optional": true,
"type": "Boolean"
},
{
"default": null,
"description": "The degree of polynomial. Valid for POLY kernels.",
"name": "degree",
"optional": true,
"type": "Integer"
},
{
"default": null,
"description": "The gamma value in the kernel function. Defaults to the reciprocal of the number of features. Valid for POLY, RBF and SIGMOID kernels.",
"name": "gamma",
"optional": true,
"type": "Float"
},
{
"default": null,
"description": "The coef₀ value in the kernel function. Defaults to 0. Valid for POLY and SIGMOID kernels.",
"name": "coef0",
"optional": true,
"type": "Float"
},
{
"default": null,
"description": "The cost (C) parameter. Defaults to 1. Only valid for C-SVC, epsilon-SVR, and nu-SVR.",
"name": "cost",
"optional": true,
"type": "Float"
},
{
"default": null,
"description": "The nu parameter. Defaults to 0.5. Only valid for of nu-SVC, one-class SVM, and nu-SVR.",
"name": "nu",
"optional": true,
"type": "Float"
},
{
"default": null,
"description": "The termination criterion tolerance (e). Defaults to 0.001. Only valid for epsilon-SVR.",
"name": "terminationEpsilon",
"optional": true,
"type": "Float"
},
{
"default": null,
"description": "The epsilon in the loss function (p). Defaults to 0.1. Only valid for epsilon-SVR.",
"name": "lossEpsilon",
"optional": true,
"type": "Float"
},
{
"default": null,
"description": "The class of the training data on which to train in a one-class svm. Defaults to 0. Only valid for one-class SVM. Possible values are 0 and 1. The classifier output is binary (0/1) and will match this class value for the data determined to be in the class.",
"name": "oneClass",
"optional": true,
"type": "Integer"
}
],
"description": "Creates a Support Vector Machine classifier.",
"returns": "Classifier",
"type": "Algorithm",
"hidden": false
},
"Image.annotate": {
"args": [
{
"description": "The input image.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"description": "The annotation to add to the image.",
"name": "annotation",
"type": "Annotation"
}
],
"description": "Adds an Annotation to an image.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"DateRange.start": {
"args": [
{
"name": "dateRange",
"type": "DateRange"
}
],
"description": "Returns the (inclusive) start of this DateRange.",
"returns": "Date",
"type": "Algorithm",
"hidden": false
},
"ImageCollection.qualityMosaic": {
"args": [
{
"description": "The collection to mosaic.",
"name": "collection",
"type": "ImageCollection"
},
{
"description": "The name of the quality band in the collection.",
"name": "qualityBand",
"type": "String"
}
],
"description": "Composites all the images in a collection, using a quality band as a per-pixel ordering function.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.leftShift": {
"args": [
{
"description": "The image from which the left operand bands are taken.",
"name": "image1",
"type": "Image<unknown bands>"
},
{
"description": "The image from which the right operand bands are taken.",
"name": "image2",
"type": "Image<unknown bands>"
}
],
"description": "Calculates the left shift of v1 by v2 bits for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is the union of the input types.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"AggregateFeatureCollection.array": {
"args": [
{
"description": "The collection to aggregate over.",
"name": "collection",
"type": "FeatureCollection"
},
{
"description": "The property to use from each element of the collection.",
"name": "property",
"type": "String"
}
],
"description": "Aggregates over a given property of the objects in a collection, calculating a list of all the values of the selected property.",
"returns": "Object",
"type": "Algorithm",
"hidden": false
},
"Array.identity": {
"args": [
{
"description": "The length of each axis.",
"name": "size",
"type": "Integer"
}
],
"description": "Creates a 2D identity matrix of the given size.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Join.simple": {
"args": [],
"description": "Returns a join that produces the elements of the primary collection that match any element of the secondary collection. No properties are added to the results.",
"returns": "Join",
"type": "Algorithm",
"hidden": false
},
"Image.cosh": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Computes the hyperbolic cosine of the input.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"AggregateFeatureCollection.mean": {
"args": [
{
"description": "The collection to aggregate over.",
"name": "collection",
"type": "FeatureCollection"
},
{
"description": "The property to use from each element of the collection.",
"name": "property",
"type": "String"
}
],
"description": "Aggregates over a given property of the objects in a collection, calculating the mean of the selected property.",
"returns": "Object",
"type": "Algorithm",
"hidden": false
},
"TemporalSegmentation.LandTrendrFit": {
"args": [
{
"description": "Time series to interpolate.",
"name": "timeSeries",
"type": "ImageCollection"
},
{
"description": "Vertices image. A 1D array of LandTrendr breakpoint years.",
"name": "vertices",
"type": "Image<unknown bands>"
},
{
"default": 0.9,
"description": "Threshold for dampening input spikes (1.0 means no dampening).",
"name": "spikeThreshold",
"optional": true,
"type": "Float"
},
{
"default": 6,
"description": "Min observations needed.",
"name": "minObservationsNeeded",
"optional": true,
"type": "Integer"
}
],
"description": "Interpolates a time series using a set of LandTrendr breakpoint years. For each input band in the timeSeries, outputs a new 1D array-valued band containing the input values interpolated between the breakpoint times identified by the vertices image. See the LandTrendr Algorithm for more details.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Feature.select": {
"args": [
{
"description": "The feature to select properties from.",
"name": "input",
"type": "Element"
},
{
"description": "A list of names or regexes specifying the properties to select.",
"name": "propertySelectors",
"type": "List<String>"
},
{
"default": null,
"description": "Optional new names for the output properties. Must match the number of properties selected.",
"name": "newProperties",
"optional": true,
"type": "List<String>"
},
{
"default": true,
"description": "When false, the result will have a NULL geometry.",
"name": "retainGeometry",
"optional": true,
"type": "Boolean"
}
],
"description": "Selects properties from a feature by name or RE2-compatible regex and optionally renames them.",
"returns": "Element",
"type": "Algorithm",
"hidden": false
},
"Kernel.gaussian": {
"args": [
{
"description": "The radius of the kernel to generate.",
"name": "radius",
"type": "Float"
},
{
"default": 1.0,
"description": "Standard deviation of the Gaussian function (same units as radius).",
"name": "sigma",
"optional": true,
"type": "Float"
},
{
"default": "pixels",
"description": "The system of measurement for the kernel ('pixels' or 'meters'). If the kernel is specified in meters, it will resize when the zoom-level is changed.",
"name": "units",
"optional": true,
"type": "String"
},
{
"default": true,
"description": "Normalize the kernel values to sum to 1.",
"name": "normalize",
"optional": true,
"type": "Boolean"
},
{
"default": 1.0,
"description": "Scale each value by this amount.",
"name": "magnitude",
"optional": true,
"type": "Float"
}
],
"description": "Generates a Gaussian kernel from a sampled continuous Gaussian.",
"returns": "Kernel",
"type": "Algorithm",
"hidden": false
},
"Reducer.group": {
"args": [
{
"description": "The reducer to apply to each group, without the group field.",
"name": "reducer",
"type": "Reducer"
},
{
"default": 0,
"description": "The field that contains record groups.",
"name": "groupField",
"optional": true,
"type": "Integer"
},
{
"default": "group",
"description": "The dictionary key that contains the group. Defaults to 'group'.",
"name": "groupName",
"optional": true,
"type": "String"
}
],
"description": "Groups reducer records by the value of a given input, and reduces each group with the given reducer.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Image.reduce": {
"args": [
{
"description": "The image to reduce.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"description": "The reducer to apply to the given image.",
"name": "reducer",
"type": "Reducer"
}
],
"description": "Applies a reducer to all of the bands of an image.\nThe reducer must have a single input and will be called at each pixel to reduce the stack of band values.\nThe output image will have one band for each reducer output.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.bitwiseAnd": {
"args": [
{
"description": "The image from which the left operand bands are taken.",
"name": "image1",
"type": "Image<unknown bands>"
},
{
"description": "The image from which the right operand bands are taken.",
"name": "image2",
"type": "Image<unknown bands>"
}
],
"description": "Calculates the bitwise AND of the input values for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is the union of the input types.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.date": {
"args": [
{
"description": "The image whose acquisition time to return.",
"name": "image",
"type": "Image<unknown bands>"
}
],
"description": "Returns the acquisition time of an image as a Date object. This helper function is equivalent to ee.Date(image.get('system:time_start')).",
"returns": "Date",
"type": "Algorithm",
"hidden": false
},
"List.filter": {
"args": [
{
"name": "list",
"type": "List<Object>"
},
{
"name": "filter",
"type": "Filter"
}
],
"description": "Filters a list to only the elements that match the given filter. To filter list items that aren't images or features, test a property named'item', e.g.: ee.Filter.gt('item', 3)",
"returns": "List<Object>",
"type": "Algorithm",
"hidden": false
},
"Array.exp": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, computes the Euler's number e raised to the power of the input.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Image.timesatValue": {
"args": [
{
"description": "Image produced by the TIMESAT reducer, where the first band must be a TIMESAT fit.",
"name": "fit",
"type": "Image<unknown bands>"
},
{
"description": "Value of the independent variable at which to evaluate the fit.",
"name": "x",
"type": "Float"
},
{
"description": "The local function used to fit the data: [AsymmetricGaussian, Fourier1, Fourier2, Fourier3]",
"name": "function",
"type": "String"
}
],
"description": "Evaluates a fit computed by the TIMESAT reducer.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.eq": {
"args": [
{
"description": "The image from which the left operand bands are taken.",
"name": "image1",
"type": "Image<unknown bands>"
},
{
"description": "The image from which the right operand bands are taken.",
"name": "image2",
"type": "Image<unknown bands>"
}
],
"description": "Returns 1 iff the first value is equal to the second for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is boolean.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.Segmentation.GMeans": {
"args": [
{
"description": "The input image for clustering.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"default": 10,
"description": "Number of iterations. Default 10.",
"name": "numIterations",
"optional": true,
"type": "Integer"
},
{
"default": 50.0,
"description": "Significance level for normality test.",
"name": "pValue",
"optional": true,
"type": "Float"
},
{
"default": 0,
"description": "Neighborhood size. The amount to extend each tile (overlap) when computing the clusters. This option is mutually exclusive with gridSize.",
"name": "neighborhoodSize",
"optional": true,
"type": "Integer"
},
{
"default": null,
"description": "Grid cell-size. If greater than 0, kMeans will be run independently on cells of this size. This has the effect of limiting the size of any cluster to be gridSize or smaller. This option is mutually exclusive with neighborhoodSize.",
"name": "gridSize",
"optional": true,
"type": "Integer"
},
{
"default": true,
"description": "If true, clusters are assigned unique IDs. Otherwise, they repeat per tile or grid cell.",
"name": "uniqueLabels",
"optional": true,
"type": "Boolean"
}
],
"description": "Performs G-Means clustering on the input image. Iteratively applies k-means followed by a normality test to automatically determine the number of clusters to use. The output contains a 'clusters' band containing the integer ID of the cluster that each pixel belongs to. The algorithm can work either on a fixed grid of non-overlapping cells (gridSize, which can be smaller than a tile) or on tiles with overlap (neighborhoodSize). The default is to use tiles with no overlap. Clusters in one cell or tile are unrelated to clusters in another. Any cluster that spans a cell or tile boundary may receive two different labels in the two halves. Any input pixels with partial masks are fully masked in the output. This algorithm is only expected to perform well for images with a narrow dynamic range (i.e. bytes or shorts).\nSee: G. Hamerly and C. Elkan. 'Learning the k in k-means'. NIPS, 2003.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Array.cbrt": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, computes the cubic root of the input.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Image.matrixQRDecomposition": {
"args": [
{
"description": "Image of 2-D matrices to be decomposed.",
"name": "image",
"type": "Image<unknown bands>"
}
],
"description": "Calculates the QR-decomposition of a matrix into two matrices Q and R such that input = QR, where Q is orthogonal, and R is upper triangular. Returns an image with bands named 'Q' and 'R'.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Array.floor": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, computes the largest integer less than or equal to the input.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"S1.dB": {
"args": [
{
"description": "The raw Sentinel 1 UINT16 image.",
"name": "image",
"type": "Image<unknown bands>"
}
],
"description": "Computes Sentinel 1 decibel values from the stored raw UINT16 image. Also applies bicubic interpolation to the incidence angle band.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": true
},
"Geometry.distance": {
"args": [
{
"description": "The geometry used as the left operand of the operation.",
"name": "left",
"type": "Geometry"
},
{
"description": "The geometry used as the right operand of the operation.",
"name": "right",
"type": "Geometry"
},
{
"default": null,
"description": "The maximum amount of error tolerated when performing any necessary reprojection.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
},
{
"default": null,
"description": "The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.",
"name": "proj",
"optional": true,
"type": "Projection"
}
],
"description": "Returns the minimum distance between two geometries.",
"returns": "Float",
"type": "Algorithm",
"hidden": false
},
"Array.matrixSingularValueDecomposition": {
"args": [
{
"description": "The array to decompose.",
"name": "array",
"type": "Array"
}
],
"description": "Calculates the Singular Value Decomposition of the input matrix into U×S×V', such that U and V are orthogonal and S is diagonal. Returns a dictionary with entries named 'U', 'S' and 'V'.",
"returns": "Dictionary<Object>",
"type": "Algorithm",
"hidden": false
},
"Filter.lte": {
"args": [
{
"default": null,
"description": "A selector for the left operand. Should not be specified if leftValue is specified.",
"name": "leftField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the right operand. Should not be specified if rightField is specified.",
"name": "rightValue",
"optional": true,
"type": "Object"
},
{
"default": null,
"description": "A selector for the right operand. Should not be specified if rightValue is specified.",
"name": "rightField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the left operand. Should not be specified if leftField is specified.",
"name": "leftValue",
"optional": true,
"type": "Object"
}
],
"description": "Creates a unary or binary filter that passes unless the left operand is greater than the right operand.",
"returns": "Filter",
"type": "Algorithm",
"hidden": false
},
"Image.sin": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Computes the sine of the input in radians.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Window.min": {
"args": [
{
"description": "The image to which to apply the operations.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"default": 1.5,
"description": "The radius of the kernel to use.",
"name": "radius",
"optional": true,
"type": "Float"
},
{
"default": "circle",
"description": "The type of kernel to use. Options include: 'circle', 'square', 'cross', 'plus', octagon' and 'diamond'.",
"name": "kernelType",
"optional": true,
"type": "String"
},
{
"default": "pixels",
"description": "If a kernel is not specified, this determines whether the kernel is in meters or pixels.",
"name": "units",
"optional": true,
"type": "String"
},
{
"default": 1,
"description": "The number of times to apply the given kernel.",
"name": "iterations",
"optional": true,
"type": "Integer"
},
{
"default": null,
"description": "A custom kernel. If used, kernelType and radius are ignored.",
"name": "kernel",
"optional": true,
"type": "Kernel"
}
],
"description": "Applies a morphological reducer() filter to each band of an image using a named or custom kernel.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Date.getRange": {
"args": [
{
"name": "date",
"type": "Date"
},
{
"description": "One of 'year', 'month' 'week', 'day', 'hour', 'minute', or 'second'.",
"name": "unit",
"type": "String"
},
{
"default": null,
"description": "The time zone (e.g. 'America/Los_Angeles'); defaults to UTC.",
"name": "timeZone",
"optional": true,
"type": "String"
}
],
"description": "Returns a DateRange covering the unit of the specified type that contains this date, e.g. Date('2013-3-15').getRange('year') returns DateRange('2013-1-1', '2014-1-1').",
"returns": "DateRange",
"type": "Algorithm",
"hidden": false
},
"Number.and": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Number"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Number"
}
],
"description": "Returns 1 iff both values are non-zero.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Feature.perimeter": {
"args": [
{
"description": "The feature from which the geometry is taken.",
"name": "feature",
"type": "Element"
},
{
"default": null,
"description": "The maximum amount of error tolerated when performing any necessary reprojection.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
},
{
"default": null,
"description": "If specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in meters.",
"name": "proj",
"optional": true,
"type": "Projection"
}
],
"description": "Returns the length of the perimeter of the polygonal parts of the geometry of a given feature. The perimeter of multi geometries is the sum of the perimeters of their components.",
"returns": "Float",
"type": "Algorithm",
"hidden": false
},
"Image.clamp": {
"args": [
{
"description": "The image to clamp.",
"name": "input",
"type": "Image<unknown bands>"
},
{
"description": "The minimum allowed value in the range.",
"name": "low",
"type": "Float"
},
{
"description": "The maximum allowed value in the range.",
"name": "high",
"type": "Float"
}
],
"description": "Clamps the values in all bands of an image to all lie within the specified range.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"reduce.mode": {
"args": [
{
"description": "The image collection to reduce.",
"name": "collection",
"type": "ImageCollection"
}
],
"description": "Reduces an image collection by calculating the most common value at each pixel across the stack of all matching bands. Bands are matched by name.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.toInt32": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Casts the input value to a signed 32-bit integer.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Number.parse": {
"args": [
{
"description": "The string to convert to a number.",
"name": "input",
"type": "String"
},
{
"default": 10,
"description": "An integer representing the base number system from which to convert. If input is not an integer, radix must equal 10 or not be specified.",
"name": "radix",
"optional": true,
"type": "Integer"
}
],
"description": "Convert a string to a number.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Geometry.isUnbounded": {
"args": [
{
"name": "geometry",
"type": "Geometry"
}
],
"description": "Returns whether the geometry is unbounded.",
"returns": "Boolean",
"type": "Algorithm",
"hidden": false
},
"Classifier.perceptron": {
"args": [
{
"default": 10,
"description": "The number of training epochs.",
"name": "epochs",
"optional": true,
"type": "Integer"
},
{
"default": true,
"description": "Whether to use an averaged perceptron.",
"name": "averaged",
"optional": true,
"type": "Boolean"
}
],
"description": "Creates an empty Perceptron classifier. See:\n \"Practical Structured Learning Techniques for Natural Language Processing\"\n H. Daume III, pp. 9-10",
"returns": "Classifier",
"type": "Algorithm",
"hidden": false,
"deprecated": "Deprecated; will be removed eventually."
},
"Element.get": {
"args": [
{
"description": "The feature to extract the property from.",
"name": "object",
"type": "Element"
},
{
"description": "The property to extract.",
"name": "property",
"type": "String"
}
],
"description": "Extract a property from a feature.",
"returns": "<any>",
"type": "Algorithm",
"hidden": false
},
"Array.long": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, casts the input value to a signed 64-bit integer.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Classifier.explain": {
"args": [
{
"description": "The classifier to describe.",
"name": "classifier",
"type": "Classifier"
}
],
"description": "Describe the results of a trained classifier.",
"returns": "Dictionary<Object>",
"type": "Algorithm",
"hidden": false
},
"Image.round": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Computes the integer nearest to the input.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"List.indexOfSublist": {
"args": [
{
"name": "list",
"type": "List<Object>"
},
{
"name": "target",
"type": "List<Object>"
}
],
"description": "Returns the starting position of the first occurrence of target within list, or -1 if there is no such occurrence.",
"returns": "Integer",
"type": "Algorithm",
"hidden": false
},
"Image.float": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Casts the input value to a 32-bit float.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Array.and": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Array"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Array"
}
],
"description": "On an element-wise basis, returns 1 iff both values are non-zero.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Image.arrayProject": {
"args": [
{
"description": "Input image.",
"name": "input",
"type": "Image<unknown bands>"
},
{
"description": "The axes to retain. Other axes will be discarded and must be at most length 1.",
"name": "axes",
"type": "List<Integer>"
}
],
"description": "Projects the array in each pixel to a lower dimensional space by specifying the axes to retain. Dropped axes must be at most length 1.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.bitwise_not": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Calculates the bitwise NOT of the input, in the smallest signed integer type that can hold the input.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Reducer.last": {
"args": [],
"description": "Returns a Reducer that returns the last of its inputs.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Image.toInt64": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Casts the input value to a signed 64-bit integer.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Filter.always": {
"args": [],
"description": "Simple filter ALWAYS.",
"returns": "Filter",
"type": "Algorithm",
"hidden": true
},
"Number.cos": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Computes the cosine of the input in radians.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"reduce.or": {
"args": [
{
"description": "The image collection to reduce.",
"name": "collection",
"type": "ImageCollection"
}
],
"description": "Reduces an image collection by setting each pixel to 1 iff any of the non-masked values at that pixel are non-zero across the stack of all matching bands. Bands are matched by name.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Feature.id": {
"args": [
{
"description": "The element from which the ID is taken.",
"name": "element",
"type": "Element"
}
],
"description": "Returns the ID of a given element within a collection. Objects outside collections are not guaranteed to have IDs.",
"returns": "String",
"type": "Algorithm",
"hidden": false
},
"AggregateFeatureCollection.sample_sd": {
"args": [
{
"description": "The collection to aggregate over.",
"name": "collection",
"type": "FeatureCollection"
},
{
"description": "The property to use from each element of the collection.",
"name": "property",
"type": "String"
}
],
"description": "Aggregates over a given property of the objects in a collection, calculating the sample std. deviation of the values of the selected property.",
"returns": "Object",
"type": "Algorithm",
"hidden": false
},
"Filter.intersects": {
"args": [
{
"default": null,
"description": "A selector for the left operand. Should not be specified if leftValue is specified.",
"name": "leftField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the right operand. Should not be specified if rightField is specified.",
"name": "rightValue",
"optional": true,
"type": "Object"
},
{
"default": null,
"description": "A selector for the right operand. Should not be specified if rightValue is specified.",
"name": "rightField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the left operand. Should not be specified if leftField is specified.",
"name": "leftValue",
"optional": true,
"type": "Object"
},
{
"default": {
"type": "ErrorMargin",
"unit": "meters",
"value": 0.1
},
"description": "The maximum reprojection error allowed during filter application.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
}
],
"description": "Creates a unary or binary filter that passes if the left geometry intersects the right geometry.",
"returns": "Filter",
"type": "Algorithm",
"hidden": false
},
"List.removeAll": {
"args": [
{
"name": "list",
"type": "List<Object>"
},
{
"name": "other",
"type": "List<Object>"
}
],
"description": "Removes from list all of the elements that are contained in other list.",
"returns": "List<Object>",
"type": "Algorithm",
"hidden": false
},
"Kernel.rectangle": {
"args": [
{
"description": "The horizontal radius of the kernel to generate.",
"name": "xRadius",
"type": "Float"
},
{
"description": "The vertical radius of the kernel to generate.",
"name": "yRadius",
"type": "Float"
},
{
"default": "pixels",
"description": "The system of measurement for the kernel (\"pixels\" or \"meters\"). If the kernel is specified in meters, it will resize when the zoom-level is changed.",
"name": "units",
"optional": true,
"type": "String"
},
{
"default": true,
"description": "Normalize the kernel values to sum to 1.",
"name": "normalize",
"optional": true,
"type": "Boolean"
},
{
"default": 1.0,
"description": "Scale each value by this amount.",
"name": "magnitude",
"optional": true,
"type": "Float"
}
],
"description": "Generates a rectangular-shaped kernel.",
"returns": "Kernel",
"type": "Algorithm",
"hidden": false
},
"Filter.withinDistance": {
"args": [
{
"description": "The maximum distance for which the filter will return true.",
"name": "distance",
"type": "Float"
},
{
"default": null,
"description": "A selector for the left operand. Should not be specified if leftValue is specified.",
"name": "leftField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the right operand. Should not be specified if rightField is specified.",
"name": "rightValue",
"optional": true,
"type": "Object"
},
{
"default": null,
"description": "A selector for the right operand. Should not be specified if rightValue is specified.",
"name": "rightField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the left operand. Should not be specified if leftField is specified.",
"name": "leftValue",
"optional": true,
"type": "Object"
},
{
"default": {
"type": "ErrorMargin",
"unit": "meters",
"value": 0.1
},
"description": "The maximum reprojection error allowed during filter application.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
}
],
"description": "Creates a unary or binary filter that passes if the left geometry is within a specified distance of the right geometry. If used as a join condition, this distance is used as a join measure.",
"returns": "Filter",
"type": "Algorithm",
"hidden": false
},
"Array.atan2": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Array"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Array"
}
],
"description": "On an element-wise basis, calculates the angle formed by the 2D vector [x, y].",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Geometry.area": {
"args": [
{
"description": "The geometry input.",
"name": "geometry",
"type": "Geometry"
},
{
"default": null,
"description": "The maximum amount of error tolerated when performing any necessary reprojection.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
},
{
"default": null,
"description": "If specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in square meters.",
"name": "proj",
"optional": true,
"type": "Projection"
}
],
"description": "Returns the area of the geometry. Area of points and line strings is 0, and the area of multi geometries is the sum of the areas of their componenets (intersecting areas are counted multiple times).",
"returns": "Float",
"type": "Algorithm",
"hidden": false
},
"Array.slice": {
"args": [
{
"description": "Array to slice.",
"name": "array",
"type": "Array"
},
{
"default": 0,
"description": "The axis to slice on.",
"name": "axis",
"optional": true,
"type": "Integer"
},
{
"default": 0,
"description": "The coordinate of the first slice (inclusive) along 'axis'. Negative numbers are used to position the start of slicing relative to the end of the array, where -1 starts at the last position on the axis, -2 starts at the next to last position, etc.",
"name": "start",
"optional": true,
"type": "Integer"
},
{
"default": null,
"description": "The coordinate (exclusive) at which to stop taking slices. By default this will be the length of the given axis. Negative numbers are used to position the end of slicing relative to the end of the array, where -1 will exclude the last position, -2 will exclude the last two positions, etc.",
"name": "end",
"optional": true,
"type": "Integer"
},
{
"default": 1,
"description": "The separation between slices along 'axis'; a slice will be taken at each whole multiple of 'step' from 'start' (inclusive) to 'end' (exclusive). Must be positive.",
"name": "step",
"optional": true,
"type": "Integer"
}
],
"description": "Creates a subarray by slicing out each position along the given axis from the 'start' (inclusive) to 'end' (exclusive) by increments of 'step'. The result will have as many dimensions as the input, and the same length in all directions except the slicing axis, where the length will be the number of positions from 'start' to 'end' by 'step' that are in range of the input array's length along 'axis'. This means the result can be length 0 along the given axis if start=end, or if the start or end values are entirely out of range.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Number.neq": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Number"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Number"
}
],
"description": "Returns 1 iff the first value is not equal to the second.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Geometry.intersection": {
"args": [
{
"description": "The geometry used as the left operand of the operation.",
"name": "left",
"type": "Geometry"
},
{
"description": "The geometry used as the right operand of the operation.",
"name": "right",
"type": "Geometry"
},
{
"default": null,
"description": "The maximum amount of error tolerated when performing any necessary reprojection.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
},
{
"default": null,
"description": "The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.",
"name": "proj",
"optional": true,
"type": "Projection"
}
],
"description": "Returns the intersection of the two geometries.",
"returns": "Geometry",
"type": "Algorithm",
"hidden": false
},
"Collection.distance": {
"args": [
{
"description": "Feature collection from which to get features used to compute pixel distances.",
"name": "features",
"type": "FeatureCollection"
},
{
"default": 100000.0,
"description": "Maximum distance in meters from each pixel to look for edges. Pixels will be masked unless there are edges within this distance.",
"name": "searchRadius",
"optional": true,
"type": "Float"
},
{
"default": 100.0,
"description": "Maximum reprojection error in meters, only used if the input polylines require reprojection. If '0' is provided, then this operation will fail if projection is required.",
"name": "maxError",
"optional": true,
"type": "Float"
}
],
"description": "Produces a DOUBLE image where each pixel is the distance in meters from the pixel center to the nearest part of any Point or LineString features in the collection. Pixels that are not within 'searchRadius' meters of a geometry will be masked out.\nDistances are computed on a sphere, so there is a small error proportional to the latitude difference between each pixel and the nearest geometry.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.toUint8": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Casts the input value to an unsigned 8-bit integer.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Annotation.append": {
"args": [
{
"name": "dst",
"type": "Annotation"
},
{
"description": "An annotation or a List of annotations to add as children of dst.",
"name": "src",
"type": "Object"
}
],
"description": "Append src as a child of dst.",
"returns": "Annotation",
"type": "Algorithm",
"hidden": false
},
"Array.toUint32": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, casts the input value to an unsigned 32-bit integer.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Number.gammainc": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Number"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Number"
}
],
"description": "Calculates the regularized lower incomplete Gamma function γ(x,a).",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Array.matrixTrace": {
"args": [
{
"description": "The array to compute on.",
"name": "input",
"type": "Array"
}
],
"description": "Computes the trace of the matrix.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Reducer.median": {
"args": [
{
"default": null,
"description": "The maximum number of buckets to use when building a histogram; will be rounded up to a power of 2.",
"name": "maxBuckets",
"optional": true,
"type": "Integer"
},
{
"default": null,
"description": "The minimum histogram bucket width, or null to allow any power of 2.",
"name": "minBucketWidth",
"optional": true,
"type": "Float"
},
{
"default": null,
"description": "The number of values to accumulate before building the initial histogram.",
"name": "maxRaw",
"optional": true,
"type": "Integer"
}
],
"description": "Create a reducer that will compute the median of the inputs. For small numbers of inputs (up to maxRaw) the median will be computed directly; for larger numbers of inputs the median will be derived from a histogram.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"String.slice": {
"args": [
{
"description": "The string to subset.",
"name": "string",
"type": "String"
},
{
"description": "The beginning index, inclusive. Negative numbers count backwards from the end of the string.",
"name": "start",
"type": "Integer"
},
{
"default": null,
"description": "The ending index, exclusive. Defaults to the length of the string. Negative numbers count backwards from the end of the string.",
"name": "end",
"optional": true,
"type": "Integer"
}
],
"description": "Returns a substring of the given string. If the specified range exceeds the length of the string, returns a shorter substring.",
"returns": "String",
"type": "Algorithm",
"hidden": false
},
"Image.reproject": {
"args": [
{
"description": "The Image to reproject.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"description": "The CRS to project the image to.",
"name": "crs",
"type": "Projection"
},
{
"default": null,
"description": "The list of CRS transform values. This is a row-major ordering of the 3x2 transform matrix. This option is mutually exclusive with the scale option, and replaces any transform already on the projection.",
"name": "crsTransform",
"optional": true,
"type": "List<Float>"
},
{
"default": null,
"description": "If scale is specified, then the projection is scaled by dividing the specified scale value by the nominal size of a meter in the specified projection. If scale is not specified, then the scale of the given projection will be used.",
"name": "scale",
"optional": true,
"type": "Float"
}
],
"description": "Force an image to be computed in a given projection and resolution.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Array.sinh": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, computes the hyperbolic sine of the input.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Image.selfMask": {
"args": [
{
"description": "The image to mask with itself.",
"name": "image",
"type": "Image<unknown bands>"
}
],
"description": "Updates an image's mask at all positions where the existing mask is not zero using the value of the image as the new mask value. The output image retains the metadata and footprint of the input image.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"ProjectionTransform": {
"args": [
{
"description": "The feature the geometry of which is being converted.",
"name": "feature",
"type": "Element"
},
{
"default": {
"crs": "EPSG:4326",
"transform": [
1.0,
0.0,
0.0,
0.0,
1.0,
0.0
],
"type": "Projection"
},
"description": "The target projection. Defaults to WGS84. If this has a geographic CRS, the edges of the geometry will be interpreted as geodesics. Otherwise they will be interpreted as straight lines in the projection.",
"name": "proj",
"optional": true,
"type": "Projection"
},
{
"default": null,
"description": "The maximum projection error.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
}
],
"description": "Transforms the geometry of a feature to a specific projection.",
"returns": "Feature",
"type": "Algorithm",
"hidden": false
},
"Image.sampleRegions": {
"args": [
{
"description": "The image to sample.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"description": "The regions to sample over.",
"name": "collection",
"type": "FeatureCollection"
},
{
"default": null,
"description": "The list of properties to copy from each input feature. Defaults to all non-system properties.",
"name": "properties",
"optional": true,
"type": "List<String>"
},
{
"default": null,
"description": "A nominal scale in meters of the projection to sample in. If unspecified,the scale of the image's first band is used.",
"name": "scale",
"optional": true,
"type": "Float"
},
{
"default": null,
"description": "The projection in which to sample. If unspecified, the projection of the image's first band is used. If specified in addition to scale, rescaled to the specified scale.",
"name": "projection",
"optional": true,
"type": "Projection"
},
{
"default": 1.0,
"description": "A scaling factor used to reduce aggregation tile size; using a larger tileScale (e.g. 2 or 4) may enable computations that run out of memory with the default.",
"name": "tileScale",
"optional": true,
"type": "Float"
},
{
"default": false,
"description": "If true, the results will include a geometry per sampled pixel. Otherwise, geometries will be omitted (saving memory).",
"name": "geometries",
"optional": true,
"type": "Boolean"
}
],
"description": "Samples the pixels of an image in one or more regions, returning them as a FeatureCollection. Each output feature will have 1 property per band in the input image, as well as any specified properties copied from the input feature. Note that geometries will be snapped to pixel centers.",
"returns": "FeatureCollection",
"type": "Algorithm",
"hidden": false
},
"List.sort": {
"args": [
{
"name": "list",
"type": "List<Object>"
}
],
"description": "Sorts the list into ascending order.",
"returns": "List<Object>",
"type": "Algorithm",
"hidden": false
},
"Array.toInt8": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, casts the input value to a signed 8-bit integer.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Number.abs": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Computes the absolute value of the input.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"DateRange.unbounded": {
"args": [],
"description": "Returns a DateRange that includes all possible dates.",
"returns": "DateRange",
"type": "Algorithm",
"hidden": false
},
"Dictionary.values": {
"args": [
{
"name": "dictionary",
"type": "Dictionary<Object>"
},
{
"default": null,
"name": "keys",
"optional": true,
"type": "List<String>"
}
],
"description": "Returns the values of a dictionary as a list. If no keys are specified, all values are returned in the natural ordering of the dictionary's keys.",
"returns": "List<Object>",
"type": "Algorithm",
"hidden": false
},
"BACCINI/ModisComposite": {
"args": [
{
"description": "Date range end point is the mosaic's last day.",
"name": "lastYear",
"type": "DateRange"
},
{
"description": "The MCD43A4 collection.",
"name": "reflectance",
"type": "ImageCollection"
},
{
"description": "The MCD43A2 collection.",
"name": "quality",
"type": "ImageCollection"
},
{
"description": "The number of years to draw images from.",
"name": "numberOfYears",
"type": "Integer"
},
{
"description": "The start of the season (1-360).",
"name": "firstDayOfYear",
"type": "Integer"
},
{
"description": "The length of the season (8-368).",
"name": "numberOfDaysPerYear",
"type": "Integer"
},
{
"description": "Only use pixels of lower quality level (1-5).",
"name": "numberOfQualityLevels",
"type": "Integer"
}
],
"description": "Creates composites of MODIS MCD43A4 (\"Nadir BRDF-Adjusted Reflectance 16-Day\") 500m global mosaics, based on an algorithm by Alessandro Baccini, Mark Friedl and Damien Sulla-Menashe.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": true
},
"GeometryConstructors.Rectangle": {
"args": [
{
"description": "The low and then high corners of the Rectangle, as a list of Points or pairs of Numbers in x,y order.",
"name": "coordinates",
"type": "List<Object>"
},
{
"default": null,
"description": "The coordinate reference system of the coordinates. The default is the projection of the inputs, where Numbers are assumed to be EPSG:4326.",
"name": "crs",
"optional": true,
"type": "Projection"
},
{
"default": null,
"description": "If false, edges are straight in the projection. If true, edges are curved to follow the shortest path on the surface of the Earth. The default is the geodesic state of the inputs, or true if the inputs are numbers.",
"name": "geodesic",
"optional": true,
"type": "Boolean"
},
{
"default": true,
"description": "If true, polygon interiors will be determined by the even/odd rule, where a point is inside if it crosses an odd number of edges to reach a point at infinity. Otherwise polygons use the left-inside rule, where interiors are on the left side of the shell's edges when walking the vertices in the given order.",
"name": "evenOdd",
"optional": true,
"type": "Boolean"
}
],
"description": "Constructs a rectangular polygon from the given corner points.",
"returns": "Geometry",
"type": "Algorithm",
"hidden": false
},
"Feature.withinDistance": {
"args": [
{
"description": "The feature containing the geometry used as the left operand of the operation.",
"name": "left",
"type": "Element"
},
{
"description": "The feature containing the geometry used as the right operand of the operation.",
"name": "right",
"type": "Element"
},
{
"description": "The distance threshold. If a projection is specified, the distance is in units of that projected coordinate system, otherwise it is in meters.",
"name": "distance",
"type": "Float"
},
{
"default": null,
"description": "The maximum amount of error tolerated when performing any necessary reprojection.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
},
{
"default": null,
"description": "The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.",
"name": "proj",
"optional": true,
"type": "Projection"
}
],
"description": "Returns true iff the geometries of two features are within a specified distance.",
"returns": "Boolean",
"type": "Algorithm",
"hidden": false
},
"ImageCollection.mosaic": {
"args": [
{
"description": "The collection to mosaic.",
"name": "collection",
"type": "ImageCollection"
}
],
"description": "Composites all the images in a collection, using the mask.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"String.decodeJSON": {
"args": [
{
"description": "The string to decode.",
"name": "string",
"type": "String"
}
],
"description": "Decodes a JSON string.",
"returns": "Object",
"type": "Algorithm",
"hidden": false
},
"Image.log": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Computes the natural logarithm of the input.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.right_shift": {
"args": [
{
"description": "The image from which the left operand bands are taken.",
"name": "image1",
"type": "Image<unknown bands>"
},
{
"description": "The image from which the right operand bands are taken.",
"name": "image2",
"type": "Image<unknown bands>"
}
],
"description": "Calculates the signed right shift of v1 by v2 bits for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is the union of the input types.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Kernel.rotate": {
"args": [
{
"description": "The kernel to be rotated.",
"name": "kernel",
"type": "Kernel"
},
{
"description": "Number of 90 deg. rotations to make (negative numbers rotate counterclockwise).",
"name": "rotations",
"type": "Integer"
}
],
"description": "Creates a Kernel.",
"returns": "Kernel",
"type": "Algorithm",
"hidden": false
},
"Array.erfInv": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, computes the inverse error function of the input.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Element.toDictionary": {
"args": [
{
"description": "The feature to extract the property from.",
"name": "element",
"type": "Element"
},
{
"default": null,
"description": "The list of properties to extract. Defaults to all non-system properties.",
"name": "properties",
"optional": true,
"type": "List<String>"
}
],
"description": "Extract properties from a feature as a dictionary.",
"returns": "Dictionary<Object>",
"type": "Algorithm",
"hidden": false
},
"Number.first": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Number"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Number"
}
],
"description": "Selects the value of the first value.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Image.toShort": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Casts the input value to a signed 16-bit integer.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Annotation.circle": {
"args": [
{
"description": "The x-axis coordinate of the center of the circle.",
"name": "cx",
"type": "Float"
},
{
"description": "The y-axis coordinate of the center of the circle.",
"name": "cy",
"type": "Float"
},
{
"description": "The radius of the circle.",
"name": "r",
"type": "Float"
}
],
"description": "Creates a circle annotation.",
"returns": "Annotation",
"type": "Algorithm",
"hidden": false
},
"Image.fastGaussianBlur": {
"args": [
{
"description": "The input image.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"description": "The standard deviation of the Gaussian kernel, in meters. Equivalently, the spatial wavelength of the low-pass filter.",
"name": "sigma",
"type": "Float"
}
],
"description": "Applies an approximate Gaussian blurring operation to each band of an image.\n\nThis algorithm computes the convolution of the image with a Gaussian smoothing kernel with the given standard deviation. Equivalently, this algorithm applies a spatial low-pass filter with a cutoff at the given spatial wavelength.\n\nThe implementation uses an efficient, approximate method for large kernels: it will evaluate the input data at a reduced resolution, apply a smaller kernel to that data, and then bicubically resample the result.\n\nNOTE: The kernel size is specified in meters, and this is converted to a kernel size in pixels based on the particular map projection in which this operation is being applied. As a result, the effective kernel size may vary if you apply this operation in a region away from the map projection's region of true scale. For example, if you are operating in a Mercator projection then the kernel size will be accurate near the equator but will become increasingly inaccurate at high latitudes.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.hsvToRgb": {
"args": [
{
"description": "The image to transform.",
"name": "image",
"type": "Image<unknown bands>"
}
],
"description": "Transforms the image from the HSV color space to the RGB color space. Produces three bands: red, green and blue, all floating point values in the range [0, 1].",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.visualize": {
"args": [
{
"description": "The image to visualize.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"default": null,
"description": "A list of the bands to visualize. If empty, the first 3 are used.",
"name": "bands",
"optional": true,
"type": "Object"
},
{
"default": null,
"description": "The visualization gain(s) to use.",
"name": "gain",
"optional": true,
"type": "Object"
},
{
"default": null,
"description": "The visualization bias(es) to use.",
"name": "bias",
"optional": true,
"type": "Object"
},
{
"default": null,
"description": "The value(s) to map to RGB8 value 0.",
"name": "min",
"optional": true,
"type": "Object"
},
{
"default": null,
"description": "The value(s) to map to RGB8 value 255.",
"name": "max",
"optional": true,
"type": "Object"
},
{
"default": null,
"description": "The gamma correction factor(s) to use.",
"name": "gamma",
"optional": true,
"type": "Object"
},
{
"default": null,
"description": "The opacity scaling factor to use.",
"name": "opacity",
"optional": true,
"type": "Number"
},
{
"default": null,
"description": "The color palette to use. List of CSS color identifiers or hexadecimal color strings (e.g. ['red', '00FF00', 'bluevlolet']).",
"name": "palette",
"optional": true,
"type": "Object"
},
{
"default": false,
"description": "Whether to produce RGB output even for single-band inputs.",
"name": "forceRgbOutput",
"optional": true,
"type": "Boolean"
}
],
"description": "Produces an RGB or grayscale visualization of an image. Each of the gain, bias, min, max and gamma arguments can take either a single value, which will be applied to all bands, or a list of values the same length as bands.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Dictionary.combine": {
"args": [
{
"name": "first",
"type": "Dictionary<Object>"
},
{
"name": "second",
"type": "Dictionary<Object>"
},
{
"default": true,
"name": "overwrite",
"optional": true,
"type": "Boolean"
}
],
"description": "Combines two dictionaries. In the case of duplicate names, the output will contain the value of the second dictionary unless overwrite is false. Null values in both dictionaries are ignored / removed.",
"returns": "Dictionary<Object>",
"type": "Algorithm",
"hidden": false
},
"Image.classify": {
"args": [
{
"description": "The image to classify. Bands are extracted from this image by name, and it must contain all the bands named in the classifier's schema.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"description": "The classifier to use.",
"name": "classifier",
"type": "Object"
},
{
"default": "classification",
"description": "The name of the band to be added.",
"name": "outputName",
"optional": true,
"type": "String"
}
],
"description": "Classifies an image.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.spectralDistance": {
"args": [
{
"description": "The first image.",
"name": "image1",
"type": "Image<unknown bands>"
},
{
"description": "The second image.",
"name": "image2",
"type": "Image<unknown bands>"
},
{
"default": "sam",
"description": "The spectral distance metric to use. One of 'sam' (spectral angle mapper), 'sid' (spectral information divergence), 'sed' (squared euclidean distance), or 'emd' (earth movers distance).",
"name": "metric",
"optional": true,
"type": "String"
}
],
"description": "Computes the per-pixel spectral distance between two images. If the images are array based then only the first band of each image is used; otherwise all bands are involved in the distance computation. The two images are therefore expected to contain the same number of bands or have the same 1-dimensional array length.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"List.reverse": {
"args": [
{
"name": "list",
"type": "List<Object>"
}
],
"description": "Reverses the order of the elements in list.",
"returns": "List<Object>",
"type": "Algorithm",
"hidden": false
},
"Date.format": {
"args": [
{
"name": "date",
"type": "Date"
},
{
"default": null,
"description": "A pattern, as described at http://joda-time.sourceforge.net/apidocs/org/joda/time/format/DateTimeFormat.html; if omitted will use ISO standard date formatting.",
"name": "format",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The time zone (e.g. 'America/Los_Angeles'); defaults to UTC.",
"name": "timeZone",
"optional": true,
"type": "String"
}
],
"description": "Convert a date to string.",
"returns": "String",
"type": "Algorithm",
"hidden": false
},
"Date.advance": {
"args": [
{
"name": "date",
"type": "Date"
},
{
"name": "delta",
"type": "Float"
},
{
"description": "One of 'year', 'month' 'week', 'day', 'hour', 'minute', or 'second'.",
"name": "unit",
"type": "String"
},
{
"default": null,
"description": "The time zone (e.g. 'America/Los_Angeles'); defaults to UTC.",
"name": "timeZone",
"optional": true,
"type": "String"
}
],
"description": "Create a new Date by adding the specified units to the given Date.",
"returns": "Date",
"type": "Algorithm",
"hidden": false
},
"Array.lanczos": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, computes the Lanczos approximation of the input.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Window.max": {
"args": [
{
"description": "The image to which to apply the operations.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"default": 1.5,
"description": "The radius of the kernel to use.",
"name": "radius",
"optional": true,
"type": "Float"
},
{
"default": "circle",
"description": "The type of kernel to use. Options include: 'circle', 'square', 'cross', 'plus', octagon' and 'diamond'.",
"name": "kernelType",
"optional": true,
"type": "String"
},
{
"default": "pixels",
"description": "If a kernel is not specified, this determines whether the kernel is in meters or pixels.",
"name": "units",
"optional": true,
"type": "String"
},
{
"default": 1,
"description": "The number of times to apply the given kernel.",
"name": "iterations",
"optional": true,
"type": "Integer"
},
{
"default": null,
"description": "A custom kernel. If used, kernelType and radius are ignored.",
"name": "kernel",
"optional": true,
"type": "Kernel"
}
],
"description": "Applies a morphological reducer() filter to each band of an image using a named or custom kernel.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Feature.containedIn": {
"args": [
{
"description": "The feature containing the geometry used as the left operand of the operation.",
"name": "left",
"type": "Element"
},
{
"description": "The feature containing the geometry used as the right operand of the operation.",
"name": "right",
"type": "Element"
},
{
"default": null,
"description": "The maximum amount of error tolerated when performing any necessary reprojection.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
},
{
"default": null,
"description": "The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.",
"name": "proj",
"optional": true,
"type": "Projection"
}
],
"description": "Returns true iff the geometry of one feature is contained in the geometry of another.",
"returns": "Boolean",
"type": "Algorithm",
"hidden": false
},
"Image.lacunarity": {
"args": [
{
"description": "The image to process.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"description": "The size and shape of the 'gliding box' is defined by the nonzero weights in this kernel.",
"name": "boxKernel",
"type": "Kernel"
},
{
"description": "The region of gliding box centers over which the distribution is computed to define lacunarity for each pixel of the output image. Weights in the kernel scale the contribution of each box to the distribution.",
"name": "windowKernel",
"type": "Kernel"
}
],
"description": "Computes lacunarity for each band in the input image, producing matching output bands.\n\nThe method used is the Differential Box-Counting algorithm, except that pixel values are not quantized into boxes, and the box and window may instead be arbitrary kernels.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Array.toFloat": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, casts the input value to a 32-bit float.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Image.glcmTexture": {
"args": [
{
"description": "The image for which to compute texture metrics.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"default": 1,
"description": "The size of the neighborhood to include in each GLCM.",
"name": "size",
"optional": true,
"type": "Integer"
},
{
"default": null,
"description": "A kernel specifying the x and y offsets over which to compute the GLCMs. A GLCM is computed for each pixel in the kernel that is non-zero, except the center pixel and as long as a GLCM hasn't already been computed for the same direction and distance. For example, if either or both of the east and west pixels are set, only 1 (horizontal) GLCM is computed. Kernels are scanned from left to right and top to bottom. The default is a 3x3 square, resulting in 4 GLCMs with the offsets (-1, -1), (0, -1), (1, -1) and (-1, 0).",
"name": "kernel",
"optional": true,
"type": "Kernel"
},
{
"default": true,
"description": "If true, the directional bands for each metric are averaged.",
"name": "average",
"optional": true,
"type": "Boolean"
}
],
"description": "Computes texture metrics from the Gray Level Co-occurrence Matrix around each pixel of every band.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"List.containsAll": {
"args": [
{
"name": "list",
"type": "List<Object>"
},
{
"name": "other",
"type": "List<Object>"
}
],
"description": "Returns true if list contains all of the elements of other, regardless of order.",
"returns": "Boolean",
"type": "Algorithm",
"hidden": false
},
"Reducer.intervalMean": {
"args": [
{
"description": "The lower bound of the percentile range.",
"name": "minPercentile",
"type": "Float"
},
{
"description": "The upper bound of the percentile range.",
"name": "maxPercentile",
"type": "Float"
},
{
"default": null,
"description": "The maximum number of buckets to use when building a histogram; will be rounded up to a power of 2.",
"name": "maxBuckets",
"optional": true,
"type": "Integer"
},
{
"default": null,
"description": "The minimum histogram bucket width, or null to allow any power of 2.",
"name": "minBucketWidth",
"optional": true,
"type": "Float"
},
{
"default": null,
"description": "The number of values to accumulate before building the initial histogram.",
"name": "maxRaw",
"optional": true,
"type": "Integer"
}
],
"description": "Creates a Reducer to compute the mean of all inputs in the specified percentile range. For small numbers of inputs (up to maxRaw) the mean will be computed directly; for larger numbers of inputs the mean will be derived from a histogram.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Array.pow": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Array"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Array"
}
],
"description": "On an element-wise basis, raises the first value to the power of the second.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"FMask.fillMinima": {
"args": [
{
"description": "The image to fill.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"default": null,
"description": "The border value.",
"name": "borderValue",
"optional": true,
"type": "Long"
},
{
"default": 50,
"description": "The size of the neighborhood to compute over.",
"name": "neighborhood",
"optional": true,
"type": "Integer"
}
],
"description": "Fills local minima. Only works on INT types.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Number.float": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Casts the input value to a 32-bit float.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Feature.convexHull": {
"args": [
{
"description": "The feature containing the geometry whole hull is being calculated.",
"name": "feature",
"type": "Element"
},
{
"default": null,
"description": "The maximum amount of error tolerated when performing any necessary reprojection.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
},
{
"default": null,
"description": "The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.",
"name": "proj",
"optional": true,
"type": "Projection"
}
],
"description": "Returns the feature, with the geometry replaced by the convex hull of the original geometry. The convex hull of a single point is the point itself, the convex hull of collinear points is a line, and the convex hull of everything else is a polygon. Note that a degenerate polygon with all vertices on the same line will result in a line segment.",
"returns": "Feature",
"type": "Algorithm",
"hidden": false
},
"Landsat.translateMetadata": {
"args": [
{
"description": "The asset to wrap.",
"name": "input",
"type": "Image<unknown bands>"
}
],
"description": "Does nothing",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": true
},
"Collection.first": {
"args": [
{
"description": "The collection from which to select the first entry.",
"name": "collection",
"type": "FeatureCollection"
}
],
"description": "Returns the first entry from a given collection.",
"returns": "Element",
"type": "Algorithm",
"hidden": false
},
"Geometry.length": {
"args": [
{
"description": "The input geometry.",
"name": "geometry",
"type": "Geometry"
},
{
"default": null,
"description": "The maximum amount of error tolerated when performing any necessary reprojection.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
},
{
"default": null,
"description": "If specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in meters.",
"name": "proj",
"optional": true,
"type": "Projection"
}
],
"description": "Returns the length of the linear parts of the geometry. Polygonal parts are ignored. The length of multi geometries is the sum of the lengths of their components.",
"returns": "Float",
"type": "Algorithm",
"hidden": false
},
"Landsat.simpleCloudScore": {
"args": [
{
"description": "The Landsat TOA image to process.",
"name": "image",
"type": "Image<unknown bands>"
}
],
"description": "Computes a simple cloud-likelihood score in the range [0,100] using a combination of brightness, temperature, and NDSI. This is not a robust cloud detector, and is intended mainly to compare multiple looks at the same point for *relative* cloud likelihood.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Array.int8": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, casts the input value to a signed 8-bit integer.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Image.reduceToVectors": {
"args": [
{
"description": "The input image. The first band is expected to be an integer type; adjacent pixels will be in the same segment if they have the same value in this band.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"default": null,
"description": "The reducer to apply. Its inputs will be taken from the image's bands after dropping the first band. Defaults to Reducer.countEvery()",
"name": "reducer",
"optional": true,
"type": "Reducer"
},
{
"default": null,
"description": "The region over which to reduce data. Defaults to the footprint of the image's first band.",
"name": "geometry",
"optional": true,
"type": "Geometry"
},
{
"default": null,
"description": "A nominal scale in meters of the projection to work in.",
"name": "scale",
"optional": true,
"type": "Float"
},
{
"default": "polygon",
"description": "How to choose the geometry of each generated feature; one of 'polygon' (a polygon enclosing the pixels in the segment), 'bb' (a rectangle bounding the pixels), or 'centroid' (the centroid of the pixels).",
"name": "geometryType",
"optional": true,
"type": "String"
},
{
"default": true,
"description": "If true, diagonally-connected pixels are considered adjacent; otherwise only pixels that share an edge are.",
"name": "eightConnected",
"optional": true,
"type": "Boolean"
},
{
"default": "label",
"description": "If non-null, the value of the first band will be saved as the specified property of each feature.",
"name": "labelProperty",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The projection to work in. If unspecified, the projection of the image's first band is used. If specified in addition to scale, rescaled to the specified scale.",
"name": "crs",
"optional": true,
"type": "Projection"
},
{
"default": null,
"description": "The list of CRS transform values. This is a row-major ordering of the 3x2 transform matrix. This option is mutually exclusive with 'scale', and replaces any transform already set on the projection.",
"name": "crsTransform",
"optional": true,
"type": "List<Float>"
},
{
"default": false,
"description": "If the polygon would contain too many pixels at the given scale, compute and use a larger scale which would allow the operation to succeed.",
"name": "bestEffort",
"optional": true,
"type": "Boolean"
},
{
"default": 10000000,
"description": "The maximum number of pixels to reduce.",
"name": "maxPixels",
"optional": true,
"type": "Long"
},
{
"default": 1.0,
"description": "A scaling factor used to reduce aggregation tile size; using a larger tileScale (e.g. 2 or 4) may enable computations that run out of memory with the default.",
"name": "tileScale",
"optional": true,
"type": "Float"
},
{
"default": false,
"description": "Create geometries in the pixel projection, rather than WGS84.",
"name": "geometryInNativeProjection",
"optional": true,
"type": "Boolean"
}
],
"description": "Convert an image to a feature collection by reducing homogenous regions. Given an image containing a band of labeled segments and zero or more additional bands, runs a reducer over the pixels in each segment producing a feature per segment.\nEither the reducer must have one fewer inputs than the image has bands, or it must have a single input and will be repeated for each band.",
"returns": "FeatureCollection",
"type": "Algorithm",
"hidden": false
},
"List.splice": {
"args": [
{
"name": "list",
"type": "List<Object>"
},
{
"name": "start",
"type": "Integer"
},
{
"name": "count",
"type": "Integer"
},
{
"default": null,
"name": "other",
"optional": true,
"type": "List<Object>"
}
],
"description": "Starting at the start index, removes count elements from list and insert the contents of other at that location. If start is negative, it counts backwards from the end of the list.",
"returns": "List<Object>",
"type": "Algorithm",
"hidden": false
},
"Filter.hasGeometry": {
"args": [],
"description": "Simple filter HAS_GEOMETRY.",
"returns": "Filter",
"type": "Algorithm",
"hidden": true
},
"List.replaceAll": {
"args": [
{
"name": "list",
"type": "List<Object>"
},
{
"name": "oldval",
"type": "Object"
},
{
"name": "newval",
"type": "Object"
}
],
"description": "Replaces all occurrences of oldVal in list with newVal.",
"returns": "List<Object>",
"type": "Algorithm",
"hidden": false
},
"Image.double": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Casts the input value to a 64-bit float.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Classifier.spectralRegion": {
"args": [
{
"description": "The coordinates of the polygon, as a list of rings. Each ring is a list of coordinate pairs (e.g.: [u1, v1, u2, v2, ..., uN, vN]). No edge may intersect any other edge. The resulting classification will be a 1 wherever the input values are within the interior of the given polygon, that is, an odd number of polygon edges must be crossed to get outside the polygon and 0 otherwise.",
"name": "coordinates",
"type": "List<List<Float>>"
},
{
"default": null,
"description": "The classifier's schema. A list of band or property names that the classifier will operate on. Since this classifier doesn't undergo a training step, these have to be specified manually. Defaults to ['u', 'v'].",
"name": "schema",
"optional": true,
"type": "List<String>"
}
],
"description": "Creates a classifier that tests if its inputs lie within a polygon defined by a set of coordinates in an arbitrary 2D coordinate system. Each input to be classified must have 2 values (e.g.: images must have 2 bands). The result will be 1 wherever the input values are contained within the given polygon and 0 otherwise.",
"returns": "Classifier",
"type": "Algorithm",
"hidden": false
},
"Array.toLong": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, casts the input value to a signed 64-bit integer.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Image.toInt16": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Casts the input value to a signed 16-bit integer.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Collection.draw": {
"args": [
{
"description": "The collection to draw.",
"name": "collection",
"type": "FeatureCollection"
},
{
"description": "A hex string in the format RRGGBB specifying the color to use for drawing the features.",
"name": "color",
"type": "String"
},
{
"default": 3,
"description": "The radius in pixels of the point markers.",
"name": "pointRadius",
"optional": true,
"type": "Integer"
},
{
"default": 2,
"description": "The width in pixels of lines and polygon borders.",
"name": "strokeWidth",
"optional": true,
"type": "Integer"
}
],
"description": "Paints a vector collection for visualization. Not intended for use as input to other algorithms.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.random": {
"args": [
{
"default": 0,
"description": "Seed for the random number generator.",
"name": "seed",
"optional": true,
"type": "Long"
}
],
"description": "Generates a uniform random number at each pixel location, in the range of 0 to 1.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"SelectorSet.Simple": {
"args": [
{
"name": "all",
"type": "Boolean"
}
],
"description": "Returns a SelectorSet for either the whole object or nothing.",
"returns": "SelectorSet",
"type": "Algorithm",
"hidden": true
},
"Image.interpolate": {
"args": [
{
"description": "The image to which the interpolation is applied.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"description": "The x axis (input) values in the piecewise function.",
"name": "x",
"type": "List<Float>"
},
{
"description": "The y axis (output) values in the piecewise function.",
"name": "y",
"type": "List<Float>"
},
{
"default": "extrapolate",
"description": "The behavior for points that are outside of the range of the supplied function. Options are: 'extrapolate', 'clamp', 'mask' or 'input'.",
"name": "behavior",
"optional": true,
"type": "String"
}
],
"description": "Interpolates each point in the first band of the input image into the piecewise-linear function specified by the x and y arrays. The x values must be strictly increasing. If an input point is less than the first or greater than the last x value, then the output is specified by the \"behavior\" argument: \"extrapolate\" specifies the output value is extrapolated from the two nearest points, \"clamp\" specifies the output value is taken from the nearest point, \"input\" specifies the output value is copied from the input and \"mask\" specifies the output value is masked.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Array.cut": {
"args": [
{
"description": "The array to cut.",
"name": "array",
"type": "Array"
},
{
"description": "Cut an array along one or more axes. The positions args specifies either a single value for each axis of the array, or -1, indicating the whole axis. The output will be an array that has the same dimensions as the input, with a length of 1 on each axis that was not -1 in the positions array.",
"name": "position",
"type": "List<Integer>"
}
],
"description": "Cut an array along one or more axes.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Image.reduceRegions": {
"args": [
{
"description": "The image to reduce.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"description": "The features to reduce over.",
"name": "collection",
"type": "FeatureCollection"
},
{
"description": "The reducer to apply.",
"name": "reducer",
"type": "Reducer"
},
{
"default": null,
"description": "A nominal scale in meters of the projection to work in.",
"name": "scale",
"optional": true,
"type": "Float"
},
{
"default": null,
"description": "The projection to work in. If unspecified, the projection of the image's first band is used. If specified in addition to scale, rescaled to the specified scale.",
"name": "crs",
"optional": true,
"type": "Projection"
},
{
"default": null,
"description": "The list of CRS transform values. This is a row-major ordering of the 3x2 transform matrix. This option is mutually exclusive with 'scale', and will replace any transform already set on the projection.",
"name": "crsTransform",
"optional": true,
"type": "List<Float>"
},
{
"default": 1.0,
"description": "A scaling factor used to reduce aggregation tile size; using a larger tileScale (e.g. 2 or 4) may enable computations that run out of memory with the default.",
"name": "tileScale",
"optional": true,
"type": "Float"
}
],
"description": "Apply a reducer over the area of each feature in the given collection.\nThe reducer must have the same number of inputs as the input image has bands.\nReturns the input features, each augmented with the corresponding reducer outputs.",
"returns": "FeatureCollection",
"type": "Algorithm",
"hidden": false
},
"Dictionary.fromLists": {
"args": [
{
"name": "keys",
"type": "List<String>"
},
{
"name": "values",
"type": "List<Object>"
}
],
"description": "Construct a dictionary from two parallel lists of keys and values.",
"returns": "Dictionary<Object>",
"type": "Algorithm",
"hidden": false
},
"ConfusionMatrix": {
"args": [
{
"description": "A square, 2D array of integers, representing the confusion matrix.",
"name": "array",
"type": "Object"
},
{
"default": null,
"description": "The row and column size and order, for non-contiguous or non-zero based matrices.",
"name": "order",
"optional": true,
"type": "List<Integer>"
}
],
"description": "Creates a confusion matrix. Axis 1 (the rows) of the matrix correspond to the actual values, and Axis 0 (the columns) to the predicted values.",
"returns": "ConfusionMatrix",
"type": "Algorithm",
"hidden": false
},
"Feature.area": {
"args": [
{
"description": "The feature from which the geometry is taken.",
"name": "feature",
"type": "Element"
},
{
"default": null,
"description": "The maximum amount of error tolerated when performing any necessary reprojection.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
},
{
"default": null,
"description": "If specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in square meters.",
"name": "proj",
"optional": true,
"type": "Projection"
}
],
"description": "Returns the area of the feature's default geometry. Area of points and line strings is 0, and the area of multi geometries is the sum of the areas of their componenets (intersecting areas are counted multiple times).",
"returns": "Float",
"type": "Algorithm",
"hidden": false
},
"Image.lt": {
"args": [
{
"description": "The image from which the left operand bands are taken.",
"name": "image1",
"type": "Image<unknown bands>"
},
{
"description": "The image from which the right operand bands are taken.",
"name": "image2",
"type": "Image<unknown bands>"
}
],
"description": "Returns 1 iff the first value is less than the second for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is boolean.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Kernel.add": {
"args": [
{
"description": "The first kernel.",
"name": "kernel1",
"type": "Kernel"
},
{
"description": "The second kernel.",
"name": "kernel2",
"type": "Kernel"
},
{
"default": false,
"description": "Normalize the kernel.",
"name": "normalize",
"optional": true,
"type": "Boolean"
}
],
"description": "Adds two kernels (pointwise), after aligning their centers.",
"returns": "Kernel",
"type": "Algorithm",
"hidden": false
},
"Geometry.contains": {
"args": [
{
"description": "The geometry used as the left operand of the operation.",
"name": "left",
"type": "Geometry"
},
{
"description": "The geometry used as the right operand of the operation.",
"name": "right",
"type": "Geometry"
},
{
"default": null,
"description": "The maximum amount of error tolerated when performing any necessary reprojection.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
},
{
"default": null,
"description": "The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.",
"name": "proj",
"optional": true,
"type": "Projection"
}
],
"description": "Returns true iff one geometry contains the other.",
"returns": "Boolean",
"type": "Algorithm",
"hidden": false
},
"Reducer.forEachBand": {
"args": [
{
"name": "reducer",
"type": "Reducer"
},
{
"name": "image",
"type": "Image<unknown bands>"
}
],
"description": "Creates a Reducer by combining a copy of the given reducer for each band in the given image, using the band names as output names.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Date.get": {
"args": [
{
"name": "date",
"type": "Date"
},
{
"description": "One of 'year', 'month' (returns 1-12), 'week' (1-53), 'day' (1-31), 'hour' (0-23), 'minute' (0-59), or 'second' (0-59).",
"name": "unit",
"type": "String"
},
{
"default": null,
"description": "The time zone (e.g. 'America/Los_Angeles'); defaults to UTC.",
"name": "timeZone",
"optional": true,
"type": "String"
}
],
"description": "Returns the specified unit of this date.",
"returns": "Long",
"type": "Algorithm",
"hidden": false
},
"Image.arrayAccum": {
"args": [
{
"description": "Input image.",
"name": "input",
"type": "Image<unknown bands>"
},
{
"description": "Axis along which to perform the cumulative sum.",
"name": "axis",
"type": "Integer"
},
{
"default": null,
"description": "Reducer to accumulate values. Default is SUM, to produce the cumulative sum of each vector along the given axis.",
"name": "reducer",
"optional": true,
"type": "Reducer"
}
],
"description": "Accumulates elements of each array pixel along the given axis, by setting each element of the result array pixel to the reduction of elements in that pixel along the given axis, up to and including the current position on the axis. May be used to make a cumulative sum, a monotonically increasing sequence, etc.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Reducer.allNonZero": {
"args": [],
"description": "Returns a Reducer that returns 1 if all of its inputs are non-zero, 0 otherwise.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Reducer.spearmansCorrelation": {
"args": [],
"description": "Creates a two-input reducer that computes the Spearman's rank-moment correlation and its p-value on a two-sided test of H0: x and y are independent. Currently, the p-value test is disabled and returns null.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Kernel.plus": {
"args": [
{
"description": "The radius of the kernel to generate.",
"name": "radius",
"type": "Float"
},
{
"default": "pixels",
"description": "The system of measurement for the kernel ('pixels' or 'meters'). If the kernel is specified in meters, it will resize when the zoom-level is changed.",
"name": "units",
"optional": true,
"type": "String"
},
{
"default": true,
"description": "Normalize the kernel values to sum to 1.",
"name": "normalize",
"optional": true,
"type": "Boolean"
},
{
"default": 1.0,
"description": "Scale each value by this amount.",
"name": "magnitude",
"optional": true,
"type": "Float"
}
],
"description": "Generates a plus-shaped boolean kernel.",
"returns": "Kernel",
"type": "Algorithm",
"hidden": false
},
"Image.arrayLength": {
"args": [
{
"description": "Input image.",
"name": "input",
"type": "Image<unknown bands>"
},
{
"description": "The axis along which to take the length.",
"name": "axis",
"type": "Integer"
}
],
"description": "Returns the length of each pixel's array along the given axis.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"List.join": {
"args": [
{
"name": "list",
"type": "List<Object>"
},
{
"default": "",
"name": "separator",
"optional": true,
"type": "String"
}
],
"description": "Returns a string containing the elements of the list joined together with the specified separator between elements.",
"returns": "String",
"type": "Algorithm",
"hidden": false
},
"ConfusionMatrix.array": {
"args": [
{
"name": "confusionMatrix",
"type": "ConfusionMatrix"
}
],
"description": "Returns a confusion matrix as an Array.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"AggregateFeatureCollection.product": {
"args": [
{
"description": "The collection to aggregate over.",
"name": "collection",
"type": "FeatureCollection"
},
{
"description": "The property to use from each element of the collection.",
"name": "property",
"type": "String"
}
],
"description": "Aggregates over a given property of the objects in a collection, calculating the product of the values of the selected property.",
"returns": "Object",
"type": "Algorithm",
"hidden": false
},
"Geometry.union": {
"args": [
{
"description": "The geometry used as the left operand of the operation.",
"name": "left",
"type": "Geometry"
},
{
"description": "The geometry used as the right operand of the operation.",
"name": "right",
"type": "Geometry"
},
{
"default": null,
"description": "The maximum amount of error tolerated when performing any necessary reprojection.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
},
{
"default": null,
"description": "The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.",
"name": "proj",
"optional": true,
"type": "Projection"
}
],
"description": "Returns the union of the two geometries.",
"returns": "Geometry",
"type": "Algorithm",
"hidden": false
},
"Blob": {
"args": [
{
"description": "The Blob's Google Cloud Storage URL.",
"name": "url",
"type": "String"
}
],
"description": "Loads a Blob from a Google Cloud Storage URL.",
"returns": "Blob",
"type": "Algorithm",
"hidden": false
},
"Image.lte": {
"args": [
{
"description": "The image from which the left operand bands are taken.",
"name": "image1",
"type": "Image<unknown bands>"
},
{
"description": "The image from which the right operand bands are taken.",
"name": "image2",
"type": "Image<unknown bands>"
}
],
"description": "Returns 1 iff the first value is less than or equal to the second for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is boolean.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Filter.listContains": {
"args": [
{
"default": null,
"description": "A selector for the left operand. Should not be specified if leftValue is specified.",
"name": "leftField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the right operand. Should not be specified if rightField is specified.",
"name": "rightValue",
"optional": true,
"type": "Object"
},
{
"default": null,
"description": "A selector for the right operand. Should not be specified if rightValue is specified.",
"name": "rightField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the left operand. Should not be specified if leftField is specified.",
"name": "leftValue",
"optional": true,
"type": "Object"
}
],
"description": "Creates a unary or binary filter that passes if the left operand, a list, contains the right operand.",
"returns": "Filter",
"type": "Algorithm",
"hidden": false
},
"Image.arrayTranspose": {
"args": [
{
"description": "Input image.",
"name": "input",
"type": "Image<unknown bands>"
},
{
"default": 0,
"description": "First axis to swap.",
"name": "axis1",
"optional": true,
"type": "Integer"
},
{
"default": 1,
"description": "Second axis to swap.",
"name": "axis2",
"optional": true,
"type": "Integer"
}
],
"description": "Transposes two dimensions of each array pixel.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Classifier.winnow": {
"args": [
{
"default": 5,
"description": "The number of training epochs.",
"name": "epochs",
"optional": true,
"type": "Integer"
},
{
"default": 0.1,
"description": "The learning rate.",
"name": "learningRate",
"optional": true,
"type": "Float"
},
{
"default": 0.1,
"description": "The learning rate for updating bias weights.",
"name": "biasLearningRate",
"optional": true,
"type": "Float"
},
{
"default": 0.2,
"description": "The \"wide-margin\" (or \"thick\"-separator) size. If this is nonzero, the classifier updates the weights even when it just barely got the answer right. See \"Mistake-Driven Learning in Text Categorization\" by I. Dagan, Y. Karov, and D. Roth.",
"name": "margin",
"optional": true,
"type": "Float"
}
],
"description": "Creates an empty Winnow classifier. Uses an updating rule similar to the one described in:\n \"Automatically categorizing written texts by author gender\"\n M. Koppel, S. Argamon, A. Shimoni\n Literary and Linguistic Computing 17(4), November 2002, pp. 401-412.",
"returns": "Classifier",
"type": "Algorithm",
"hidden": false,
"deprecated": "Deprecated; will be removed eventually."
},
"Array.uint8": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, casts the input value to an unsigned 8-bit integer.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Reducer.setOutputs": {
"args": [
{
"name": "reducer",
"type": "Reducer"
},
{
"description": "The new output names; any output whose name is null or empty will be dropped.",
"name": "outputs",
"type": "List<String>"
}
],
"description": "Returns a Reducer with the same inputs as the given Reducer, but with outputs renamed and/or removed.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Element.setMulti": {
"args": [
{
"description": "The object whose properties to override.",
"name": "object",
"type": "Element"
},
{
"description": "The property values to override.",
"name": "properties",
"type": "Dictionary<Object>"
}
],
"description": "Overrides one or more metadata properties of an object.",
"returns": "Element",
"type": "Algorithm",
"hidden": false
},
"Feature.centroid": {
"args": [
{
"description": "Calculates the centroid of this feature's default geometry.",
"name": "feature",
"type": "Element"
},
{
"default": null,
"description": "The maximum amount of error tolerated when performing any necessary reprojection.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
},
{
"default": null,
"description": "If specified, the result will be in this projection. Otherwise it will be in WGS84.",
"name": "proj",
"optional": true,
"type": "Projection"
}
],
"description": "Returns a feature containing the point at the center of the highest-dimension components of the geometry of a feature. Lower-dimensional components are ignored, so the centroid of a geometry containing two polygons, three lines and a point is equivalent to the centroid of a geometry containing just the two polygons.",
"returns": "Feature",
"type": "Algorithm",
"hidden": false
},
"List.replace": {
"args": [
{
"name": "list",
"type": "List<Object>"
},
{
"name": "oldval",
"type": "Object"
},
{
"name": "newval",
"type": "Object"
}
],
"description": "Replaces the first occurrence of oldVal in list with newVal.",
"returns": "List<Object>",
"type": "Algorithm",
"hidden": false
},
"Number.round": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Computes the integer nearest to the input.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Image.ceil": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Computes the smallest integer greater than or equal to the input.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"List.remove": {
"args": [
{
"name": "list",
"type": "List<Object>"
},
{
"name": "element",
"type": "Object"
}
],
"description": "Removes the first occurrence of the specified element from list, if it is present.",
"returns": "List<Object>",
"type": "Algorithm",
"hidden": false
},
"Image.byte": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Casts the input value to an unsigned 8-bit integer.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"AggregateFeatureCollection.histogram": {
"args": [
{
"description": "The collection to aggregate over.",
"name": "collection",
"type": "FeatureCollection"
},
{
"description": "The property to use from each element of the collection.",
"name": "property",
"type": "String"
}
],
"description": "Aggregates over a given property of the objects in a collection, calculating a histogram of the selected property.",
"returns": "Object",
"type": "Algorithm",
"hidden": false
},
"Feature.difference": {
"args": [
{
"description": "The feature containing the geometry used as the left operand of the operation. The properties of the result will be copied from this object.",
"name": "left",
"type": "Element"
},
{
"description": "The feature containing the geometry used as the right operand of the operation. The properties of this object are ignored.",
"name": "right",
"type": "Element"
},
{
"default": null,
"description": "The maximum amount of error tolerated when performing any necessary reprojection.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
},
{
"default": null,
"description": "The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.",
"name": "proj",
"optional": true,
"type": "Projection"
}
],
"description": "Returns a feature with the properties of the 'left' feature, and the geometry that results from subtracting the 'right' geometry from the 'left' geometry.",
"returns": "Feature",
"type": "Algorithm",
"hidden": false
},
"Test.Clustering.InterTileRegionMerge": {
"args": [
{
"description": "The input image for clustering.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"description": "Scale parameter, also known as number of iterations: The number of iterations determines how strict of a threshold is enforced with respect to spectral and shape properties in allowing merging. Successive iterations allow for merges with increasingly poor merge criteria up to the final threshold, determined by the number of iterations. For inter-tile merging post-processing, the scale parameter determines how strict a threshold to allow for merging regions across adjacent tiles.",
"name": "scale",
"type": "Integer"
},
{
"description": "Shape parameter: The shape parameter determines how important the shape of a merged segment is relative to spectral similarity. Shape and spectral parameters add to 1 (e.g., if you only care about spectral, put shape as 0).",
"name": "shape",
"type": "Float"
},
{
"description": "Compactness parameter: Within the shape consideration, there are two properties evaluated - compactness and smoothness. Compactness can be thought of as the area of an object compared to its perimeter (e.g., a square has high compactness, a long and thin rectangle does not). Smoothness can be thought of as the perimeter of an object compared to its bounding box perimeter (e.g., a square has high smoothness, an amoeba-like shape would not). Compactness and smoothness add to 1 (e.g., if you only care about smoothness, put compactness as 0).",
"name": "compactness",
"type": "Float"
},
{
"default": null,
"description": "The weights for each band, in order of the bands. This determines the spectral importance of each band in merging. Defaulted to uniform band weights. If band weights are specified, they will be automatically normalized.",
"name": "bandWeights",
"optional": true,
"type": "List<Float>"
},
{
"default": 256,
"description": "Maximum object size. Regions cannot be merged across tiles iftheir length is over this limit.",
"name": "maxObjectSize",
"optional": true,
"type": "Integer"
},
{
"default": true,
"description": "Whether to treat corner cases. If enabled, as is by default, if a region A in the center tile is determined to merge with a region B in an adjacent tile (either north or west) and region B is determined to merge with a region C in its adjacent tile (this is the northwest tile from the center tile's perspective), then both regions A and B will take on the label of region C. That is, enabling this allows merging between 3 tiles at corners.",
"name": "cornerCases",
"optional": true,
"type": "Boolean"
}
],
"description": "Performs post-processing inter-tile region merging phase according to Berkeley image segmentation algorithm. Takes image that is a result of running tile-independent segmentation. Input image should have first band named 'clusters' containing segment labels. The other bands are spectral bands. Examines tile boundaries and merges adjacent segments across tiles if sufficient merging critieria is satisfied. Merging criteria is determined by user specified parameters indicating relative importance of spectral and shape properties.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": true
},
"Kernel.euclidean": {
"args": [
{
"description": "The radius of the kernel to generate.",
"name": "radius",
"type": "Float"
},
{
"default": "pixels",
"description": "The system of measurement for the kernel ('pixels' or 'meters'). If the kernel is specified in meters, it will resize when the zoom-level is changed.",
"name": "units",
"optional": true,
"type": "String"
},
{
"default": false,
"description": "Normalize the kernel values to sum to 1.",
"name": "normalize",
"optional": true,
"type": "Boolean"
},
{
"default": 1.0,
"description": "Scale each value by this amount.",
"name": "magnitude",
"optional": true,
"type": "Float"
}
],
"description": "Generates a distance kernel based on Euclidean (straight-line) distance.",
"returns": "Kernel",
"type": "Algorithm",
"hidden": false
},
"Filter.stringStartsWith": {
"args": [
{
"default": null,
"description": "A selector for the left operand. Should not be specified if leftValue is specified.",
"name": "leftField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the right operand. Should not be specified if rightField is specified.",
"name": "rightValue",
"optional": true,
"type": "Object"
},
{
"default": null,
"description": "A selector for the right operand. Should not be specified if rightValue is specified.",
"name": "rightField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the left operand. Should not be specified if leftField is specified.",
"name": "leftValue",
"optional": true,
"type": "Object"
}
],
"description": "Creates a unary or binary filter that passes if the left operand, a string, starts with the right operand, also a string.",
"returns": "Filter",
"type": "Algorithm",
"hidden": false
},
"Reducer.combine": {
"args": [
{
"name": "reducer1",
"type": "Reducer"
},
{
"name": "reducer2",
"type": "Reducer"
},
{
"default": "",
"description": "Prefix for reducer2's output names.",
"name": "outputPrefix",
"optional": true,
"type": "String"
},
{
"default": false,
"name": "sharedInputs",
"optional": true,
"type": "Boolean"
}
],
"description": "Creates a Reducer that runs two reducers in parallel. The combined reducer's outputs will be those of reducer1 followed by those of reducer2, where the output names of reducer2 are prefixed with the given string.\nIf sharedInputs is true, the reducers must have the same number of inputs, and the combined reducer's will match them; if it is false, the inputs of the combined reducer will be those of reducer1 followed by those of reducer2.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Array.short": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, casts the input value to a signed 16-bit integer.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Image.stratifiedSample": {
"args": [
{
"description": "The image to sample.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"description": "The default number of points to sample in each class. Can be overridden for specific classes using the 'classValues' and 'classPoints' properties.",
"name": "numPoints",
"type": "Integer"
},
{
"default": null,
"description": "The name of the band containing the classes to use for stratification. If unspecified, the first band of the input image is used.",
"name": "classBand",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The region to sample from. If unspecified, the input image's whole footprint is used.",
"name": "region",
"optional": true,
"type": "Geometry"
},
{
"default": null,
"description": "A nominal scale in meters of the projection to sample in. Defaults to the scale of the first band of the input image.",
"name": "scale",
"optional": true,
"type": "Float"
},
{
"default": null,
"description": "The projection in which to sample. If unspecified, the projection of the input image's first band is used. If specified in addition to scale, rescaled to the specified scale.",
"name": "projection",
"optional": true,
"type": "Projection"
},
{
"default": 0,
"description": "A randomization seed to use for subsampling.",
"name": "seed",
"optional": true,
"type": "Integer"
},
{
"default": null,
"description": "A list of class values for which to override the numPixels parameter. Must be the same size as classPoints or null.",
"name": "classValues",
"optional": true,
"type": "List<Integer>"
},
{
"default": null,
"description": "A list of the per-class maximum number of pixels to sample for each class in the classValues list. Must be the same size as classValues or null.",
"name": "classPoints",
"optional": true,
"type": "List<Integer>"
},
{
"default": true,
"description": "Skip pixels in which any band is masked.",
"name": "dropNulls",
"optional": true,
"type": "Boolean"
},
{
"default": 1.0,
"description": "A scaling factor used to reduce aggregation tile size; using a larger tileScale (e.g. 2 or 4) may enable computations that run out of memory with the default.",
"name": "tileScale",
"optional": true,
"type": "Float"
},
{
"default": false,
"description": "If true, the results will include a geometry per sampled pixel. Otherwise, geometries will be omitted (saving memory).",
"name": "geometries",
"optional": true,
"type": "Boolean"
}
],
"description": "Extracts a stratified random sample of points from an image. Extracts the specified number of samples for each distinct value discovered within the 'classBand'. Returns a FeatureCollection of 1 Feature per extracted point, with each feature having 1 property per band in the input image. If there are less than the specified number of samples available for a given class value, then all of the points for that class will be included. Requires that the classBand contain integer values.",
"returns": "FeatureCollection",
"type": "Algorithm",
"hidden": false
},
"Image.cluster": {
"args": [
{
"description": "The image to cluster. Must contain all the bands in the clusterer's schema.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"description": "The clusterer to use.",
"name": "clusterer",
"type": "Clusterer"
},
{
"default": "cluster",
"description": "The name of the output band.",
"name": "outputName",
"optional": true,
"type": "String"
}
],
"description": "Applies a clusterer to an image. Returns a new image with a single band containing values from 0 to N, indicating the cluster each pixel is assigned to.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Reducer.mode": {
"args": [
{
"default": null,
"description": "The maximum number of buckets to use when building a histogram; will be rounded up to a power of 2.",
"name": "maxBuckets",
"optional": true,
"type": "Integer"
},
{
"default": null,
"description": "The minimum histogram bucket width, or null to allow any power of 2.",
"name": "minBucketWidth",
"optional": true,
"type": "Float"
},
{
"default": null,
"description": "The number of values to accumulate before building the initial histogram.",
"name": "maxRaw",
"optional": true,
"type": "Integer"
}
],
"description": "Create a reducer that will compute the mode of the inputs. For small numbers of inputs (up to maxRaw) the mode will be computed directly; for larger numbers of inputs the mode will be derived from a histogram.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Feature.union": {
"args": [
{
"description": "The feature containing the geometry used as the left operand of the operation. The properties of the result will be copied from this object.",
"name": "left",
"type": "Element"
},
{
"description": "The feature containing the geometry used as the right operand of the operation. The properties of this object are ignored.",
"name": "right",
"type": "Element"
},
{
"default": null,
"description": "The maximum amount of error tolerated when performing any necessary reprojection.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
},
{
"default": null,
"description": "The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.",
"name": "proj",
"optional": true,
"type": "Projection"
}
],
"description": "Returns a feature containing the union of the geometries of two features.",
"returns": "Feature",
"type": "Algorithm",
"hidden": false
},
"Array.sort": {
"args": [
{
"description": "Array image to sort.",
"name": "array",
"type": "Array"
},
{
"default": null,
"description": "Optional keys to sort by. If not provided, the values are used as the keys. The keys can only have multiple elements along one axis, which determines the direction to sort in.",
"name": "keys",
"optional": true,
"type": "Array"
}
],
"description": "Sorts elements of the array along one axis.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Image.or": {
"args": [
{
"description": "The image from which the left operand bands are taken.",
"name": "image1",
"type": "Image<unknown bands>"
},
{
"description": "The image from which the right operand bands are taken.",
"name": "image2",
"type": "Image<unknown bands>"
}
],
"description": "Returns 1 iff either input value is non-zero for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is boolean.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Array.not": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, returns 0 if the input is non-zero, and 1 otherwise.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Classifier.pegasosLinear": {
"args": [
{
"default": false,
"description": "Whether to use exponentiated update.",
"name": "useExponentiated",
"optional": true,
"type": "Boolean"
},
{
"default": "HingeSum",
"description": "The loss function to use. Valid values are: 'HingeSum', 'HingeMax', 'LogSum' and 'LogMax'",
"name": "lossFunction",
"optional": true,
"type": "String"
},
{
"default": 0.001,
"description": "The regularization parameter of SVM (lambda).",
"name": "lambda",
"optional": true,
"type": "Float"
},
{
"default": 0,
"description": "The number of iterations (T). When set to 0 (default), the number of training iterations is automatically set to 5 * training data size (~5 epochs).",
"name": "iterations",
"optional": true,
"type": "Integer"
},
{
"default": 1,
"description": "The subset size (k), i.e. the number of random samples to process on each iteration.",
"name": "subsetSize",
"optional": true,
"type": "Integer"
},
{
"default": 1.0,
"description": "The norm of w for regularization.",
"name": "regularizationNorm",
"optional": true,
"type": "Float"
},
{
"default": 0.01,
"description": "The gamma value for the loss function in multi-class classification.",
"name": "multiGamma",
"optional": true,
"type": "Float"
}
],
"description": "Creates an empty linear Pegasos classifier. See:\n \"Pegasos (Primal Estimated sub-GrAdient SOlver for SVM)\"\n S. Shalev-Shwartz, Y. Singer, N. Srebro, A. Cotter",
"returns": "Classifier",
"type": "Algorithm",
"hidden": false,
"deprecated": "Deprecated; will be removed eventually."
},
"Image.normalizedDifference": {
"args": [
{
"description": "The input image.",
"name": "input",
"type": "Image<unknown bands>"
},
{
"default": null,
"description": "A list of names specifying the bands to use. If not specified, the first and second bands are used.",
"name": "bandNames",
"optional": true,
"type": "List<String>"
}
],
"description": "Computes the normalized difference between two bands. If the bands to use are not specified, uses the first two bands. The normalized difference is computed as (first − second) / (first + second).",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"ImageCollection.toArray": {
"args": [
{
"description": "Image collection to convert to an array image. Bands must have scalar values, not array values.",
"name": "collection",
"type": "ImageCollection"
}
],
"description": "Converts an image collection into an image of 2D arrays. At each pixel, the images that have valid (unmasked) values in all bands are laid out along the first axis of the array in the order they appear in the image collection. The bands of each image are laid out along the second axis of the array, in the order the bands appear in that image. The array element type will be the union of the types of each band.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Array.matrixSolve": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Array"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Array"
}
],
"description": "Solves for x in the matrix equation A*x=B, finding a least-squares solution if A is overdetermined.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Date": {
"args": [
{
"description": "A number (interpreted as milliseconds since 1970-01-01T00:00:00Z), or string such as '1996-01-01' or '1996-001' or '1996-01-01T08:00'.",
"name": "value",
"type": "Object"
},
{
"default": null,
"description": "The time zone (e.g. 'America/Los_Angeles'); defaults to UTC.",
"name": "timeZone",
"optional": true,
"type": "String"
}
],
"description": "Creates a Date.",
"returns": "Date",
"type": "Algorithm",
"hidden": false
},
"Date.getRelative": {
"args": [
{
"name": "date",
"type": "Date"
},
{
"description": "One of 'month' 'week', 'day', 'hour', 'minute', or 'second'.",
"name": "unit",
"type": "String"
},
{
"description": "One of 'year', 'month' 'week', 'day', 'hour', or 'minute'.",
"name": "inUnit",
"type": "String"
},
{
"default": null,
"description": "The time zone (e.g. 'America/Los_Angeles'); defaults to UTC.",
"name": "timeZone",
"optional": true,
"type": "String"
}
],
"description": "Returns the specified (0-based) unit of this date relative to a larger unit, e.g. getRelative('day', 'year') returns a value between 0 and 365.",
"returns": "Long",
"type": "Algorithm",
"hidden": false
},
"Reducer.bitwiseAnd": {
"args": [],
"description": "Returns a Reducer that computes the bitwise-and summation of its inputs.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Image.polynomial": {
"args": [
{
"description": "The input image.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"description": "The polynomial coefficients in increasing order of degree starting with the constant term.",
"name": "coefficients",
"type": "List<Float>"
}
],
"description": "Compute a polynomial at each pixel using the given coefficients.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Array.transpose": {
"args": [
{
"description": "Array to transpose.",
"name": "array",
"type": "Array"
},
{
"default": 0,
"description": "First axis to swap.",
"name": "axis1",
"optional": true,
"type": "Integer"
},
{
"default": 1,
"description": "Second axis to swap.",
"name": "axis2",
"optional": true,
"type": "Integer"
}
],
"description": "Transposes two dimensions of an array.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Projection.wkt": {
"args": [
{
"name": "projection",
"type": "Projection"
}
],
"description": "Returns a WKT representation of the base coordinate system of this Projection.",
"returns": "String",
"type": "Algorithm",
"hidden": false
},
"Number.add": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Number"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Number"
}
],
"description": "Adds the first value to the second.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"ImageCollection.toArrayPerBand": {
"args": [
{
"description": "Images to concatenate. A separate concatenation is done per band, so all the images must have the same dimensionality and shape per band, except length along the concatenation axis.",
"name": "collection",
"type": "ImageCollection"
},
{
"default": 0,
"description": "Axis to concatenate along; must be at least 0 and at most the minimum dimension of any band in the collection.",
"name": "axis",
"optional": true,
"type": "Integer"
}
],
"description": "Concatenates multiple images into a single array image. The result will be masked if any input is masked.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Kernel.fixed": {
"args": [
{
"default": -1,
"description": "The width of the kernel in pixels.",
"name": "width",
"optional": true,
"type": "Integer"
},
{
"default": -1,
"description": "The height of the kernel in pixels.",
"name": "height",
"optional": true,
"type": "Integer"
},
{
"description": "The pixel values of the kernel.",
"name": "weights",
"type": "List<List<Object>>"
},
{
"default": -1,
"description": "The location of the focus, as an offset from the left.",
"name": "x",
"optional": true,
"type": "Integer"
},
{
"default": -1,
"description": "The location of the focus, as an offset from the top.",
"name": "y",
"optional": true,
"type": "Integer"
},
{
"default": false,
"description": "Normalize the kernel values to sum to 1.",
"name": "normalize",
"optional": true,
"type": "Boolean"
}
],
"description": "Creates a Kernel.",
"returns": "Kernel",
"type": "Algorithm",
"hidden": false
},
"Image.gamma": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Computes the gamma function of the input.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Array.toInt": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, casts the input value to a signed 32-bit integer.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"BetterDateRangeCollection": {
"args": [
{
"description": "The start of the date range (inclusive).",
"name": "start",
"type": "Date"
},
{
"description": "The end of the date range (exclusive).",
"name": "end",
"type": "Date"
},
{
"default": 1,
"description": "The time interval between successive date ranges, in units specified by 'units'. If negative, 'start' must be after 'end'.",
"name": "delta",
"optional": true,
"type": "Integer"
},
{
"default": "day",
"description": "The units in which 'delta' is specified:One of 'year', 'month' 'week', 'day', 'hour', 'minute', or 'second'.",
"name": "unit",
"optional": true,
"type": "String"
},
{
"default": false,
"description": "If true, the start time of the intervals will align to the start of each year (but the end times will still be delta * units).",
"name": "resetAtYearBoundaries",
"optional": true,
"type": "Boolean"
},
{
"default": null,
"description": "A pattern to use to format the system:index, as described at http://joda-time.sourceforge.net/apidocs/org/joda/time/format/DateTimeFormat.html.If omitted will use a portion of the format 'YYYYMMddHHmmss', up to the specified 'unit' (ie: for unit='year' format will default to 'YYYY', and for unit='day', format will default to 'YYYYMMdd'. When 'unit' is 'week' format defaultsto 'YYYYMMdd'.",
"name": "format",
"optional": true,
"type": "String"
}
],
"description": "Returns a collection of objects with 'system:index' and 'date_range' properties in a defined sequence at regular intervals, suitable for mapping over.",
"returns": "FeatureCollection",
"type": "Algorithm",
"hidden": true
},
"Reducer.linearFit": {
"args": [],
"description": "Returns a Reducer that computes the slope and offset for a (weighted) linear regression of 2 inputs. The inputs are expected to be x data followed by y data..",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Array.first": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Array"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Array"
}
],
"description": "On an element-wise basis, selects the value of the first value.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Clusterer.wekaCascadeKMeans": {
"args": [
{
"default": 2,
"description": "Min number of clusters.",
"name": "minClusters",
"optional": true,
"type": "Integer"
},
{
"default": 10,
"description": "Max number of clusters.",
"name": "maxClusters",
"optional": true,
"type": "Integer"
},
{
"default": 10,
"description": "Number of restarts.",
"name": "restarts",
"optional": true,
"type": "Integer"
},
{
"default": false,
"description": "Manually select the number of clusters.",
"name": "manual",
"optional": true,
"type": "Boolean"
},
{
"default": false,
"description": "Set whether to initialize using the probabilistic farthest first like method of the k-means++ algorithm (rather than the standard random selection of initial cluster centers).",
"name": "init",
"optional": true,
"type": "Boolean"
},
{
"default": "Euclidean",
"description": "Distance function to use. Options are: Euclidean & Manhattan",
"name": "distanceFunction",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "Maximum number of iterations for k-means.",
"name": "maxIterations",
"optional": true,
"type": "Integer"
}
],
"description": "Cascade simple k-means, selects the best k according to calinski-harabasz criterion. For more information see:\nCalinski, T. and J. Harabasz. 1974. A dendrite method for cluster analysis. Commun. Stat. 3: 1-27.",
"returns": "Clusterer",
"type": "Algorithm",
"hidden": false
},
"FeatureCollection.plx": {
"args": [
{
"description": "The PLX SQL query to execute.",
"name": "sql",
"type": "String"
},
{
"default": "DREMEL",
"description": "The name of the PLX query engine to use.",
"name": "queryEngine",
"optional": true,
"type": "String"
},
{
"default": 0,
"description": "Cached query results may be used if newer than the given time in milliseconds since the epoch (1970-01-01). If 0, the result cache may be used at the service's discretion. If -1, the result cache may not be used.",
"name": "minCacheTimestampMs",
"optional": true,
"type": "Long"
}
],
"description": "Returns a FeatureCollection containing the results of a Plx SQL query.",
"returns": "FeatureCollection",
"type": "Algorithm",
"hidden": false
},
"Array.tan": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, computes the tangent of the input in radians.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Classifier.naiveBayes": {
"args": [
{
"default": 0.0000010,
"description": "A smoothing lambda. Used to avoid assigning zero probability to classes not seen during training, instead using lambda / (lambda * nFeatures).",
"name": "lambda",
"optional": true,
"type": "Float"
}
],
"description": "Creates an empty Fast Naive Bayes classifier.",
"returns": "Classifier",
"type": "Algorithm",
"hidden": false
},
"Collection.size": {
"args": [
{
"description": "The collection to count.",
"name": "collection",
"type": "FeatureCollection"
}
],
"description": "Returns the number of elements in the collection.",
"returns": "Integer",
"type": "Algorithm",
"hidden": false
},
"Number.toByte": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Casts the input value to an unsigned 8-bit integer.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Terrain.hillshade": {
"args": [
{
"description": "An elevation image, in meters.",
"name": "input",
"type": "Image<unknown bands>"
},
{
"default": 270.0,
"description": "The illumination azimuth in degrees from north.",
"name": "azimuth",
"optional": true,
"type": "Float"
},
{
"default": 45.0,
"description": "The illumination elevation in degrees.",
"name": "elevation",
"optional": true,
"type": "Float"
}
],
"description": "Computes a simple hillshade from a DEM.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"String.rindex": {
"args": [
{
"description": "The string to search.",
"name": "target",
"type": "String"
},
{
"description": "The string to find.",
"name": "pattern",
"type": "String"
}
],
"description": "Searches a string for the last occurrence of a substring. Returns the index of the first match, or -1.",
"returns": "Integer",
"type": "Algorithm",
"hidden": false
},
"PixelType.int32": {
"args": [],
"description": "Returns the 32-bit signed integer pixel type.",
"returns": "PixelType",
"type": "Algorithm",
"hidden": false
},
"Image.pow": {
"args": [
{
"description": "The image from which the left operand bands are taken.",
"name": "image1",
"type": "Image<unknown bands>"
},
{
"description": "The image from which the right operand bands are taken.",
"name": "image2",
"type": "Image<unknown bands>"
}
],
"description": "Raises the first value to the power of the second for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is float.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Terrain.aspect": {
"args": [
{
"description": "An elevation image, in meters.",
"name": "input",
"type": "Image<unknown bands>"
}
],
"description": "Calculates aspect in degrees from a terrain DEM.\n\nThe local gradient is computed using the 4-connected neighbors of each pixel, so missing values will occur around the edges of an image.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"AggregateFeatureCollection.count": {
"args": [
{
"description": "The collection to aggregate over.",
"name": "collection",
"type": "FeatureCollection"
},
{
"description": "The property to use from each element of the collection.",
"name": "property",
"type": "String"
}
],
"description": "Aggregates over a given property of the objects in a collection, calculating the number of non-null values of the property.",
"returns": "Object",
"type": "Algorithm",
"hidden": false
},
"Number.gamma": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Computes the gamma function of the input.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Number.sqrt": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Computes the square root of the input.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Filter.equals": {
"args": [
{
"default": null,
"description": "A selector for the left operand. Should not be specified if leftValue is specified.",
"name": "leftField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the right operand. Should not be specified if rightField is specified.",
"name": "rightValue",
"optional": true,
"type": "Object"
},
{
"default": null,
"description": "A selector for the right operand. Should not be specified if rightValue is specified.",
"name": "rightField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the left operand. Should not be specified if leftField is specified.",
"name": "leftValue",
"optional": true,
"type": "Object"
}
],
"description": "Creates a unary or binary filter that passes if the two operands are equals.",
"returns": "Filter",
"type": "Algorithm",
"hidden": false
},
"CcdcCoefficients": {
"args": [
{
"description": "Collection from which to extract trends. Must be sorted by time in ascending order.",
"name": "timeSeries",
"type": "ImageCollection"
},
{
"description": "Sum of the root mean square error (RMSE) from all band fits at which we consider the set of fits to have become disturbed.",
"name": "rmse",
"type": "Float"
},
{
"default": 3,
"description": "Consecutive disturbances to force reclassifying the terrain.",
"name": "disturbanceWindow",
"optional": true,
"type": "Integer"
}
],
"description": "Provides Continuous Change Detection and Classification (CCDC) coefficients by fitting a simple piecewise linear model to a given image collection.\nThe linear model used for each fit is 'Y = A + B*t + C*sin(season(t)) + D*cos(season(t))', where 't' is the start time of the image in years, and season(t) returns the phase of the year from 0 to 2*PI.\nThe result is a 3D array per pixel, with axis 0 having as many elements as there are pieces in the piecewise fit, axis 1 having as many elements as there are bands, and axis 2 having length 7, for each parameter of the fit:\n1. Start time in years (e.g. 2005.678.)\n2. End time in years (e.g. 2006.0123.)\n3. Total root mean square error (RMSE) summed from each separately fit band's RMSE.\n4. A coefficient.\n5. B coefficient.\n6. C coefficient.\n7. D coefficient.\nThe function is fit for each band separately, and the RMSE is summed from all the fits. If the sum exceeds the given RMSE, that sample is considered disturbed. If there are 'disturbanceWindow' disturbed samples in a row, the last good fit that did not involve disturbed samples is added to the output array, and a new fit is started after the last disturbed sample. The samples in the disturbed area are thus not part of any of the fit results.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": true
},
"Window.mean": {
"args": [
{
"description": "The image to which to apply the operations.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"default": 1.5,
"description": "The radius of the kernel to use.",
"name": "radius",
"optional": true,
"type": "Float"
},
{
"default": "circle",
"description": "The type of kernel to use. Options include: 'circle', 'square', 'cross', 'plus', octagon' and 'diamond'.",
"name": "kernelType",
"optional": true,
"type": "String"
},
{
"default": "pixels",
"description": "If a kernel is not specified, this determines whether the kernel is in meters or pixels.",
"name": "units",
"optional": true,
"type": "String"
},
{
"default": 1,
"description": "The number of times to apply the given kernel.",
"name": "iterations",
"optional": true,
"type": "Integer"
},
{
"default": null,
"description": "A custom kernel. If used, kernelType and radius are ignored.",
"name": "kernel",
"optional": true,
"type": "Kernel"
}
],
"description": "Applies a morphological mean filter to each band of an image using a named or custom kernel.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Geometry.transform": {
"args": [
{
"description": "The geometry to reproject.",
"name": "geometry",
"type": "Geometry"
},
{
"default": {
"crs": "EPSG:4326",
"transform": [
1.0,
0.0,
0.0,
0.0,
1.0,
0.0
],
"type": "Projection"
},
"description": "The target projection. Defaults to WGS84. If this has a geographic CRS, the edges of the geometry will be interpreted as geodesics. Otherwise they will be interpreted as straight lines in the projection.",
"name": "proj",
"optional": true,
"type": "Projection"
},
{
"default": null,
"description": "The maximum projection error.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
}
],
"description": "Transforms the geometry to a specific projection.",
"returns": "Geometry",
"type": "Algorithm",
"hidden": false
},
"TemporalSegmentation.VCT": {
"args": [
{
"description": "Collection from which to extract VCT disturbances, containing the bands: B3, B4, B5, B7, thermal, NDVI, DNBR and COMP. This collection is expected to contain 1 image for each year, sorted by time.",
"name": "timeSeries",
"type": "ImageCollection"
},
{
"description": "Collection from which to extract VCT masks. This collection is expected to contain 1 image for each image in the timeSeries, sorted by time.",
"name": "landCover",
"type": "ImageCollection"
},
{
"default": 4.0,
"description": "Maximum Z-score composite value for detecting forest.",
"name": "maxUd",
"optional": true,
"type": "Float"
},
{
"default": 0.45,
"description": "Minimum NDVI value for forest.",
"name": "minNdvi",
"optional": true,
"type": "Float"
},
{
"default": 3.0,
"description": "Maximum threshold for forest.",
"name": "forThrMax",
"optional": true,
"type": "Float"
},
{
"default": 30,
"description": "Maximum number of years.",
"name": "nYears",
"optional": true,
"type": "Integer"
}
],
"description": "Vegetation Change Tracker, an automated approach for reconstructing recent forest disturbance history using dense Landsat time series stacks.\nThe output is a 2D array per pixel containing 6 rows x N years. The output rows contain: input years, VCT landcover mask, magnitude in term of the UD composite, magnitude of distubance in B4, magnitude of distubance in NDVI, magnitude of distubance in dNBR.\nSee: Huang, C., Goward, S.N., Masek, J.G., Thomas, N., Zhu, Z. and Vogelmann, J.E., 2010. An automated approach for reconstructing recent forest disturbance history using dense Landsat time series stacks. Remote Sensing of Environment, 114(1), pp.183-198.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"ImageCollection.cast": {
"args": [
{
"description": "The image collection to cast.",
"name": "collection",
"type": "ImageCollection"
},
{
"description": "A dictionary from band name to band types. Types can be PixelTypes or strings. The valid strings are: 'int8', 'int16', 'int32', 'int64', 'uint8', 'uint16', 'uint32', 'byte', 'short', 'int', 'long', 'float' and 'double'. Must include all bands already in any image in the collection. If this includes bands that are not already in an input image, they will be added to the image as transparent bands.",
"name": "bandTypes",
"type": "Dictionary<Object>"
},
{
"description": "A list specifying the order of the bands in the result.Must match the keys of bandTypes.",
"name": "bandOrder",
"type": "List<String>"
}
],
"description": "Casts some or all bands of each image in an ImageCollection to the specified types.",
"returns": "ImageCollection",
"type": "Algorithm",
"hidden": false
},
"Profile.getProfiles": {
"args": [
{
"description": "One or more profile IDs returned by previous computations.",
"name": "ids",
"type": "List<String>"
},
{
"default": "text",
"description": "Format to return data in, either 'text' or 'json'.",
"name": "format",
"optional": true,
"type": "String"
}
],
"description": "Retrieve computation profile data given profile IDs.",
"returns": "Object",
"type": "Algorithm",
"hidden": true
},
"TemporalSegmentation.Ewmacd": {
"args": [
{
"description": "Collection from which to extract EWMA. This collection is expected to contain 1 image for each year and be sorted temporally.",
"name": "timeSeries",
"type": "ImageCollection"
},
{
"description": "Threshold for vegetation. Values below this are considered non-vegetation.",
"name": "vegetationThreshold",
"type": "Float"
},
{
"description": "Start year of training period, inclusive.",
"name": "trainingStartYear",
"type": "Integer"
},
{
"description": "End year of training period, exclusive.",
"name": "trainingEndYear",
"type": "Integer"
},
{
"default": 2,
"description": "Number of harmonic function pairs (sine and cosine) used.",
"name": "harmonicCount",
"optional": true,
"type": "Integer"
},
{
"default": 1.5,
"description": "Threshold for initial training xBar limit.",
"name": "xBarLimit1",
"optional": true,
"type": "Float"
},
{
"default": 20,
"description": "Threshold for running xBar limit.",
"name": "xBarLimit2",
"optional": true,
"type": "Integer"
},
{
"default": 0.3,
"description": "The 'lambda' tuning parameter weighting new years vs the running average.",
"name": "lambda",
"optional": true,
"type": "Float"
},
{
"default": 3.0,
"description": "EWMA control bounds, in units of standard deviations.",
"name": "lambdasigs",
"optional": true,
"type": "Float"
},
{
"default": true,
"description": "Should rounding be performed for EWMA",
"name": "rounding",
"optional": true,
"type": "Boolean"
},
{
"default": 3,
"description": "Minimum number of observations needed to consider a change.",
"name": "persistence",
"optional": true,
"type": "Integer"
}
],
"description": "Exponentially Weighted Moving Average Change Detection. This algorithm computes a harmonic model for the 'training' portion of the input data and subtracts that from the original results. The residuals are then subjected to Shewhart X-bar charts and an exponentially weighted moving average. Disturbed pixels are indicated when the charts signal a deviation from the given control limits.\n The output is a 5 band image containining the bands:\n ewma: a 1D array of the EWMA score for each input image. Negative values represent disturbance and positive values represent recovery.\n harmonicCoefficients: A 1-D array of the computed harmonic coefficient pairs. The coefficients are ordered as [constant, sin0, cos0, sin1, cos1...]\n rmse: the RMSE from the harmonic regression.\n rSquared: r-squared value from the harmonic regression.\n residuals: 1D array of residuals from the harmonic regression.\nSee: Brooks, E.B., Wynne, R.H., Thomas, V.A., Blinn, C.E. and Coulston, J.W., 2014. On-the-fly massively multitemporal change detection using statistical quality control charts and Landsat data. IEEE Transactions on Geoscience and Remote Sensing, 52(6), pp.3316-3332.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Array.rightShift": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Array"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Array"
}
],
"description": "On an element-wise basis, calculates the signed right shift of v1 by v2 bits.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Image.metadata": {
"args": [
{
"description": "The image from which to get the metadata",
"name": "image",
"type": "Image<unknown bands>"
},
{
"description": "The property from which to take the value.",
"name": "property",
"type": "String"
},
{
"default": null,
"description": "The name for the output band. If unspecified, it will be the same as the property name.",
"name": "name",
"optional": true,
"type": "String"
}
],
"description": "Generates a constant image of type double from a metadata property.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Collection.merge": {
"args": [
{
"description": "The first collection to merge.",
"name": "collection1",
"type": "FeatureCollection"
},
{
"description": "The second collection to merge.",
"name": "collection2",
"type": "FeatureCollection"
}
],
"description": "Merges two collections into one. The result has all the elements that were in either collection.",
"returns": "FeatureCollection",
"type": "Algorithm",
"hidden": false
},
"Image.bitwise_xor": {
"args": [
{
"description": "The image from which the left operand bands are taken.",
"name": "image1",
"type": "Image<unknown bands>"
},
{
"description": "The image from which the right operand bands are taken.",
"name": "image2",
"type": "Image<unknown bands>"
}
],
"description": "Calculates the bitwise XOR of the input values for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is the union of the input types.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"FeatureCollection.makeArray": {
"args": [
{
"description": "The input collection from which properties will be selected.",
"name": "collection",
"type": "FeatureCollection"
},
{
"description": "The properties to select.",
"name": "properties",
"type": "List<String>"
},
{
"default": "array",
"description": "The name of the new array property.",
"name": "name",
"optional": true,
"type": "String"
}
],
"description": "Add a 1-D Array to each feature in a collection by combining a list of properties for each feature into a 1-D Array. All of the properties must be numeric values. If a feature doesn't contain all of the named properties, or any of them aren't numeric, the feature will be dropped from the resulting collection.",
"returns": "FeatureCollection",
"type": "Algorithm",
"hidden": false
},
"ReduceToVectors.ReduceSegmentsEnumerator": {
"args": [
{
"name": "image",
"type": "Image<unknown bands>"
},
{
"name": "proj",
"type": "Projection"
},
{
"name": "geom",
"type": "Geometry"
},
{
"name": "reducer",
"type": "Reducer"
},
{
"name": "geometryType",
"type": "String"
},
{
"name": "eightConnected",
"type": "Boolean"
},
{
"name": "labelProperty",
"type": "String"
},
{
"name": "tileScale",
"type": "Float"
},
{
"name": "geometryInNativeProjection",
"type": "Boolean"
},
{
"name": "streaming",
"type": "Boolean"
}
],
"description": "Creates a Object.",
"returns": "Object",
"type": "Algorithm",
"hidden": true
},
"Image.uint8": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Casts the input value to an unsigned 8-bit integer.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Array.get": {
"args": [
{
"description": "The array to extract from.",
"name": "array",
"type": "Array"
},
{
"description": "The coordinates of the element to get.",
"name": "position",
"type": "List<Integer>"
}
],
"description": "Extracts the value at the given position from the input array.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Dictionary.select": {
"args": [
{
"name": "dictionary",
"type": "Dictionary<Object>"
},
{
"description": "A list of keys or regular expressions to select.",
"name": "selectors",
"type": "List<String>"
},
{
"default": false,
"description": "Ignore selectors that don't match at least 1 key.",
"name": "ignoreMissing",
"optional": true,
"type": "Boolean"
}
],
"description": "Returns a dictionary with only the specified keys.",
"returns": "Dictionary<Object>",
"type": "Algorithm",
"hidden": false
},
"Number.gt": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Number"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Number"
}
],
"description": "Returns 1 iff the first value is greater than the second.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Number.lanczos": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Computes the Lanczos approximation of the input.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Geometry.edgesAreGeodesics": {
"args": [
{
"name": "geometry",
"type": "Geometry"
}
],
"description": "Returns true if the geometry edges, if any, are geodesics along a spherical model of the earth; if false, any edges are straight lines in the projection.",
"returns": "Boolean",
"type": "Algorithm",
"hidden": false
},
"Image.where": {
"args": [
{
"description": "The input image.",
"name": "input",
"type": "Image<unknown bands>"
},
{
"description": "The test image. The pixels of this image determines which of the input pixels is returned. If this is a single band, it is used for all bands in the input image. This may not be an array image.",
"name": "test",
"type": "Image<unknown bands>"
},
{
"description": "The output value to use where test is not zero. If this is a single band, it is used for all bands in the input image.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Performs conditional replacement of values.\n\nFor each pixel in each band of 'input', if the corresponding pixel in 'test' is nonzero, output the corresponding pixel in value, otherwise output the input pixel.\n\nIf at a given pixel, either test or value is masked, the input value is used. If the input is masked, nothing is done.\n\nThe output bands have the same names as the input bands. The output type of each band is the larger of the input and value types. The output image retains the metadata and footprint of the input image.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"String.cat": {
"args": [
{
"description": "The first string.",
"name": "string1",
"type": "String"
},
{
"description": "The second string.",
"name": "string2",
"type": "String"
}
],
"description": "Concatenates two strings.",
"returns": "String",
"type": "Algorithm",
"hidden": false
},
"Projection.translate": {
"args": [
{
"name": "projection",
"type": "Projection"
},
{
"name": "x",
"type": "Float"
},
{
"name": "y",
"type": "Float"
}
],
"description": "Returns the projection translated by the given amount in each axis.",
"returns": "Projection",
"type": "Algorithm",
"hidden": false
},
"ReduceRegion.AggregationContainer": {
"args": [
{
"name": "image",
"type": "Image<unknown bands>"
},
{
"name": "proj",
"type": "Projection"
},
{
"name": "geom",
"type": "Geometry"
},
{
"name": "reducer",
"type": "Reducer"
},
{
"name": "tileScale",
"type": "Float"
}
],
"description": "INTERNAL",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": true
},
"Collection.flatten": {
"args": [
{
"description": "The input collection of collections.",
"name": "collection",
"type": "FeatureCollection"
}
],
"description": "Flattens collections of collections.",
"returns": "FeatureCollection",
"type": "Algorithm",
"hidden": false
},
"Filter.neq": {
"args": [
{
"default": null,
"description": "A selector for the left operand. Should not be specified if leftValue is specified.",
"name": "leftField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the right operand. Should not be specified if rightField is specified.",
"name": "rightValue",
"optional": true,
"type": "Object"
},
{
"default": null,
"description": "A selector for the right operand. Should not be specified if rightValue is specified.",
"name": "rightField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the left operand. Should not be specified if leftField is specified.",
"name": "leftValue",
"optional": true,
"type": "Object"
}
],
"description": "Creates a unary or binary filter that passes unless the two operands are equals.",
"returns": "Filter",
"type": "Algorithm",
"hidden": false
},
"Terrain.hillShadow": {
"args": [
{
"description": "The image to which to apply the shadow algorithm, in whicheach pixel should represent an elevation in meters.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"description": "Azimuth in degrees.",
"name": "azimuth",
"type": "Float"
},
{
"description": "Zenith in degrees.",
"name": "zenith",
"type": "Float"
},
{
"default": 0,
"description": "Neighborhood size.",
"name": "neighborhoodSize",
"optional": true,
"type": "Integer"
},
{
"default": false,
"description": "Use hysteresis. Less physically accurate, but may generate better images.",
"name": "hysteresis",
"optional": true,
"type": "Boolean"
}
],
"description": "Creates a shadow band, with output 1 where pixels are illumunated and 0 where they are shadowed. Takes as input an elevation band, azimuth and zenith of the light source in degrees, a neighborhood size, and whether or not to apply hysteresis when a shadow appears. Currently, this algorithm only works for Mercator projections, in which light rays are parallel.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"PixelType.int16": {
"args": [],
"description": "Returns the 16-bit signed integer pixel type.",
"returns": "PixelType",
"type": "Algorithm",
"hidden": false
},
"Array.sqrt": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, computes the square root of the input.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"List.contains": {
"args": [
{
"name": "list",
"type": "List<Object>"
},
{
"name": "element",
"type": "Object"
}
],
"description": "Returns true if list contains element.",
"returns": "Boolean",
"type": "Algorithm",
"hidden": false
},
"ConfusionMatrix.consumersAccuracy": {
"args": [
{
"name": "confusionMatrix",
"type": "ConfusionMatrix"
}
],
"description": "Computes the consumer's accuracy (reliability) of a confusion matrix defined as (correct / total) for each row.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Filter.stringEndsWith": {
"args": [
{
"default": null,
"description": "A selector for the left operand. Should not be specified if leftValue is specified.",
"name": "leftField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the right operand. Should not be specified if rightField is specified.",
"name": "rightValue",
"optional": true,
"type": "Object"
},
{
"default": null,
"description": "A selector for the right operand. Should not be specified if rightValue is specified.",
"name": "rightField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the left operand. Should not be specified if leftField is specified.",
"name": "leftValue",
"optional": true,
"type": "Object"
}
],
"description": "Creates a unary or binary filter that passes if the left operand, a string, ends with the right operand, also a string.",
"returns": "Filter",
"type": "Algorithm",
"hidden": false
},
"List.insert": {
"args": [
{
"name": "list",
"type": "List<Object>"
},
{
"name": "index",
"type": "Integer"
},
{
"name": "element",
"type": "Object"
}
],
"description": "Inserts element at the specified position in list. A negative index counts backwards from the end of the list.",
"returns": "List<Object>",
"type": "Algorithm",
"hidden": false
},
"Image.resample": {
"args": [
{
"description": "The Image to resample.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"default": "bilinear",
"description": "The interpolation mode to use. One of 'bilinear' or 'bicubic'.)",
"name": "mode",
"optional": true,
"type": "String"
}
],
"description": "An algorithm that returns an image identical to its argument, but which uses bilinear or bicubic interpolation (rather than the default nearest-neighbor) to compute pixels in projections other than its native projection or other levels of the same image pyramid.\nThis relies on the input image's default projection being meaningful, and so cannot be used on composites, for example. (Instead, you should resample the images that are used to create the composite.)",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"String.split": {
"args": [
{
"description": "The string to split.",
"name": "string",
"type": "String"
},
{
"description": "A regular expression to split on. If regex is the empty string, then the input string is split into individual characters.",
"name": "regex",
"type": "String"
},
{
"default": "",
"description": "A string specifying the regular expression flag: 'i' (ignore case)",
"name": "flags",
"optional": true,
"type": "String"
}
],
"description": "Splits a string on a regular expression, Returning a list of strings.",
"returns": "List<String>",
"type": "Algorithm",
"hidden": false
},
"ReduceToVectors.AggregationContainer": {
"args": [
{
"name": "enumerator",
"type": "Object"
},
{
"default": null,
"name": "filter",
"optional": true,
"type": "Filter"
}
],
"description": "INTERNAL",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": true
},
"Image.arrayDimensions": {
"args": [
{
"description": "Input image.",
"name": "input",
"type": "Image<unknown bands>"
}
],
"description": "Returns the number of dimensions in each array band, and 0 for scalar image bands.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Array.matrixDiagonal": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "Computes the diagonal of the matrix in a single column.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Array.accum": {
"args": [
{
"description": "Array to accumulate.",
"name": "array",
"type": "Array"
},
{
"description": "Axis along which to perform the accumulation.",
"name": "axis",
"type": "Integer"
},
{
"default": null,
"description": "Reducer to accumulate values. Default is SUM, to produce the cumulative sum of each vector along the given axis.",
"name": "reducer",
"optional": true,
"type": "Reducer"
}
],
"description": "Accumulates elements of an array along the given axis, by setting each element of the result to the reduction of elements along that axis up to and including the current position. May be used to make a cumulative sum, a monotonically increasing sequence, etc.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Array.subtract": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Array"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Array"
}
],
"description": "On an element-wise basis, subtracts the second value from the first.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Number.int": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Casts the input value to a signed 32-bit integer.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"List.add": {
"args": [
{
"name": "list",
"type": "List<Object>"
},
{
"name": "element",
"type": "Object"
}
],
"description": "Appends the element to the end of list.",
"returns": "List<Object>",
"type": "Algorithm",
"hidden": false
},
"Clusterer.wekaCobweb": {
"args": [
{
"default": 1.0,
"description": "Acuity (minimum standard deviation).",
"name": "acuity",
"optional": true,
"type": "Float"
},
{
"default": 0.002,
"description": "Cutoff (minimum category utility).",
"name": "cutoff",
"optional": true,
"type": "Float"
},
{
"default": 42,
"description": "Random number seed.",
"name": "seed",
"optional": true,
"type": "Integer"
}
],
"description": "Implementation of the Cobweb clustering algorithm. For more information see:\nD. Fisher (1987). Knowledge acquisition via incremental conceptual clustering. Machine Learning. 2(2):139-172. and J. H. Gennari, P. Langley, D. Fisher (1990). Models of incremental concept formation. Artificial Intelligence. 40:11-61.",
"returns": "Clusterer",
"type": "Algorithm",
"hidden": false
},
"Terrain.fillMinima": {
"args": [
{
"description": "The image to fill.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"default": null,
"description": "The border value.",
"name": "borderValue",
"optional": true,
"type": "Long"
},
{
"default": 50,
"description": "The size of the neighborhood to compute over.",
"name": "neighborhood",
"optional": true,
"type": "Integer"
}
],
"description": "Fills local minima. Only works on INT types.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Collection.map": {
"args": [
{
"description": "The collection of the elements to which the algorithm is applied.",
"name": "collection",
"type": "FeatureCollection"
},
{
"description": "The algorithm being applied to each element.",
"name": "baseAlgorithm",
"type": "Algorithm"
},
{
"default": false,
"description": "If true, the mapped algorithm is allowed to return nulls, and the elements for which it returns nulls will be dropped.",
"name": "dropNulls",
"optional": true,
"type": "Boolean"
}
],
"description": "Maps an algorithm over a collection.",
"returns": "FeatureCollection",
"type": "Algorithm",
"hidden": false
},
"Image.trainClassifier": {
"args": [
{
"description": "The input data.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"default": null,
"description": "The names of the bands from the image argument to train on.",
"name": "bands",
"optional": true,
"type": "List<String>"
},
{
"default": null,
"description": "The pre-classified image for supervised training. If specified, training_band must be specified. Either this or training_features must be specified.",
"name": "training_image",
"optional": true,
"type": "Image<unknown bands>"
},
{
"default": null,
"description": "The name of the band in training_image to use. Ignored if training_image is not used.",
"name": "training_band",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The region of the training band to use for training. If not specified, the whole band is used. Ignored if training_image is not used.",
"name": "training_region",
"optional": true,
"type": "Geometry"
},
{
"default": null,
"description": "A collection of classified features to use for supervised classification. Either this or training_image must be specified.",
"name": "training_features",
"optional": true,
"type": "FeatureCollection"
},
{
"default": "classification",
"description": "The name of the property in each element of training_features containing its class number.",
"name": "training_property",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The ID of the coordinate reference system into which the training data will be rasterized. If not specified, the projection of the training data is used. If not applicable, the projection of the input data. If this is specified, crs_transform must be specified too.",
"name": "crs",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The 6-element CRS transform matrix in the order: xScale, yShearing, xShearing, yScale, xTranslation and yTranslation. If crs is specified, this must be specified.",
"name": "crs_transform",
"optional": true,
"type": "List<Float>"
},
{
"default": null,
"description": "The maximum class number. Deprecated and unused.",
"name": "max_classification",
"optional": true,
"type": "Integer"
},
{
"default": 1.0,
"description": "Random sample the training raster by this factor. Ignored if a classifier argument is provided.",
"name": "subsampling",
"optional": true,
"type": "Float"
},
{
"default": 0,
"description": "The random seed used for subsampling.",
"name": "seed",
"optional": true,
"type": "Long"
},
{
"default": "FastNaiveBayes",
"description": "The name of the Abe classifier to use. Currently supported values are FastNaiveBayes, GmoMaxEnt, Winnow, MultiClassPerceptron, Pegasos, Cart, RifleSerialClassifier, IKPamir, VotingSvm, MarginSvm, ContinuousNaiveBayes. Ignored if a classifier argument is provided.",
"name": "classifier_name",
"optional": true,
"type": "String"
},
{
"default": "",
"description": "The Abe classifier parameters. Ignored if a classifier argument is provided.",
"name": "classifier_parameters",
"optional": true,
"type": "String"
},
{
"default": "classification",
"description": "The classifier mode. Accepted values are 'classification', 'regression' and 'probability'. Ignored if a classifier argument is provided.",
"name": "classifier_mode",
"optional": true,
"type": "String"
},
{
"default": 1,
"description": "The number of subsamples to use for cross-validation or bagging. If 1, no cross-validation or bagging is performed. Ignored if a classifier argument is provided.",
"name": "num_subsamples",
"optional": true,
"type": "Integer"
},
{
"default": null,
"description": "The bootstrap subsampling factor. Ignored if a classifier argument is provided.",
"name": "bootstrap_subsampling",
"optional": true,
"type": "Float"
},
{
"default": null,
"description": "The bootstrap aggregator. Ignored if a classifier argument is provided.",
"name": "bootstrap_aggregator",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "A pre-built classifier to use.",
"name": "classifier",
"optional": true,
"type": "OldClassifier"
}
],
"description": "Trains an image classifier.\n\nThe input data is specified with the image and bands arguments.\n\nTo use a raster as training data, specify training_image, training_band, and training_region. The region is optional if the band is bounded. To use vector training data, specify training_features and training_property. The property defaults to 'classification'. You must specify either raster or vector training data, but not both.\n\nThe training data will be rasterized in a projection configured by the crs and crs_transform arguments. By default the projection of your training data will be used (if applicable); otherwise the projection of your input data.\n\nTo use the classifier library, specify the classifier_name, classifier_parameters, and classifier_mode arguments.\n\nTo enable cross-validation or bagging, set the num_subsamples argument. When bagging, set the bootstrap_subsampling factor and the bootstrap_aggregator as well.\n\nTo use a custom classifier, specify it using the classifier parameter.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": true,
"deprecated": "Use Classifier.train()."
},
"Number.asin": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Computes the arc sine in radians of the input.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Image.select": {
"args": [
{
"description": "The image to select bands from.",
"name": "input",
"type": "Image<unknown bands>"
},
{
"description": "A list of names, regexes or numeric indicies specifying the bands to select.",
"name": "bandSelectors",
"type": "List<Object>"
},
{
"default": null,
"description": "Optional new names for the output bands. Must match the number of bands selected.",
"name": "newNames",
"optional": true,
"type": "List<String>"
}
],
"description": "Selects bands from an image by name, RE2-compatible regex or index and optionally renames them.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Number.eq": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Number"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Number"
}
],
"description": "Returns 1 iff the first value is equal to the second.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Collection.loadTable": {
"args": [
{
"description": "The ID of the table to load. Either an asset ID or a Fusion Table DocID prefixed with 'ft:'.",
"name": "tableId",
"type": "Object"
},
{
"default": null,
"description": "The name of the column to use as the main feature geometry. Not used if tableId is an asset ID.",
"name": "geometryColumn",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The version of the asset. -1 signifies the latest version. Ignored unless tableId is an asset ID.",
"name": "version",
"optional": true,
"type": "Long"
}
],
"description": "Returns a Collection of features from a specified table.",
"returns": "FeatureCollection",
"type": "Algorithm",
"hidden": false
},
"Image.unmask": {
"args": [
{
"description": "Input image.",
"name": "input",
"type": "Image<unknown bands>"
},
{
"default": null,
"description": "New value and mask for the masked pixels of the input image. If not specified, defaults to constant zero image which is valid everywhere.",
"name": "value",
"optional": true,
"type": "Image<unknown bands>"
},
{
"default": true,
"description": "If true (or unspecified), the output retains the footprint of the input image. If false, the footprint of the output is the union of the input footprint with the footprint of the value image.",
"name": "sameFootprint",
"optional": true,
"type": "Boolean"
}
],
"description": "Replaces mask and value of the input image with the mask and value of another image at all positions where the input mask is zero. The output image retains the metadata of the input image. By default, the output image also retains the footprint of the input, but setting sameFootprint to false allows to extend the footprint.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Feature.transform": {
"args": [
{
"description": "The feature the geometry of which is being converted.",
"name": "feature",
"type": "Element"
},
{
"default": {
"crs": "EPSG:4326",
"transform": [
1.0,
0.0,
0.0,
0.0,
1.0,
0.0
],
"type": "Projection"
},
"description": "The target projection. Defaults to WGS84. If this has a geographic CRS, the edges of the geometry will be interpreted as geodesics. Otherwise they will be interpreted as straight lines in the projection.",
"name": "proj",
"optional": true,
"type": "Projection"
},
{
"default": null,
"description": "The maximum projection error.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
}
],
"description": "Transforms the geometry of a feature to a specific projection.",
"returns": "Feature",
"type": "Algorithm",
"hidden": false
},
"FeatureCollection.cluster": {
"args": [
{
"description": "The collection of features to cluster. Each feature must contain all the properties in the clusterer's schema.",
"name": "features",
"type": "FeatureCollection"
},
{
"description": "The clusterer to use.",
"name": "clusterer",
"type": "Clusterer"
},
{
"default": "cluster",
"description": "The name of the output property to be added.",
"name": "outputName",
"optional": true,
"type": "String"
}
],
"description": "Clusters each feature in a collection, adding a new column to each feature containing the cluster number to which it has been assigned.",
"returns": "FeatureCollection",
"type": "Algorithm",
"hidden": false
},
"Array.tanh": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, computes the hyperbolic tangent of the input.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Image.not": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Returns 0 if the input is non-zero, and 1 otherwise.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Baccini.modisComposite": {
"args": [
{
"description": "Date range end point is the mosaic's last day.",
"name": "lastYear",
"type": "DateRange"
},
{
"description": "The MCD43A4 collection.",
"name": "reflectance",
"type": "ImageCollection"
},
{
"description": "The MCD43A2 collection.",
"name": "quality",
"type": "ImageCollection"
},
{
"description": "The number of years to draw images from.",
"name": "numberOfYears",
"type": "Integer"
},
{
"description": "The start of the season (1-360).",
"name": "firstDayOfYear",
"type": "Integer"
},
{
"description": "The length of the season (8-368).",
"name": "numberOfDaysPerYear",
"type": "Integer"
},
{
"description": "Only use pixels of lower quality level (1-5).",
"name": "numberOfQualityLevels",
"type": "Integer"
}
],
"description": "Creates composites of MODIS MCD43A4 (\"Nadir BRDF-Adjusted Reflectance 16-Day\") 500m global mosaics, based on an algorithm by Alessandro Baccini, Mark Friedl and Damien Sulla-Menashe.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": true
},
"Classifier.cart": {
"args": [
{
"default": 10,
"description": "The cross-validation factor for pruning.",
"name": "crossvalidationFactor",
"optional": true,
"type": "Integer"
},
{
"default": 10,
"description": "Do not grow initial tree deeper than this many levels.",
"name": "maxDepth",
"optional": true,
"type": "Integer"
},
{
"default": 1,
"description": "Only create nodes whose training set contains at least this many points.",
"name": "minLeafPopulation",
"optional": true,
"type": "Integer"
},
{
"default": 1,
"description": "Do not split unless node has at least this many points.",
"name": "minSplitPoplulation",
"optional": true,
"type": "Integer"
},
{
"default": 1.0E-10,
"description": "Do not split if training set cost less than this.",
"name": "minSplitCost",
"optional": true,
"type": "Float"
},
{
"default": false,
"description": "Whether to skip pruning; i.e., only impose stopping criteria while growing the tree.",
"name": "prune",
"optional": true,
"type": "Boolean"
},
{
"default": 0.5,
"description": "The standard error threshold to use in determining the simplest tree whose accuracy is comparable to the minimum cost-complexity tree.",
"name": "pruneErrorTolerance",
"optional": true,
"type": "Float"
},
{
"default": 100,
"description": "The quantization resolution for numerical features.",
"name": "quantizationResolution",
"optional": true,
"type": "Integer"
},
{
"default": 0.1,
"description": "The margin reserved by quantizer to avoid overload, as a fraction of the range observed in the training data.",
"name": "quantizationMargin",
"optional": true,
"type": "Float"
},
{
"default": 0,
"description": "The randomization seed.",
"name": "randomSeed",
"optional": true,
"type": "Integer"
}
],
"description": "Creates an empty CART classifier. See:\n \"Classification and Regression Trees,\"\n L. Breiman, J. Friedman, R. Olshen, C. Stone\n Chapman and Hall, 1984.",
"returns": "Classifier",
"type": "Algorithm",
"hidden": false
},
"Filter.and": {
"args": [
{
"description": "The filters to conjunct.",
"name": "filters",
"type": "List<Filter>"
}
],
"description": "Returns a filter that passes if each of the component filters pass.",
"returns": "Filter",
"type": "Algorithm",
"hidden": false
},
"Image.divide": {
"args": [
{
"description": "The image from which the left operand bands are taken.",
"name": "image1",
"type": "Image<unknown bands>"
},
{
"description": "The image from which the right operand bands are taken.",
"name": "image2",
"type": "Image<unknown bands>"
}
],
"description": "Divides the first value by the second, returning 0 for division by 0 for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is the union of the input types.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.first_nonzero": {
"args": [
{
"description": "The image from which the left operand bands are taken.",
"name": "image1",
"type": "Image<unknown bands>"
},
{
"description": "The image from which the right operand bands are taken.",
"name": "image2",
"type": "Image<unknown bands>"
}
],
"description": "Selects the first value if it is non-zero, and the second value otherwise for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is the union of the input types.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Dictionary.size": {
"args": [
{
"name": "dictionary",
"type": "Dictionary<Object>"
}
],
"description": "Returns the number of entries in a dictionary.",
"returns": "Integer",
"type": "Algorithm",
"hidden": false
},
"Array.toInt64": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, casts the input value to a signed 64-bit integer.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Kernel.inverse": {
"args": [
{
"description": "The kernel to have its entries inverted.",
"name": "kernel",
"type": "Kernel"
}
],
"description": "Returns a kernel which has each of its weights multiplicatively inverted. Weights with a value of zero are not inverted and remain zero.",
"returns": "Kernel",
"type": "Algorithm",
"hidden": false
},
"GeometryConstructors.MultiLineString": {
"args": [
{
"description": "The list of LineStrings, or to wrap a single LineString, the list of Points or pairs of Numbers in x,y order.",
"name": "coordinates",
"type": "List<Object>"
},
{
"default": null,
"description": "The coordinate reference system of the coordinates. The default is the projection of the inputs, where Numbers are assumed to be EPSG:4326.",
"name": "crs",
"optional": true,
"type": "Projection"
},
{
"default": null,
"description": "If false, edges are straight in the projection. If true, edges are curved to follow the shortest path on the surface of the Earth. The default is the geodesic state of the inputs, or true if the inputs are numbers.",
"name": "geodesic",
"optional": true,
"type": "Boolean"
},
{
"default": null,
"description": "Max error when input geometry must be reprojected to an explicitly requested result projection or geodesic state.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
}
],
"description": "Constructs a MultiLineString from the given coordinates.",
"returns": "Geometry",
"type": "Algorithm",
"hidden": false
},
"Image.subtract": {
"args": [
{
"description": "The image from which the left operand bands are taken.",
"name": "image1",
"type": "Image<unknown bands>"
},
{
"description": "The image from which the right operand bands are taken.",
"name": "image2",
"type": "Image<unknown bands>"
}
],
"description": "Subtracts the second value from the first for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is the union of the input types.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Kernel.sobel": {
"args": [
{
"default": 1.0,
"description": "Scale each value by this amount.",
"name": "magnitude",
"optional": true,
"type": "Float"
},
{
"default": false,
"description": "Normalize the kernel values to sum to 1.",
"name": "normalize",
"optional": true,
"type": "Boolean"
}
],
"description": "Generates a 3x3 Sobel edge-detection kernel.",
"returns": "Kernel",
"type": "Algorithm",
"hidden": false
},
"Date.difference": {
"args": [
{
"name": "date",
"type": "Date"
},
{
"name": "start",
"type": "Date"
},
{
"description": "One of 'year', 'month' 'week', 'day', 'hour', 'minute', or 'second'.",
"name": "unit",
"type": "String"
}
],
"description": "Returns the difference between two Dates in the specified units; the result is floating-point and based on the average length of the unit.",
"returns": "Float",
"type": "Algorithm",
"hidden": false
},
"Image.floor": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Computes the largest integer less than or equal to the input.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Number.uint32": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Casts the input value to an unsigned 32-bit integer.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Array.asin": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, computes the arc sine in radians of the input.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Number.uint8": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Casts the input value to an unsigned 8-bit integer.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Kernel.diamond": {
"args": [
{
"description": "The radius of the kernel to generate.",
"name": "radius",
"type": "Float"
},
{
"default": "pixels",
"description": "The system of measurement for the kernel ('pixels' or 'meters'). If the kernel is specified in meters, it will resize when the zoom-level is changed.",
"name": "units",
"optional": true,
"type": "String"
},
{
"default": true,
"description": "Normalize the kernel values to sum to 1.",
"name": "normalize",
"optional": true,
"type": "Boolean"
},
{
"default": 1.0,
"description": "Scale each value by this amount.",
"name": "magnitude",
"optional": true,
"type": "Float"
}
],
"description": "Generates a diamond-shaped boolean kernel.",
"returns": "Kernel",
"type": "Algorithm",
"hidden": false
},
"Number.double": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Casts the input value to a 64-bit float.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Number.uint16": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Casts the input value to an unsigned 16-bit integer.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Reducer.sensSlope": {
"args": [],
"description": "Creates a two-input reducer that computes the Sen's slope estimator. The inputs are expected to be x data followed by y data. It returns two double values; the estimated slope and the offset.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Image.reduceToVectorsStreaming": {
"args": [
{
"description": "The input image. The first band is expected to be an integer type; adjacent pixels will be in the same segment if they have the same value in this band.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"default": null,
"description": "The reducer to apply. Its inputs will be taken from the image's bands after dropping the first band. Defaults to Reducer.countEvery()",
"name": "reducer",
"optional": true,
"type": "Reducer"
},
{
"default": null,
"description": "The region over which to reduce data. Defaults to the footprint of the image's first band.",
"name": "geometry",
"optional": true,
"type": "Geometry"
},
{
"default": null,
"description": "A nominal scale in meters of the projection to work in.",
"name": "scale",
"optional": true,
"type": "Float"
},
{
"default": "polygon",
"description": "How to choose the geometry of each generated feature; one of 'polygon' (a polygon enclosing the pixels in the segment), 'bb' (a rectangle bounding the pixels), or 'centroid' (the centroid of the pixels).",
"name": "geometryType",
"optional": true,
"type": "String"
},
{
"default": true,
"description": "If true, diagonally-connected pixels are considered adjacent; otherwise only pixels that share an edge are.",
"name": "eightConnected",
"optional": true,
"type": "Boolean"
},
{
"default": "label",
"description": "If non-null, the value of the first band will be saved as the specified property of each feature.",
"name": "labelProperty",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The projection to work in. If unspecified, the projection of the image's first band is used. If specified in addition to scale, rescaled to the specified scale.",
"name": "crs",
"optional": true,
"type": "Projection"
},
{
"default": null,
"description": "The list of CRS transform values. This is a row-major ordering of the 3x2 transform matrix. This option is mutually exclusive with 'scale', and replaces any transform already set on the projection.",
"name": "crsTransform",
"optional": true,
"type": "List<Float>"
},
{
"default": false,
"description": "If the polygon would contain too many pixels at the given scale, compute and use a larger scale which would allow the operation to succeed.",
"name": "bestEffort",
"optional": true,
"type": "Boolean"
},
{
"default": 10000000,
"description": "The maximum number of pixels to reduce.",
"name": "maxPixels",
"optional": true,
"type": "Long"
},
{
"default": 1.0,
"description": "A scaling factor used to reduce aggregation tile size; using a larger tileScale (e.g. 2 or 4) may enable computations that run out of memory with the default.",
"name": "tileScale",
"optional": true,
"type": "Float"
},
{
"default": false,
"description": "Create geometries in the pixel projection, rather than WGS84.",
"name": "geometryInNativeProjection",
"optional": true,
"type": "Boolean"
}
],
"description": "Convert an image to a feature collection by reducing homogenous regions. Given an image containing a band of labeled segments and zero or more additional bands, runs a reducer over the pixels in each segment producing a feature per segment.\nEither the reducer must have one fewer inputs than the image has bands, or it must have a single input and will be repeated for each band.",
"returns": "FeatureCollection",
"type": "Algorithm",
"hidden": true
},
"Number.short": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Casts the input value to a signed 16-bit integer.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Array.int": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, casts the input value to a signed 32-bit integer.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Feature.snap": {
"args": [
{
"description": "The feature whose geometry is being snapped.",
"name": "feature",
"type": "Element"
},
{
"description": "The max distance to move vertices during snapping. If in meters, 'proj' must not be specified, otherwise if in units, 'proj' must specified.",
"name": "snapRadius",
"type": "ErrorMargin"
},
{
"default": null,
"description": "If unspecified the result will be in WGS84 with geodesic edges and the snap radius must be in meters, otherwise the snap radius must be in units and the result will be in this projection with planar edges.",
"name": "proj",
"optional": true,
"type": "Projection"
}
],
"description": "Snaps the vertices of the default geometry to a regular cell grid with radius near but less than the given snap radius in meters. Snapping can reduce the number of vertices, close gaps in adjacent spatial features, and push degenerate elements to lower dimensional objects, e.g. a narrow polygon may collapse to a line. When applied to a GeometryCollection, overlap created between different elements is not removed.",
"returns": "Feature",
"type": "Algorithm",
"hidden": false
},
"Filter.calendarRange": {
"args": [
{
"description": "The start of the desired calendar field, inclusive.",
"name": "start",
"type": "Integer"
},
{
"default": null,
"description": "The end of the desired calendar field, inclusive. Defaults to the same value as start.",
"name": "end",
"optional": true,
"type": "Integer"
},
{
"default": "day_of_year",
"description": "The calendar field to filter over. Options are: 'year', 'month', 'hour', 'minute', 'day_of_year', 'day_of_month', and 'day_of_week'.",
"name": "field",
"optional": true,
"type": "String"
}
],
"description": "Returns a filter that passes if the object's timestamp falls within the given range of a calendar field. The month, day_of_year, day_of_month, and day_of_week are 1-based. Times are assumed to be in UTC. Weeks are assumed to begin on Monday as day 1. If end < start then this tests for value >= start OR value <= end, to allow for wrapping.",
"returns": "Filter",
"type": "Algorithm",
"hidden": false
},
"Array.toInt32": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, casts the input value to a signed 32-bit integer.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"StratifiedSampleImage.AggregationContainer": {
"args": [
{
"name": "image",
"type": "Image<unknown bands>"
},
{
"name": "classIndex",
"type": "Integer"
},
{
"name": "proj",
"type": "Projection"
},
{
"name": "region",
"type": "Geometry"
},
{
"name": "numPixels",
"type": "Integer"
},
{
"name": "classValues",
"type": "List<Integer>"
},
{
"name": "classPoints",
"type": "List<Integer>"
},
{
"name": "dropNulls",
"type": "Boolean"
},
{
"name": "seed",
"type": "Long"
},
{
"name": "tileScale",
"type": "Float"
}
],
"description": "INTERNAL",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": true
},
"Number.firstNonZero": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Number"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Number"
}
],
"description": "Selects the first value if it is non-zero, and the second value otherwise.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Array.cat": {
"args": [
{
"description": "Arrays to concatenate.",
"name": "arrays",
"type": "List<Array>"
},
{
"default": 0,
"description": "Axis to concatenate along.",
"name": "axis",
"optional": true,
"type": "Integer"
}
],
"description": "Concatenates multiple arrays into a single array along the given axis. Each array must have the same dimensionality and the same length on all axes except the concatenation axis.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Array.float": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, casts the input value to a 32-bit float.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Reducer.histogramCombiner": {
"args": [
{
"default": null,
"description": "The number of buckets of the output histogram. If null, the default is used.",
"name": "maxBuckets",
"optional": true,
"type": "Integer"
},
{
"default": null,
"description": "The minimum bucket width of the output histogram. If null, the default is used.",
"name": "minBucketWidth",
"optional": true,
"type": "Float"
}
],
"description": "Some doc",
"returns": "Reducer",
"type": "Algorithm",
"hidden": true
},
"reduce.count": {
"args": [
{
"description": "The image collection to reduce.",
"name": "collection",
"type": "ImageCollection"
}
],
"description": "Reduces an image collection by calculating the number of images with a valid mask at each pixel across the stack of all matching bands. Bands are matched by name.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Reducer.centeredCovariance": {
"args": [],
"description": "Creates a reducer that reduces some number of 1-D arrays of the same length N to a covariance matrix of shape NxN. WARNING: this reducer requires that the data has been mean centered.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Image.sample": {
"args": [
{
"description": "The image to sample.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"default": null,
"description": "The region to sample from. If unspecified, uses the image's whole footprint.",
"name": "region",
"optional": true,
"type": "Geometry"
},
{
"default": null,
"description": "A nominal scale in meters of the projection to sample in.",
"name": "scale",
"optional": true,
"type": "Float"
},
{
"default": null,
"description": "The projection in which to sample. If unspecified, the projection of the image's first band is used. If specified in addition to scale, rescaled to the specified scale.",
"name": "projection",
"optional": true,
"type": "Projection"
},
{
"default": null,
"description": "A subsampling factor, within (0, 1]. If specified, 'numPixels' must not be specified. Defaults to no subsampling.",
"name": "factor",
"optional": true,
"type": "Float"
},
{
"default": null,
"description": "The approximate number of pixels to sample. If specified, 'factor' must not be specified.",
"name": "numPixels",
"optional": true,
"type": "Long"
},
{
"default": 0,
"description": "A randomization seed to use for subsampling.",
"name": "seed",
"optional": true,
"type": "Integer"
},
{
"default": true,
"description": "Post filter the result to drop features that have null-valued properties.",
"name": "dropNulls",
"optional": true,
"type": "Boolean"
},
{
"default": 1.0,
"description": "A scaling factor used to reduce aggregation tile size; using a larger tileScale (e.g. 2 or 4) may enable computations that run out of memory with the default.",
"name": "tileScale",
"optional": true,
"type": "Float"
},
{
"default": false,
"description": "If true, adds the center of the sampled pixel as the geometry property of the output feature. Otherwise, geometries will be omitted (saving memory).",
"name": "geometries",
"optional": true,
"type": "Boolean"
}
],
"description": "Samples the pixels of an image, returning them as a FeatureCollection. Each feature will have 1 property per band in the input image.",
"returns": "FeatureCollection",
"type": "Algorithm",
"hidden": false
},
"Profile.getProfilesInternal": {
"args": [
{
"description": "One or more profile IDs returned by previous computations.",
"name": "ids",
"type": "List<String>"
},
{
"default": "text",
"description": "Format to return data in, either 'text' or 'json'.",
"name": "format",
"optional": true,
"type": "String"
}
],
"description": "Retrieve computation profile data given profile IDs. Includes internal-only information about tasks.",
"returns": "Object",
"type": "Algorithm",
"hidden": true
},
"SelectorSet.Geometry": {
"args": [
{
"name": "errorMeters",
"type": "Float"
},
{
"name": "region",
"type": "Rectangle"
}
],
"description": "Returns a geometry SelectorSet for a given error margin and region.",
"returns": "SelectorSet",
"type": "Algorithm",
"hidden": true
},
"Classifier.gmoMaxEnt": {
"args": [
{
"default": 0.0,
"description": "The weight for L1 regularization.",
"name": "weight1",
"optional": true,
"type": "Float"
},
{
"default": 0.000010,
"description": "The weight for L2 regularization.",
"name": "weight2",
"optional": true,
"type": "Float"
},
{
"default": 0.000010,
"description": "The epsilon for stopping optimization.",
"name": "epsilon",
"optional": true,
"type": "Float"
},
{
"default": 0,
"description": "The minimum number of iterations of optimizer.",
"name": "minIterations",
"optional": true,
"type": "Integer"
},
{
"default": 100,
"description": "The maximum number of iterations of optimizer.",
"name": "maxIterations",
"optional": true,
"type": "Integer"
}
],
"description": "Creates an empty GMO Maximum Entropy classifier. See:\n \"Efficient Large-Scale Distributed Training of Conditional Maximum Entropy Models,\"\n G. Mann, R. McDonald, M. Mohri, N. Silberman, D. Walker.",
"returns": "Classifier",
"type": "Algorithm",
"hidden": false
},
"Geometry.centroid": {
"args": [
{
"description": "Calculates the centroid of this geometry.",
"name": "geometry",
"type": "Geometry"
},
{
"default": null,
"description": "The maximum amount of error tolerated when performing any necessary reprojection.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
},
{
"default": null,
"description": "If specified, the result will be in this projection. Otherwise it will be in WGS84.",
"name": "proj",
"optional": true,
"type": "Projection"
}
],
"description": "Returns a point at the center of the highest-dimension components of the geometry. Lower-dimensional components are ignored, so the centroid of a geometry containing two polygons, three lines and a point is equivalent to the centroid of a geometry containing just the two polygons.",
"returns": "Geometry",
"type": "Algorithm",
"hidden": false
},
"Number.leftShift": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Number"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Number"
}
],
"description": "Calculates the left shift of v1 by v2 bits.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Image.int8": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Casts the input value to a signed 8-bit integer.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Array.matrixLUDecomposition": {
"args": [
{
"description": "The array to decompose.",
"name": "array",
"type": "Array"
}
],
"description": "Calculates the LU matrix decomposition such that P×input=L×U, where L is lower triangular (with unit diagonal terms), U is upper triangular and P is a partial pivot permutation matrix. The input matrix must be square. Returns a dictionary with entries named 'L', 'U' and 'P'.",
"returns": "Dictionary<Object>",
"type": "Algorithm",
"hidden": false
},
"Image.toInt": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Casts the input value to a signed 32-bit integer.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Classifier.setOutputMode": {
"args": [
{
"description": "An input classifier.",
"name": "classifier",
"type": "Classifier"
},
{
"description": "The output mode. One of:\n - CLASSIFICATION (default): The output is the class number.\n - REGRESSION: The output is the result of standard regression.\n - PROBABILITY: The output is the probability that the classification is correct.\nNot all classifier types support REGRESSION and PROBABILITY modes.",
"name": "mode",
"type": "String"
}
],
"description": "Sets the output mode.",
"returns": "Classifier",
"type": "Algorithm",
"hidden": false
},
"Number.bitwiseOr": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Number"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Number"
}
],
"description": "Calculates the bitwise OR of the input values.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Image.cumulativeCost": {
"args": [
{
"description": "A single-band image representing the cost to traverse each pixel. Masked pixels can't be traversed.",
"name": "cost",
"type": "Image<unknown bands>"
},
{
"description": "A single-band image representing the sources. A pixel value different from 0 defines a source pixel.",
"name": "source",
"type": "Image<unknown bands>"
},
{
"description": "Maximum distance for computation, in meters.",
"name": "maxDistance",
"type": "Float"
},
{
"default": true,
"description": "If true, geodetic distance along the curved surface is used, assuming a spherical Earth of radius 6378137.0. If false, euclidean distance in the 2D plane of the map projection is used (faster, but less accurate).",
"name": "geodeticDistance",
"optional": true,
"type": "Boolean"
}
],
"description": "Computes a cumulative cost map based on an image containing costs to traverse each pixel and an image containing source locations.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Number.tan": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Computes the tangent of the input in radians.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Number.tanh": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Computes the hyperbolic tangent of the input.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Feature.disjoint": {
"args": [
{
"description": "The feature containing the geometry used as the left operand of the operation.",
"name": "left",
"type": "Element"
},
{
"description": "The feature containing the geometry used as the right operand of the operation.",
"name": "right",
"type": "Element"
},
{
"default": null,
"description": "The maximum amount of error tolerated when performing any necessary reprojection.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
},
{
"default": null,
"description": "The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.",
"name": "proj",
"optional": true,
"type": "Projection"
}
],
"description": "Returns true iff the feature geometries are disjoint.",
"returns": "Boolean",
"type": "Algorithm",
"hidden": false
},
"Image.arrayGet": {
"args": [
{
"description": "Array to get an element from.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"description": "The coordinates of the element to get. There must be as many scalar bands as there are dimensions in the input image.",
"name": "position",
"type": "Image<unknown bands>"
}
],
"description": "For each band, an output band of the same name is created with the value at the given position extracted from the input multidimensional pixel in that band.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.matrixPseudoInverse": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Computes the Moore-Penrose pseudoinverse of the matrix.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Geometry.snap": {
"args": [
{
"description": "The geometry to snap.",
"name": "geometry",
"type": "Geometry"
},
{
"description": "The max distance to move vertices during snapping. If in meters, 'proj' must not be specified, otherwise if in units, 'proj' must specified.",
"name": "snapRadius",
"type": "ErrorMargin"
},
{
"default": null,
"description": "If unspecified the result will be in WGS84 with geodesic edges and the snap radius must be in meters, otherwise the snap radius must be in units and the result will be in this projection with planar edges.",
"name": "proj",
"optional": true,
"type": "Projection"
}
],
"description": "Snaps the vertices of the geometry to a regular cell grid with radius near but less than the given snap radius in meters. Snapping can reduce the number of vertices, close gaps in adjacent spatial features, and push degenerate elements to lower dimensional objects, e.g. a narrow polygon may collapse to a line. When applied to a GeometryCollection, overlap created between different elements is not removed.",
"returns": "Geometry",
"type": "Algorithm",
"hidden": false
},
"Reducer.histogram": {
"args": [
{
"default": null,
"description": "The maximum number of buckets to use when building a histogram; will be rounded up to a power of 2.",
"name": "maxBuckets",
"optional": true,
"type": "Integer"
},
{
"default": null,
"description": "The minimum histogram bucket width, or null to allow any power of 2.",
"name": "minBucketWidth",
"optional": true,
"type": "Float"
},
{
"default": null,
"description": "The number of values to accumulate before building the initial histogram.",
"name": "maxRaw",
"optional": true,
"type": "Integer"
}
],
"description": "Create a reducer that will compute a histogram of the inputs.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Reducer.percentile": {
"args": [
{
"description": "A list of numbers between 0 and 100.",
"name": "percentiles",
"type": "List<Number>"
},
{
"default": null,
"description": "A list of names for the outputs, or null to get default names.",
"name": "outputNames",
"optional": true,
"type": "List<String>"
},
{
"default": null,
"description": "The maximum number of buckets to use when building a histogram; will be rounded up to a power of 2.",
"name": "maxBuckets",
"optional": true,
"type": "Integer"
},
{
"default": null,
"description": "The minimum histogram bucket width, or null to allow any power of 2.",
"name": "minBucketWidth",
"optional": true,
"type": "Float"
},
{
"default": null,
"description": "The number of values to accumulate before building the initial histogram.",
"name": "maxRaw",
"optional": true,
"type": "Integer"
}
],
"description": "Create a reducer that will compute the specified percentiles, e.g. given [0, 50, 100] will produce outputs named 'p0', 'p50', and 'p100' with the min, median, and max respectively. For small numbers of inputs (up to maxRaw) the percentiles will be computed directly; for larger numbers of inputs the percentiles will be derived from a histogram.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Array.gamma": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, computes the gamma function of the input.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Collection.geometry": {
"args": [
{
"description": "The collection whose geometries will be extracted.",
"name": "collection",
"type": "FeatureCollection"
},
{
"default": {
"type": "ErrorMargin",
"unit": "meters",
"value": 0.0
},
"description": "An error margin to use when merging geometries.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
}
],
"description": "Extracts and merges the geometries of a collection. Requires that all the geometries in the collection share the projection and edge interpretation.",
"returns": "Geometry",
"type": "Algorithm",
"hidden": false
},
"Filter.maxDifference": {
"args": [
{
"description": "The maximum difference for which the filter will return true.",
"name": "difference",
"type": "Float"
},
{
"default": null,
"description": "A selector for the left operand. Should not be specified if leftValue is specified.",
"name": "leftField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the right operand. Should not be specified if rightField is specified.",
"name": "rightValue",
"optional": true,
"type": "Object"
},
{
"default": null,
"description": "A selector for the right operand. Should not be specified if rightValue is specified.",
"name": "rightField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the left operand. Should not be specified if leftField is specified.",
"name": "leftValue",
"optional": true,
"type": "Object"
}
],
"description": "Creates a unary or binary filter that passes if the left and right operands, both numbers, are within a given maximum difference. If used as a join condition, this numeric difference is used as a join measure.",
"returns": "Filter",
"type": "Algorithm",
"hidden": false
},
"Reducer.or": {
"args": [],
"description": "Returns a Reducer that returns 1 if any of its inputs are non-zero, 0 otherwise.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false,
"deprecated": "Use Reducer.anyNonZero()."
},
"Collection.toList": {
"args": [
{
"description": "The input collection to fetch.",
"name": "collection",
"type": "FeatureCollection"
},
{
"description": "The maximum number of elements to fetch.",
"name": "count",
"type": "Integer"
},
{
"default": 0,
"description": "The number of elements to discard from the start. If set, (offset + count) elements will be fetched and the first offset elements will be discarded.",
"name": "offset",
"optional": true,
"type": "Integer"
}
],
"description": "Returns the elements of a collection as a list.",
"returns": "List<Object>",
"type": "Algorithm",
"hidden": false
},
"Dictionary.get": {
"args": [
{
"name": "dictionary",
"type": "Dictionary<Object>"
},
{
"name": "key",
"type": "String"
}
],
"description": "Extracts a named value from a dictionary.",
"returns": "Object",
"type": "Algorithm",
"hidden": false
},
"PointMatcher.PointMatcherContainer": {
"args": [
{
"description": "The image containing the point to align.",
"name": "templateImage",
"type": "Image<unknown bands>"
},
{
"name": "searchImage",
"type": "Image<unknown bands>"
},
{
"name": "x",
"type": "Integer"
},
{
"name": "y",
"type": "Integer"
},
{
"name": "proj",
"type": "Projection"
},
{
"name": "maxOffset",
"type": "Integer"
},
{
"default": null,
"name": "templateBandNames",
"optional": true,
"type": "List<String>"
},
{
"default": null,
"name": "searchBandNames",
"optional": true,
"type": "List<String>"
},
{
"default": 15,
"name": "windowSize",
"optional": true,
"type": "Integer"
},
{
"default": 0,
"name": "expectedXOffset",
"optional": true,
"type": "Integer"
},
{
"default": 0,
"name": "expectedYOffset",
"optional": true,
"type": "Integer"
},
{
"default": 1,
"name": "maxResults",
"optional": true,
"type": "Integer"
},
{
"default": 0.0,
"name": "maxMaskedFrac",
"optional": true,
"type": "Float"
}
],
"description": "INTERNAL",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": true
},
"Annotation.svg": {
"args": [
{
"description": "The x-axis coordinate of the upper-left corner.",
"name": "x",
"type": "Float"
},
{
"description": "The y-axis coordinate of the upper-left corner.",
"name": "y",
"type": "Float"
}
],
"description": "Creates a SVG container. Any annotations added to the container are positioned relative to the container's x and y position, and inherit any styles applied to the container.",
"returns": "Annotation",
"type": "Algorithm",
"hidden": false
},
"Array.reduce": {
"args": [
{
"description": "The array.",
"name": "array",
"type": "Array"
},
{
"description": "The reducer to apply",
"name": "reducer",
"type": "Reducer"
},
{
"description": "The list of axes over which to reduce. The output will have a length of 1 in all these axes.",
"name": "axes",
"type": "List<Integer>"
},
{
"default": null,
"description": "The axis for the reducer's input and output fields. Only required if the reducer has multiple inputs or outputs.",
"name": "fieldAxis",
"optional": true,
"type": "Integer"
}
],
"description": "Apply a reducer to an array by collapsing all the input values along each specified axis into a single output value computed by the reducer.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Image.translate": {
"args": [
{
"name": "input",
"type": "Image<unknown bands>"
},
{
"name": "x",
"type": "Float"
},
{
"name": "y",
"type": "Float"
},
{
"default": "meters",
"description": "The units for x and y; \"meters\" or \"pixels\".",
"name": "units",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The projection in which to translate the image; defaults to the projection of the first band.",
"name": "proj",
"optional": true,
"type": "Projection"
}
],
"description": "Translate the input image.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Classifier.pegasosPolynomial": {
"args": [
{
"default": 3,
"description": "The degree of the Polynomial kernel.",
"name": "polyDegree",
"optional": true,
"type": "Integer"
},
{
"default": 1.0,
"description": "The bias of the Polynomial kernel.",
"name": "polyBias",
"optional": true,
"type": "Float"
},
{
"default": "HingeSum",
"description": "The loss function to use. Valid values are: 'HingeSum', 'HingeMax', 'LogSum' and 'LogMax'",
"name": "lossFunction",
"optional": true,
"type": "String"
},
{
"default": 0.001,
"description": "The regularization parameter of SVM (lambda).",
"name": "lambda",
"optional": true,
"type": "Float"
},
{
"default": 0,
"description": "The number of iterations (T). When set to 0 (default), the number of training iterations is automatically set to 5 * training data size (~5 epochs).",
"name": "iterations",
"optional": true,
"type": "Integer"
},
{
"default": 1,
"description": "The subset size (k), i.e. the number of random samples to process on each iteration.",
"name": "subsetSize",
"optional": true,
"type": "Integer"
},
{
"default": 1.0,
"description": "The norm of w for regularization.",
"name": "regularizationNorm",
"optional": true,
"type": "Float"
},
{
"default": 0.01,
"description": "The gamma value for the loss function in multi-class classification.",
"name": "multiGamma",
"optional": true,
"type": "Float"
}
],
"description": "Creates an empty polynomial Pegasos classifier. See:\n \"Pegasos (Primal Estimated sub-GrAdient SOlver for SVM)\"\n S. Shalev-Shwartz, Y. Singer, N. Srebro, A. Cotter",
"returns": "Classifier",
"type": "Algorithm",
"hidden": false,
"deprecated": "Deprecated; will be removed eventually."
},
"Join.inner": {
"args": [
{
"default": "primary",
"description": "The property name used to save the primary match.",
"name": "primaryKey",
"optional": true,
"type": "String"
},
{
"default": "secondary",
"description": "The property name used to save the secondary match.",
"name": "secondaryKey",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "An optional property name used to save the measure of the join condition.",
"name": "measureKey",
"optional": true,
"type": "String"
}
],
"description": "Returns a join that pairs elements from the primary collection with matching elements from the secondary collection. Each result has a 'primary' property that contains the element from the primary collection, and a 'secondary' property containing the matching element from the secondary collection. If measureKey is specified, the join measure is also attached to the object as a property.",
"returns": "Join",
"type": "Algorithm",
"hidden": false
},
"Image.first": {
"args": [
{
"description": "The image from which the left operand bands are taken.",
"name": "image1",
"type": "Image<unknown bands>"
},
{
"description": "The image from which the right operand bands are taken.",
"name": "image2",
"type": "Image<unknown bands>"
}
],
"description": "Selects the value of the first value for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is the union of the input types.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Array.add": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Array"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Array"
}
],
"description": "On an element-wise basis, adds the first value to the second.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Number.toUint16": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Casts the input value to an unsigned 16-bit integer.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Number.toInt": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Casts the input value to a signed 32-bit integer.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Image.connectedPixelCount": {
"args": [
{
"description": "The input image.",
"name": "input",
"type": "Image<unknown bands>"
},
{
"default": 100,
"description": "The maximum size of the neighborhood in pixels.",
"name": "maxSize",
"optional": true,
"type": "Integer"
},
{
"default": true,
"description": "Whether to use 8-connected rather 4-connected rules.",
"name": "eightConnected",
"optional": true,
"type": "Boolean"
}
],
"description": "Generate an image where each pixel contains the number of 4- or 8-connected neighbors (including itself).",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Number.int8": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Casts the input value to a signed 8-bit integer.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Image.bandTypes": {
"args": [
{
"description": "The image from which to get band types.",
"name": "image",
"type": "Image<unknown bands>"
}
],
"description": "Returns a dictionary of the image's band types.",
"returns": "Dictionary<Object>",
"type": "Algorithm",
"hidden": false
},
"Number.min": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Number"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Number"
}
],
"description": "Selects the minimum of the first and second values.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Image.erf": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Computes the error function of the input.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.matrixSolve": {
"args": [
{
"description": "The image from which the left operand bands are taken.",
"name": "image1",
"type": "Image<unknown bands>"
},
{
"description": "The image from which the right operand bands are taken.",
"name": "image2",
"type": "Image<unknown bands>"
}
],
"description": "Solves for x in the matrix equation A*x=B, finding a least-squares solution if A is overdetermined for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is the union of the input types.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"List.slice": {
"args": [
{
"name": "list",
"type": "List<Object>"
},
{
"name": "start",
"type": "Integer"
},
{
"default": null,
"name": "end",
"optional": true,
"type": "Integer"
}
],
"description": "Returns a portion of list between the start index, inclusive, and end index, exclusive. Negative values for start or end count backwards from the end of the list. Values greater than the size of the list are legal but are truncated to the size of list.",
"returns": "List<Object>",
"type": "Algorithm",
"hidden": false
},
"Image.constant": {
"args": [
{
"description": "The value of the pixels in the constant image. Must be a number or an Array or a list of numbers or Arrays.",
"name": "value",
"type": "Object"
}
],
"description": "Generates an image containing a constant value everywhere.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Number.sinh": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Computes the hyperbolic sine of the input.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Image.left_shift": {
"args": [
{
"description": "The image from which the left operand bands are taken.",
"name": "image1",
"type": "Image<unknown bands>"
},
{
"description": "The image from which the right operand bands are taken.",
"name": "image2",
"type": "Image<unknown bands>"
}
],
"description": "Calculates the left shift of v1 by v2 bits for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is the union of the input types.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Geometry.s2Cell": {
"args": [
{
"description": "The S2 cell id.",
"name": "cellId",
"type": "Long"
}
],
"description": "Constructs the Polygon corresponding to an S2 cell id.",
"returns": "Geometry",
"type": "Algorithm",
"hidden": false
},
"Number.atan2": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Number"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Number"
}
],
"description": "Calculates the angle formed by the 2D vector [x, y].",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Array.length": {
"args": [
{
"description": "The array from which to extract the axis lengths.",
"name": "array",
"type": "Array"
}
],
"description": "Returns a 1-D EEArray containing the length of each dimension of the given EEArray.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Annotation.rect": {
"args": [
{
"description": "The x-axis coordinate of the upper-left corner of the rectangle.",
"name": "x",
"type": "Float"
},
{
"description": "The y-axis coordinate of the upper-left corner of the rectangle.",
"name": "y",
"type": "Float"
},
{
"description": "The width of the rectangle.",
"name": "width",
"type": "Float"
},
{
"description": "The height of the rectangle.",
"name": "height",
"type": "Float"
},
{
"default": null,
"description": "The color with which to fill the rectangle.",
"name": "fill",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "For rounded rectangles, the radius of the circle to used to round off corners of the rectangle.",
"name": "radius",
"optional": true,
"type": "Float"
}
],
"description": "Creates a rectangle annotation.",
"returns": "Annotation",
"type": "Algorithm",
"hidden": false
},
"Number.long": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Casts the input value to a signed 64-bit integer.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Array.abs": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, computes the absolute value of the input.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Reducer.kendallsCorrelation": {
"args": [
{
"default": 1,
"description": "The number of inputs to expect (1 or 2). If 1 is specified, automatically generates sequence numbers for the x value (meaning there can be no ties).",
"name": "numInputs",
"optional": true,
"type": "Integer"
}
],
"description": "Creates a reducer that computes the Kendall's Tau-b rank correlation and p-value on a two-sided test of H0: x and y are independent. A positive tau value indicates an increasing trend; negative value indicates a decreasing trend. Currently the p-value test is disabled and only returns null.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Reducer.forEachElement": {
"args": [
{
"description": "The reducer to apply to each array element.",
"name": "reducer",
"type": "Reducer"
}
],
"description": "Separately reduces each position in array inputs of equal shape, producing an array output of the same shape.\nFor example, with the 'sum' reducer applied to 5 arrays with shape 2x2, the output will be a 2x2 array, where each position is the sum of the 5 values at that position.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Filter.not": {
"args": [
{
"description": "The filter to negate.",
"name": "filter",
"type": "Filter"
}
],
"description": "Returns a filter that passes if the provided filter fails.",
"returns": "Filter",
"type": "Algorithm",
"hidden": false
},
"Image.long": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Casts the input value to a signed 64-bit integer.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Annotation.attr": {
"args": [
{
"name": "annotation",
"type": "Annotation"
},
{
"name": "attr",
"type": "Dictionary<Object>"
}
],
"description": "Apply additional attributes to an annotation.",
"returns": "Annotation",
"type": "Algorithm",
"hidden": false
},
"AggregateFeatureCollection.total_sd": {
"args": [
{
"description": "The collection to aggregate over.",
"name": "collection",
"type": "FeatureCollection"
},
{
"description": "The property to use from each element of the collection.",
"name": "property",
"type": "String"
}
],
"description": "Aggregates over a given property of the objects in a collection, calculating the total std. deviation of the values of the selected property.",
"returns": "Object",
"type": "Algorithm",
"hidden": false
},
"Number.toUint32": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Casts the input value to an unsigned 32-bit integer.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"ReduceRegions.AggregationContainer": {
"args": [
{
"name": "enumerator",
"type": "Object"
}
],
"description": "INTERNAL",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": true
},
"List.cat": {
"args": [
{
"name": "list",
"type": "List<Object>"
},
{
"name": "other",
"type": "List<Object>"
}
],
"description": "Concatenates the contents of other onto list.",
"returns": "List<Object>",
"type": "Algorithm",
"hidden": false
},
"Image.cos": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Computes the cosine of the input in radians.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Array.repeat": {
"args": [
{
"description": "Array to repeat.",
"name": "array",
"type": "Array"
},
{
"default": 0,
"description": "The axis along which to repeat the array.",
"name": "axis",
"optional": true,
"type": "Integer"
},
{
"default": 2,
"description": "The number of copies of this array to concatenate along the given axis.",
"name": "copies",
"optional": true,
"type": "Integer"
}
],
"description": "Repeats the array along the given axis. The result will have the shape of the input, except length along the repeated axis will be multiplied by the given number of copies.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Collection.reduceColumns": {
"args": [
{
"description": "The collection to aggregate over.",
"name": "collection",
"type": "FeatureCollection"
},
{
"description": "The reducer to apply.",
"name": "reducer",
"type": "Reducer"
},
{
"description": "A selector for each input of the reducer.",
"name": "selectors",
"type": "List<String>"
},
{
"default": null,
"description": "A selector for each weighted input of the reducer.",
"name": "weightSelectors",
"optional": true,
"type": "List<String>"
}
],
"description": "Apply a reducer to each element of a collection, using the given selectors to determine the inputs.\nReturns a dictionary of results, keyed with the output names.",
"returns": "Dictionary<Object>",
"type": "Algorithm",
"hidden": false
},
"Number.toDouble": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Casts the input value to a 64-bit float.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Reducer.disaggregate": {
"args": [
{
"description": "The reducer for which to disaggregate inputs.",
"name": "reducer",
"type": "Reducer"
},
{
"default": null,
"description": "If specified, indicates an array axis along which to disaggregate. If not specified, arrays are completely disaggregated. Ignored for non-array types.",
"name": "axis",
"optional": true,
"type": "Integer"
}
],
"description": "Separates aggregate inputs (Arrays, Lists or Dictionaries) into individual items that are then each passed to the specified reducer. When used on dictionaries, the dictionary keys are ignored. Non-aggregated inputs (ie: numbers or strings) are passed to the underlying reducer directly.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Element.geometry": {
"args": [
{
"description": "The feature from which the geometry is taken.",
"name": "feature",
"type": "Element"
},
{
"default": null,
"description": "The maximum amount of error tolerated when performing any necessary reprojection.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
},
{
"default": null,
"description": "If specified, the geometry will be in this projection. If unspecified, the geometry will be in its default projection.",
"name": "proj",
"optional": true,
"type": "Projection"
},
{
"default": null,
"description": "If true, the geometry will have geodesic edges. If false, it will have edges as straight lines in the specified projection. If null, the edge interpretation will be the same as the original geometry. This argument is ignored if proj is not specified.",
"name": "geodesics",
"optional": true,
"type": "Boolean"
}
],
"description": "Returns the geometry of a given feature in a given projection.",
"returns": "Geometry",
"type": "Algorithm",
"hidden": false
},
"Image.erfcInv": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Computes the inverse complementary error function of the input.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"DateRangeCollection": {
"args": [
{
"description": "The start time of the range, in msec since the epoch.",
"name": "startTime",
"type": "Long"
},
{
"description": "The ending time of the range, in msec since the epoch.",
"name": "endTime",
"type": "Long"
},
{
"default": 1,
"description": "The time interval between successive data ranges, in units specified by 'units'.",
"name": "interval",
"optional": true,
"type": "Integer"
},
{
"default": "days",
"description": "The units in which 'period' is specified: currently only 'days' and 'years' are recognized.",
"name": "units",
"optional": true,
"type": "String"
},
{
"default": false,
"description": "If true, the intervals will align to the start of each year.",
"name": "resetAtYearBoundaries",
"optional": true,
"type": "Boolean"
}
],
"description": "Returns a collection of objects with 'system:index', 'date_range' properties in a defined sequence at regular intervals, suitable for mapping over.",
"returns": "FeatureCollection",
"type": "Algorithm",
"hidden": true
},
"Feature.length": {
"args": [
{
"description": "The feature from which the geometry is taken.",
"name": "feature",
"type": "Element"
},
{
"default": null,
"description": "The maximum amount of error tolerated when performing any necessary reprojection.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
},
{
"default": null,
"description": "If specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in meters.",
"name": "proj",
"optional": true,
"type": "Projection"
}
],
"description": "Returns the length of the linear parts of the geometry of a given feature. Polygonal parts are ignored. The length of multi geometries is the sum of the lengths of their components.",
"returns": "Float",
"type": "Algorithm",
"hidden": false
},
"Geometry.buffer": {
"args": [
{
"description": "The geometry being buffered.",
"name": "geometry",
"type": "Geometry"
},
{
"description": "The distance of the buffering, which may be negative. If no projection is specified, the unit is meters. Otherwise the unit is in the coordinate system of the projection.",
"name": "distance",
"type": "Float"
},
{
"default": null,
"description": "The maximum amount of error tolerated when approximating the buffering circle and performing any necessary reprojection. If unspecified, defaults to 1% of the distance.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
},
{
"default": null,
"description": "If specified, the buffering will be performed in this projection and the distance will be interpreted as units of the coordinate system of this projection. Otherwise the distance is interpereted as meters and the buffering is performed in a spherical coordinate system.",
"name": "proj",
"optional": true,
"type": "Projection"
}
],
"description": "Returns the input buffered by a given distance. If the distance is positive, the geometry is expanded, and if the distance is negative, the geometry is contracted.",
"returns": "Geometry",
"type": "Algorithm",
"hidden": false
},
"Image.neq": {
"args": [
{
"description": "The image from which the left operand bands are taken.",
"name": "image1",
"type": "Image<unknown bands>"
},
{
"description": "The image from which the right operand bands are taken.",
"name": "image2",
"type": "Image<unknown bands>"
}
],
"description": "Returns 1 iff the first value is not equal to the second for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is boolean.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.pixelArea": {
"args": [],
"description": "Generate an image in which the value of each pixel is the area of that pixel in square meters.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Annotation": {
"args": [
{
"name": "attributes",
"type": "Object"
},
{
"default": null,
"name": "style",
"optional": true,
"type": "Dictionary<Object>"
},
{
"default": null,
"name": "transforms",
"optional": true,
"type": "List<String>"
},
{
"default": null,
"name": "children",
"optional": true,
"type": "List<Annotation>"
}
],
"description": "Creates a Annotation.",
"returns": "Annotation",
"type": "Algorithm",
"hidden": true
},
"List.sequence": {
"args": [
{
"name": "start",
"type": "Number"
},
{
"default": null,
"name": "end",
"optional": true,
"type": "Number"
},
{
"default": 1.0,
"name": "step",
"optional": true,
"type": "Number"
},
{
"default": null,
"name": "count",
"optional": true,
"type": "Integer"
}
],
"description": "Generate a sequence of numbers from start to end (inclusive) in increments of step, or in count equally-spaced increments. If end is not specified it is computed from start + step * count, so at least one of end or count must be specified.",
"returns": "List<Number>",
"type": "Algorithm",
"hidden": false
},
"Terrain": {
"args": [
{
"description": "An elevation image, in meters.",
"name": "input",
"type": "Image<unknown bands>"
}
],
"description": "Calculates slope, aspect, and a simple hillshade from a terrain DEM.\n\nExpects an image containing either a single band of elevation, measured in meters, or if there's more than one band, one named 'elevation'. Adds output bands named 'slope' and 'aspect' measured in degrees plus an unsigned byte output band named 'hillshade' for visualization. All other bands and metadata are copied from the input image. The local gradient is computed using the 4-connected neighbors of each pixel, so missing values will occur around the edges of an image.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Test.Clustering.BerkeleySegmentation": {
"args": [
{
"description": "The image to segment.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"description": "Number of iterations, also known as scale parameter: The number of iterations determines how strict of a threshold is enforced with respect to spectral and shape properties in allowing merging. Successive iterations allow for merges with increasingly poor merge criteria up to the final threshold, determined by the number of iterations. Thus, a large number of iterations will generate few large segments while a small number of iterations will generate many small segments.",
"name": "numIterations",
"type": "Integer"
},
{
"description": "Shape parameter: The shape parameter determines how important the shape of a merged segment is relative to spectral similarity. Shape and spectral parameters add to 1 (e.g., if you only care about spectral, put shape as 0).",
"name": "shape",
"type": "Float"
},
{
"description": "Compactness parameter: Within the shape consideration, there are two properties evaluated - compactness and smoothness. Compactness can be thought of as the area of an object compared to its perimeter (e.g., a square has high compactness, a long and thin rectangle does not). Smoothness can be thought of as the perimeter of an object compared to its bounding box perimeter (e.g., a square has high smoothness, an amoeba-like shape would not). Compactness and smoothness add to 1 (e.g., if you only care about smoothness, put compactness as 0).",
"name": "compactness",
"type": "Float"
},
{
"default": 256,
"description": "Maximum object size. Regions cannot be merged across tiles iftheir length is over this limit.",
"name": "maxObjectSize",
"optional": true,
"type": "Integer"
},
{
"default": null,
"description": "The weights for each band, in order of the bands. This determines the spectral importance of each band in merging. Defaulted to uniform band weights. If band weights are specified, they will be automatically normalized.",
"name": "bandWeights",
"optional": true,
"type": "List<Float>"
}
],
"description": "Performs region merging image segmentation. Initially, each pixel is its own segment. Over a series of iterations, adjacent segments with sufficient criteria are merged. Merging criteria is determined by user specified parameters. The output image will have a segment label band and bands corresponding to each of the input bands with the spectral mean for each segment.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": true
},
"Image.bitwiseOr": {
"args": [
{
"description": "The image from which the left operand bands are taken.",
"name": "image1",
"type": "Image<unknown bands>"
},
{
"description": "The image from which the right operand bands are taken.",
"name": "image2",
"type": "Image<unknown bands>"
}
],
"description": "Calculates the bitwise OR of the input values for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is the union of the input types.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.sinh": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Computes the hyperbolic sine of the input.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Clusterer.schema": {
"args": [
{
"name": "clusterer",
"type": "Clusterer"
}
],
"description": "Returns the names of the inputs used by this Clusterer, or null if this Clusterer has not had any training data added yet.",
"returns": "List<String>",
"type": "Algorithm",
"hidden": false
},
"Reducer.mean": {
"args": [],
"description": "Returns a Reducer that computes the (weighted) arithmetic mean of its inputs.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Image.register": {
"args": [
{
"description": "The image to register.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"description": "The image to register to.",
"name": "referenceImage",
"type": "Image<unknown bands>"
},
{
"description": "The maximum offset allowed when attempting to align the input images, in meters. Using a smaller value can reduce computation time significantly, but it must still be large enough to cover the greatest displacement within the entire image region.",
"name": "maxOffset",
"type": "Float"
},
{
"default": null,
"description": "Patch size for detecting image offsets, in meters. This should be set large enough to capture texture, as well as large enough that ignorable objects are small within the patch. Default is null. Patch size will be determined automatically if notprovided.",
"name": "patchWidth",
"optional": true,
"type": "Float"
},
{
"default": 5.0,
"description": "Enforces a stiffness constraint on the solution. Valid values are in the range [0,10]. The stiffness is used for outlier rejection when determining displacements at adjacent grid points. Higher values move the solution towards a rigid transformation. Lower values allow more distortion or warping of the image during registration.",
"name": "stiffness",
"optional": true,
"type": "Float"
}
],
"description": "Registers an image to a reference image while allowing local, rubber sheet deformations. Displacements are computed in the CRS of the reference image, at a scale dictated by the lowest resolution of the following three projections: input image projection, reference image projection, and requested projection. The displacements then applied to the input image to register it with the reference.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Number.floor": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Computes the largest integer less than or equal to the input.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Array.gte": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Array"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Array"
}
],
"description": "On an element-wise basis, returns 1 iff the first value is greater than or equal to the second.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"TrainImageClassifier.AggregationContainer": {
"args": [
{
"name": "image",
"type": "Image<unknown bands>"
},
{
"default": null,
"name": "classifierName",
"optional": true,
"type": "String"
},
{
"default": null,
"name": "classifierParameters",
"optional": true,
"type": "String"
},
{
"default": null,
"name": "classifierMode",
"optional": true,
"type": "String"
},
{
"default": 0,
"name": "numSubsamples",
"optional": true,
"type": "Integer"
},
{
"default": null,
"name": "bootstrapSubsampling",
"optional": true,
"type": "Float"
},
{
"default": null,
"name": "bootstrapAggregator",
"optional": true,
"type": "String"
},
{
"default": null,
"name": "classifier",
"optional": true,
"type": "OldClassifier"
},
{
"default": null,
"name": "bands",
"optional": true,
"type": "List<String>"
},
{
"default": null,
"name": "trainingImage",
"optional": true,
"type": "Image<unknown bands>"
},
{
"default": null,
"name": "trainingBand",
"optional": true,
"type": "String"
},
{
"default": null,
"name": "trainingRegion",
"optional": true,
"type": "Geometry"
},
{
"default": null,
"name": "trainingFeatures",
"optional": true,
"type": "FeatureCollection"
},
{
"default": null,
"name": "trainingProperty",
"optional": true,
"type": "String"
},
{
"default": null,
"name": "trainingProj",
"optional": true,
"type": "Projection"
},
{
"default": 0,
"name": "maxClass",
"optional": true,
"type": "Integer"
},
{
"default": 1.0,
"name": "subsampling",
"optional": true,
"type": "Float"
},
{
"default": 0,
"name": "seed",
"optional": true,
"type": "Long"
}
],
"description": "INTERNAL",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": true
},
"Image.bitwiseNot": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Calculates the bitwise NOT of the input, in the smallest signed integer type that can hold the input.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"AggregateFeatureCollection.first": {
"args": [
{
"description": "The collection to aggregate over.",
"name": "collection",
"type": "FeatureCollection"
},
{
"description": "The property to use from each element of the collection.",
"name": "property",
"type": "String"
}
],
"description": "Aggregates over a given property of the objects in a collection, calculating the property value of the first object in the collection.",
"returns": "Object",
"type": "Algorithm",
"hidden": false
},
"FeatureCollection.loadSSTable": {
"args": [
{
"description": "The base filename pattern.",
"name": "filebase",
"type": "String"
},
{
"default": null,
"description": "Metadata properties of the asset.",
"name": "properties",
"optional": true,
"type": "Dictionary<Object>"
}
],
"description": "Loads a FeatureCollection from a vector sstable.",
"returns": "FeatureCollection",
"type": "Algorithm",
"hidden": false
},
"Number.mod": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Number"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Number"
}
],
"description": "Calculates the remainder of the first value divided by the second.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Kernel.laplacian8": {
"args": [
{
"default": 1.0,
"description": "Scale each value by this amount.",
"name": "magnitude",
"optional": true,
"type": "Float"
},
{
"default": false,
"description": "Normalize the kernel values to sum to 1.",
"name": "normalize",
"optional": true,
"type": "Boolean"
}
],
"description": "Generates a 3x3 Laplacian-8 edge-detection kernel.",
"returns": "Kernel",
"type": "Algorithm",
"hidden": false
},
"Image.mask": {
"args": [
{
"description": "The input image.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"default": null,
"description": "The mask image. If specified, the input image is copied to the output but given the mask by the values of this image. If this is a single band, it is used for all bands in the input image. If not specified, returns an image created from the mask of the input image, scaled to the range [0:1] (invalid = 0, valid = 1.0).",
"name": "mask",
"optional": true,
"type": "Image<unknown bands>"
}
],
"description": "Gets or sets an image's mask. The output image retains the metadata and footprint of the input image. Pixels where the mask changes from zero to another value will be filled with zeros, or the values closest to zero within the range of the pixel type.\nNote: the version that sets a mask will be deprecated. To set a mask from an image on previously unmasked pixels, use Image.updateMask. To unmask previously masked pixels, use Image.unmask.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.randomVisualizer": {
"args": [
{
"description": "Image with at least one band.",
"name": "image",
"type": "Image<unknown bands>"
}
],
"description": "Creates a vizualization image by assigning a random color to each unique value of the pixels of the first band. The first three bands of the output image will contan 8-bit R, G and B values, followed by all bands of the input image.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Kernel.laplacian4": {
"args": [
{
"default": 1.0,
"description": "Scale each value by this amount.",
"name": "magnitude",
"optional": true,
"type": "Float"
},
{
"default": false,
"description": "Normalize the kernel values to sum to 1.",
"name": "normalize",
"optional": true,
"type": "Boolean"
}
],
"description": "Generates a 3x3 Laplacian-4 edge-detection kernel.",
"returns": "Kernel",
"type": "Algorithm",
"hidden": false
},
"Image.bitwise_or": {
"args": [
{
"description": "The image from which the left operand bands are taken.",
"name": "image1",
"type": "Image<unknown bands>"
},
{
"description": "The image from which the right operand bands are taken.",
"name": "image2",
"type": "Image<unknown bands>"
}
],
"description": "Calculates the bitwise OR of the input values for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is the union of the input types.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.cbrt": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Computes the cubic root of the input.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.and": {
"args": [
{
"description": "The image from which the left operand bands are taken.",
"name": "image1",
"type": "Image<unknown bands>"
},
{
"description": "The image from which the right operand bands are taken.",
"name": "image2",
"type": "Image<unknown bands>"
}
],
"description": "Returns 1 iff both values are non-zero for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is boolean.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Collection.limit": {
"args": [
{
"description": "The collection to limit or order.",
"name": "collection",
"type": "FeatureCollection"
},
{
"default": null,
"description": "The maximum number of items in the output collection. null is used to represent no limit.",
"name": "limit",
"optional": true,
"type": "Integer"
},
{
"default": null,
"description": "The property on which the collection is sorted.",
"name": "key",
"optional": true,
"type": "String"
},
{
"default": true,
"description": "Whether the sorting is ascending rather than descending.",
"name": "ascending",
"optional": true,
"type": "Boolean"
}
],
"description": "Applies an ordering and limit to a given collection.",
"returns": "FeatureCollection",
"type": "Algorithm",
"hidden": false
},
"GeometryConstructors.MultiPoint": {
"args": [
{
"description": "The list of Points or pairs of Numbers in x,y order.",
"name": "coordinates",
"type": "List<Object>"
},
{
"default": null,
"description": "The coordinate reference system of the coordinates. The default is the projection of the inputs, where Numbers are assumed to be EPSG:4326.",
"name": "crs",
"optional": true,
"type": "Projection"
}
],
"description": "Constructs a MultiPoint from the given coordinates.",
"returns": "Geometry",
"type": "Algorithm",
"hidden": false
},
"Geometry.type": {
"args": [
{
"name": "geometry",
"type": "Geometry"
}
],
"description": "Returns the GeoJSON type of the geometry.",
"returns": "String",
"type": "Algorithm",
"hidden": false
},
"Collection": {
"args": [
{
"description": "The features comprising the collection.",
"name": "features",
"type": "List<Element>"
}
],
"description": "Returns a Collection containing the specified features.",
"returns": "FeatureCollection",
"type": "Algorithm",
"hidden": false
},
"Kernel.octagon": {
"args": [
{
"description": "The radius of the kernel to generate.",
"name": "radius",
"type": "Float"
},
{
"default": "pixels",
"description": "The system of measurement for the kernel ('pixels' or 'meters'). If the kernel is specified in meters, it will resize when the zoom-level is changed.",
"name": "units",
"optional": true,
"type": "String"
},
{
"default": true,
"description": "Normalize the kernel values to sum to 1.",
"name": "normalize",
"optional": true,
"type": "Boolean"
},
{
"default": 1.0,
"description": "Scale each value by this amount.",
"name": "magnitude",
"optional": true,
"type": "Float"
}
],
"description": "Generates an octagon-shaped boolean kernel.",
"returns": "Kernel",
"type": "Algorithm",
"hidden": false
},
"Dictionary": {
"args": [
{
"default": null,
"description": "An object to convert to a dictionary. Either a JSON dictionary or a list of alternating key/value pairs. Keys must be strings.",
"name": "input",
"optional": true,
"type": "Object"
}
],
"description": "Constructs a dictionary.",
"returns": "Dictionary<Object>",
"type": "Algorithm",
"hidden": false
},
"Reducer.autoHistogram": {
"args": [
{
"default": null,
"description": "The maximum number of buckets to use when building a histogram; will be rounded up to a power of 2.",
"name": "maxBuckets",
"optional": true,
"type": "Integer"
},
{
"default": null,
"description": "The minimum histogram bucket width, or null to allow any power of 2.",
"name": "minBucketWidth",
"optional": true,
"type": "Float"
},
{
"default": null,
"description": "The number of values to accumulate before building the initial histogram.",
"name": "maxRaw",
"optional": true,
"type": "Integer"
}
],
"description": "Create a reducer that will compute a histogram of the inputs. The output is a Nx2 array of the lower bucket bounds and the counts of each bucket, and is suitable for use per-pixel.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Image.clipToCollection": {
"args": [
{
"description": "The image to clip.",
"name": "input",
"type": "Image<unknown bands>"
},
{
"description": "The FeatureCollection to clip to.",
"name": "collection",
"type": "Object"
}
],
"description": "Clips an image to a FeatureCollection. The output bands correspond exactly the input bands, except data not covered by the geometry of at least one feature from the collection is masked. The output image retains the metadata of the input image.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Filter.never": {
"args": [],
"description": "Simple filter NEVER.",
"returns": "Filter",
"type": "Algorithm",
"hidden": true
},
"Image.pointMatch": {
"args": [
{
"description": "The image containing the point to align.",
"name": "templateImage",
"type": "Image<unknown bands>"
},
{
"name": "searchImage",
"type": "Image<unknown bands>"
},
{
"name": "x",
"type": "Integer"
},
{
"name": "y",
"type": "Integer"
},
{
"name": "proj",
"type": "Projection"
},
{
"name": "maxOffset",
"type": "Integer"
},
{
"default": null,
"name": "templateBandNames",
"optional": true,
"type": "List<String>"
},
{
"default": null,
"name": "searchBandNames",
"optional": true,
"type": "List<String>"
},
{
"default": 15,
"name": "windowSize",
"optional": true,
"type": "Integer"
},
{
"default": 0,
"name": "expectedXOffset",
"optional": true,
"type": "Integer"
},
{
"default": 0,
"name": "expectedYOffset",
"optional": true,
"type": "Integer"
},
{
"default": 1,
"name": "maxResults",
"optional": true,
"type": "Integer"
},
{
"default": 0.0,
"name": "maxMaskedFrac",
"optional": true,
"type": "Float"
}
],
"description": "Wraps correlation as an algorithm so that single points may be matched, and the results will be cached. An image patch from the templateImage at (x, y) is correlated with multiple patches in the searchImage over a search window, and a set of the best offsets with scores is returned. ",
"returns": "Object",
"type": "Algorithm",
"hidden": true
},
"Element.set": {
"args": [
{
"description": "The object on which to set the property.",
"name": "object",
"type": "Element"
},
{
"description": "The name of the property to set.",
"name": "key",
"type": "String"
},
{
"default": null,
"description": "The new value of the property.",
"name": "value",
"optional": true,
"type": "Object"
}
],
"description": "Overrides a metadata property of an object.",
"returns": "Element",
"type": "Algorithm",
"hidden": false
},
"Element.copyProperties": {
"args": [
{
"default": null,
"description": "The object whose properties to override.",
"name": "destination",
"optional": true,
"type": "Element"
},
{
"default": null,
"description": "The object from which to copy the properties.",
"name": "source",
"optional": true,
"type": "Element"
},
{
"default": null,
"description": "The properties to copy. If omitted, all ordinary (i.e. non-system) properties are copied.",
"name": "properties",
"optional": true,
"type": "List<String>"
},
{
"default": null,
"description": "The list of properties to exclude when copying all properties. Must not be specified if properties is.",
"name": "exclude",
"optional": true,
"type": "List<String>"
}
],
"description": "Copies metadata properties from one element to another.",
"returns": "Element",
"type": "Algorithm",
"hidden": false
},
"List.get": {
"args": [
{
"name": "list",
"type": "List<Object>"
},
{
"name": "index",
"type": "Integer"
}
],
"description": "Returns the element at the specified position in list. A negative index counts backwards from the end of the list.",
"returns": "Object",
"type": "Algorithm",
"hidden": false
},
"Landsat.simpleComposite": {
"args": [
{
"description": "The raw Landsat ImageCollection to composite.",
"name": "collection",
"type": "ImageCollection"
},
{
"default": 50,
"description": "The percentile value to use when compositing each band.",
"name": "percentile",
"optional": true,
"type": "Integer"
},
{
"default": 10,
"description": "The size of the range of cloud scores to accept per pixel.",
"name": "cloudScoreRange",
"optional": true,
"type": "Integer"
},
{
"default": 40,
"description": "An approximate limit on the maximum number of scenes used to compute each pixel.",
"name": "maxDepth",
"optional": true,
"type": "Integer"
},
{
"default": false,
"description": "If true, output bands are in the same units as the Landsat.TOA algorithm; if false, TOA values are converted to uint8 by multiplying by 255 (reflective bands) or subtracting 100 (thermal bands) and rounding to the nearest integer.",
"name": "asFloat",
"optional": true,
"type": "Boolean"
}
],
"description": "Computes a Landsat TOA composite from a collection of raw Landsat scenes. It applies standard TOA calibration and then assigns a cloud score to each pixel using the SimpleLandsatCloudScore algorithm. It selects the lowest possible range of cloud scores at each point and then computes per-band percentile values from the accepted pixels. This algorithm also uses the LandsatPathRowLimit algorithm to select only the least-cloudy scenes in regions where more than maxDepth input scenes are available.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"PixelType": {
"args": [
{
"description": "The pixel precision, one of 'int', 'float', or 'double'.",
"name": "precision",
"type": "Object"
},
{
"default": null,
"description": "The minimum value of pixels of this type. If precision is 'float' or 'double', this can be null, signifying negative infinity.",
"name": "minValue",
"optional": true,
"type": "Number"
},
{
"default": null,
"description": "The maximum value of pixels of this type. If precision is 'float' or 'double', this can be null, signifying positive infinity.",
"name": "maxValue",
"optional": true,
"type": "Number"
},
{
"default": 0,
"description": "The number of dimensions in which pixels of this type can vary; 0 is a scalar, 1 is a vector, 2 is a matrix, etc.",
"name": "dimensions",
"optional": true,
"type": "Integer"
}
],
"description": "Returns a PixelType of the given precision with the given limits per element, and an optional dimensionality.",
"returns": "PixelType",
"type": "Algorithm",
"hidden": false
},
"Image.bitwise_and": {
"args": [
{
"description": "The image from which the left operand bands are taken.",
"name": "image1",
"type": "Image<unknown bands>"
},
{
"description": "The image from which the right operand bands are taken.",
"name": "image2",
"type": "Image<unknown bands>"
}
],
"description": "Calculates the bitwise AND of the input values for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is the union of the input types.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Reducer.toList": {
"args": [
{
"default": null,
"description": "The size of each output tuple, or null for no grouping. Also determines the number of inputs (null tupleSize has 1 input).",
"name": "tupleSize",
"optional": true,
"type": "Integer"
},
{
"default": 0,
"description": "The last numOptional inputs will be considered optional; the other inputs must be non-null or the input tuple will be dropped.",
"name": "numOptional",
"optional": true,
"type": "Integer"
}
],
"description": "Creates a reducer that collects its inputs into a list, optionally grouped into tuples.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Image.exp": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Computes the Euler's number e raised to the power of the input.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.multiply": {
"args": [
{
"description": "The image from which the left operand bands are taken.",
"name": "image1",
"type": "Image<unknown bands>"
},
{
"description": "The image from which the right operand bands are taken.",
"name": "image2",
"type": "Image<unknown bands>"
}
],
"description": "Multiplies the first value by the second for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is the union of the input types.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Kernel.cross": {
"args": [
{
"description": "The radius of the kernel to generate.",
"name": "radius",
"type": "Float"
},
{
"default": "pixels",
"description": "The system of measurement for the kernel ('pixels' or 'meters'). If the kernel is specified in meters, it will resize when the zoom-level is changed.",
"name": "units",
"optional": true,
"type": "String"
},
{
"default": true,
"description": "Normalize the kernel values to sum to 1.",
"name": "normalize",
"optional": true,
"type": "Boolean"
},
{
"default": 1.0,
"description": "Scale each value by this amount.",
"name": "magnitude",
"optional": true,
"type": "Float"
}
],
"description": "Generates a cross-shaped boolean kernel.",
"returns": "Kernel",
"type": "Algorithm",
"hidden": false
},
"Reducer.firstNonNull": {
"args": [],
"description": "Returns a Reducer that returns the first of its non-null inputs.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Reducer.bitwiseOr": {
"args": [],
"description": "Returns a Reducer that computes the bitwise-or summation of its inputs.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Reducer.stdDev": {
"args": [],
"description": "Returns a Reducer that computes the standard deviation of its inputs.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Element.propertyNames": {
"args": [
{
"name": "element",
"type": "Element"
}
],
"description": "Returns the names of properties on this element.",
"returns": "List<String>",
"type": "Algorithm",
"hidden": false
},
"Filter.lessThan": {
"args": [
{
"default": null,
"description": "A selector for the left operand. Should not be specified if leftValue is specified.",
"name": "leftField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the right operand. Should not be specified if rightField is specified.",
"name": "rightValue",
"optional": true,
"type": "Object"
},
{
"default": null,
"description": "A selector for the right operand. Should not be specified if rightValue is specified.",
"name": "rightField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the left operand. Should not be specified if leftField is specified.",
"name": "leftValue",
"optional": true,
"type": "Object"
}
],
"description": "Creates a unary or binary filter that passes if the left operand is less than the right operand.",
"returns": "Filter",
"type": "Algorithm",
"hidden": false
},
"Image.bitsToArrayImage": {
"args": [
{
"description": "Input image.",
"name": "input",
"type": "Image<unknown bands>"
}
],
"description": "Turns the bits of an integer into a 1-D array. The array has a lengthup to the highest 'on' bit in the input.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.toByte": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Casts the input value to an unsigned 8-bit integer.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.matrixInverse": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Computes the inverse of the matrix.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"String.index": {
"args": [
{
"description": "The string to search.",
"name": "target",
"type": "String"
},
{
"description": "The string to find.",
"name": "pattern",
"type": "String"
}
],
"description": "Searches a string for the first occurrence of a substring. Returns the index of the first match, or -1.",
"returns": "Integer",
"type": "Algorithm",
"hidden": false
},
"Image.cast": {
"args": [
{
"description": "The image to cast.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"description": "A dictionary from band name to band types. Types can be PixelTypes or strings. The valid strings are: 'int8', 'int16', 'int32', 'int64', 'uint8', 'uint16', 'uint32', 'byte', 'short', 'int', 'long', 'float' and 'double'. If bandTypes includes bands that are not already in the input image, they will be added to the image as transparent bands. If bandOrder isn't also specified, new bands will be appended in alphabetical order.",
"name": "bandTypes",
"type": "Dictionary<Object>"
},
{
"default": null,
"description": "A list specifying the order of the bands in the result. If specified, must match the full list of bands in the result.",
"name": "bandOrder",
"optional": true,
"type": "List<String>"
}
],
"description": "Casts some or all bands of an image to the specified types.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.Segmentation.KMeans": {
"args": [
{
"description": "The input image for clustering.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"default": 8,
"description": "Number of clusters.",
"name": "numClusters",
"optional": true,
"type": "Integer"
},
{
"default": 20,
"description": "Number of iterations.",
"name": "numIterations",
"optional": true,
"type": "Integer"
},
{
"default": 0,
"description": "Neighborhood size. The amount to extend each tile (overlap) when computing the clusters. This option is mutually exclusive with gridSize.",
"name": "neighborhoodSize",
"optional": true,
"type": "Integer"
},
{
"default": null,
"description": "Grid cell-size. If greater than 0, kMeans will be run independently on cells of this size. This has the effect of limiting the size of any cluster to be gridSize or smaller. This option is mutually exclusive with neighborhoodSize.",
"name": "gridSize",
"optional": true,
"type": "Integer"
},
{
"default": false,
"description": "If true, an error is thrown if convergence is not achieved before numIterations.",
"name": "forceConvergence",
"optional": true,
"type": "Boolean"
},
{
"default": true,
"description": "If true, clusters are assigned unique IDs. Otherwise, they repeat per tile or grid cell.",
"name": "uniqueLabels",
"optional": true,
"type": "Boolean"
}
],
"description": "Performs K-Means clustering on the input image. Outputs a 1-band image containing the ID of the cluster that each pixel belongs to. The algorithm can work either on a fixed grid of non-overlapping cells (gridSize, which can be smaller than a tile) or on tiles with overlap (neighborhoodSize). The default is to use tiles with no overlap. Clusters in one cell or tile are unrelated to clusters in another. Any cluster that spans a cell or tile boundary may receive two different labels in the two halves. Any input pixels with partial masks are fully masked in the output.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Array.gt": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Array"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Array"
}
],
"description": "On an element-wise basis, returns 1 iff the first value is greater than the second.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Reducer.kurtosis": {
"args": [],
"description": "Returns a Reducer that Computes the kurtosis of its inputs.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"List.zip": {
"args": [
{
"name": "list",
"type": "List<Object>"
},
{
"name": "other",
"type": "List<Object>"
}
],
"description": "Pairs the elements of two lists to create a list of two-element lists. When the input lists are of different sizes, the final list has the same size as the shortest one.",
"returns": "List<List<Object>>",
"type": "Algorithm",
"hidden": false
},
"Image.displace": {
"args": [
{
"description": "The image to warp.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"description": "An image containing displacement values. The first band is interpreted as the 'X' displacement and the second as the 'Y' displacement. Each displacement pixel is a [dx,dy] vector added to the pixel location to determine the corresponding pixel location in 'image'. Displacements are interpreted as meters in the default projection of the displacement image.",
"name": "displacement",
"type": "Image<unknown bands>"
},
{
"default": "bicubic",
"description": "The interpolation mode to use. One of 'nearest_neighbor', 'bilinear' or 'bicubic'.)",
"name": "mode",
"optional": true,
"type": "String"
}
],
"description": "Warps an image using an image of displacements.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Window.mode": {
"args": [
{
"description": "The image to which to apply the operations.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"default": 1.5,
"description": "The radius of the kernel to use.",
"name": "radius",
"optional": true,
"type": "Float"
},
{
"default": "circle",
"description": "The type of kernel to use. Options include: 'circle', 'square', 'cross', 'plus', octagon' and 'diamond'.",
"name": "kernelType",
"optional": true,
"type": "String"
},
{
"default": "pixels",
"description": "If a kernel is not specified, this determines whether the kernel is in meters or pixels.",
"name": "units",
"optional": true,
"type": "String"
},
{
"default": 1,
"description": "The number of times to apply the given kernel.",
"name": "iterations",
"optional": true,
"type": "Integer"
},
{
"default": null,
"description": "A custom kernel. If used, kernelType and radius are ignored.",
"name": "kernel",
"optional": true,
"type": "Kernel"
}
],
"description": "Applies a morphological reducer() filter to each band of an image using a named or custom kernel.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Dictionary.toImage": {
"args": [
{
"description": "The dictionary to convert.",
"name": "dictionary",
"type": "Dictionary<Object>"
},
{
"default": null,
"description": "The order of the output bands.",
"name": "names",
"optional": true,
"type": "List<String>"
}
],
"description": "Creates an image of constants from values in a dictionary. The bands of the image are ordered and named according to the names argument. If no names are specified, the bands are sorted alpha-numerically.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Number.bitwiseNot": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Calculates the bitwise NOT of the input, in the smallest signed integer type that can hold the input.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Reducer.anyNonZero": {
"args": [],
"description": "Returns a Reducer that returns 1 if any of its inputs are non-zero, 0 otherwise.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Image.remap": {
"args": [
{
"description": "The image to which the remapping is applied.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"description": "The source values (numbers or EEArrays). All values in this list will be mapped to the corresponding value in 'to'.",
"name": "from",
"type": "List<Object>"
},
{
"description": "The destination values (numbers or EEArrays). These are used to replace the corresponding values in 'from'. Must have the same number of values as 'from'.",
"name": "to",
"type": "List<Object>"
},
{
"default": null,
"description": "The default value to replace values that weren't matched by a value in 'from'. If not specified, unmatched values are masked out.",
"name": "defaultValue",
"optional": true,
"type": "Object"
},
{
"default": null,
"description": "The name of the band to remap. If not specified, the first band in the image is used.",
"name": "bandName",
"optional": true,
"type": "String"
}
],
"description": "Maps from input values to output values, represented by two parallel lists. Any input values not included in the input list are either set to defaultValue if it is given, or masked if it isn't. Note that inputs containing floating point values might sometimes fail to match due to floating point precision errors.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.changeProj": {
"args": [
{
"name": "input",
"type": "Image<unknown bands>"
},
{
"description": "The original projection.",
"name": "srcProj",
"type": "Projection"
},
{
"description": "The new projection.",
"name": "dstProj",
"type": "Projection"
}
],
"description": "Tweaks the projection of the input image, moving each pixel from its location in srcProj to the same coordinates in dstProj.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Filter.lessThanOrEquals": {
"args": [
{
"default": null,
"description": "A selector for the left operand. Should not be specified if leftValue is specified.",
"name": "leftField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the right operand. Should not be specified if rightField is specified.",
"name": "rightValue",
"optional": true,
"type": "Object"
},
{
"default": null,
"description": "A selector for the right operand. Should not be specified if rightValue is specified.",
"name": "rightField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the left operand. Should not be specified if leftField is specified.",
"name": "leftValue",
"optional": true,
"type": "Object"
}
],
"description": "Creates a unary or binary filter that passes unless the left operand is greater than the right operand.",
"returns": "Filter",
"type": "Algorithm",
"hidden": false
},
"Collection.union": {
"args": [
{
"description": "The collection being merged.",
"name": "collection",
"type": "FeatureCollection"
},
{
"default": null,
"description": "The maximum error allowed when performing any necessary reprojections. If not specified, defaults to the error margin requested from the output.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
}
],
"description": "Merges all geometries in a given collection into one and returns a collection containing a single feature with only an ID of 'union_result' and a geometry.",
"returns": "FeatureCollection",
"type": "Algorithm",
"hidden": false
},
"AggregateFeatureCollection.max": {
"args": [
{
"description": "The collection to aggregate over.",
"name": "collection",
"type": "FeatureCollection"
},
{
"description": "The property to use from each element of the collection.",
"name": "property",
"type": "String"
}
],
"description": "Aggregates over a given property of the objects in a collection, calculating the maximum of the values of the selected property.",
"returns": "Object",
"type": "Algorithm",
"hidden": false
},
"GeometryConstructors.MultiPolygon": {
"args": [
{
"description": "A list of Polygons, or for one simple polygon, a list of Points or pairs of Numbers in x,y order.",
"name": "coordinates",
"type": "List<Object>"
},
{
"default": null,
"description": "The coordinate reference system of the coordinates. The default is the projection of the inputs, where Numbers are assumed to be EPSG:4326.",
"name": "crs",
"optional": true,
"type": "Projection"
},
{
"default": null,
"description": "If false, edges are straight in the projection. If true, edges are curved to follow the shortest path on the surface of the Earth. The default is the geodesic state of the inputs, or true if the inputs are numbers.",
"name": "geodesic",
"optional": true,
"type": "Boolean"
},
{
"default": null,
"description": "Max error when input geometry must be reprojected to an explicitly requested result projection or geodesic state.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
},
{
"default": true,
"description": "If true, polygon interiors will be determined by the even/odd rule, where a point is inside if it crosses an odd number of edges to reach a point at infinity. Otherwise polygons use the left-inside rule, where interiors are on the left side of the shell's edges when walking the vertices in the given order.",
"name": "evenOdd",
"optional": true,
"type": "Boolean"
}
],
"description": "Constructs a MultiPolygon from the given coordinates.",
"returns": "Geometry",
"type": "Algorithm",
"hidden": false
},
"Number.rightShift": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Number"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Number"
}
],
"description": "Calculates the signed right shift of v1 by v2 bits.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Number.toInt64": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Casts the input value to a signed 64-bit integer.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Clusterer.TrainingContainer": {
"args": [
{
"name": "clusterer",
"type": "Clusterer"
}
],
"description": "INTERNAL",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": true
},
"ConfusionMatrix.producersAccuracy": {
"args": [
{
"name": "confusionMatrix",
"type": "ConfusionMatrix"
}
],
"description": "Computes the producer's accuracy of a confusion matrix defined as (correct / total) for each column.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Projection.crs": {
"args": [
{
"name": "projection",
"type": "Projection"
}
],
"description": "Returns the authority code (e.g. 'EPSG:4326') for the base coordinate system of this projection, or null if the base coordinate system is not found in any available database.",
"returns": "String",
"type": "Algorithm",
"hidden": false
},
"Image.abs": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Computes the absolute value of the input.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.bandNames": {
"args": [
{
"description": "The image from which to get band names.",
"name": "image",
"type": "Image<unknown bands>"
}
],
"description": "Returns a list containing the names of the bands of an image.",
"returns": "List<Object>",
"type": "Algorithm",
"hidden": false
},
"Image.clip": {
"args": [
{
"description": "The image to clip.",
"name": "input",
"type": "Image<unknown bands>"
},
{
"default": null,
"description": "The Geometry or Feature to clip to.",
"name": "geometry",
"optional": true,
"type": "Object"
}
],
"description": "Clips an image to a Geometry or Feature (use clipToCollection to clip an image to a FeatureCollection). The output bands correspond exactly the input bands, except data not covered by the geometry is masked. The output image retains the metadata of the input image.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Number.digamma": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Computes the digamma function of the input.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Number.max": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Number"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Number"
}
],
"description": "Selects the maximum of the first and second values.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Image.rgbToHsv": {
"args": [
{
"description": "The image to transform.",
"name": "image",
"type": "Image<unknown bands>"
}
],
"description": "Transforms the image from the RGB color space to the HSV color space. Produces three bands: hue, saturation and value, all floating point values in the range [0, 1].",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"ExtractRegion.AggregationContainer": {
"args": [
{
"name": "input",
"type": "ImageCollection"
},
{
"name": "proj",
"type": "Projection"
},
{
"name": "geom",
"type": "Geometry"
}
],
"description": "INTERNAL",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": true
},
"Projection.transform": {
"args": [
{
"name": "projection",
"type": "Projection"
}
],
"description": "Returns a WKT representation of the transform of this Projection. This is the transform that converts from projected coordinates to the base coordinate system.",
"returns": "String",
"type": "Algorithm",
"hidden": false
},
"Reducer.frequencyHistogram": {
"args": [],
"description": "Returns a Reducer that returns a (weighted) frequency table of its inputs.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Array.eq": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Array"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Array"
}
],
"description": "On an element-wise basis, returns 1 iff the first value is equal to the second.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"FeatureCollection.loadById": {
"args": [
{
"description": "The asset ID of the feature collection.",
"name": "id",
"type": "String"
},
{
"default": null,
"description": "The version of the asset. -1 signifies the latest version.",
"name": "version",
"optional": true,
"type": "Long"
}
],
"description": "Returns the feature collection given its ID.",
"returns": "FeatureCollection",
"type": "Algorithm",
"hidden": false
},
"Clusterer.train": {
"args": [
{
"description": "An input Clusterer.",
"name": "clusterer",
"type": "Clusterer"
},
{
"description": "The collection to train on.",
"name": "features",
"type": "FeatureCollection"
},
{
"default": null,
"description": "The list of property names to include as training data. Each feature must have all these properties, and their values must be numeric. This argument is optional if the input collection contains a 'band_order' property, (as produced by Image.sample).",
"name": "inputProperties",
"optional": true,
"type": "List<String>"
},
{
"default": 1.0,
"description": "An optional subsampling factor, within (0, 1].",
"name": "subsampling",
"optional": true,
"type": "Float"
},
{
"default": 0,
"description": "A randomization seed to use for subsampling.",
"name": "subsamplingSeed",
"optional": true,
"type": "Integer"
}
],
"description": "Trains the Clusterer on a collection of features, using the specified numeric properties of each feature as training data. The geometry of the features is ignored.",
"returns": "Clusterer",
"type": "Algorithm",
"hidden": false
},
"Image.rsedTransform": {
"args": [
{
"description": "The input image.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"default": 256,
"description": "Neighborhood size in pixels.",
"name": "neighborhood",
"optional": true,
"type": "Integer"
},
{
"default": "pixels",
"description": "The units of the neighborhood, currently only 'pixels' are supported.",
"name": "units",
"optional": true,
"type": "String"
}
],
"description": "Computes the 2D maximal height surface created by placing an inverted parabola over each non-zero pixel of the input image, where the pixel's value is the height of the parabola. Viewed as a binary image (zero/not-zero) this is equivalent to buffering each non-zero input pixel by the square root of its value, in pixels.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.reduceNeighborhood": {
"args": [
{
"description": "The input image.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"description": "The reducer to apply to pixels within the neighborhood.",
"name": "reducer",
"type": "Reducer"
},
{
"description": "The kernel defining the neighborhood.",
"name": "kernel",
"type": "Kernel"
},
{
"default": "kernel",
"description": "One of 'mask', 'kernel', or 'min'.",
"name": "inputWeight",
"optional": true,
"type": "String"
},
{
"default": true,
"description": "Mask output pixels if the corresponding input pixel is masked.",
"name": "skipMasked",
"optional": true,
"type": "Boolean"
},
{
"default": null,
"description": "Optimization strategy. Options are 'boxcar' and 'window'. The 'boxcar' method is a fast method for computing count, sum or mean. It requires a homogeneous kernel, a single-input reducer and either MASK, KERNEL or no weighting. The 'window' method uses a running window, and has the same requirements as 'boxcar', but can use any single input reducer. Both methods require considerable additional memory.",
"name": "optimization",
"optional": true,
"type": "String"
}
],
"description": "Applies the given reducer to the neighborhood around each pixel, as determined by the given kernel. If the reducer has a single input, it will be applied separately to each band of the collection; otherwise it must have the same number of inputs as the input image has bands.\nThe reducer output names determine the names of the output bands: reducers with multiple inputs will use the output names directly, while reducers with a single input will prefix the output name with the input band name (e.g. '10_mean', '20_mean', etc.).\nReducers with weighted inputs can have the input weight based on the input mask, the kernel value, or the smaller of those two.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Feature.distance": {
"args": [
{
"description": "The feature containing the geometry used as the left operand of the operation.",
"name": "left",
"type": "Element"
},
{
"description": "The feature containing the geometry used as the right operand of the operation.",
"name": "right",
"type": "Element"
},
{
"default": null,
"description": "The maximum amount of error tolerated when performing any necessary reprojection.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
},
{
"default": null,
"description": "The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.",
"name": "proj",
"optional": true,
"type": "Projection"
}
],
"description": "Returns the minimum distance between the geometries of two features.",
"returns": "Float",
"type": "Algorithm",
"hidden": false
},
"DateRange.intersects": {
"args": [
{
"name": "dateRange",
"type": "DateRange"
},
{
"name": "other",
"type": "DateRange"
}
],
"description": "Returns true if the given DateRange has at least one point in common with this DateRange.",
"returns": "Boolean",
"type": "Algorithm",
"hidden": false
},
"Array.matrixCholeskyDecomposition": {
"args": [
{
"description": "The array to decompose.",
"name": "array",
"type": "Array"
}
],
"description": "Calculates the Cholesky decomposition of a matrix. The Cholesky decomposition is a decomposition into the form L*L' where L is a lower triangular matrix. The input must be a symmetric positive-definite matrix. Returns a dictionary with 1 entry named 'L'.",
"returns": "Dictionary<Object>",
"type": "Algorithm",
"hidden": false
},
"Image.derivative": {
"args": [
{
"description": "The input image.",
"name": "image",
"type": "Image<unknown bands>"
}
],
"description": "Computes the X and Y discrete derivatives for each band in the input image, in pixel coordinates.\nFor each band of the input image, the output image will have two bands named with the suffixes '_x' and '_y', containing the respective derivatives.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Geometry.cutLines": {
"args": [
{
"description": "Cuts the lines of this geometry.",
"name": "geometry",
"type": "Geometry"
},
{
"description": "Distances along each LineString to cut the line into separate pieces, measured in units of the given proj, or meters if proj is unspecified.",
"name": "distances",
"type": "List<Float>"
},
{
"default": null,
"description": "The maximum amount of error tolerated when performing any necessary reprojection.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
},
{
"default": null,
"description": "Projection of the result and distance measurements, or WGS84 if unspecified.",
"name": "proj",
"optional": true,
"type": "Projection"
}
],
"description": "Converts LineStrings into a MultiLineString by cutting it in two at each distance along the length of the LineString.",
"returns": "Geometry",
"type": "Algorithm",
"hidden": false
},
"Array.max": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Array"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Array"
}
],
"description": "On an element-wise basis, selects the maximum of the first and second values.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Image.add": {
"args": [
{
"description": "The image from which the left operand bands are taken.",
"name": "image1",
"type": "Image<unknown bands>"
},
{
"description": "The image from which the right operand bands are taken.",
"name": "image2",
"type": "Image<unknown bands>"
}
],
"description": "Adds the first value to the second for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is the union of the input types.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.arrayMask": {
"args": [
{
"description": "Array image to mask.",
"name": "input",
"type": "Image<unknown bands>"
},
{
"description": "Array image to mask with.",
"name": "mask",
"type": "Image<unknown bands>"
}
],
"description": "Creates an array image where each array-valued pixel is masked with another array-valued pixel, retaining only the elements where the mask is non-zero. If the mask image has one band it will be applied to all the bands of 'input', otherwise they must have the same number of bands.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Geometry.intersects": {
"args": [
{
"description": "The geometry used as the left operand of the operation.",
"name": "left",
"type": "Geometry"
},
{
"description": "The geometry used as the right operand of the operation.",
"name": "right",
"type": "Geometry"
},
{
"default": null,
"description": "The maximum amount of error tolerated when performing any necessary reprojection.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
},
{
"default": null,
"description": "The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.",
"name": "proj",
"optional": true,
"type": "Projection"
}
],
"description": "Returns true iff the geometries intersect.",
"returns": "Boolean",
"type": "Algorithm",
"hidden": false
},
"Array.matrixDeterminant": {
"args": [
{
"description": "The array to compute on.",
"name": "input",
"type": "Array"
}
],
"description": "Computes the determinant of the matrix.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Clusterer.wekaLVQ": {
"args": [
{
"default": 7,
"description": "The number of clusters.",
"name": "numClusters",
"optional": true,
"type": "Integer"
},
{
"default": 1.0,
"description": "The learning rate for the training algorithm. (Value should be greaterthan 0 and less or equal to 1).",
"name": "learningRate",
"optional": true,
"type": "Float"
},
{
"default": 1000,
"description": "Number of training epochs. (Value should be greater than or equal to 1).",
"name": "epochs",
"optional": true,
"type": "Integer"
},
{
"default": false,
"description": "Skip normalizing the attributes.",
"name": "normalizeInput",
"optional": true,
"type": "Boolean"
}
],
"description": "A Clusterer that implements the Learning Vector Quantization algorithm. For more details, see:\nT. Kohonen, \"Learning Vector Quantization\", The Handbook of Brain Theory and Neural Networks, 2nd Edition, MIT Press, 2003, pp. 631-634.",
"returns": "Clusterer",
"type": "Algorithm",
"hidden": false
},
"Image.reduceConnectedComponents": {
"args": [
{
"description": "The input image.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"description": "The reducer to apply to pixels within the connected component.",
"name": "reducer",
"type": "Reducer"
},
{
"default": null,
"description": "The name of the band to use to detect connectedness. If unspecified, the first band is used.",
"name": "labelBand",
"optional": true,
"type": "String"
},
{
"default": 256,
"description": "Size of the neighborhood to consider when aggregating values. Any objects larger than maxSize in either the horizontal or vertical dimension will be masked, since portions of the object might be outside of the neighborhood.",
"name": "maxSize",
"optional": true,
"type": "Integer"
}
],
"description": "Applies a reducer to all of the pixels inside of each 'object'. Pixels are considered to belong to an object if they are connected (8-way) and have the same value in the 'label' band. The label band is only used to identify the connectedness; the rest are provided as inputs to the reducer.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Number.bitwise_and": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Number"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Number"
}
],
"description": "Calculates the bitwise AND of the input values.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Number.right_shift": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Number"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Number"
}
],
"description": "Calculates the signed right shift of v1 by v2 bits.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Number.divide": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Number"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Number"
}
],
"description": "Divides the first value by the second, returning 0 for division by 0.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Kernel.compass": {
"args": [
{
"default": 1.0,
"description": "Scale each value by this amount.",
"name": "magnitude",
"optional": true,
"type": "Float"
},
{
"default": false,
"description": "Normalize the kernel values to sum to 1.",
"name": "normalize",
"optional": true,
"type": "Boolean"
}
],
"description": "Generates a 3x3 Prewitt's Compass edge-detection kernel.",
"returns": "Kernel",
"type": "Algorithm",
"hidden": false
},
"Image.arrayCat": {
"args": [
{
"description": "First array image to concatenate.",
"name": "image1",
"type": "Image<unknown bands>"
},
{
"description": "Second array image to concatenate.",
"name": "image2",
"type": "Image<unknown bands>"
},
{
"description": "Axis to concatenate along.",
"name": "axis",
"type": "Integer"
}
],
"description": "Creates an array image by concatenating each array pixel along the given axis in each band.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Number.format": {
"args": [
{
"description": "The number to convert to a string.",
"name": "number",
"type": "Number"
},
{
"default": "%s",
"description": "A printf-style format string. For example, '%.2f' produces numbers formatted like '3.14', and '%05d' produces numbers formatted like '00042'. The format string must satisfy the following criteria:\n1. Zero or more prefix characters.\n2. Exactly one '%'.\n3. Zero or more modifier characters in the set [#-+ 0,(.\\d].\n4. Exactly one conversion character in the set [sdoxXeEfgGaA].\n5. Zero or more suffix characters.\n \nFor more about format strings, see https://docs.oracle.com/javase/7/docs/api/java/util/Formatter.html",
"name": "pattern",
"optional": true,
"type": "String"
}
],
"description": "Convert a number to a string using printf-style formatting.",
"returns": "String",
"type": "Algorithm",
"hidden": false
},
"HillShadow": {
"args": [
{
"description": "The image to which to apply the shadow algorithm, in whicheach pixel should represent an elevation in meters.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"description": "Azimuth in degrees.",
"name": "azimuth",
"type": "Float"
},
{
"description": "Zenith in degrees.",
"name": "zenith",
"type": "Float"
},
{
"default": 0,
"description": "Neighborhood size.",
"name": "neighborhoodSize",
"optional": true,
"type": "Integer"
},
{
"default": false,
"description": "Use hysteresis. Less physically accurate, but may generate better images.",
"name": "hysteresis",
"optional": true,
"type": "Boolean"
}
],
"description": "Creates a shadow band, with output 1 where pixels are illumunated and 0 where they are shadowed. Takes as input an elevation band, azimuth and zenith of the light source in degrees, a neighborhood size, and whether or not to apply hysteresis when a shadow appears. Currently, this algorithm only works for Mercator projections, in which light rays are parallel.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.pixelLonLat": {
"args": [],
"description": "Creates an image with two bands named 'longitude' and 'latitude', containing the longitude and latitude at each pixel, in degrees.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.gammainc": {
"args": [
{
"description": "The image from which the left operand bands are taken.",
"name": "image1",
"type": "Image<unknown bands>"
},
{
"description": "The image from which the right operand bands are taken.",
"name": "image2",
"type": "Image<unknown bands>"
}
],
"description": "Calculates the regularized lower incomplete Gamma function γ(x,a) for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is float.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"ImageCollection.load": {
"args": [
{
"description": "The asset ID of the image collection.",
"name": "id",
"type": "String"
},
{
"default": null,
"description": "The version of the asset. -1 signifies the latest version.",
"name": "version",
"optional": true,
"type": "Long"
}
],
"description": "Returns the image collection given its ID.",
"returns": "ImageCollection",
"type": "Algorithm",
"hidden": false
},
"Collection.remap": {
"args": [
{
"description": "The collection to be modified.",
"name": "collection",
"type": "FeatureCollection"
},
{
"description": "The input mapping values. Restricted to strings and integers.",
"name": "lookupIn",
"type": "List<Object>"
},
{
"description": "The output mapping values. Must be the same size as lookupIn.",
"name": "lookupOut",
"type": "List<Integer>"
},
{
"description": "The name of the property to remap.",
"name": "columnName",
"type": "String"
}
],
"description": "Remaps the value of a specific property in a collection. Takes two parallel lists and maps values found in one to values in the other. Any element with a value that is not specified in the first list is dropped from the output collection.",
"returns": "FeatureCollection",
"type": "Algorithm",
"hidden": false
},
"Array.eigen": {
"args": [
{
"description": "A square, 2D array from which to compute the eigenvalue decomposition.",
"name": "input",
"type": "Array"
}
],
"description": "Computes the real eigenvectors and eigenvalues of a square 2D array of A rows and A columns. Returns an array with A rows and A+1 columns, where each row contains an eigenvalue in the first column, and the corresponding eigenvector in the remaining A columns. The rows are sorted by eigenvalue, in descending order.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Number.toInt16": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Casts the input value to a signed 16-bit integer.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Reducer.sampleStdDev": {
"args": [],
"description": "Returns a Reducer that computes the sample standard deviation of its inputs.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Array.bitwiseAnd": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Array"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Array"
}
],
"description": "On an element-wise basis, calculates the bitwise AND of the input values.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Image.spectralDilation": {
"args": [
{
"description": "The input image.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"default": "sam",
"description": "The spectral distance metric to use. One of 'sam' (spectral angle mapper), 'sid' (spectral information divergence), 'sed' (squared euclidean distance), or 'emd' (earth movers distance).",
"name": "metric",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "Connectedness kernel. Defaults to a square of radius 1 (8-way connected).",
"name": "kernel",
"optional": true,
"type": "Kernel"
},
{
"default": false,
"description": "If true, distances are computed from the mean of all pixels under the kernel instead of the kernel's center pixel.",
"name": "useCentroid",
"optional": true,
"type": "Boolean"
}
],
"description": "Computes the spectral/spatial dilation of an image by computing the spectral distance of each pixel under a structuring kernel from the centroid of all pixels under the kernel and taking the most distant result. See 'Spatial/spectral endmember extraction by multidimensional morphological operations.' IEEE transactions on geoscience and remote sensing 40.9 (2002): 2025-2041.\n",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Reducer.count": {
"args": [],
"description": "Returns a Reducer that computes the number of non-null inputs.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Number.left_shift": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Number"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Number"
}
],
"description": "Calculates the left shift of v1 by v2 bits.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Image.matrixMultiply": {
"args": [
{
"description": "The image from which the left operand bands are taken.",
"name": "image1",
"type": "Image<unknown bands>"
},
{
"description": "The image from which the right operand bands are taken.",
"name": "image2",
"type": "Image<unknown bands>"
}
],
"description": "Returns the matrix multiplication A*B for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is the union of the input types.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Kernel.circle": {
"args": [
{
"description": "The radius of the kernel to generate.",
"name": "radius",
"type": "Float"
},
{
"default": "pixels",
"description": "The system of measurement for the kernel ('pixels' or 'meters'). If the kernel is specified in meters, it will resize when the zoom-level is changed.",
"name": "units",
"optional": true,
"type": "String"
},
{
"default": true,
"description": "Normalize the kernel values to sum to 1.",
"name": "normalize",
"optional": true,
"type": "Boolean"
},
{
"default": 1.0,
"description": "Scale each value by this amount.",
"name": "magnitude",
"optional": true,
"type": "Float"
}
],
"description": "Generates a circle-shaped boolean kernel.",
"returns": "Kernel",
"type": "Algorithm",
"hidden": false
},
"Dictionary.keys": {
"args": [
{
"name": "dictionary",
"type": "Dictionary<Object>"
}
],
"description": "Retrieve the keys of a dictionary as a list. The keys will be sorted in natural order.",
"returns": "List<String>",
"type": "Algorithm",
"hidden": false
},
"Classifier.schema": {
"args": [
{
"name": "classifier",
"type": "Classifier"
}
],
"description": "Returns the names of the inputs used by this classifier, or null if this classifier has not had any training data added yet.",
"returns": "List<String>",
"type": "Algorithm",
"hidden": false
},
"Terrain.products": {
"args": [
{
"description": "An elevation image, in meters.",
"name": "input",
"type": "Image<unknown bands>"
}
],
"description": "Calculates slope, aspect, and a simple hillshade from a terrain DEM.\n\nExpects an image containing either a single band of elevation, measured in meters, or if there's more than one band, one named 'elevation'. Adds output bands named 'slope' and 'aspect' measured in degrees plus an unsigned byte output band named 'hillshade' for visualization. All other bands and metadata are copied from the input image. The local gradient is computed using the 4-connected neighbors of each pixel, so missing values will occur around the edges of an image.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Array.erfcInv": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, computes the inverse complementary error function of the input.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"reduce.min": {
"args": [
{
"description": "The image collection to reduce.",
"name": "collection",
"type": "ImageCollection"
}
],
"description": "Reduces an image collection by calculating the minimum value of each pixel across the stack of all matching bands. Bands are matched by name.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.int16": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Casts the input value to a signed 16-bit integer.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Feature.symmetricDifference": {
"args": [
{
"description": "The feature containing the geometry used as the left operand of the operation. The properties of the result will be copied from this object.",
"name": "left",
"type": "Element"
},
{
"description": "The feature containing the geometry used as the right operand of the operation. The properties of this object are ignored.",
"name": "right",
"type": "Element"
},
{
"default": null,
"description": "The maximum amount of error tolerated when performing any necessary reprojection.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
},
{
"default": null,
"description": "The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.",
"name": "proj",
"optional": true,
"type": "Projection"
}
],
"description": "Returns a feature containing the symmetric difference between geometries of two features.",
"returns": "Feature",
"type": "Algorithm",
"hidden": false
},
"Image.neighborhoodToBands": {
"args": [
{
"description": "The image to get pixels from.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"description": "The kernel specifying the neighborhood. Zero-weight values are ignored.",
"name": "kernel",
"type": "Kernel"
}
],
"description": "Turn the neighborhood of a pixel into a set of bands. The neighborhood is specified using a Kernel, and only non-zero-weight kernel values are used. The weights of the kernel is otherwise ignored.\n\nEach input band produces x * y output bands. Each output band is named 'input_x_y' where x and y indicate the pixel's location in the kernel. For example, a 3x3 kernel operating on a 2-band image produces 18 output bands.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Collection.reduceToImage": {
"args": [
{
"description": "Feature collection to intersect with each output pixel.",
"name": "collection",
"type": "FeatureCollection"
},
{
"description": "Properties to select from each feature and pass into the reducer.",
"name": "properties",
"type": "List<String>"
},
{
"description": "A Reducer to combine the properties of each intersecting feature into a final result to store in the pixel.",
"name": "reducer",
"type": "Reducer"
}
],
"description": "Creates an image from a feature collection by applying a reducer over the selected properties of all the features that intersect each pixel.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"reduce.sum": {
"args": [
{
"description": "The image collection to reduce.",
"name": "collection",
"type": "ImageCollection"
}
],
"description": "Reduces an image collection by calculating the sum of all values at each pixel across the stack of all matching bands. Bands are matched by name.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"TypedImageCollection.Constructor": {
"args": [
{
"name": "collection",
"type": "ImageCollection"
},
{
"name": "bandNames",
"type": "List<String>"
},
{
"name": "bandTypes",
"type": "List<PixelType>"
}
],
"description": "INTERNAL",
"returns": "Object",
"type": "Algorithm",
"hidden": true
},
"Reducer.max": {
"args": [
{
"default": 1,
"description": "The number of inputs.",
"name": "numInputs",
"optional": true,
"type": "Integer"
}
],
"description": "Creates a reducer that outputs the maximum value of its (first) input. If numInputs is greater than one, also outputs the corresponding values of the additional inputs.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Image.slice": {
"args": [
{
"description": "The image from which to select bands.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"description": "Where to start the selection. Negative numbers select from the end, counting backwards.",
"name": "start",
"type": "Integer"
},
{
"default": null,
"description": "Where to end the selection. If omitted, selects all bands from the start position to the end.",
"name": "end",
"optional": true,
"type": "Integer"
}
],
"description": "Selects a contiguous group of bands from an image by position.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"SelectorSet": {
"args": [
{
"name": "paths",
"type": "Object"
}
],
"description": "Returns a SelectorSet for a list of selector paths.",
"returns": "SelectorSet",
"type": "Algorithm",
"hidden": false
},
"AggregateFeatureCollection.total_var": {
"args": [
{
"description": "The collection to aggregate over.",
"name": "collection",
"type": "FeatureCollection"
},
{
"description": "The property to use from each element of the collection.",
"name": "property",
"type": "String"
}
],
"description": "Aggregates over a given property of the objects in a collection, calculating the total variance of the values of the selected property.",
"returns": "Object",
"type": "Algorithm",
"hidden": false
},
"Number.bitwise_or": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Number"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Number"
}
],
"description": "Calculates the bitwise OR of the input values.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Array.round": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, computes the integer nearest to the input.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"String.match": {
"args": [
{
"description": "The string in which to search.",
"name": "input",
"type": "String"
},
{
"description": "The regular expression to match.",
"name": "regex",
"type": "String"
},
{
"default": "",
"description": "A string specifying a combination of regular expression flags, specifically one or more of: 'g' (global match) or 'i' (ignore case)",
"name": "flags",
"optional": true,
"type": "String"
}
],
"description": "Matches a string against a regular expression. Returns a list of matching strings.",
"returns": "List<String>",
"type": "Algorithm",
"hidden": false
},
"Number.toInt32": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Casts the input value to a signed 32-bit integer.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Image.sldStyle": {
"args": [
{
"description": "The image to rendering using the SLD.",
"name": "input",
"type": "Image<unknown bands>"
},
{
"description": "The OGC SLD 1.0 or 1.1 document (or fragment).",
"name": "sldXml",
"type": "String"
}
],
"description": "Styles a raster input with the provided OGC SLD styling.\n\nPoints of note:\n * OGC SLD 1.0 and OGC SE 1.1 are supported.\n * The XML document passed in can be complete, or just the SldRasterSymbolizer element and down.\n * Exactly one SldRasterSymbolizer is required.\n * Bands may be selected by their proper EarthEngine names or using numeric identifiers (\"1\", \"2\", ...). Proper EarthEngine names are tried first.\n * The Histogram and Normalize contrast stretch mechanisms are supported.\n * The type=\"values\", type=\"intervals\" and type=\"ramp\" attributes for ColorMap element in SLD 1.0 (GeoServer extensions) are\n supported.\n * Opacity is only taken into account when it is 0.0 (transparent). Non-zero opacity values are treated as completely opaque.\n * The OverlapBehavior definition is currently ignored.\n * The ShadedRelief mechanism is not currently supported.\n * The ImageOutline mechanism is not currently supported.\n * The Geometry element is ignored.\n\nThe output image will have histogram_bandname metadata if histogram equalization or normalization is requested.\n",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Feature.dissolve": {
"args": [
{
"description": "The feature the geometry of which is being unioned.",
"name": "feature",
"type": "Element"
},
{
"default": null,
"description": "The maximum amount of error tolerated when performing any necessary reprojection.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
},
{
"default": null,
"description": "If specified, the union will be performed in this projection. Otherwise it will be performed in a spherical coordinate system.",
"name": "proj",
"optional": true,
"type": "Projection"
}
],
"description": "Returns a feature containing the union of the geometry of a feature. This leaves single geometries untouched, and unions multi geometries.",
"returns": "Element",
"type": "Algorithm",
"hidden": false
},
"Feature.intersection": {
"args": [
{
"description": "The feature containing the geometry used as the left operand of the operation. The properties of the result will be copied from this object.",
"name": "left",
"type": "Element"
},
{
"description": "The feature containing the geometry used as the right operand of the operation. The properties of this object are ignored.",
"name": "right",
"type": "Element"
},
{
"default": null,
"description": "The maximum amount of error tolerated when performing any necessary reprojection.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
},
{
"default": null,
"description": "The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.",
"name": "proj",
"optional": true,
"type": "Projection"
}
],
"description": "Returns a feature containing the intersection of the geometries of two features, with the properties of the left feature.",
"returns": "Feature",
"type": "Algorithm",
"hidden": false
},
"Image.gte": {
"args": [
{
"description": "The image from which the left operand bands are taken.",
"name": "image1",
"type": "Image<unknown bands>"
},
{
"description": "The image from which the right operand bands are taken.",
"name": "image2",
"type": "Image<unknown bands>"
}
],
"description": "Returns 1 iff the first value is greater than or equal to the second for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is boolean.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Number.cbrt": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Computes the cubic root of the input.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Kernel.chebyshev": {
"args": [
{
"description": "The radius of the kernel to generate.",
"name": "radius",
"type": "Float"
},
{
"default": "pixels",
"description": "The system of measurement for the kernel ('pixels' or 'meters'). If the kernel is specified in meters, it will resize when the zoom-level is changed.",
"name": "units",
"optional": true,
"type": "String"
},
{
"default": false,
"description": "Normalize the kernel values to sum to 1.",
"name": "normalize",
"optional": true,
"type": "Boolean"
},
{
"default": 1.0,
"description": "Scale each value by this amount.",
"name": "magnitude",
"optional": true,
"type": "Float"
}
],
"description": "Generates a distance kernel based on Chebyshev distance (greatest distance along any dimension).",
"returns": "Kernel",
"type": "Algorithm",
"hidden": false
},
"Number.erfInv": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Computes the inverse error function of the input.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Array.bitCount": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, calculates the number of one-bits in the 64-bit two's complement binary representation of the input.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Reducer.robustLinearRegression": {
"args": [
{
"description": "The number of input dimensions.",
"name": "numX",
"type": "Integer"
},
{
"default": 1,
"description": "The number of output dimensions.",
"name": "numY",
"optional": true,
"type": "Integer"
},
{
"default": null,
"description": "Residual error outlier margin. If null, a default value will be computed.",
"name": "beta",
"optional": true,
"type": "Float"
}
],
"description": "Creates a reducer that computes a robust least squares regression with numX independent variables and numY dependent variables, using iteratively reweighted least squares with the Talwar cost function. A point is considered an outlier if the RMS of residuals is greater than beta.\nEach input tuple will have values for the independent variables followed by the dependent variables.\nThe first output is a coefficients array with dimensions (numX, numY); each column contains the coefficients for the corresponding dependent variable. The second is a vector of the root mean square of the residuals of each dependent variable. Both outputs are null if the system is underdetermined, e.g. the number of inputs is less than numX.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Number.toUint8": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Casts the input value to an unsigned 8-bit integer.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Reducer.first": {
"args": [],
"description": "Returns a Reducer that returns the first of its inputs.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Image.atan2": {
"args": [
{
"description": "The image from which the left operand bands are taken.",
"name": "image1",
"type": "Image<unknown bands>"
},
{
"description": "The image from which the right operand bands are taken.",
"name": "image2",
"type": "Image<unknown bands>"
}
],
"description": "Calculates the angle formed by the 2D vector [x, y] for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is float.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"String.toLowerCase": {
"args": [
{
"description": "The string to convert to lower case.",
"name": "string",
"type": "String"
}
],
"description": "Converts all of the characters in a string to lower case.",
"returns": "String",
"type": "Algorithm",
"hidden": false
},
"Dictionary.remove": {
"args": [
{
"name": "dictionary",
"type": "Dictionary<Object>"
},
{
"description": "A list of keys names or regular expressions of key names to remove.",
"name": "selectors",
"type": "List<String>"
},
{
"default": false,
"description": "Ignore selectors that don't match at least 1 key.",
"name": "ignoreMissing",
"optional": true,
"type": "Boolean"
}
],
"description": "Returns a dictionary with the specified keys removed.",
"returns": "Dictionary<Object>",
"type": "Algorithm",
"hidden": false
},
"Kernel.prewitt": {
"args": [
{
"default": 1.0,
"description": "Scale each value by this amount.",
"name": "magnitude",
"optional": true,
"type": "Float"
},
{
"default": false,
"description": "Normalize the kernel values to sum to 1.",
"name": "normalize",
"optional": true,
"type": "Boolean"
}
],
"description": "Generates a 3x3 Prewitt edge-detection kernel.",
"returns": "Kernel",
"type": "Algorithm",
"hidden": false
},
"Projection": {
"args": [
{
"description": "The base coordinate reference system of this Projection, given as a well-known authority code (e.g. 'EPSG:4326') or a WKT string.",
"name": "crs",
"type": "Object"
},
{
"default": null,
"description": "The transform between projected coordinates and the base coordinate system, specified as a 2x3 affine transform matrix in row-major order: [xScale, xShearing, xTranslation, yShearing, yScale, yTranslation]. May not specify both this and 'transformWkt'.",
"name": "transform",
"optional": true,
"type": "List<Object>"
},
{
"default": null,
"description": "The transform between projected coordinates and the base coordinate system, specified as a WKT string. May not specify both this and 'transform'.",
"name": "transformWkt",
"optional": true,
"type": "String"
}
],
"description": "Returns a Projection with the given base coordinate system and the given transform between projected coordinates and the base. If no transform is specified, the identity transform is assumed.",
"returns": "Projection",
"type": "Algorithm",
"hidden": false
},
"List.swap": {
"args": [
{
"name": "list",
"type": "List<Object>"
},
{
"name": "pos1",
"type": "Integer"
},
{
"name": "pos2",
"type": "Integer"
}
],
"description": "Swaps the elements at the specified positions. A negative position counts backwards from the end of the list.",
"returns": "List<Object>",
"type": "Algorithm",
"hidden": false
},
"Filter.inList": {
"args": [
{
"default": null,
"description": "A selector for the left operand. Should not be specified if leftValue is specified.",
"name": "leftField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the right operand. Should not be specified if rightField is specified.",
"name": "rightValue",
"optional": true,
"type": "Object"
},
{
"default": null,
"description": "A selector for the right operand. Should not be specified if rightValue is specified.",
"name": "rightField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the left operand. Should not be specified if leftField is specified.",
"name": "leftValue",
"optional": true,
"type": "Object"
}
],
"description": "Creates a unary or binary filter that passes if the left operand, a list, contains the right operand.",
"returns": "Filter",
"type": "Algorithm",
"hidden": false
},
"Image.zeroCrossing": {
"args": [
{
"description": "The image from which to compute zero crossings.",
"name": "image",
"type": "Image<unknown bands>"
}
],
"description": "Finds zero-crossings on each band of an image.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.matrixSingularValueDecomposition": {
"args": [
{
"description": "Image of 2-D matrices to be decomposed.",
"name": "image",
"type": "Image<unknown bands>"
}
],
"description": "Calculates the Singular Value Decomposition of the input matrix into U×S×V', such that U and V are orthogonal and S is diagonal. Returns an image with bands named 'U', 'S' and 'V'.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Filter.notNull": {
"args": [
{
"name": "properties",
"type": "List<String>"
}
],
"description": "Creates a Filter.",
"returns": "Filter",
"type": "Algorithm",
"hidden": false
},
"Image.trigamma": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Computes the trigamma function of the input.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Number.bitwiseAnd": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Number"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Number"
}
],
"description": "Calculates the bitwise AND of the input values.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Array.bitwiseXor": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Array"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Array"
}
],
"description": "On an element-wise basis, calculates the bitwise XOR of the input values.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Reducer.unweighted": {
"args": [
{
"name": "reducer",
"type": "Reducer"
}
],
"description": "Returns a Reducer with the same inputs and outputs as the given Reducer, but with no weighted inputs.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Classifier.train": {
"args": [
{
"description": "An input classifier.",
"name": "classifier",
"type": "Classifier"
},
{
"description": "The collection to train on.",
"name": "features",
"type": "FeatureCollection"
},
{
"description": "The name of the property containing the class value. Each feature must have this property, and its value must be numeric.",
"name": "classProperty",
"type": "String"
},
{
"default": null,
"description": "The list of property names to include as training data. Each feature must have all these properties, and their values must be numeric. This argument is optional if the input collection contains a 'band_order' property, (as produced by Image.sample).",
"name": "inputProperties",
"optional": true,
"type": "List<String>"
},
{
"default": 1.0,
"description": "An optional subsampling factor, within (0, 1].",
"name": "subsampling",
"optional": true,
"type": "Float"
},
{
"default": 0,
"description": "A randomization seed to use for subsampling.",
"name": "subsamplingSeed",
"optional": true,
"type": "Integer"
}
],
"description": "Trains the classifier on a collection of features, using the specified numeric properties of each feature as training data. The geometry of the features is ignored.",
"returns": "Classifier",
"type": "Algorithm",
"hidden": false
},
"GeometryConstructors.MultiGeometry": {
"args": [
{
"description": "The list of geometries for the MultiGeometry.",
"name": "geometries",
"type": "List<Geometry>"
},
{
"default": null,
"description": "The coordinate reference system of the coordinates. The default is the projection of the inputs, where Numbers are assumed to be EPSG:4326.",
"name": "crs",
"optional": true,
"type": "Projection"
},
{
"default": null,
"description": "If false, edges are straight in the projection. If true, edges are curved to follow the shortest path on the surface of the Earth. The default is the geodesic state of the inputs, or true if the inputs are numbers.",
"name": "geodesic",
"optional": true,
"type": "Boolean"
},
{
"default": null,
"description": "Max error when input geometry must be reprojected to an explicitly requested result projection or geodesic state.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
}
],
"description": "Constructs a MultiGeometry from the given list of geometry elements.",
"returns": "Geometry",
"type": "Algorithm",
"hidden": false
},
"Collection.style": {
"args": [
{
"description": "The collection to draw.",
"name": "collection",
"type": "FeatureCollection"
},
{
"default": "black",
"description": "A default color (CSS 3.0 color value e.g. 'FF0000' or 'red') to use for drawing the features. Supports opacity (e.g.: 'FF000088' for 50% transparent red).",
"name": "color",
"optional": true,
"type": "String"
},
{
"default": 3,
"description": "The default size in pixels of the point markers.",
"name": "pointSize",
"optional": true,
"type": "Integer"
},
{
"default": "circle",
"description": "The default shape of the marker to draw at each point location. One of: circle, square, diamond, cross, plus, pentagram, hexagram, triangle, triangle_up triangle_down, triangle_left, triangle_right, pentagon, hexagon, star5, star6. This argument also supports the following Matlab marker abbreviations: o, s, d, x, +, p, h, ^, v, <, >.",
"name": "pointShape",
"optional": true,
"type": "String"
},
{
"default": 2.0,
"description": "The default line width for lines and outlines for polygons and point shapes.",
"name": "width",
"optional": true,
"type": "Float"
},
{
"default": null,
"description": "The color for filling polygons and point shapes. Defaults to 'color' at 0.66 opacity.",
"name": "fillColor",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "A per-feature property expected to contain a dictionary. Values in the dictionary override any default values for that feature.",
"name": "styleProperty",
"optional": true,
"type": "String"
},
{
"default": 5,
"description": "If styleProperty is used and any feature has a pointSize or width larger than the defaults, tiling artifacts can occur. Specifies the maximum neighborhood (pointSize + width) needed for any feature.",
"name": "neighborhood",
"optional": true,
"type": "Integer"
}
],
"description": "Draw a vector collection for visualization using a simple style language.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"List.frequency": {
"args": [
{
"name": "list",
"type": "List<Object>"
},
{
"name": "element",
"type": "Object"
}
],
"description": "Returns the number of elements in list equal to element.",
"returns": "Integer",
"type": "Algorithm",
"hidden": false
},
"Image.fastDistanceTransform": {
"args": [
{
"description": "The input image.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"default": 256,
"description": "Neighborhood size in pixels.",
"name": "neighborhood",
"optional": true,
"type": "Integer"
},
{
"default": "pixels",
"description": "The units of the neighborhood, currently only 'pixels' are supported.",
"name": "units",
"optional": true,
"type": "String"
},
{
"default": "squared_euclidean",
"description": "Distance metric to use: options are 'squared_euclidean', 'manhattan' or 'chebyshev'.",
"name": "metric",
"optional": true,
"type": "String"
}
],
"description": "Returns the distance, as determined by the specified distance metric, to the nearest non-zero valued pixel in the input. The output contains values for all pixels within the given neighborhood size, regardless of the input's mask. Note: the default distance metric returns squared distance.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Kernel.square": {
"args": [
{
"description": "The radius of the kernel to generate.",
"name": "radius",
"type": "Float"
},
{
"default": "pixels",
"description": "The system of measurement for the kernel ('pixels' or 'meters'). If the kernel is specified in meters, it will resize when the zoom-level is changed.",
"name": "units",
"optional": true,
"type": "String"
},
{
"default": true,
"description": "Normalize the kernel values to sum to 1.",
"name": "normalize",
"optional": true,
"type": "Boolean"
},
{
"default": 1.0,
"description": "Scale each value by this amount.",
"name": "magnitude",
"optional": true,
"type": "Float"
}
],
"description": "Generates a square-shaped boolean kernel.",
"returns": "Kernel",
"type": "Algorithm",
"hidden": false
},
"Dictionary.map": {
"args": [
{
"name": "dictionary",
"type": "Dictionary<Object>"
},
{
"name": "baseAlgorithm",
"type": "Algorithm"
}
],
"description": "Map an algorithm over a dictionary. The algorithm is expected to take 2 arguments, a key from the existing dictionary and the value it corresponds to, and return a new value for the given key. If the algorithm returns null, the key is dropped.",
"returns": "Dictionary<Object>",
"type": "Algorithm",
"hidden": false
},
"Image.arrayLengths": {
"args": [
{
"description": "Input image.",
"name": "input",
"type": "Image<unknown bands>"
}
],
"description": "Returns a 1D array image with the length of each array axis.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Fail.loop": {
"args": [],
"description": "Starts an infinite loop on a compute thread. For testing run-away requests.",
"returns": "Integer",
"type": "Algorithm",
"hidden": false
},
"Array.toInt16": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, casts the input value to a signed 16-bit integer.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Number.toShort": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Casts the input value to a signed 16-bit integer.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Classifier.mode": {
"args": [
{
"name": "classifier",
"type": "Classifier"
}
],
"description": "Returns the classifier mode: CLASSIFICATION, REGRESSION or PROBABILITY.",
"returns": "String",
"type": "Algorithm",
"hidden": false
},
"Geometry.containedIn": {
"args": [
{
"description": "The geometry used as the left operand of the operation.",
"name": "left",
"type": "Geometry"
},
{
"description": "The geometry used as the right operand of the operation.",
"name": "right",
"type": "Geometry"
},
{
"default": null,
"description": "The maximum amount of error tolerated when performing any necessary reprojection.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
},
{
"default": null,
"description": "The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.",
"name": "proj",
"optional": true,
"type": "Projection"
}
],
"description": "Returns true iff one geometry is contained in the other.",
"returns": "Boolean",
"type": "Algorithm",
"hidden": false
},
"Image.arraySort": {
"args": [
{
"description": "Array image to sort.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"default": null,
"description": "Optional keys to sort by. If not provided, the values are used as the keys. The keys can only have multiple elements along one axis, which determines the direction to sort in.",
"name": "keys",
"optional": true,
"type": "Image<unknown bands>"
}
],
"description": "Sorts elements of each array pixel along one axis.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Feature.buffer": {
"args": [
{
"description": "The feature the geometry of which is being buffered.",
"name": "feature",
"type": "Element"
},
{
"description": "The distance of the buffering, which may be negative. If no projection is specified, the unit is meters. Otherwise the unit is in the coordinate system of the projection.",
"name": "distance",
"type": "Float"
},
{
"default": null,
"description": "The maximum amount of error tolerated when approximating the buffering circle and performing any necessary reprojection. If unspecified, defaults to 1% of the distance.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
},
{
"default": null,
"description": "If specified, the buffering will be performed in this projection and the distance will be interpreted as units of the coordinate system of this projection. Otherwise the distance is interpereted as meters and the buffering is performed in a spherical coordinate system.",
"name": "proj",
"optional": true,
"type": "Projection"
}
],
"description": "Returns the input buffered by a given distance. If the distance is positive, the geometry is expanded, and if the distance is negative, the geometry is contracted.",
"returns": "Feature",
"type": "Algorithm",
"hidden": false
},
"AggregateFeatureCollection.stats": {
"args": [
{
"description": "The collection to aggregate over.",
"name": "collection",
"type": "FeatureCollection"
},
{
"description": "The property to use from each element of the collection.",
"name": "property",
"type": "String"
}
],
"description": "Aggregates over a given property of the objects in a collection, calculating the sum, min, max, mean, sample standard deviation, sample variance, total standard deviation and total variance of the selected property.",
"returns": "Object",
"type": "Algorithm",
"hidden": false
},
"Classifier.decisionTree": {
"args": [
{
"description": "The decision tree, specified in the text format generated by R and other similar tools.",
"name": "treeString",
"type": "String"
}
],
"description": "Creates a classifier that applies the given decision tree.",
"returns": "Classifier",
"type": "Algorithm",
"hidden": false
},
"Number.int32": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Casts the input value to a signed 32-bit integer.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Feature.simplify": {
"args": [
{
"description": "The feature whose geometry is being simplified.",
"name": "feature",
"type": "Element"
},
{
"description": "The maximum amount of error by which the result may differ from the input.",
"name": "maxError",
"type": "ErrorMargin"
},
{
"default": null,
"description": "If specified, the result will be in this projection. Otherwise it will be in the same projection as the input. If the error margin is in projected units, the margin will be interpreted as units of this projection",
"name": "proj",
"optional": true,
"type": "Projection"
}
],
"description": "Simplifies the geometry of a feature to within a given error margin. Note that this does not respect the error margin requested by the consumer of this algorithm, unless maxError is explicitly specified to be null.\nThis overrides the default Earth Engine policy for propagating error margins, so regardless of the geometry accuracy requested from the output, the inputs will be requested with the error margin specified in the arguments to this algorithm. This results in consistent rendering at all zoom levels of a rendered vector map, but at lower zoom levels (i.e. zoomed out), the geometry won't be simplified, which may harm performance.",
"returns": "Feature",
"type": "Algorithm",
"hidden": false
},
"GeometryConstructors.Polygon": {
"args": [
{
"description": "A list of LinearRings where the first is the shell and the rest are holes, or for a simple polygon, a list of Points or pairs of Numbers in x,y order.",
"name": "coordinates",
"type": "List<Object>"
},
{
"default": null,
"description": "The coordinate reference system of the coordinates. The default is the projection of the inputs, where Numbers are assumed to be EPSG:4326.",
"name": "crs",
"optional": true,
"type": "Projection"
},
{
"default": null,
"description": "If false, edges are straight in the projection. If true, edges are curved to follow the shortest path on the surface of the Earth. The default is the geodesic state of the inputs, or true if the inputs are numbers.",
"name": "geodesic",
"optional": true,
"type": "Boolean"
},
{
"default": null,
"description": "Max error when input geometry must be reprojected to an explicitly requested result projection or geodesic state.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
},
{
"default": true,
"description": "If true, polygon interiors will be determined by the even/odd rule, where a point is inside if it crosses an odd number of edges to reach a point at infinity. Otherwise polygons use the left-inside rule, where interiors are on the left side of the shell's edges when walking the vertices in the given order.",
"name": "evenOdd",
"optional": true,
"type": "Boolean"
}
],
"description": "Constructs a Polygon from the given coordinates.",
"returns": "Geometry",
"type": "Algorithm",
"hidden": false
},
"Image.connectedComponents": {
"args": [
{
"description": "The image to label.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"description": "Connectedness kernel.",
"name": "connectedness",
"type": "Kernel"
},
{
"description": "Maximum size of objects to be labeled.",
"name": "maxSize",
"type": "Integer"
}
],
"description": "Finds connected components with the same value of the first band of the input and labels them with a globally unique value. Connectedness is specified by the given kernel. Objects larger than maxSize are considered background, and are masked.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Number.or": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Number"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Number"
}
],
"description": "Returns 1 iff either input value is non-zero.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"AggregateFeatureCollection.sample_var": {
"args": [
{
"description": "The collection to aggregate over.",
"name": "collection",
"type": "FeatureCollection"
},
{
"description": "The property to use from each element of the collection.",
"name": "property",
"type": "String"
}
],
"description": "Aggregates over a given property of the objects in a collection, calculating the sample variance of the values of the selected property.",
"returns": "Object",
"type": "Algorithm",
"hidden": false
},
"Reducer.skew": {
"args": [],
"description": "Returns a Reducer that Computes the skewness of its inputs.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Image.firstNonZero": {
"args": [
{
"description": "The image from which the left operand bands are taken.",
"name": "image1",
"type": "Image<unknown bands>"
},
{
"description": "The image from which the right operand bands are taken.",
"name": "image2",
"type": "Image<unknown bands>"
}
],
"description": "Selects the first value if it is non-zero, and the second value otherwise for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is the union of the input types.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Reducer.countEvery": {
"args": [],
"description": "Returns a Reducer that computes the number of inputs.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Geometry.coordinates": {
"args": [
{
"name": "geometry",
"type": "Geometry"
}
],
"description": "Returns a GeoJSON-style list of the geometry's coordinates.",
"returns": "List<Object>",
"type": "Algorithm",
"hidden": false
},
"Geometry.symmetricDifference": {
"args": [
{
"description": "The geometry used as the left operand of the operation.",
"name": "left",
"type": "Geometry"
},
{
"description": "The geometry used as the right operand of the operation.",
"name": "right",
"type": "Geometry"
},
{
"default": null,
"description": "The maximum amount of error tolerated when performing any necessary reprojection.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
},
{
"default": null,
"description": "The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.",
"name": "proj",
"optional": true,
"type": "Projection"
}
],
"description": "Returns the symmetric difference between two geometries.",
"returns": "Geometry",
"type": "Algorithm",
"hidden": false
},
"Image.spectralErosion": {
"args": [
{
"description": "The input image.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"default": "sam",
"description": "The spectral distance metric to use. One of 'sam' (spectral angle mapper), 'sid' (spectral information divergence), 'sed' (squared euclidean distance), or 'emd' (earth movers distance).",
"name": "metric",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "Connectedness kernel. Defaults to a square of radius 1 (8-way connected).",
"name": "kernel",
"optional": true,
"type": "Kernel"
},
{
"default": false,
"description": "If true, distances are computed from the mean of all pixels under the kernel instead of the kernel's center pixel.",
"name": "useCentroid",
"optional": true,
"type": "Boolean"
}
],
"description": "Computes the spectral/spatial erosion of an image by computing the spectral distance of each pixel under a structuring kernel from the centroid of all pixels under the kernel and taking the closest result. See 'Spatial/spectral endmember extraction by multidimensional morphological operations.' IEEE transactions on geoscience and remote sensing 40.9 (2002): 2025-2041.\n",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.arrayDotProduct": {
"args": [
{
"description": "First array image of 1-D vectors.",
"name": "image1",
"type": "Image<unknown bands>"
},
{
"description": "Second array image of 1-D vectors.",
"name": "image2",
"type": "Image<unknown bands>"
}
],
"description": "Computes the dot product of each pair of 1-D arrays in the bands of the input images.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.unmix": {
"args": [
{
"description": "The input image.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"description": "The endmembers to unmix with.",
"name": "endmembers",
"type": "List<List<Float>>"
},
{
"default": false,
"description": "Constrain the outputs to sum to one.",
"name": "sumToOne",
"optional": true,
"type": "Boolean"
},
{
"default": false,
"description": "Constrain the outputs to be non-negative.",
"name": "nonNegative",
"optional": true,
"type": "Boolean"
}
],
"description": "Unmix each pixel with the given endmembers, by computing the pseudo-inverse and multiplying it through each pixel. Returns an image of doubles with the same number of bands as endmembers.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.arraySlice": {
"args": [
{
"description": "Input array image.",
"name": "input",
"type": "Image<unknown bands>"
},
{
"default": 0,
"description": "Axis to subset.",
"name": "axis",
"optional": true,
"type": "Integer"
},
{
"default": null,
"description": "The coordinate of the first slice (inclusive) along 'axis'. Negative numbers are used to position the start of slicing relative to the end of the array, where -1 starts at the last position on the axis, -2 starts at the next to last position, etc. There must one band for start indices, or one band per 'input' band. If this argument is not set or masked at some pixel, then the slice at that pixel will start at index 0.",
"name": "start",
"optional": true,
"type": "Image<unknown bands>"
},
{
"default": null,
"description": "The coordinate (exclusive) at which to stop taking slices. By default this will be the length of the given axis. Negative numbers are used to position the end of slicing relative to the end of the array, where -1 will exclude the last position, -2 will exclude the last two positions, etc. There must be one band for end indices, or one band per 'input' band. If this argument is not set or masked at some pixel, then the slice at that pixel will end just after the last index.",
"name": "end",
"optional": true,
"type": "Image<unknown bands>"
},
{
"default": 1,
"description": "The separation between slices along 'axis'; a slice will be taken at each whole multiple of 'step' from 'start' (inclusive) to 'end' (exclusive). Must be positive.",
"name": "step",
"optional": true,
"type": "Integer"
}
],
"description": "Creates a subarray by slicing out each position along the given axis from the 'start' (inclusive) to 'end' (exclusive) by increments of 'step'. The result will have as many dimensions as the input, and the same length in all directions except the slicing axis, where the length will be the number of positions from 'start' to 'end' by 'step' that are in range of the input array's length along 'axis'. This means the result can be length 0 along the given axis if start=end, or if the start or end values are entirely out of range.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"reduce.median": {
"args": [
{
"description": "The image collection to reduce.",
"name": "collection",
"type": "ImageCollection"
}
],
"description": "Reduces an image collection by calculating the median of all values at each pixel across the stack of all matching bands. Bands are matched by name.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Date.unitRatio": {
"args": [
{
"name": "numerator",
"type": "String"
},
{
"name": "denominator",
"type": "String"
}
],
"description": "Returns the ratio of the length of one unit to the length of another, e.g. unitRatio('day', 'minute') returns 1440. Valid units are 'year', 'month' 'week', 'day', 'hour', 'minute', and 'second'.",
"returns": "Float",
"type": "Algorithm",
"hidden": false
},
"AggregateFeatureCollection.min": {
"args": [
{
"description": "The collection to aggregate over.",
"name": "collection",
"type": "FeatureCollection"
},
{
"description": "The property to use from each element of the collection.",
"name": "property",
"type": "String"
}
],
"description": "Aggregates over a given property of the objects in a collection, calculating the minimum of the values of the selected property.",
"returns": "Object",
"type": "Algorithm",
"hidden": false
},
"Array.toShort": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, casts the input value to a signed 16-bit integer.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"ErrorMargin": {
"args": [
{
"default": null,
"description": "The maximum error value allowed by the margin. Ignored if the unit is 'infinite'.",
"name": "value",
"optional": true,
"type": "Float"
},
{
"default": "meters",
"description": "The unit of this margin: 'meters', 'projected' or 'infinite'.",
"name": "unit",
"optional": true,
"type": "String"
}
],
"description": "Returns an ErrorMargin of the given type with the given value.",
"returns": "ErrorMargin",
"type": "Algorithm",
"hidden": false
},
"Proj": {
"args": [
{
"description": "The base coordinate reference system of this Projection, given as a well-known authority code (e.g. 'EPSG:4326') or a WKT string.",
"name": "crs",
"type": "Object"
},
{
"default": null,
"description": "The transform between projected coordinates and the base coordinate system, specified as a 2x3 affine transform matrix in row-major order: [xScale, xShearing, xTranslation, yShearing, yScale, yTranslation]. May not specify both this and 'transformWkt'.",
"name": "transform",
"optional": true,
"type": "List<Object>"
},
{
"default": null,
"description": "The transform between projected coordinates and the base coordinate system, specified as a WKT string. May not specify both this and 'transform'.",
"name": "transformWkt",
"optional": true,
"type": "String"
}
],
"description": "Returns a Projection with the given base coordinate system and the given transform between projected coordinates and the base. If no transform is specified, the identity transform is assumed.",
"returns": "Projection",
"type": "Algorithm",
"hidden": false,
"deprecated": "Use Projection()."
},
"Feature.toArray": {
"args": [
{
"description": "The object from which to select array properties.",
"name": "feature",
"type": "Feature"
},
{
"description": "The property selectors for each array element.",
"name": "properties",
"type": "List<String>"
}
],
"description": "Creates an array from the given properties of an object, which must all be numbers.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"AggregateFeatureCollection.sum": {
"args": [
{
"description": "The collection to aggregate over.",
"name": "collection",
"type": "FeatureCollection"
},
{
"description": "The property to use from each element of the collection.",
"name": "property",
"type": "String"
}
],
"description": "Aggregates over a given property of the objects in a collection, calculating the sum of the values of the selected property.",
"returns": "Object",
"type": "Algorithm",
"hidden": false
},
"Array.multiply": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Array"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Array"
}
],
"description": "On an element-wise basis, multiplies the first value by the second.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Clusterer.wekaXMeans": {
"args": [
{
"default": 2,
"description": "Minimum number of clusters.",
"name": "minClusters",
"optional": true,
"type": "Integer"
},
{
"default": 8,
"description": "Maximum number of clusters.",
"name": "maxClusters",
"optional": true,
"type": "Integer"
},
{
"default": 3,
"description": "Maximum number of overall iterations.",
"name": "maxIterations",
"optional": true,
"type": "Integer"
},
{
"default": 1000,
"description": "The maximum number of iterations to perform in KMeans.",
"name": "maxKMeans",
"optional": true,
"type": "Integer"
},
{
"default": 1000,
"description": "The maximum number of iterations in KMeans that is performed on the child centers.",
"name": "maxForChildren",
"optional": true,
"type": "Integer"
},
{
"default": false,
"description": "Use a KDTree.",
"name": "useKD",
"optional": true,
"type": "Boolean"
},
{
"default": 0.0,
"description": "Takes the given percentage of the splitted centroids if none of the children win.",
"name": "cutoffFactor",
"optional": true,
"type": "Float"
},
{
"default": "Euclidean",
"description": "Distance function to use. Options are: Chebyshev, Euclidean & Manhattan.",
"name": "distanceFunction",
"optional": true,
"type": "String"
},
{
"default": 10,
"description": "The randomization seed.",
"name": "seed",
"optional": true,
"type": "Integer"
}
],
"description": "X-Means is K-Means with an efficient estimation of the number of clusters. For more information see:\nDan Pelleg, Andrew W. Moore: X-means: Extending K-means with Efficient Estimation of the Number of Clusters. In: Seventeenth International Conference on Machine Learning, 727-734, 2000.",
"returns": "Clusterer",
"type": "Algorithm",
"hidden": false
},
"AggregateFeatureCollection.count_distinct": {
"args": [
{
"description": "The collection to aggregate over.",
"name": "collection",
"type": "FeatureCollection"
},
{
"description": "The property to use from each element of the collection.",
"name": "property",
"type": "String"
}
],
"description": "Aggregates over a given property of the objects in a collection, calculating the number of distinct values for the selected property.",
"returns": "Object",
"type": "Algorithm",
"hidden": false
},
"TemporalSegmentation.Verdet": {
"args": [
{
"description": "Collection from which to extract VeRDET scores. This collection is expected to contain 1 image for each year, sorted temporally.",
"name": "timeSeries",
"type": "ImageCollection"
},
{
"default": 0.00010,
"description": "convergence tolerance",
"name": "tolerance",
"optional": true,
"type": "Float"
},
{
"default": 0.03333333333333333,
"description": "Regularization parameter for segmentation.",
"name": "alpha",
"optional": true,
"type": "Float"
},
{
"default": 100,
"description": "Maximum number of runs for convergence.",
"name": "nRuns",
"optional": true,
"type": "Integer"
}
],
"description": "Vegetation Regeneration and Disturbance Estimates through Time, forest change detection algorithm. This algorithm generates a yearly clear-sky composite from satellite imagery, calculates a spectral vegetation index for each pixel in that composite, spatially segments the vegetation index image into patches, temporally divides the time series into differently sloped segments, and then labels those segments as disturbed, stable, or regenerating. Segmentation at both the spatial and temporal steps are performed using total variation regularization.\nThe output consists of a 1D array per pixel containing the slope of fitted trend lines. Negative values indicate disturbance and positive values regeneration.\nSee: Hughes, M.J., Kaylor, S.D. and Hayes, D.J., 2017. Patch-based forest change detection from Landsat time series. Forests, 8(5), p.166.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Array.log10": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, computes the base-10 logarithm of the input.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Collection.filter": {
"args": [
{
"description": "The collection to filter.",
"name": "collection",
"type": "FeatureCollection"
},
{
"description": "The filter to apply.",
"name": "filter",
"type": "Filter"
}
],
"description": "Applies a filter to a given collection.",
"returns": "FeatureCollection",
"type": "Algorithm",
"hidden": false
},
"Image.tan": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Computes the tangent of the input in radians.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Blob.string": {
"args": [
{
"name": "blob",
"type": "Blob"
},
{
"default": null,
"name": "encoding",
"optional": true,
"type": "String"
}
],
"description": "Returns the contents of the blob as a String.",
"returns": "String",
"type": "Algorithm",
"hidden": false
},
"Dictionary.toArray": {
"args": [
{
"name": "dictionary",
"type": "Dictionary<Object>"
},
{
"default": null,
"name": "keys",
"optional": true,
"type": "List<String>"
},
{
"default": 0,
"name": "axis",
"optional": true,
"type": "Integer"
}
],
"description": "Returns numeric values of a dictionary as an array. If no keys are specified, all values are returned in the natural ordering of the dictionary's keys. The default 'axis' is 0.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Array.erfc": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, computes the complementary error function of the input.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Array.min": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Array"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Array"
}
],
"description": "On an element-wise basis, selects the minimum of the first and second values.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Array.or": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Array"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Array"
}
],
"description": "On an element-wise basis, returns 1 iff either input value is non-zero.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Number.bitwise_not": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Calculates the bitwise NOT of the input, in the smallest signed integer type that can hold the input.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Image.clipToBoundsAndScale": {
"args": [
{
"description": "The image to clip and scale.",
"name": "input",
"type": "Image<unknown bands>"
},
{
"default": null,
"description": "The Geometry to clip the image to. The image will be clipped to the bounding box, in the image's projection, of this geometry.",
"name": "geometry",
"optional": true,
"type": "Geometry"
},
{
"default": null,
"description": "The width to scale the image to, in pixels. Must be provided along with \"height\". Exclusive with \"maxDimension\" and \"scale\".",
"name": "width",
"optional": true,
"type": "Integer"
},
{
"default": null,
"description": "The height to scale the image to, in pixels. Must be provided along with \"width\". Exclusive with \"maxDimension\" and \"scale\".",
"name": "height",
"optional": true,
"type": "Integer"
},
{
"default": null,
"description": "The maximum dimension to scale the image to, in pixels. Exclusive with \"width\", \"height\" and \"scale\".",
"name": "maxDimension",
"optional": true,
"type": "Integer"
},
{
"default": null,
"description": "If scale is specified, then the projection is scaled by dividing the specified scale value by the nominal size of a meter in the image's projection. Exclusive with \"width\", \"height\" and \"maxDimension\".",
"name": "scale",
"optional": true,
"type": "Float"
}
],
"description": "Clips an image to the bounds of a Geometry, and scales the clipped image to a particular size or scale.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.displacement": {
"args": [
{
"description": "The image to register.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"description": "The image to register to.",
"name": "referenceImage",
"type": "Image<unknown bands>"
},
{
"description": "The maximum offset allowed when attempting to align the input images, in meters. Using a smaller value can reduce computation time significantly, but it must still be large enough to cover the greatest displacement within the entire image region.",
"name": "maxOffset",
"type": "Float"
},
{
"default": null,
"description": "The projection in which to output displacement values. The default is the projection of the first band of the reference image.",
"name": "projection",
"optional": true,
"type": "Projection"
},
{
"default": null,
"description": "Patch size for detecting image offsets, in meters. This should be set large enough to capture texture, as well as large enough that ignorable objects are small within the patch. Default is null. Patch size will be determined automatically if not provided.",
"name": "patchWidth",
"optional": true,
"type": "Float"
},
{
"default": 5.0,
"description": "Enforces a stiffness constraint on the solution. Valid values are in the range [0,10]. The stiffness is used for outlier rejection when determining displacements at adjacent grid points. Higher values move the solution towards a rigid transformation. Lower values allow more distortion or warping of the image during registration.",
"name": "stiffness",
"optional": true,
"type": "Float"
}
],
"description": "Determines displacements required to register an image to a reference image while allowing local, rubber sheet deformations. Displacements are computed in the CRS of the reference image, at a scale dictated by the lowest resolution of the following three projections: input image projection, reference image projection, and requested projection. The displacements are then transformed into the user-specified projection for output.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Number.int16": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Casts the input value to a signed 16-bit integer.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Filter.dateRangeContains": {
"args": [
{
"default": null,
"description": "A selector for the left operand. Should not be specified if leftValue is specified.",
"name": "leftField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the right operand. Should not be specified if rightField is specified.",
"name": "rightValue",
"optional": true,
"type": "Object"
},
{
"default": null,
"description": "A selector for the right operand. Should not be specified if rightValue is specified.",
"name": "rightField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the left operand. Should not be specified if leftField is specified.",
"name": "leftValue",
"optional": true,
"type": "Object"
}
],
"description": "Creates a unary or binary filter that passes if the left operand, a date range, contains the right operand, a date.",
"returns": "Filter",
"type": "Algorithm",
"hidden": false
},
"Image.requestArea": {
"args": [
{
"default": false,
"description": "Whether to draw a border of masked pixels to highlight tile edges.",
"name": "border",
"optional": true,
"type": "Boolean"
}
],
"description": "An image in which the bands are the coordinates of the requested BB.\n\nIntended for use in debugging computation only.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Classifier.pegasos": {
"args": [
{
"name": "kernelType",
"type": "String"
},
{
"name": "lossFunction",
"type": "String"
},
{
"name": "lambda",
"type": "Float"
},
{
"name": "iterations",
"type": "Integer"
},
{
"name": "subsetSize",
"type": "Integer"
},
{
"name": "regularizationNorm",
"type": "Float"
},
{
"name": "multiGamma",
"type": "Float"
},
{
"default": null,
"name": "useExponentiated",
"optional": true,
"type": "Boolean"
},
{
"default": null,
"name": "polyDegree",
"optional": true,
"type": "Integer"
},
{
"default": null,
"name": "polyBias",
"optional": true,
"type": "Float"
},
{
"default": null,
"name": "rbfGamma",
"optional": true,
"type": "Float"
}
],
"description": "Creates a Classifier.",
"returns": "Classifier",
"type": "Algorithm",
"hidden": true,
"deprecated": "Deprecated; will be removed eventually."
},
"Number.cosh": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Computes the hyperbolic cosine of the input.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Reducer.min": {
"args": [
{
"default": 1,
"description": "The number of inputs.",
"name": "numInputs",
"optional": true,
"type": "Integer"
}
],
"description": "Creates a reducer that outputs the minimum value of its (first) input. If numInputs is greater than one, also outputs the corresponding values of the additional inputs.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"CrossCorrelation": {
"args": [
{
"description": "First image, with N bands.",
"name": "imageA",
"type": "Image<unknown bands>"
},
{
"description": "Second image, must have the same number of bands as imageA.",
"name": "imageB",
"type": "Image<unknown bands>"
},
{
"description": "The greatest distance a pixel may shift in either X or Y.",
"name": "maxGap",
"type": "Integer"
},
{
"description": "Size of the window to be compared.",
"name": "windowSize",
"type": "Integer"
},
{
"default": 0.0,
"description": "The maximum fraction of pixels within the correlation window that are allowed to be masked. This test is applied at each offset location within the search region. For each offset, the overlapping image patches are compared and a correlation score computed. A pixel within these overlapping patches is considered masked if either of the patches is masked there. If the test fails at any single location in the search region, the ouput pixel for which the correlation is being computed is considered invalid, and will be masked.",
"name": "maxMaskedFrac",
"optional": true,
"type": "Float"
}
],
"description": "Gives information on the quality of image registration between two (theoretically) co-registered images. The input is two images with the same number of bands. This function outputs an image composed of four bands of information. The first three are distances: the deltaX, deltaY, and the Euclidean distance for each pixel in imageA to the pixel which has the highest corresponding correlation coefficient in imageB. The fourth band is the value of the correlation coefficient for that pixel [-1 : +1].",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"ImageCollection.combine": {
"args": [
{
"description": "The primary collection to join.",
"name": "primary",
"type": "ImageCollection"
},
{
"description": "The secondary collection to join.",
"name": "secondary",
"type": "ImageCollection"
},
{
"default": false,
"description": "If true, bands with the same name will get overwritten. If false, bands with the same name will be renamed.",
"name": "overwrite",
"optional": true,
"type": "Boolean"
}
],
"description": "Makes a new collection that is a copy of the images in primary, adding all the bands from the image in secondary with a matching ID. If there's no matching image, the primary image is just copied. This is equivalent to a join on ID with merging of the bands of the result.\n\nNote that this algorithm assumes that for a matching pair of inputs, both have the same footprint and metadata.",
"returns": "ImageCollection",
"type": "Algorithm",
"hidden": false
},
"Array.lt": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Array"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Array"
}
],
"description": "On an element-wise basis, returns 1 iff the first value is less than the second.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Reducer.sum": {
"args": [],
"description": "Returns a Reducer that computes the (weighted) sum of its inputs.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"Classifier.TrainingContainer": {
"args": [
{
"name": "classifier",
"type": "Classifier"
}
],
"description": "INTERNAL",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": true
},
"Image.tanh": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Computes the hyperbolic tangent of the input.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.toFloat": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Casts the input value to a 32-bit float.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Array.gammainc": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Array"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Array"
}
],
"description": "On an element-wise basis, calculates the regularized lower incomplete Gamma function γ(x,a).",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Feature.intersects": {
"args": [
{
"description": "The feature containing the geometry used as the left operand of the operation.",
"name": "left",
"type": "Element"
},
{
"description": "The feature containing the geometry used as the right operand of the operation.",
"name": "right",
"type": "Element"
},
{
"default": null,
"description": "The maximum amount of error tolerated when performing any necessary reprojection.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
},
{
"default": null,
"description": "The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.",
"name": "proj",
"optional": true,
"type": "Projection"
}
],
"description": "Returns true iff the feature geometries intersect.",
"returns": "Boolean",
"type": "Algorithm",
"hidden": false
},
"Collection.randomColumn": {
"args": [
{
"description": "The input collection to which to add a random column.",
"name": "collection",
"type": "FeatureCollection"
},
{
"default": "random",
"description": "The name of the column to add.",
"name": "columnName",
"optional": true,
"type": "String"
},
{
"default": 0,
"description": "A seed used when generating the random numbers.",
"name": "seed",
"optional": true,
"type": "Long"
}
],
"description": "Adds a column of deterministic pseudorandom numbers to a collection. The numbers are double-precision floating point numbers in the range 0.0 (inclusive) to 1.0 (exclusive).",
"returns": "FeatureCollection",
"type": "Algorithm",
"hidden": false
},
"Array.matrixPseudoInverse": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "Computes the Moore-Penrose pseudoinverse of the matrix.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"reduce.max": {
"args": [
{
"description": "The image collection to reduce.",
"name": "collection",
"type": "ImageCollection"
}
],
"description": "Reduces an image collection by calculating the maximum value of each pixel across the stack of all matching bands. Bands are matched by name.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.load": {
"args": [
{
"description": "The asset ID of the image.",
"name": "id",
"type": "String"
},
{
"default": -1,
"description": "The version of the asset. -1 signifies the latest version.",
"name": "version",
"optional": true,
"type": "Long"
}
],
"description": "Returns the image given its ID.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.matrixDiagonal": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Computes the diagonal of the matrix in a single column.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"GeometryConstructors.LinearRing": {
"args": [
{
"description": "The list of Points or pairs of Numbers in x,y order.",
"name": "coordinates",
"type": "List<Object>"
},
{
"default": null,
"description": "The coordinate reference system of the coordinates. The default is the projection of the inputs, where Numbers are assumed to be EPSG:4326.",
"name": "crs",
"optional": true,
"type": "Projection"
},
{
"default": null,
"description": "If false, edges are straight in the projection. If true, edges are curved to follow the shortest path on the surface of the Earth. The default is the geodesic state of the inputs, or true if the inputs are numbers.",
"name": "geodesic",
"optional": true,
"type": "Boolean"
}
],
"description": "Constructs a LinearRing from the given coordinates, automatically adding the first point at the end if the ring is not explicitly closed.",
"returns": "Geometry",
"type": "Algorithm",
"hidden": false
},
"Classifier.gmoLinearRegression": {
"args": [
{
"default": 0.0,
"description": "The weight for L1 regularization. Larger weight leads to heavier regularization.",
"name": "weight1",
"optional": true,
"type": "Float"
},
{
"default": 0.0,
"description": "The weight for L2 regularization. Larger weight leads to heavier regularization.",
"name": "weight2",
"optional": true,
"type": "Float"
},
{
"default": 0.000010,
"description": "The epsilon for stopping optimization.",
"name": "epsilon",
"optional": true,
"type": "Float"
},
{
"default": 100,
"description": "The maximum number of iterations.",
"name": "maxIterations",
"optional": true,
"type": "Integer"
},
{
"default": false,
"description": "Use a logistic loss function for the L1 regularization.",
"name": "smooth",
"optional": true,
"type": "Boolean"
}
],
"description": "Creates an empty linear regression. This regression supports L1 and L2 regularization as well as a smoothed L1 regularization using a logistic loss function. Note that the model used by this regression does not include a bias by default and a constant value should be included if a bias is required (it is suggested). This classifier only supports REGRESSION mode.",
"returns": "Classifier",
"type": "Algorithm",
"hidden": false,
"deprecated": "Deprecated; will be removed eventually."
},
"Blob.url": {
"args": [
{
"name": "blob",
"type": "Blob"
}
],
"description": "Returns the Blob's Google Cloud Storage URL.",
"returns": "String",
"type": "Algorithm",
"hidden": false
},
"ReduceRegions.ReduceRegionsEnumerator": {
"args": [
{
"name": "image",
"type": "Image<unknown bands>"
},
{
"name": "collection",
"type": "FeatureCollection"
},
{
"name": "reducer",
"type": "Reducer"
},
{
"name": "proj",
"type": "Projection"
},
{
"name": "tileScale",
"type": "Float"
}
],
"description": "Creates a Object.",
"returns": "Object",
"type": "Algorithm",
"hidden": true
},
"Number.atan": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Computes the arc tangent in radians of the input.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"reduce.product": {
"args": [
{
"description": "The image collection to reduce.",
"name": "collection",
"type": "ImageCollection"
}
],
"description": "Reduces an image collection by calculating the product of all values at each pixel across the stack of all matching bands. Bands are matched by name.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Number.sin": {
"args": [
{
"description": "The input value.",
"name": "input",
"type": "Number"
}
],
"description": "Computes the sine of the input in radians.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Geometry.bounds": {
"args": [
{
"description": "Return the bounding box of this geometry.",
"name": "geometry",
"type": "Geometry"
},
{
"default": null,
"description": "The maximum amount of error tolerated when performing any necessary reprojection.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
},
{
"default": null,
"description": "If specified, the result will be in this projection. Otherwise it will be in WGS84.",
"name": "proj",
"optional": true,
"type": "Projection"
}
],
"description": "Returns the bounding rectangle of the geometry.",
"returns": "Geometry",
"type": "Algorithm",
"hidden": false
},
"Image.int": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Casts the input value to a signed 32-bit integer.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Date.parse": {
"args": [
{
"description": "A pattern, as described at http://joda-time.sourceforge.net/apidocs/org/joda/time/format/DateTimeFormat.html.",
"name": "format",
"type": "String"
},
{
"description": "A string matching the given pattern.",
"name": "date",
"type": "String"
},
{
"default": null,
"description": "The time zone (e.g. 'America/Los_Angeles'); defaults to UTC.",
"name": "timeZone",
"optional": true,
"type": "String"
}
],
"description": "Parse a date string, given a string describing its format.",
"returns": "Date",
"type": "Algorithm",
"hidden": false
},
"Geometry.withinDistance": {
"args": [
{
"description": "The geometry used as the left operand of the operation.",
"name": "left",
"type": "Geometry"
},
{
"description": "The geometry used as the right operand of the operation.",
"name": "right",
"type": "Geometry"
},
{
"description": "The distance threshold. If a projection is specified, the distance is in units of that projected coordinate system, otherwise it is in meters.",
"name": "distance",
"type": "Float"
},
{
"default": null,
"description": "The maximum amount of error tolerated when performing any necessary reprojection.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
},
{
"default": null,
"description": "The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.",
"name": "proj",
"optional": true,
"type": "Projection"
}
],
"description": "Returns true iff the geometries are within a specified distance.",
"returns": "Boolean",
"type": "Algorithm",
"hidden": false
},
"Feature.geometry": {
"args": [
{
"description": "The feature from which the geometry is taken.",
"name": "feature",
"type": "Element"
},
{
"default": null,
"description": "The maximum amount of error tolerated when performing any necessary reprojection.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
},
{
"default": null,
"description": "If specified, the geometry will be in this projection. If unspecified, the geometry will be in its default projection.",
"name": "proj",
"optional": true,
"type": "Projection"
},
{
"default": null,
"description": "If true, the geometry will have geodesic edges. If false, it will have edges as straight lines in the specified projection. If null, the edge interpretation will be the same as the original geometry. This argument is ignored if proj is not specified.",
"name": "geodesics",
"optional": true,
"type": "Boolean"
}
],
"description": "Returns the geometry of a given feature in a given projection.",
"returns": "Geometry",
"type": "Algorithm",
"hidden": false,
"deprecated": "Use Element.geometry()"
},
"Image.asin": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Computes the arc sine in radians of the input.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Array.mod": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Array"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Array"
}
],
"description": "On an element-wise basis, calculates the remainder of the first value divided by the second.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Array.matrixFnorm": {
"args": [
{
"description": "The array to compute on.",
"name": "input",
"type": "Array"
}
],
"description": "Computes the Frobenius norm of the matrix.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"Array.acos": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, computes the arc cosine in radians of the input.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Image.parseExpression": {
"args": [
{
"description": "The expression to parse.",
"name": "expression",
"type": "String"
},
{
"description": "The name of the default image argument.",
"name": "argName",
"type": "String"
},
{
"description": "The parameters the resulting algorithm should have, which must be a superset of the free variables in the expression, including the default image argument if it is used.",
"name": "vars",
"type": "List<String>"
}
],
"description": "Generates an algorithm from an arithmetic expression on images. By default the generated algorithm takes one argument to denote the 'default' image. Other variables in the expression are interpreted as image arguments that will be passed to the returned algorithm. The bands of each image can be accessed as image.band_name or image[0]. The bands of the default image are available using the built-in function b(), as b(0) or b('band_name'). Both b() and image[] allow multiple arguments, to specify multiple bands, such as b(1, 'name', 3). Calling b() with no arguments returns all bands of the image.",
"returns": "Algorithm",
"type": "Algorithm",
"hidden": true
},
"Reducer.countDistinct": {
"args": [],
"description": "Returns a Reducer that computes the number of distinct inputs.",
"returns": "Reducer",
"type": "Algorithm",
"hidden": false
},
"List.map": {
"args": [
{
"name": "list",
"type": "List<Object>"
},
{
"name": "baseAlgorithm",
"type": "Algorithm"
}
],
"description": "Map an algorithm over a list. The algorithm is expected to take an Object and return an Object.",
"returns": "List<Object>",
"type": "Algorithm",
"hidden": false
},
"Image.sqrt": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Computes the square root of the input.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.short": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Casts the input value to a signed 16-bit integer.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Annotation.style": {
"args": [
{
"name": "annotation",
"type": "Annotation"
},
{
"name": "style",
"type": "Dictionary<Object>"
}
],
"description": "Apply a style to an annotation.",
"returns": "Annotation",
"type": "Algorithm",
"hidden": false
},
"Validate.AggregationContainer": {
"args": [
{
"name": "classifier",
"type": "Classifier"
}
],
"description": "INTERNAL",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": true
},
"Image.toArray": {
"args": [
{
"description": "Image of bands to convert to an array per pixel. Bands must have scalar pixels, or array pixels with equal dimensionality.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"default": 0,
"description": "Axis to concatenate along; must be at least 0 and at most the dimension of the inputs. If the axis equals the dimension of the inputs, the result will have 1 more dimension than the inputs.",
"name": "axis",
"optional": true,
"type": "Integer"
}
],
"description": "Concatenates pixels from each band into a single array per pixel. The result will be masked if any input bands are masked.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Image.matrixTrace": {
"args": [
{
"description": "The image to which the operation is applied.",
"name": "value",
"type": "Image<unknown bands>"
}
],
"description": "Computes the trace of the matrix.",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Array.bitwise_not": {
"args": [
{
"description": "The input array.",
"name": "input",
"type": "Array"
}
],
"description": "On an element-wise basis, calculates the bitwise NOT of the input, in the smallest signed integer type that can hold the input.",
"returns": "Array",
"type": "Algorithm",
"hidden": false
},
"Filter.rangeContains": {
"args": [
{
"description": "A selector for the property being tested.",
"name": "field",
"type": "String"
},
{
"description": "The lower bound of the range.",
"name": "minValue",
"type": "Object"
},
{
"description": "The upper bound of the range.",
"name": "maxValue",
"type": "Object"
}
],
"description": "Returns a filter that passes if the value of the selected field is in the specified range (inclusive).",
"returns": "Filter",
"type": "Algorithm",
"hidden": false
},
"Number.lt": {
"args": [
{
"description": "The left-hand value.",
"name": "left",
"type": "Number"
},
{
"description": "The right-hand value.",
"name": "right",
"type": "Number"
}
],
"description": "Returns 1 iff the first value is less than the second.",
"returns": "Number",
"type": "Algorithm",
"hidden": false
},
"DateRange.union": {
"args": [
{
"name": "dateRange",
"type": "DateRange"
},
{
"name": "other",
"type": "DateRange"
}
],
"description": "Returns a DateRange that contains all points in the union of this DateRange and another.",
"returns": "DateRange",
"type": "Algorithm",
"hidden": false
},
"Filter.notEquals": {
"args": [
{
"default": null,
"description": "A selector for the left operand. Should not be specified if leftValue is specified.",
"name": "leftField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the right operand. Should not be specified if rightField is specified.",
"name": "rightValue",
"optional": true,
"type": "Object"
},
{
"default": null,
"description": "A selector for the right operand. Should not be specified if rightValue is specified.",
"name": "rightField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the left operand. Should not be specified if leftField is specified.",
"name": "leftValue",
"optional": true,
"type": "Object"
}
],
"description": "Creates a unary or binary filter that passes unless the two operands are equals.",
"returns": "Filter",
"type": "Algorithm",
"hidden": false
},
"Filter.gte": {
"args": [
{
"default": null,
"description": "A selector for the left operand. Should not be specified if leftValue is specified.",
"name": "leftField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the right operand. Should not be specified if rightField is specified.",
"name": "rightValue",
"optional": true,
"type": "Object"
},
{
"default": null,
"description": "A selector for the right operand. Should not be specified if rightValue is specified.",
"name": "rightField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the left operand. Should not be specified if leftField is specified.",
"name": "leftValue",
"optional": true,
"type": "Object"
}
],
"description": "Creates a unary or binary filter that passes unless the left operand is less than the right operand.",
"returns": "Filter",
"type": "Algorithm",
"hidden": false
},
"Filter.disjoint": {
"args": [
{
"default": null,
"description": "A selector for the left operand. Should not be specified if leftValue is specified.",
"name": "leftField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the right operand. Should not be specified if rightField is specified.",
"name": "rightValue",
"optional": true,
"type": "Object"
},
{
"default": null,
"description": "A selector for the right operand. Should not be specified if rightValue is specified.",
"name": "rightField",
"optional": true,
"type": "String"
},
{
"default": null,
"description": "The value of the left operand. Should not be specified if leftField is specified.",
"name": "leftValue",
"optional": true,
"type": "Object"
},
{
"default": {
"type": "ErrorMargin",
"unit": "meters",
"value": 0.1
},
"description": "The maximum reprojection error allowed during filter application.",
"name": "maxError",
"optional": true,
"type": "ErrorMargin"
}
],
"description": "Creates a unary or binary filter that passes unless the left geometry intersects the right geometry.",
"returns": "Filter",
"type": "Algorithm",
"hidden": false
},
"PixelType.int64": {
"args": [],
"description": "Returns the 64-bit signed integer pixel type.",
"returns": "PixelType",
"type": "Algorithm",
"hidden": false
},
"HoughTransform": {
"args": [
{
"description": "The image to which to apply the transform.",
"name": "image",
"type": "Image<unknown bands>"
},
{
"default": 256,
"description": "Grid size.",
"name": "gridSize",
"optional": true,
"type": "Integer"
},
{
"default": 64.0,
"description": "Value threshold for input image. Pixels equal to or above this value are considered active.",
"name": "inputThreshold",
"optional": true,
"type": "Float"
},
{
"default": 72.0,
"description": "Threshold for line detection. Values equal to or above this threshold on the Hough transform are considered to be detected lines.",
"name": "lineThreshold",
"optional": true,
"type": "Float"
},
{
"default": true,
"description": "Whether to smooth the Hough transform before line detection.",
"name": "smooth",
"optional": true,
"type": "Boolean"
}
],
"description": "Applies the Hough transform to an image. For every input band, outputs a band where lines are detected by thresholding the Hough transform with a value of lineThreshold. The output band is named [input]_lines, where [input] is the name of the original band. The defaults provided for the parameters are intended as a starting point for use with UINT8 images. ",
"returns": "Image<unknown bands>",
"type": "Algorithm",
"hidden": false
},
"Collection.distinct": {
"args": [
{
"description": "The input collection from which objects will be selected.",
"name": "collection",
"type": "FeatureCollection"
},
{
"description": "Which parts of the object to use for comparisons.",
"name": "selectors",
"type": "SelectorSet"
}
],
"description": "Removes duplicates from a collection. Note that duplicates are determined using a strong hash over the serialized form of the selected properties.",
"returns": "FeatureCollection",
"type": "Algorithm",
"hidden": false
}
}
}
Raw
gen-jsdoc.js
/**
* Generate JSDoc from Earth Engine algorithm descriptors.
*
* Copyright 2019 Google LLC.
* SPDX-License-Identifier: Apache-2.0
*/
const fs = require('fs');
const algorithms = require('./algorithms.json');
const filterType = (type) => type.replace('<unknown bands>', '');
const docs = Object.keys(algorithms.data).sort().map((fn) => {
const def = algorithms.data[fn];
if (def.hidden) return '';
const className = fn.split('.').shift();
let isStatic = true;
const params = def.args.map((arg, index) => {
// Functions are instance methods if the first argument has the same type as
// the base object, otherwise static.
// TODO(donmccurdy): Does this apply to subclasses?
if (index === 0 && arg.type === className) {
isStatic = false;
}
return `@param {${filterType(arg.type)}} ${arg.name} ${arg.description || ''}`;
});
if (!isStatic) {
let fnParts = fn.split('.');
fn = [fnParts[0], 'prototype',fnParts.slice(1)].join('.');
}
return `
/**
* ${def.description}
* ${params.join('\n * ')}
* @return ${def.returns ? '{' + filterType(def.returns) + '}' : ''}
*/
ee.${fn};`;
}).join('\n');
fs.writeFileSync('output-jsdoc.js', docs);
Raw
output-jsdoc.js
This file has been truncated, but you can view the full file.
/**
* Aggregates over a given property of the objects in a collection, calculating a list of all the values of the selected property.
* @param {FeatureCollection} collection The collection to aggregate over.
* @param {String} property The property to use from each element of the collection.
* @return {Object}
*/
ee.AggregateFeatureCollection.array;
/**
* Aggregates over a given property of the objects in a collection, calculating the number of non-null values of the property.
* @param {FeatureCollection} collection The collection to aggregate over.
* @param {String} property The property to use from each element of the collection.
* @return {Object}
*/
ee.AggregateFeatureCollection.count;
/**
* Aggregates over a given property of the objects in a collection, calculating the number of distinct values for the selected property.
* @param {FeatureCollection} collection The collection to aggregate over.
* @param {String} property The property to use from each element of the collection.
* @return {Object}
*/
ee.AggregateFeatureCollection.count_distinct;
/**
* Aggregates over a given property of the objects in a collection, calculating the property value of the first object in the collection.
* @param {FeatureCollection} collection The collection to aggregate over.
* @param {String} property The property to use from each element of the collection.
* @return {Object}
*/
ee.AggregateFeatureCollection.first;
/**
* Aggregates over a given property of the objects in a collection, calculating a histogram of the selected property.
* @param {FeatureCollection} collection The collection to aggregate over.
* @param {String} property The property to use from each element of the collection.
* @return {Object}
*/
ee.AggregateFeatureCollection.histogram;
/**
* Aggregates over a given property of the objects in a collection, calculating the maximum of the values of the selected property.
* @param {FeatureCollection} collection The collection to aggregate over.
* @param {String} property The property to use from each element of the collection.
* @return {Object}
*/
ee.AggregateFeatureCollection.max;
/**
* Aggregates over a given property of the objects in a collection, calculating the mean of the selected property.
* @param {FeatureCollection} collection The collection to aggregate over.
* @param {String} property The property to use from each element of the collection.
* @return {Object}
*/
ee.AggregateFeatureCollection.mean;
/**
* Aggregates over a given property of the objects in a collection, calculating the minimum of the values of the selected property.
* @param {FeatureCollection} collection The collection to aggregate over.
* @param {String} property The property to use from each element of the collection.
* @return {Object}
*/
ee.AggregateFeatureCollection.min;
/**
* Aggregates over a given property of the objects in a collection, calculating the product of the values of the selected property.
* @param {FeatureCollection} collection The collection to aggregate over.
* @param {String} property The property to use from each element of the collection.
* @return {Object}
*/
ee.AggregateFeatureCollection.product;
/**
* Aggregates over a given property of the objects in a collection, calculating the sample std. deviation of the values of the selected property.
* @param {FeatureCollection} collection The collection to aggregate over.
* @param {String} property The property to use from each element of the collection.
* @return {Object}
*/
ee.AggregateFeatureCollection.sample_sd;
/**
* Aggregates over a given property of the objects in a collection, calculating the sample variance of the values of the selected property.
* @param {FeatureCollection} collection The collection to aggregate over.
* @param {String} property The property to use from each element of the collection.
* @return {Object}
*/
ee.AggregateFeatureCollection.sample_var;
/**
* Aggregates over a given property of the objects in a collection, calculating the sum, min, max, mean, sample standard deviation, sample variance, total standard deviation and total variance of the selected property.
* @param {FeatureCollection} collection The collection to aggregate over.
* @param {String} property The property to use from each element of the collection.
* @return {Object}
*/
ee.AggregateFeatureCollection.stats;
/**
* Aggregates over a given property of the objects in a collection, calculating the sum of the values of the selected property.
* @param {FeatureCollection} collection The collection to aggregate over.
* @param {String} property The property to use from each element of the collection.
* @return {Object}
*/
ee.AggregateFeatureCollection.sum;
/**
* Aggregates over a given property of the objects in a collection, calculating the total std. deviation of the values of the selected property.
* @param {FeatureCollection} collection The collection to aggregate over.
* @param {String} property The property to use from each element of the collection.
* @return {Object}
*/
ee.AggregateFeatureCollection.total_sd;
/**
* Aggregates over a given property of the objects in a collection, calculating the total variance of the values of the selected property.
* @param {FeatureCollection} collection The collection to aggregate over.
* @param {String} property The property to use from each element of the collection.
* @return {Object}
*/
ee.AggregateFeatureCollection.total_var;
/**
* Append src as a child of dst.
* @param {Annotation} dst
* @param {Object} src An annotation or a List of annotations to add as children of dst.
* @return {Annotation}
*/
ee.Annotation.prototype.append;
/**
* Apply additional attributes to an annotation.
* @param {Annotation} annotation
* @param {Dictionary<Object>} attr
* @return {Annotation}
*/
ee.Annotation.prototype.attr;
/**
* Creates a circle annotation.
* @param {Float} cx The x-axis coordinate of the center of the circle.
* @param {Float} cy The y-axis coordinate of the center of the circle.
* @param {Float} r The radius of the circle.
* @return {Annotation}
*/
ee.Annotation.circle;
/**
* Creates an ellipse annotation.
* @param {Float} cx The x-axis coordinate of the center of the ellipse.
* @param {Float} cy The y-axis coordinate of the center of the ellipse.
* @param {Float} rx The x-axis radius of the ellipse.
* @param {Float} ry The y-axis radius of the ellipse.
* @return {Annotation}
*/
ee.Annotation.ellipse;
/**
* Creates a rectangle annotation.
* @param {Float} x The x-axis coordinate of the upper-left corner of the rectangle.
* @param {Float} y The y-axis coordinate of the upper-left corner of the rectangle.
* @param {Float} width The width of the rectangle.
* @param {Float} height The height of the rectangle.
* @param {String} fill The color with which to fill the rectangle.
* @param {Float} radius For rounded rectangles, the radius of the circle to used to round off corners of the rectangle.
* @return {Annotation}
*/
ee.Annotation.rect;
/**
* Apply a style to an annotation.
* @param {Annotation} annotation
* @param {Dictionary<Object>} style
* @return {Annotation}
*/
ee.Annotation.prototype.style;
/**
* Creates a SVG container. Any annotations added to the container are positioned relative to the container's x and y position, and inherit any styles applied to the container.
* @param {Float} x The x-axis coordinate of the upper-left corner.
* @param {Float} y The y-axis coordinate of the upper-left corner.
* @return {Annotation}
*/
ee.Annotation.svg;
/**
* Creates a text annotation.
* @param {Float} x The x-axis coordinate for the start of the text.
* @param {Float} y The y-axis coordinate for the start of the text.
* @param {String} text The text to render.
* @param {Float} fontSize The size of the font to use in rendering the text (in pixels).
* @return {Annotation}
*/
ee.Annotation.text;
/**
* Returns an array with the given coordinates.
* @param {Object} values An existing array to cast, or a number/list of numbers/nested list of numbers of any depth to create an array from. For nested lists, all inner arrays at the same depth must have the same length, and numbers may only be present at the deepest level.
* @param {PixelType} pixelType The type of each number in the values argument. If the pixel type is not provided, it will be inferred from the numbers in 'values'. If there aren't any numbers in 'values', this type must be provided.
* @return {Array}
*/
ee.Array;
/**
* On an element-wise basis, computes the absolute value of the input.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.abs;
/**
* Accumulates elements of an array along the given axis, by setting each element of the result to the reduction of elements along that axis up to and including the current position. May be used to make a cumulative sum, a monotonically increasing sequence, etc.
* @param {Array} array Array to accumulate.
* @param {Integer} axis Axis along which to perform the accumulation.
* @param {Reducer} reducer Reducer to accumulate values. Default is SUM, to produce the cumulative sum of each vector along the given axis.
* @return {Array}
*/
ee.Array.prototype.accum;
/**
* On an element-wise basis, computes the arc cosine in radians of the input.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.acos;
/**
* On an element-wise basis, adds the first value to the second.
* @param {Array} left The left-hand value.
* @param {Array} right The right-hand value.
* @return {Array}
*/
ee.Array.prototype.add;
/**
* On an element-wise basis, returns 1 iff both values are non-zero.
* @param {Array} left The left-hand value.
* @param {Array} right The right-hand value.
* @return {Array}
*/
ee.Array.prototype.and;
/**
* On an element-wise basis, computes the arc sine in radians of the input.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.asin;
/**
* On an element-wise basis, computes the arc tangent in radians of the input.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.atan;
/**
* On an element-wise basis, calculates the angle formed by the 2D vector [x, y].
* @param {Array} left The left-hand value.
* @param {Array} right The right-hand value.
* @return {Array}
*/
ee.Array.prototype.atan2;
/**
* On an element-wise basis, calculates the number of one-bits in the 64-bit two's complement binary representation of the input.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.bitCount;
/**
* Convert the bits of an integer to an Array. The array has as many elements as the position of the highest set bit, or a single 0 for a value of 0.
* @param {Number} input
* @return {Array}
*/
ee.Array.bitsToArray;
/**
* On an element-wise basis, calculates the bitwise AND of the input values.
* @param {Array} left The left-hand value.
* @param {Array} right The right-hand value.
* @return {Array}
*/
ee.Array.prototype.bitwiseAnd;
/**
* On an element-wise basis, calculates the bitwise NOT of the input, in the smallest signed integer type that can hold the input.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.bitwiseNot;
/**
* On an element-wise basis, calculates the bitwise OR of the input values.
* @param {Array} left The left-hand value.
* @param {Array} right The right-hand value.
* @return {Array}
*/
ee.Array.prototype.bitwiseOr;
/**
* On an element-wise basis, calculates the bitwise XOR of the input values.
* @param {Array} left The left-hand value.
* @param {Array} right The right-hand value.
* @return {Array}
*/
ee.Array.prototype.bitwiseXor;
/**
* On an element-wise basis, calculates the bitwise AND of the input values.
* @param {Array} left The left-hand value.
* @param {Array} right The right-hand value.
* @return {Array}
*/
ee.Array.prototype.bitwise_and;
/**
* On an element-wise basis, calculates the bitwise NOT of the input, in the smallest signed integer type that can hold the input.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.bitwise_not;
/**
* On an element-wise basis, calculates the bitwise OR of the input values.
* @param {Array} left The left-hand value.
* @param {Array} right The right-hand value.
* @return {Array}
*/
ee.Array.prototype.bitwise_or;
/**
* On an element-wise basis, calculates the bitwise XOR of the input values.
* @param {Array} left The left-hand value.
* @param {Array} right The right-hand value.
* @return {Array}
*/
ee.Array.prototype.bitwise_xor;
/**
* On an element-wise basis, casts the input value to an unsigned 8-bit integer.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.byte;
/**
* Concatenates multiple arrays into a single array along the given axis. Each array must have the same dimensionality and the same length on all axes except the concatenation axis.
* @param {List<Array>} arrays Arrays to concatenate.
* @param {Integer} axis Axis to concatenate along.
* @return {Array}
*/
ee.Array.cat;
/**
* On an element-wise basis, computes the cubic root of the input.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.cbrt;
/**
* On an element-wise basis, computes the smallest integer greater than or equal to the input.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.ceil;
/**
* On an element-wise basis, computes the cosine of the input in radians.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.cos;
/**
* On an element-wise basis, computes the hyperbolic cosine of the input.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.cosh;
/**
* Cut an array along one or more axes.
* @param {Array} array The array to cut.
* @param {List<Integer>} position Cut an array along one or more axes. The positions args specifies either a single value for each axis of the array, or -1, indicating the whole axis. The output will be an array that has the same dimensions as the input, with a length of 1 on each axis that was not -1 in the positions array.
* @return {Array}
*/
ee.Array.prototype.cut;
/**
* On an element-wise basis, computes the digamma function of the input.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.digamma;
/**
* On an element-wise basis, divides the first value by the second, returning 0 for division by 0.
* @param {Array} left The left-hand value.
* @param {Array} right The right-hand value.
* @return {Array}
*/
ee.Array.prototype.divide;
/**
* Compute the dot product between two 1-D arrays.
* @param {Array} array1 The first 1-D array.
* @param {Array} array2 The second 1-D array.
* @return {Number}
*/
ee.Array.prototype.dotProduct;
/**
* On an element-wise basis, casts the input value to a 64-bit float.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.double;
/**
* Computes the real eigenvectors and eigenvalues of a square 2D array of A rows and A columns. Returns an array with A rows and A+1 columns, where each row contains an eigenvalue in the first column, and the corresponding eigenvector in the remaining A columns. The rows are sorted by eigenvalue, in descending order.
* @param {Array} input A square, 2D array from which to compute the eigenvalue decomposition.
* @return {Array}
*/
ee.Array.prototype.eigen;
/**
* On an element-wise basis, returns 1 iff the first value is equal to the second.
* @param {Array} left The left-hand value.
* @param {Array} right The right-hand value.
* @return {Array}
*/
ee.Array.prototype.eq;
/**
* On an element-wise basis, computes the error function of the input.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.erf;
/**
* On an element-wise basis, computes the inverse error function of the input.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.erfInv;
/**
* On an element-wise basis, computes the complementary error function of the input.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.erfc;
/**
* On an element-wise basis, computes the inverse complementary error function of the input.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.erfcInv;
/**
* On an element-wise basis, computes the Euler's number e raised to the power of the input.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.exp;
/**
* On an element-wise basis, selects the value of the first value.
* @param {Array} left The left-hand value.
* @param {Array} right The right-hand value.
* @return {Array}
*/
ee.Array.prototype.first;
/**
* On an element-wise basis, selects the first value if it is non-zero, and the second value otherwise.
* @param {Array} left The left-hand value.
* @param {Array} right The right-hand value.
* @return {Array}
*/
ee.Array.prototype.firstNonZero;
/**
* On an element-wise basis, selects the first value if it is non-zero, and the second value otherwise.
* @param {Array} left The left-hand value.
* @param {Array} right The right-hand value.
* @return {Array}
*/
ee.Array.prototype.first_nonzero;
/**
* On an element-wise basis, casts the input value to a 32-bit float.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.float;
/**
* On an element-wise basis, computes the largest integer less than or equal to the input.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.floor;
/**
* On an element-wise basis, computes the gamma function of the input.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.gamma;
/**
* On an element-wise basis, calculates the regularized lower incomplete Gamma function γ(x,a).
* @param {Array} left The left-hand value.
* @param {Array} right The right-hand value.
* @return {Array}
*/
ee.Array.prototype.gammainc;
/**
* Extracts the value at the given position from the input array.
* @param {Array} array The array to extract from.
* @param {List<Integer>} position The coordinates of the element to get.
* @return {Number}
*/
ee.Array.prototype.get;
/**
* On an element-wise basis, returns 1 iff the first value is greater than the second.
* @param {Array} left The left-hand value.
* @param {Array} right The right-hand value.
* @return {Array}
*/
ee.Array.prototype.gt;
/**
* On an element-wise basis, returns 1 iff the first value is greater than or equal to the second.
* @param {Array} left The left-hand value.
* @param {Array} right The right-hand value.
* @return {Array}
*/
ee.Array.prototype.gte;
/**
* On an element-wise basis, calculates the magnitude of the 2D vector [x, y].
* @param {Array} left The left-hand value.
* @param {Array} right The right-hand value.
* @return {Array}
*/
ee.Array.prototype.hypot;
/**
* Creates a 2D identity matrix of the given size.
* @param {Integer} size The length of each axis.
* @return {Array}
*/
ee.Array.identity;
/**
* On an element-wise basis, casts the input value to a signed 32-bit integer.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.int;
/**
* On an element-wise basis, casts the input value to a signed 16-bit integer.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.int16;
/**
* On an element-wise basis, casts the input value to a signed 32-bit integer.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.int32;
/**
* On an element-wise basis, casts the input value to a signed 64-bit integer.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.int64;
/**
* On an element-wise basis, casts the input value to a signed 8-bit integer.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.int8;
/**
* On an element-wise basis, computes the Lanczos approximation of the input.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.lanczos;
/**
* On an element-wise basis, calculates the left shift of v1 by v2 bits.
* @param {Array} left The left-hand value.
* @param {Array} right The right-hand value.
* @return {Array}
*/
ee.Array.prototype.leftShift;
/**
* On an element-wise basis, calculates the left shift of v1 by v2 bits.
* @param {Array} left The left-hand value.
* @param {Array} right The right-hand value.
* @return {Array}
*/
ee.Array.prototype.left_shift;
/**
* Returns a 1-D EEArray containing the length of each dimension of the given EEArray.
* @param {Array} array The array from which to extract the axis lengths.
* @return {Array}
*/
ee.Array.prototype.length;
/**
* On an element-wise basis, computes the natural logarithm of the input.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.log;
/**
* On an element-wise basis, computes the base-10 logarithm of the input.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.log10;
/**
* On an element-wise basis, casts the input value to a signed 64-bit integer.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.long;
/**
* On an element-wise basis, returns 1 iff the first value is less than the second.
* @param {Array} left The left-hand value.
* @param {Array} right The right-hand value.
* @return {Array}
*/
ee.Array.prototype.lt;
/**
* On an element-wise basis, returns 1 iff the first value is less than or equal to the second.
* @param {Array} left The left-hand value.
* @param {Array} right The right-hand value.
* @return {Array}
*/
ee.Array.prototype.lte;
/**
* Creates a subarray by slicing out each position in an input array that is parallel to a non-zero element of the given mask array.
* @param {Array} input Array to mask.
* @param {Array} mask Mask array.
* @return {Array}
*/
ee.Array.prototype.mask;
/**
* Calculates the Cholesky decomposition of a matrix. The Cholesky decomposition is a decomposition into the form L*L' where L is a lower triangular matrix. The input must be a symmetric positive-definite matrix. Returns a dictionary with 1 entry named 'L'.
* @param {Array} array The array to decompose.
* @return {Dictionary<Object>}
*/
ee.Array.prototype.matrixCholeskyDecomposition;
/**
* Computes the determinant of the matrix.
* @param {Array} input The array to compute on.
* @return {Number}
*/
ee.Array.prototype.matrixDeterminant;
/**
* Computes the diagonal of the matrix in a single column.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.matrixDiagonal;
/**
* Computes the Frobenius norm of the matrix.
* @param {Array} input The array to compute on.
* @return {Number}
*/
ee.Array.prototype.matrixFnorm;
/**
* Computes the inverse of the matrix.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.matrixInverse;
/**
* Calculates the LU matrix decomposition such that P×input=L×U, where L is lower triangular (with unit diagonal terms), U is upper triangular and P is a partial pivot permutation matrix. The input matrix must be square. Returns a dictionary with entries named 'L', 'U' and 'P'.
* @param {Array} array The array to decompose.
* @return {Dictionary<Object>}
*/
ee.Array.prototype.matrixLUDecomposition;
/**
* Returns the matrix multiplication A*B.
* @param {Array} left The left-hand value.
* @param {Array} right The right-hand value.
* @return {Array}
*/
ee.Array.prototype.matrixMultiply;
/**
* Computes the Moore-Penrose pseudoinverse of the matrix.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.matrixPseudoInverse;
/**
* Calculates the QR-decomposition of a matrix into two matrices Q and R such that input = QR, where Q is orthogonal, and R is upper triangular. Returns a dictionary with entries named 'Q' and 'R'.
* @param {Array} array The array to decompose.
* @return {Dictionary<Object>}
*/
ee.Array.prototype.matrixQRDecomposition;
/**
* Calculates the Singular Value Decomposition of the input matrix into U×S×V', such that U and V are orthogonal and S is diagonal. Returns a dictionary with entries named 'U', 'S' and 'V'.
* @param {Array} array The array to decompose.
* @return {Dictionary<Object>}
*/
ee.Array.prototype.matrixSingularValueDecomposition;
/**
* Solves for x in the matrix equation A*x=B, finding a least-squares solution if A is overdetermined.
* @param {Array} left The left-hand value.
* @param {Array} right The right-hand value.
* @return {Array}
*/
ee.Array.prototype.matrixSolve;
/**
* Computes a square diagonal matrix from a single column matrix.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.matrixToDiag;
/**
* Computes the trace of the matrix.
* @param {Array} input The array to compute on.
* @return {Number}
*/
ee.Array.prototype.matrixTrace;
/**
* Transposes two dimensions of an array.
* @param {Array} array Array to transpose.
* @param {Integer} axis1 First axis to swap.
* @param {Integer} axis2 Second axis to swap.
* @return {Array}
*/
ee.Array.prototype.matrixTranspose;
/**
* On an element-wise basis, selects the maximum of the first and second values.
* @param {Array} left The left-hand value.
* @param {Array} right The right-hand value.
* @return {Array}
*/
ee.Array.prototype.max;
/**
* On an element-wise basis, selects the minimum of the first and second values.
* @param {Array} left The left-hand value.
* @param {Array} right The right-hand value.
* @return {Array}
*/
ee.Array.prototype.min;
/**
* On an element-wise basis, calculates the remainder of the first value divided by the second.
* @param {Array} left The left-hand value.
* @param {Array} right The right-hand value.
* @return {Array}
*/
ee.Array.prototype.mod;
/**
* On an element-wise basis, multiplies the first value by the second.
* @param {Array} left The left-hand value.
* @param {Array} right The right-hand value.
* @return {Array}
*/
ee.Array.prototype.multiply;
/**
* On an element-wise basis, returns 1 iff the first value is not equal to the second.
* @param {Array} left The left-hand value.
* @param {Array} right The right-hand value.
* @return {Array}
*/
ee.Array.prototype.neq;
/**
* On an element-wise basis, returns 0 if the input is non-zero, and 1 otherwise.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.not;
/**
* On an element-wise basis, returns 1 iff either input value is non-zero.
* @param {Array} left The left-hand value.
* @param {Array} right The right-hand value.
* @return {Array}
*/
ee.Array.prototype.or;
/**
* On an element-wise basis, raises the first value to the power of the second.
* @param {Array} left The left-hand value.
* @param {Array} right The right-hand value.
* @return {Array}
*/
ee.Array.prototype.pow;
/**
* Projects an array to a lower dimensional space by specifying the axes to retain. Dropped axes must be at most length 1.
* @param {Array} array Array to project.
* @param {List<Integer>} axes The axes to project onto. Other axes will be discarded, and must be at most length 1.
* @return {Array}
*/
ee.Array.prototype.project;
/**
* Apply a reducer to an array by collapsing all the input values along each specified axis into a single output value computed by the reducer.
* @param {Array} array The array.
* @param {Reducer} reducer The reducer to apply
* @param {List<Integer>} axes The list of axes over which to reduce. The output will have a length of 1 in all these axes.
* @param {Integer} fieldAxis The axis for the reducer's input and output fields. Only required if the reducer has multiple inputs or outputs.
* @return {Array}
*/
ee.Array.prototype.reduce;
/**
* Repeats the array along the given axis. The result will have the shape of the input, except length along the repeated axis will be multiplied by the given number of copies.
* @param {Array} array Array to repeat.
* @param {Integer} axis The axis along which to repeat the array.
* @param {Integer} copies The number of copies of this array to concatenate along the given axis.
* @return {Array}
*/
ee.Array.prototype.repeat;
/**
* On an element-wise basis, calculates the signed right shift of v1 by v2 bits.
* @param {Array} left The left-hand value.
* @param {Array} right The right-hand value.
* @return {Array}
*/
ee.Array.prototype.rightShift;
/**
* On an element-wise basis, calculates the signed right shift of v1 by v2 bits.
* @param {Array} left The left-hand value.
* @param {Array} right The right-hand value.
* @return {Array}
*/
ee.Array.prototype.right_shift;
/**
* On an element-wise basis, computes the integer nearest to the input.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.round;
/**
* On an element-wise basis, casts the input value to a signed 16-bit integer.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.short;
/**
* On an element-wise basis, computes the sine of the input in radians.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.sin;
/**
* On an element-wise basis, computes the hyperbolic sine of the input.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.sinh;
/**
* Creates a subarray by slicing out each position along the given axis from the 'start' (inclusive) to 'end' (exclusive) by increments of 'step'. The result will have as many dimensions as the input, and the same length in all directions except the slicing axis, where the length will be the number of positions from 'start' to 'end' by 'step' that are in range of the input array's length along 'axis'. This means the result can be length 0 along the given axis if start=end, or if the start or end values are entirely out of range.
* @param {Array} array Array to slice.
* @param {Integer} axis The axis to slice on.
* @param {Integer} start The coordinate of the first slice (inclusive) along 'axis'. Negative numbers are used to position the start of slicing relative to the end of the array, where -1 starts at the last position on the axis, -2 starts at the next to last position, etc.
* @param {Integer} end The coordinate (exclusive) at which to stop taking slices. By default this will be the length of the given axis. Negative numbers are used to position the end of slicing relative to the end of the array, where -1 will exclude the last position, -2 will exclude the last two positions, etc.
* @param {Integer} step The separation between slices along 'axis'; a slice will be taken at each whole multiple of 'step' from 'start' (inclusive) to 'end' (exclusive). Must be positive.
* @return {Array}
*/
ee.Array.prototype.slice;
/**
* Sorts elements of the array along one axis.
* @param {Array} array Array image to sort.
* @param {Array} keys Optional keys to sort by. If not provided, the values are used as the keys. The keys can only have multiple elements along one axis, which determines the direction to sort in.
* @return {Array}
*/
ee.Array.prototype.sort;
/**
* On an element-wise basis, computes the square root of the input.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.sqrt;
/**
* On an element-wise basis, subtracts the second value from the first.
* @param {Array} left The left-hand value.
* @param {Array} right The right-hand value.
* @return {Array}
*/
ee.Array.prototype.subtract;
/**
* On an element-wise basis, computes the tangent of the input in radians.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.tan;
/**
* On an element-wise basis, computes the hyperbolic tangent of the input.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.tanh;
/**
* On an element-wise basis, casts the input value to an unsigned 8-bit integer.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.toByte;
/**
* On an element-wise basis, casts the input value to a 64-bit float.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.toDouble;
/**
* On an element-wise basis, casts the input value to a 32-bit float.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.toFloat;
/**
* On an element-wise basis, casts the input value to a signed 32-bit integer.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.toInt;
/**
* On an element-wise basis, casts the input value to a signed 16-bit integer.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.toInt16;
/**
* On an element-wise basis, casts the input value to a signed 32-bit integer.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.toInt32;
/**
* On an element-wise basis, casts the input value to a signed 64-bit integer.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.toInt64;
/**
* On an element-wise basis, casts the input value to a signed 8-bit integer.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.toInt8;
/**
* Turns an Array into a list of lists of numbers.
* @param {Array} array Array to convert.
* @return {List<Object>}
*/
ee.Array.prototype.toList;
/**
* On an element-wise basis, casts the input value to a signed 64-bit integer.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.toLong;
/**
* On an element-wise basis, casts the input value to a signed 16-bit integer.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.toShort;
/**
* On an element-wise basis, casts the input value to an unsigned 16-bit integer.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.toUint16;
/**
* On an element-wise basis, casts the input value to an unsigned 32-bit integer.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.toUint32;
/**
* On an element-wise basis, casts the input value to an unsigned 8-bit integer.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.toUint8;
/**
* Transposes two dimensions of an array.
* @param {Array} array Array to transpose.
* @param {Integer} axis1 First axis to swap.
* @param {Integer} axis2 Second axis to swap.
* @return {Array}
*/
ee.Array.prototype.transpose;
/**
* On an element-wise basis, computes the trigamma function of the input.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.trigamma;
/**
* On an element-wise basis, casts the input value to an unsigned 16-bit integer.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.uint16;
/**
* On an element-wise basis, casts the input value to an unsigned 32-bit integer.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.uint32;
/**
* On an element-wise basis, casts the input value to an unsigned 8-bit integer.
* @param {Array} input The input array.
* @return {Array}
*/
ee.Array.prototype.uint8;
/**
* Loads a Blob from a Google Cloud Storage URL.
* @param {String} url The Blob's Google Cloud Storage URL.
* @return {Blob}
*/
ee.Blob;
/**
* Returns the contents of the blob as a String.
* @param {Blob} blob
* @param {String} encoding
* @return {String}
*/
ee.Blob.prototype.string;
/**
* Returns the Blob's Google Cloud Storage URL.
* @param {Blob} blob
* @return {String}
*/
ee.Blob.prototype.url;
/**
* Applies the Canny edge detection algorithm to an image. The output is an image whose bands have the same names as the input bands, and in which non-zero values indicate edges, and the magnitude of the value is the gradient magnitude.
* @param {Image} image The image on which to apply edge detection.
* @param {Float} threshold Threshold value. The pixel is only considered for edge detection if the gradient magnitude is higher than this threshold.
* @param {Float} sigma Sigma value for a gaussian filter applied before edge detection. 0 means apply no filtering.
* @return {Image}
*/
ee.CannyEdgeDetector;
/**
* Creates an empty CART classifier. See:
"Classification and Regression Trees,"
L. Breiman, J. Friedman, R. Olshen, C. Stone
Chapman and Hall, 1984.
* @param {Integer} crossvalidationFactor The cross-validation factor for pruning.
* @param {Integer} maxDepth Do not grow initial tree deeper than this many levels.
* @param {Integer} minLeafPopulation Only create nodes whose training set contains at least this many points.
* @param {Integer} minSplitPoplulation Do not split unless node has at least this many points.
* @param {Float} minSplitCost Do not split if training set cost less than this.
* @param {Boolean} prune Whether to skip pruning; i.e., only impose stopping criteria while growing the tree.
* @param {Float} pruneErrorTolerance The standard error threshold to use in determining the simplest tree whose accuracy is comparable to the minimum cost-complexity tree.
* @param {Integer} quantizationResolution The quantization resolution for numerical features.
* @param {Float} quantizationMargin The margin reserved by quantizer to avoid overload, as a fraction of the range observed in the training data.
* @param {Integer} randomSeed The randomization seed.
* @return {Classifier}
*/
ee.Classifier.cart;
/**
* Computes a 2D confusion matrix for a classifier based on its training data (ie: resubstitution error). Axis 0 of the matrix correspond to the input classes, and axis 1 to the output classes. The rows and columns start at class 0 and increase sequentially up to the maximum class value, so some rows or columns might be empty if the input classes aren't 0-based or sequential.
* @param {Classifier} classifier The classifier to use.
* @return {ConfusionMatrix}
*/
ee.Classifier.prototype.confusionMatrix;
/**
* Creates an empty Continuous Naive Bayes classifier.
* @param {Float} lambda A smoothing lambda. Used to avoid assigning zero probability to classes not seen during training, instead using lambda / (lambda * nFeatures).
* @return {Classifier}
*/
ee.Classifier.continuousNaiveBayes;
/**
* Creates a classifier that applies the given decision tree.
* @param {String} treeString The decision tree, specified in the text format generated by R and other similar tools.
* @return {Classifier}
*/
ee.Classifier.decisionTree;
/**
* Describe the results of a trained classifier.
* @param {Classifier} classifier The classifier to describe.
* @return {Dictionary<Object>}
*/
ee.Classifier.prototype.explain;
/**
* Creates an empty linear regression. This regression supports L1 and L2 regularization as well as a smoothed L1 regularization using a logistic loss function. Note that the model used by this regression does not include a bias by default and a constant value should be included if a bias is required (it is suggested). This classifier only supports REGRESSION mode.
* @param {Float} weight1 The weight for L1 regularization. Larger weight leads to heavier regularization.
* @param {Float} weight2 The weight for L2 regularization. Larger weight leads to heavier regularization.
* @param {Float} epsilon The epsilon for stopping optimization.
* @param {Integer} maxIterations The maximum number of iterations.
* @param {Boolean} smooth Use a logistic loss function for the L1 regularization.
* @return {Classifier}
*/
ee.Classifier.gmoLinearRegression;
/**
* Creates an empty GMO Maximum Entropy classifier. See:
"Efficient Large-Scale Distributed Training of Conditional Maximum Entropy Models,"
G. Mann, R. McDonald, M. Mohri, N. Silberman, D. Walker.
* @param {Float} weight1 The weight for L1 regularization.
* @param {Float} weight2 The weight for L2 regularization.
* @param {Float} epsilon The epsilon for stopping optimization.
* @param {Integer} minIterations The minimum number of iterations of optimizer.
* @param {Integer} maxIterations The maximum number of iterations of optimizer.
* @return {Classifier}
*/
ee.Classifier.gmoMaxEnt;
/**
* Creates an IKPAMIR (Intersection Kernel Passive-Aggressive Method for Information Retrieval) classifier. See:
"Classification using Intersection Kernel Support Vector Machinesis Efficient"
S. Maji, A. Berg, J. Malik
* @param {Integer} numBins The number of histogram bins per dimension.
* @param {Float} learningRate The rate of learning from each example.
* @param {Integer} epochs The maximum number of epochs.
* @return {Classifier}
*/
ee.Classifier.ikpamir;
/**
* Creates a minimum distance classifier for the given distance metric.
* @param {String} metric The distance metric to use. Options are:
'euclidean' - euclidean distance from the unnormalized class mean.
'cosine' - spectral angle from the unnormalized class mean.
'mahalanobis' - Mahalanobis distance from the class mean.
* @return {Classifier}
*/
ee.Classifier.minimumDistance;
/**
* Returns the classifier mode: CLASSIFICATION, REGRESSION or PROBABILITY.
* @param {Classifier} classifier
* @return {String}
*/
ee.Classifier.prototype.mode;
/**
* Creates an empty Fast Naive Bayes classifier.
* @param {Float} lambda A smoothing lambda. Used to avoid assigning zero probability to classes not seen during training, instead using lambda / (lambda * nFeatures).
* @return {Classifier}
*/
ee.Classifier.naiveBayes;
/**
* Creates an empty gaussian Pegasos classifier. See:
"Pegasos (Primal Estimated sub-GrAdient SOlver for SVM)"
S. Shalev-Shwartz, Y. Singer, N. Srebro, A. Cotter
* @param {Float} rbfGamma The gamma value of the Gaussian kernel.
* @param {String} lossFunction The loss function to use. Valid values are: 'HingeSum', 'HingeMax', 'LogSum' and 'LogMax'
* @param {Float} lambda The regularization parameter of SVM (lambda).
* @param {Integer} iterations The number of iterations (T). When set to 0 (default), the number of training iterations is automatically set to 5 * training data size (~5 epochs).
* @param {Integer} subsetSize The subset size (k), i.e. the number of random samples to process on each iteration.
* @param {Float} regularizationNorm The norm of w for regularization.
* @param {Float} multiGamma The gamma value for the loss function in multi-class classification.
* @return {Classifier}
*/
ee.Classifier.pegasosGaussian;
/**
* Creates an empty linear Pegasos classifier. See:
"Pegasos (Primal Estimated sub-GrAdient SOlver for SVM)"
S. Shalev-Shwartz, Y. Singer, N. Srebro, A. Cotter
* @param {Boolean} useExponentiated Whether to use exponentiated update.
* @param {String} lossFunction The loss function to use. Valid values are: 'HingeSum', 'HingeMax', 'LogSum' and 'LogMax'
* @param {Float} lambda The regularization parameter of SVM (lambda).
* @param {Integer} iterations The number of iterations (T). When set to 0 (default), the number of training iterations is automatically set to 5 * training data size (~5 epochs).
* @param {Integer} subsetSize The subset size (k), i.e. the number of random samples to process on each iteration.
* @param {Float} regularizationNorm The norm of w for regularization.
* @param {Float} multiGamma The gamma value for the loss function in multi-class classification.
* @return {Classifier}
*/
ee.Classifier.pegasosLinear;
/**
* Creates an empty polynomial Pegasos classifier. See:
"Pegasos (Primal Estimated sub-GrAdient SOlver for SVM)"
S. Shalev-Shwartz, Y. Singer, N. Srebro, A. Cotter
* @param {Integer} polyDegree The degree of the Polynomial kernel.
* @param {Float} polyBias The bias of the Polynomial kernel.
* @param {String} lossFunction The loss function to use. Valid values are: 'HingeSum', 'HingeMax', 'LogSum' and 'LogMax'
* @param {Float} lambda The regularization parameter of SVM (lambda).
* @param {Integer} iterations The number of iterations (T). When set to 0 (default), the number of training iterations is automatically set to 5 * training data size (~5 epochs).
* @param {Integer} subsetSize The subset size (k), i.e. the number of random samples to process on each iteration.
* @param {Float} regularizationNorm The norm of w for regularization.
* @param {Float} multiGamma The gamma value for the loss function in multi-class classification.
* @return {Classifier}
*/
ee.Classifier.pegasosPolynomial;
/**
* Creates an empty Perceptron classifier. See:
"Practical Structured Learning Techniques for Natural Language Processing"
H. Daume III, pp. 9-10
* @param {Integer} epochs The number of training epochs.
* @param {Boolean} averaged Whether to use an averaged perceptron.
* @return {Classifier}
*/
ee.Classifier.perceptron;
/**
* Creates an empty Rifle Serial classifier, which uses the Random Forest algorithm.
* @param {Integer} numberOfTrees The number of Rifle decision trees to create per class.
* @param {Integer} variablesPerSplit The number of variables per split. If set to 0 (default), defaults to the square root of the number of variables.
* @param {Integer} minLeafPopulation The minimum size of a terminal node.
* @param {Float} bagFraction The fraction of input to bag per tree.
* @param {Boolean} outOfBagMode Whether the classifier should run in out-of-bag mode.
* @param {Integer} seed Random seed.
* @return {Classifier}
*/
ee.Classifier.randomForest;
/**
* Returns the names of the inputs used by this classifier, or null if this classifier has not had any training data added yet.
* @param {Classifier} classifier
* @return {List<String>}
*/
ee.Classifier.prototype.schema;
/**
* Sets the output mode.
* @param {Classifier} classifier An input classifier.
* @param {String} mode The output mode. One of:
- CLASSIFICATION (default): The output is the class number.
- REGRESSION: The output is the result of standard regression.
- PROBABILITY: The output is the probability that the classification is correct.
Not all classifier types support REGRESSION and PROBABILITY modes.
* @return {Classifier}
*/
ee.Classifier.prototype.setOutputMode;
/**
* Creates a classifier that tests if its inputs lie within a polygon defined by a set of coordinates in an arbitrary 2D coordinate system. Each input to be classified must have 2 values (e.g.: images must have 2 bands). The result will be 1 wherever the input values are contained within the given polygon and 0 otherwise.
* @param {List<List<Float>>} coordinates The coordinates of the polygon, as a list of rings. Each ring is a list of coordinate pairs (e.g.: [u1, v1, u2, v2, ..., uN, vN]). No edge may intersect any other edge. The resulting classification will be a 1 wherever the input values are within the interior of the given polygon, that is, an odd number of polygon edges must be crossed to get outside the polygon and 0 otherwise.
* @param {List<String>} schema The classifier's schema. A list of band or property names that the classifier will operate on. Since this classifier doesn't undergo a training step, these have to be specified manually. Defaults to ['u', 'v'].
* @return {Classifier}
*/
ee.Classifier.spectralRegion;
/**
* Creates a Support Vector Machine classifier.
* @param {String} decisionProcedure The decision procedure to use for classification. Either 'Voting' or 'Margin'. Not used for regression.
* @param {String} svmType The SVM type. One of C_SVC, NU_SVC, ONE_CLASS, EPSILON_SVR or NU_SVR.
* @param {String} kernelType The kernel type. One of LINEAR (u′×v), POLY ((γ×u′×v + coef₀)ᵈᵉᵍʳᵉᵉ), RBF (exp(-γ×|u-v|²)) or SIGMOID (tanh(γ×u′×v + coef₀)).
* @param {Boolean} shrinking Whether to use shrinking heuristics.
* @param {Integer} degree The degree of polynomial. Valid for POLY kernels.
* @param {Float} gamma The gamma value in the kernel function. Defaults to the reciprocal of the number of features. Valid for POLY, RBF and SIGMOID kernels.
* @param {Float} coef0 The coef₀ value in the kernel function. Defaults to 0. Valid for POLY and SIGMOID kernels.
* @param {Float} cost The cost (C) parameter. Defaults to 1. Only valid for C-SVC, epsilon-SVR, and nu-SVR.
* @param {Float} nu The nu parameter. Defaults to 0.5. Only valid for of nu-SVC, one-class SVM, and nu-SVR.
* @param {Float} terminationEpsilon The termination criterion tolerance (e). Defaults to 0.001. Only valid for epsilon-SVR.
* @param {Float} lossEpsilon The epsilon in the loss function (p). Defaults to 0.1. Only valid for epsilon-SVR.
* @param {Integer} oneClass The class of the training data on which to train in a one-class svm. Defaults to 0. Only valid for one-class SVM. Possible values are 0 and 1. The classifier output is binary (0/1) and will match this class value for the data determined to be in the class.
* @return {Classifier}
*/
ee.Classifier.svm;
/**
* Trains the classifier on a collection of features, using the specified numeric properties of each feature as training data. The geometry of the features is ignored.
* @param {Classifier} classifier An input classifier.
* @param {FeatureCollection} features The collection to train on.
* @param {String} classProperty The name of the property containing the class value. Each feature must have this property, and its value must be numeric.
* @param {List<String>} inputProperties The list of property names to include as training data. Each feature must have all these properties, and their values must be numeric. This argument is optional if the input collection contains a 'band_order' property, (as produced by Image.sample).
* @param {Float} subsampling An optional subsampling factor, within (0, 1].
* @param {Integer} subsamplingSeed A randomization seed to use for subsampling.
* @return {Classifier}
*/
ee.Classifier.prototype.train;
/**
* Creates an empty Winnow classifier. Uses an updating rule similar to the one described in:
"Automatically categorizing written texts by author gender"
M. Koppel, S. Argamon, A. Shimoni
Literary and Linguistic Computing 17(4), November 2002, pp. 401-412.
* @param {Integer} epochs The number of training epochs.
* @param {Float} learningRate The learning rate.
* @param {Float} biasLearningRate The learning rate for updating bias weights.
* @param {Float} margin The "wide-margin" (or "thick"-separator) size. If this is nonzero, the classifier updates the weights even when it just barely got the answer right. See "Mistake-Driven Learning in Text Categorization" by I. Dagan, Y. Karov, and D. Roth.
* @return {Classifier}
*/
ee.Classifier.winnow;
/**
* Returns the names of the inputs used by this Clusterer, or null if this Clusterer has not had any training data added yet.
* @param {Clusterer} clusterer
* @return {List<String>}
*/
ee.Clusterer.prototype.schema;
/**
* Trains the Clusterer on a collection of features, using the specified numeric properties of each feature as training data. The geometry of the features is ignored.
* @param {Clusterer} clusterer An input Clusterer.
* @param {FeatureCollection} features The collection to train on.
* @param {List<String>} inputProperties The list of property names to include as training data. Each feature must have all these properties, and their values must be numeric. This argument is optional if the input collection contains a 'band_order' property, (as produced by Image.sample).
* @param {Float} subsampling An optional subsampling factor, within (0, 1].
* @param {Integer} subsamplingSeed A randomization seed to use for subsampling.
* @return {Clusterer}
*/
ee.Clusterer.prototype.train;
/**
* Cascade simple k-means, selects the best k according to calinski-harabasz criterion. For more information see:
Calinski, T. and J. Harabasz. 1974. A dendrite method for cluster analysis. Commun. Stat. 3: 1-27.
* @param {Integer} minClusters Min number of clusters.
* @param {Integer} maxClusters Max number of clusters.
* @param {Integer} restarts Number of restarts.
* @param {Boolean} manual Manually select the number of clusters.
* @param {Boolean} init Set whether to initialize using the probabilistic farthest first like method of the k-means++ algorithm (rather than the standard random selection of initial cluster centers).
* @param {String} distanceFunction Distance function to use. Options are: Euclidean & Manhattan
* @param {Integer} maxIterations Maximum number of iterations for k-means.
* @return {Clusterer}
*/
ee.Clusterer.wekaCascadeKMeans;
/**
* Implementation of the Cobweb clustering algorithm. For more information see:
D. Fisher (1987). Knowledge acquisition via incremental conceptual clustering. Machine Learning. 2(2):139-172. and J. H. Gennari, P. Langley, D. Fisher (1990). Models of incremental concept formation. Artificial Intelligence. 40:11-61.
* @param {Float} acuity Acuity (minimum standard deviation).
* @param {Float} cutoff Cutoff (minimum category utility).
* @param {Integer} seed Random number seed.
* @return {Clusterer}
*/
ee.Clusterer.wekaCobweb;
/**
* Cluster data using the k means algorithm. Can use either the Euclidean distance (default) or the Manhattan distance. If the Manhattan distance is used, then centroids are computed as the component-wise median rather than mean. For more information see:
D. Arthur, S. Vassilvitskii: k-means++: the advantages of carefull seeding. In: Proceedings of the eighteenth annual ACM-SIAM symposium on Discrete algorithms, 1027-1035, 2007.
* @param {Integer} nClusters Number of clusters.
* @param {Integer} init Initialization method to use.0 = random, 1 = k-means++, 2 = canopy, 3 = farthest first.
* @param {Boolean} canopies Use canopies to reduce the number of distance calculations.
* @param {Integer} maxCandidates Maximum number of candidate canopies to retain in memory at any one time when using canopy clustering. T2 distance plus, data characteristics, will determine how many candidate canopies are formed before periodic and final pruning are performed, which might result in exceess memory consumption. This setting avoids large numbers of candidate canopies consuming memory.
* @param {Integer} periodicPruning How often to prune low density canopies when using canopy clustering.
* @param {Integer} minDensity Minimum canopy density, when using canopy clustering, below which a canopy will be pruned during periodic pruning.
* @param {Float} t1 The T1 distance to use when using canopy clustering. A value < 0 is taken as a positive multiplier for T2.
* @param {Float} t2 The T2 distance to use when using canopy clustering. Values < 0 cause a heuristic based on attribute std. deviation to be used.
* @param {String} distanceFunction Distance function to use. Options are: Euclidean & Manhattan
* @param {Integer} maxIterations Maximum number of iterations.
* @param {Boolean} preserveOrder Preserve order of instances.
* @param {Boolean} fast Enables faster distance calculations, using cut-off values. Disables the calculation/output of squared errors/distances
* @param {Integer} seed The randomization seed.
* @return {Clusterer}
*/
ee.Clusterer.wekaKMeans;
/**
* A Clusterer that implements the Learning Vector Quantization algorithm. For more details, see:
T. Kohonen, "Learning Vector Quantization", The Handbook of Brain Theory and Neural Networks, 2nd Edition, MIT Press, 2003, pp. 631-634.
* @param {Integer} numClusters The number of clusters.
* @param {Float} learningRate The learning rate for the training algorithm. (Value should be greaterthan 0 and less or equal to 1).
* @param {Integer} epochs Number of training epochs. (Value should be greater than or equal to 1).
* @param {Boolean} normalizeInput Skip normalizing the attributes.
* @return {Clusterer}
*/
ee.Clusterer.wekaLVQ;
/**
* X-Means is K-Means with an efficient estimation of the number of clusters. For more information see:
Dan Pelleg, Andrew W. Moore: X-means: Extending K-means with Efficient Estimation of the Number of Clusters. In: Seventeenth International Conference on Machine Learning, 727-734, 2000.
* @param {Integer} minClusters Minimum number of clusters.
* @param {Integer} maxClusters Maximum number of clusters.
* @param {Integer} maxIterations Maximum number of overall iterations.
* @param {Integer} maxKMeans The maximum number of iterations to perform in KMeans.
* @param {Integer} maxForChildren The maximum number of iterations in KMeans that is performed on the child centers.
* @param {Boolean} useKD Use a KDTree.
* @param {Float} cutoffFactor Takes the given percentage of the splitted centroids if none of the children win.
* @param {String} distanceFunction Distance function to use. Options are: Chebyshev, Euclidean & Manhattan.
* @param {Integer} seed The randomization seed.
* @return {Clusterer}
*/
ee.Clusterer.wekaXMeans;
/**
* Returns a Collection containing the specified features.
* @param {List<Element>} features The features comprising the collection.
* @return {FeatureCollection}
*/
ee.Collection;
/**
* Produces a DOUBLE image where each pixel is the distance in meters from the pixel center to the nearest part of any Point or LineString features in the collection. Pixels that are not within 'searchRadius' meters of a geometry will be masked out.
Distances are computed on a sphere, so there is a small error proportional to the latitude difference between each pixel and the nearest geometry.
* @param {FeatureCollection} features Feature collection from which to get features used to compute pixel distances.
* @param {Float} searchRadius Maximum distance in meters from each pixel to look for edges. Pixels will be masked unless there are edges within this distance.
* @param {Float} maxError Maximum reprojection error in meters, only used if the input polylines require reprojection. If '0' is provided, then this operation will fail if projection is required.
* @return {Image}
*/
ee.Collection.distance;
/**
* Removes duplicates from a collection. Note that duplicates are determined using a strong hash over the serialized form of the selected properties.
* @param {FeatureCollection} collection The input collection from which objects will be selected.
* @param {SelectorSet} selectors Which parts of the object to use for comparisons.
* @return {FeatureCollection}
*/
ee.Collection.distinct;
/**
* Paints a vector collection for visualization. Not intended for use as input to other algorithms.
* @param {FeatureCollection} collection The collection to draw.
* @param {String} color A hex string in the format RRGGBB specifying the color to use for drawing the features.
* @param {Integer} pointRadius The radius in pixels of the point markers.
* @param {Integer} strokeWidth The width in pixels of lines and polygon borders.
* @return {Image}
*/
ee.Collection.draw;
/**
* Computes a 2D error matrix for a collection by comparing two columns of a collection: one containing the actual values, and one containing predicted values.The values are expected to be small contiguous integers, starting from 0. Axis 0 (the rows) of the matrix correspond to the actual values, and Axis 1 (the columns) to the predicted values.
* @param {FeatureCollection} collection The input collection.
* @param {String} actual The name of the property containing the actual value.
* @param {String} predicted The name of the property containing the predicted value.
* @param {List<Integer>} order A list of the expected values. If this argument is not specified, the values are assumed to be contiguous and span the range 0 to maxValue. If specified, only values matching this list are used, and the matrix will have dimensions and order matching the this list.
* @return {ConfusionMatrix}
*/
ee.Collection.errorMatrix;
/**
* Applies a filter to a given collection.
* @param {FeatureCollection} collection The collection to filter.
* @param {Filter} filter The filter to apply.
* @return {FeatureCollection}
*/
ee.Collection.filter;
/**
* Returns the first entry from a given collection.
* @param {FeatureCollection} collection The collection from which to select the first entry.
* @return {Element}
*/
ee.Collection.first;
/**
* Flattens collections of collections.
* @param {FeatureCollection} collection The input collection of collections.
* @return {FeatureCollection}
*/
ee.Collection.flatten;
/**
* Extracts and merges the geometries of a collection. Requires that all the geometries in the collection share the projection and edge interpretation.
* @param {FeatureCollection} collection The collection whose geometries will be extracted.
* @param {ErrorMargin} maxError An error margin to use when merging geometries.
* @return {Geometry}
*/
ee.Collection.geometry;
/**
* Applies a user-supplied function to each element of a collection. The user-supplied function is given two arguments: the current element, and the value returned by the previous call to iterate() or the first argument, for the first iteration. The result is the value returned by the final call to the user-supplied function.
* @param {FeatureCollection} collection The collection to which the algorithm is applied.
* @param {Algorithm} function The function to apply to each element. Must take two arguments: an element of the collection and the value from the previous iteration.
* @param {Object} first The initial state.
* @return {Object}
*/
ee.Collection.iterate;
/**
* Applies an ordering and limit to a given collection.
* @param {FeatureCollection} collection The collection to limit or order.
* @param {Integer} limit The maximum number of items in the output collection. null is used to represent no limit.
* @param {String} key The property on which the collection is sorted.
* @param {Boolean} ascending Whether the sorting is ascending rather than descending.
* @return {FeatureCollection}
*/
ee.Collection.limit;
/**
* Returns a Collection of features from a specified table.
* @param {Object} tableId The ID of the table to load. Either an asset ID or a Fusion Table DocID prefixed with 'ft:'.
* @param {String} geometryColumn The name of the column to use as the main feature geometry. Not used if tableId is an asset ID.
* @param {Long} version The version of the asset. -1 signifies the latest version. Ignored unless tableId is an asset ID.
* @return {FeatureCollection}
*/
ee.Collection.loadTable;
/**
* Maps an algorithm over a collection.
* @param {FeatureCollection} collection The collection of the elements to which the algorithm is applied.
* @param {Algorithm} baseAlgorithm The algorithm being applied to each element.
* @param {Boolean} dropNulls If true, the mapped algorithm is allowed to return nulls, and the elements for which it returns nulls will be dropped.
* @return {FeatureCollection}
*/
ee.Collection.map;
/**
* Merges two collections into one. The result has all the elements that were in either collection.
* @param {FeatureCollection} collection1 The first collection to merge.
* @param {FeatureCollection} collection2 The second collection to merge.
* @return {FeatureCollection}
*/
ee.Collection.merge;
/**
* Adds a column of deterministic pseudorandom numbers to a collection. The numbers are double-precision floating point numbers in the range 0.0 (inclusive) to 1.0 (exclusive).
* @param {FeatureCollection} collection The input collection to which to add a random column.
* @param {String} columnName The name of the column to add.
* @param {Long} seed A seed used when generating the random numbers.
* @return {FeatureCollection}
*/
ee.Collection.randomColumn;
/**
* Apply a reducer to each element of a collection, using the given selectors to determine the inputs.
Returns a dictionary of results, keyed with the output names.
* @param {FeatureCollection} collection The collection to aggregate over.
* @param {Reducer} reducer The reducer to apply.
* @param {List<String>} selectors A selector for each input of the reducer.
* @param {List<String>} weightSelectors A selector for each weighted input of the reducer.
* @return {Dictionary<Object>}
*/
ee.Collection.reduceColumns;
/**
* Creates an image from a feature collection by applying a reducer over the selected properties of all the features that intersect each pixel.
* @param {FeatureCollection} collection Feature collection to intersect with each output pixel.
* @param {List<String>} properties Properties to select from each feature and pass into the reducer.
* @param {Reducer} reducer A Reducer to combine the properties of each intersecting feature into a final result to store in the pixel.
* @return {Image}
*/
ee.Collection.reduceToImage;
/**
* Remaps the value of a specific property in a collection. Takes two parallel lists and maps values found in one to values in the other. Any element with a value that is not specified in the first list is dropped from the output collection.
* @param {FeatureCollection} collection The collection to be modified.
* @param {List<Object>} lookupIn The input mapping values. Restricted to strings and integers.
* @param {List<Integer>} lookupOut The output mapping values. Must be the same size as lookupIn.
* @param {String} columnName The name of the property to remap.
* @return {FeatureCollection}
*/
ee.Collection.remap;
/**
* Returns the number of elements in the collection.
* @param {FeatureCollection} collection The collection to count.
* @return {Integer}
*/
ee.Collection.size;
/**
* Draw a vector collection for visualization using a simple style language.
* @param {FeatureCollection} collection The collection to draw.
* @param {String} color A default color (CSS 3.0 color value e.g. 'FF0000' or 'red') to use for drawing the features. Supports opacity (e.g.: 'FF000088' for 50% transparent red).
* @param {Integer} pointSize The default size in pixels of the point markers.
* @param {String} pointShape The default shape of the marker to draw at each point location. One of: circle, square, diamond, cross, plus, pentagram, hexagram, triangle, triangle_up triangle_down, triangle_left, triangle_right, pentagon, hexagon, star5, star6. This argument also supports the following Matlab marker abbreviations: o, s, d, x, +, p, h, ^, v, <, >.
* @param {Float} width The default line width for lines and outlines for polygons and point shapes.
* @param {String} fillColor The color for filling polygons and point shapes. Defaults to 'color' at 0.66 opacity.
* @param {String} styleProperty A per-feature property expected to contain a dictionary. Values in the dictionary override any default values for that feature.
* @param {Integer} neighborhood If styleProperty is used and any feature has a pointSize or width larger than the defaults, tiling artifacts can occur. Specifies the maximum neighborhood (pointSize + width) needed for any feature.
* @return {Image}
*/
ee.Collection.style;
/**
* Returns the elements of a collection as a list.
* @param {FeatureCollection} collection The input collection to fetch.
* @param {Integer} count The maximum number of elements to fetch.
* @param {Integer} offset The number of elements to discard from the start. If set, (offset + count) elements will be fetched and the first offset elements will be discarded.
* @return {List<Object>}
*/
ee.Collection.toList;
/**
* Merges all geometries in a given collection into one and returns a collection containing a single feature with only an ID of 'union_result' and a geometry.
* @param {FeatureCollection} collection The collection being merged.
* @param {ErrorMargin} maxError The maximum error allowed when performing any necessary reprojections. If not specified, defaults to the error margin requested from the output.
* @return {FeatureCollection}
*/
ee.Collection.union;
/**
* Creates a confusion matrix. Axis 1 (the rows) of the matrix correspond to the actual values, and Axis 0 (the columns) to the predicted values.
* @param {Object} array A square, 2D array of integers, representing the confusion matrix.
* @param {List<Integer>} order The row and column size and order, for non-contiguous or non-zero based matrices.
* @return {ConfusionMatrix}
*/
ee.ConfusionMatrix;
/**
* Computes the overall accuracy of a confusion matrix defined as correct / total.
* @param {ConfusionMatrix} confusionMatrix
* @return {Float}
*/
ee.ConfusionMatrix.prototype.accuracy;
/**
* Returns a confusion matrix as an Array.
* @param {ConfusionMatrix} confusionMatrix
* @return {Array}
*/
ee.ConfusionMatrix.prototype.array;
/**
* Computes the consumer's accuracy (reliability) of a confusion matrix defined as (correct / total) for each row.
* @param {ConfusionMatrix} confusionMatrix
* @return {Array}
*/
ee.ConfusionMatrix.prototype.consumersAccuracy;
/**
* Computes the Kappa statistic for the confusion matrix.
* @param {ConfusionMatrix} confusionMatrix
* @return {Float}
*/
ee.ConfusionMatrix.prototype.kappa;
/**
* Returns the name and order of the rows and columns of the matrix.
* @param {ConfusionMatrix} confusionMatrix
* @return {List<Integer>}
*/
ee.ConfusionMatrix.prototype.order;
/**
* Computes the producer's accuracy of a confusion matrix defined as (correct / total) for each column.
* @param {ConfusionMatrix} confusionMatrix
* @return {Array}
*/
ee.ConfusionMatrix.prototype.producersAccuracy;
/**
* Gives information on the quality of image registration between two (theoretically) co-registered images. The input is two images with the same number of bands. This function outputs an image composed of four bands of information. The first three are distances: the deltaX, deltaY, and the Euclidean distance for each pixel in imageA to the pixel which has the highest corresponding correlation coefficient in imageB. The fourth band is the value of the correlation coefficient for that pixel [-1 : +1].
* @param {Image} imageA First image, with N bands.
* @param {Image} imageB Second image, must have the same number of bands as imageA.
* @param {Integer} maxGap The greatest distance a pixel may shift in either X or Y.
* @param {Integer} windowSize Size of the window to be compared.
* @param {Float} maxMaskedFrac The maximum fraction of pixels within the correlation window that are allowed to be masked. This test is applied at each offset location within the search region. For each offset, the overlapping image patches are compared and a correlation score computed. A pixel within these overlapping patches is considered masked if either of the patches is masked there. If the test fails at any single location in the search region, the ouput pixel for which the correlation is being computed is considered invalid, and will be masked.
* @return {Image}
*/
ee.CrossCorrelation;
/**
* Creates a Date.
* @param {Object} value A number (interpreted as milliseconds since 1970-01-01T00:00:00Z), or string such as '1996-01-01' or '1996-001' or '1996-01-01T08:00'.
* @param {String} timeZone The time zone (e.g. 'America/Los_Angeles'); defaults to UTC.
* @return {Date}
*/
ee.Date;
/**
* Create a new Date by adding the specified units to the given Date.
* @param {Date} date
* @param {Float} delta
* @param {String} unit One of 'year', 'month' 'week', 'day', 'hour', 'minute', or 'second'.
* @param {String} timeZone The time zone (e.g. 'America/Los_Angeles'); defaults to UTC.
* @return {Date}
*/
ee.Date.prototype.advance;
/**
* Returns the difference between two Dates in the specified units; the result is floating-point and based on the average length of the unit.
* @param {Date} date
* @param {Date} start
* @param {String} unit One of 'year', 'month' 'week', 'day', 'hour', 'minute', or 'second'.
* @return {Float}
*/
ee.Date.prototype.difference;
/**
* Convert a date to string.
* @param {Date} date
* @param {String} format A pattern, as described at http://joda-time.sourceforge.net/apidocs/org/joda/time/format/DateTimeFormat.html; if omitted will use ISO standard date formatting.
* @param {String} timeZone The time zone (e.g. 'America/Los_Angeles'); defaults to UTC.
* @return {String}
*/
ee.Date.prototype.format;
/**
* Returns a Date given year, month, day.
* @param {Integer} year
* @param {Integer} month
* @param {Integer} day
* @param {String} timeZone The time zone (e.g. 'America/Los_Angeles'); defaults to UTC.
* @return {Date}
*/
ee.Date.fromYMD;
/**
* Returns the specified unit of this date.
* @param {Date} date
* @param {String} unit One of 'year', 'month' (returns 1-12), 'week' (1-53), 'day' (1-31), 'hour' (0-23), 'minute' (0-59), or 'second' (0-59).
* @param {String} timeZone The time zone (e.g. 'America/Los_Angeles'); defaults to UTC.
* @return {Long}
*/
ee.Date.prototype.get;
/**
* Returns this date's elapsed fraction of the specified unit (between 0 and 1).
* @param {Date} date
* @param {String} unit One of 'year', 'month' 'week', 'day', 'hour', 'minute', or 'second'.
* @param {String} timeZone The time zone (e.g. 'America/Los_Angeles'); defaults to UTC.
* @return {Float}
*/
ee.Date.prototype.getFraction;
/**
* Returns a DateRange covering the unit of the specified type that contains this date, e.g. Date('2013-3-15').getRange('year') returns DateRange('2013-1-1', '2014-1-1').
* @param {Date} date
* @param {String} unit One of 'year', 'month' 'week', 'day', 'hour', 'minute', or 'second'.
* @param {String} timeZone The time zone (e.g. 'America/Los_Angeles'); defaults to UTC.
* @return {DateRange}
*/
ee.Date.prototype.getRange;
/**
* Returns the specified (0-based) unit of this date relative to a larger unit, e.g. getRelative('day', 'year') returns a value between 0 and 365.
* @param {Date} date
* @param {String} unit One of 'month' 'week', 'day', 'hour', 'minute', or 'second'.
* @param {String} inUnit One of 'year', 'month' 'week', 'day', 'hour', or 'minute'.
* @param {String} timeZone The time zone (e.g. 'America/Los_Angeles'); defaults to UTC.
* @return {Long}
*/
ee.Date.prototype.getRelative;
/**
* The number of milliseconds since 1970-01-01T00:00:00Z.
* @param {Date} date
* @return {Long}
*/
ee.Date.prototype.millis;
/**
* Parse a date string, given a string describing its format.
* @param {String} format A pattern, as described at http://joda-time.sourceforge.net/apidocs/org/joda/time/format/DateTimeFormat.html.
* @param {String} date A string matching the given pattern.
* @param {String} timeZone The time zone (e.g. 'America/Los_Angeles'); defaults to UTC.
* @return {Date}
*/
ee.Date.parse;
/**
* Returns the ratio of the length of one unit to the length of another, e.g. unitRatio('day', 'minute') returns 1440. Valid units are 'year', 'month' 'week', 'day', 'hour', 'minute', and 'second'.
* @param {String} numerator
* @param {String} denominator
* @return {Float}
*/
ee.Date.unitRatio;
/**
* Create a new Date by setting one or more of the units of the given Date to a new value. If a timeZone is given the new value(s) is interpreted in that zone.
* @param {Date} date
* @param {Integer} year
* @param {Integer} month
* @param {Integer} day
* @param {Integer} hour
* @param {Integer} minute
* @param {Integer} second
* @param {String} timeZone The time zone (e.g. 'America/Los_Angeles'); defaults to UTC.
* @return {Date}
*/
ee.Date.prototype.update;
/**
* Creates a DateRange with the given start (inclusive) and end (exclusive), which may be Dates, numbers (interpreted as milliseconds since 1970-01-01T00:00:00Z), or strings (such as '1996-01-01T08:00'). If 'end' is not specified, a 1-millisecond range starting at 'start' is created.
* @param {Object} start
* @param {Object} end
* @param {String} timeZone If start and/or end are provided as strings, the time zone in which to interpret them; defaults to UTC.
* @return {DateRange}
*/
ee.DateRange;
/**
* Returns true if the given Date or DateRange is within this DateRange.
* @param {DateRange} dateRange
* @param {Object} other
* @return {Boolean}
*/
ee.DateRange.prototype.contains;
/**
* Returns the (exclusive) end of this DateRange.
* @param {DateRange} dateRange
* @return {Date}
*/
ee.DateRange.prototype.end;
/**
* Returns a DateRange that contains all points in the intersection of this DateRange and another.
* @param {DateRange} dateRange
* @param {DateRange} other
* @return {DateRange}
*/
ee.DateRange.prototype.intersection;
/**
* Returns true if the given DateRange has at least one point in common with this DateRange.
* @param {DateRange} dateRange
* @param {DateRange} other
* @return {Boolean}
*/
ee.DateRange.prototype.intersects;
/**
* Returns true if this DateRange contains no dates (i.e. start >= end).
* @param {DateRange} dateRange
* @return {Boolean}
*/
ee.DateRange.prototype.isEmpty;
/**
* Returns true if this DateRange contains all dates.
* @param {DateRange} dateRange
* @return {Boolean}
*/
ee.DateRange.prototype.isUnbounded;
/**
* Returns the (inclusive) start of this DateRange.
* @param {DateRange} dateRange
* @return {Date}
*/
ee.DateRange.prototype.start;
/**
* Returns a DateRange that includes all possible dates.
*
* @return {DateRange}
*/
ee.DateRange.unbounded;
/**
* Returns a DateRange that contains all points in the union of this DateRange and another.
* @param {DateRange} dateRange
* @param {DateRange} other
* @return {DateRange}
*/
ee.DateRange.prototype.union;
/**
* Describes an object using a simple JSON-compatible structure.
* @param {Object} input The object to describe.
* @return {Object}
*/
ee.Describe;
/**
* Constructs a dictionary.
* @param {Object} input An object to convert to a dictionary. Either a JSON dictionary or a list of alternating key/value pairs. Keys must be strings.
* @return {Dictionary<Object>}
*/
ee.Dictionary;
/**
* Combines two dictionaries. In the case of duplicate names, the output will contain the value of the second dictionary unless overwrite is false. Null values in both dictionaries are ignored / removed.
* @param {Dictionary<Object>} first
* @param {Dictionary<Object>} second
* @param {Boolean} overwrite
* @return {Dictionary<Object>}
*/
ee.Dictionary.combine;
/**
* Returns true if the dictionary contains the given key.
* @param {Dictionary<Object>} dictionary
* @param {String} key
* @return {Boolean}
*/
ee.Dictionary.contains;
/**
* Construct a dictionary from two parallel lists of keys and values.
* @param {List<String>} keys
* @param {List<Object>} values
* @return {Dictionary<Object>}
*/
ee.Dictionary.fromLists;
/**
* Extracts a named value from a dictionary.
* @param {Dictionary<Object>} dictionary
* @param {String} key
* @return {Object}
*/
ee.Dictionary.get;
/**
* Retrieve the keys of a dictionary as a list. The keys will be sorted in natural order.
* @param {Dictionary<Object>} dictionary
* @return {List<String>}
*/
ee.Dictionary.keys;
/**
* Map an algorithm over a dictionary. The algorithm is expected to take 2 arguments, a key from the existing dictionary and the value it corresponds to, and return a new value for the given key. If the algorithm returns null, the key is dropped.
* @param {Dictionary<Object>} dictionary
* @param {Algorithm} baseAlgorithm
* @return {Dictionary<Object>}
*/
ee.Dictionary.map;
/**
* Returns a dictionary with the specified keys removed.
* @param {Dictionary<Object>} dictionary
* @param {List<String>} selectors A list of keys names or regular expressions of key names to remove.
* @param {Boolean} ignoreMissing Ignore selectors that don't match at least 1 key.
* @return {Dictionary<Object>}
*/
ee.Dictionary.remove;
/**
* Rename elements in a dictionary.
* @param {Dictionary<Object>} dictionary
* @param {List<String>} from A list of keys to be renamed.
* @param {List<String>} to A list of the new names for the keys listed in the 'from' parameter. Must have the same length as the 'from' list.
* @param {Boolean} overwrite Allow overwriting existing properties with the same name.
* @return {Dictionary<Object>}
*/
ee.Dictionary.rename;
/**
* Returns a dictionary with only the specified keys.
* @param {Dictionary<Object>} dictionary
* @param {List<String>} selectors A list of keys or regular expressions to select.
* @param {Boolean} ignoreMissing Ignore selectors that don't match at least 1 key.
* @return {Dictionary<Object>}
*/
ee.Dictionary.select;
/**
* Set a value in a dictionary.
* @param {Dictionary<Object>} dictionary
* @param {String} key
* @param {Object} value
* @return {Object}
*/
ee.Dictionary.set;
/**
* Returns the number of entries in a dictionary.
* @param {Dictionary<Object>} dictionary
* @return {Integer}
*/
ee.Dictionary.size;
/**
* Returns numeric values of a dictionary as an array. If no keys are specified, all values are returned in the natural ordering of the dictionary's keys. The default 'axis' is 0.
* @param {Dictionary<Object>} dictionary
* @param {List<String>} keys
* @param {Integer} axis
* @return {Array}
*/
ee.Dictionary.toArray;
/**
* Creates an image of constants from values in a dictionary. The bands of the image are ordered and named according to the names argument. If no names are specified, the bands are sorted alpha-numerically.
* @param {Dictionary<Object>} dictionary The dictionary to convert.
* @param {List<String>} names The order of the output bands.
* @return {Image}
*/
ee.Dictionary.toImage;
/**
* Returns the values of a dictionary as a list. If no keys are specified, all values are returned in the natural ordering of the dictionary's keys.
* @param {Dictionary<Object>} dictionary
* @param {List<String>} keys
* @return {List<Object>}
*/
ee.Dictionary.values;
/**
* Copies metadata properties from one element to another.
* @param {Element} destination The object whose properties to override.
* @param {Element} source The object from which to copy the properties.
* @param {List<String>} properties The properties to copy. If omitted, all ordinary (i.e. non-system) properties are copied.
* @param {List<String>} exclude The list of properties to exclude when copying all properties. Must not be specified if properties is.
* @return {Element}
*/
ee.Element.prototype.copyProperties;
/**
* Returns the geometry of a given feature in a given projection.
* @param {Element} feature The feature from which the geometry is taken.
* @param {ErrorMargin} maxError The maximum amount of error tolerated when performing any necessary reprojection.
* @param {Projection} proj If specified, the geometry will be in this projection. If unspecified, the geometry will be in its default projection.
* @param {Boolean} geodesics If true, the geometry will have geodesic edges. If false, it will have edges as straight lines in the specified projection. If null, the edge interpretation will be the same as the original geometry. This argument is ignored if proj is not specified.
* @return {Geometry}
*/
ee.Element.prototype.geometry;
/**
* Extract a property from a feature.
* @param {Element} object The feature to extract the property from.
* @param {String} property The property to extract.
* @return {<any>}
*/
ee.Element.prototype.get;
/**
* Returns the names of properties on this element.
* @param {Element} element
* @return {List<String>}
*/
ee.Element.prototype.propertyNames;
/**
* Overrides a metadata property of an object.
* @param {Element} object The object on which to set the property.
* @param {String} key The name of the property to set.
* @param {Object} value The new value of the property.
* @return {Element}
*/
ee.Element.prototype.set;
/**
* Overrides one or more metadata properties of an object.
* @param {Element} object The object whose properties to override.
* @param {Dictionary<Object>} properties The property values to override.
* @return {Element}
*/
ee.Element.prototype.setMulti;
/**
* Extract properties from a feature as a dictionary.
* @param {Element} element The feature to extract the property from.
* @param {List<String>} properties The list of properties to extract. Defaults to all non-system properties.
* @return {Dictionary<Object>}
*/
ee.Element.prototype.toDictionary;
/**
* Returns an ErrorMargin of the given type with the given value.
* @param {Float} value The maximum error value allowed by the margin. Ignored if the unit is 'infinite'.
* @param {String} unit The unit of this margin: 'meters', 'projected' or 'infinite'.
* @return {ErrorMargin}
*/
ee.ErrorMargin;
/**
* Fills local minima. Only works on INT types.
* @param {Image} image The image to fill.
* @param {Long} borderValue The border value.
* @param {Integer} neighborhood The size of the neighborhood to compute over.
* @return {Image}
*/
ee.FMask.fillMinima;
/**
* Runs the FMask cloud and shadow matching. Outputs a single band ('csm'), containing the computed cloud and shadow masks.
* @param {Image} input The scene for which to compute cloud and shadow masks.
* @param {Image} cloud Potential cloud mask image. Expected to contain 1s for cloudy pixels and masked pixels everywhere else.
* @param {Image} shadow Potential shadow mask image. Expected to contain 1s for shadow pixels and masked pixels everywhere else.
* @param {Image} btemp Brightness temperature image, in Celsius.
* @param {Float} sceneLow The 0.175 percentile brightness temperature of the scene.
* @param {Float} sceneHigh The 0.825 percentile brightness temperature of the scene.
* @param {Integer} neighborhood The neighborhood to pad around each tile.
* @return {Image}
*/
ee.FMask.matchClouds;
/**
* Temporarily allocates the specified amount of memory, in the view of Earth Engine memorytracking. Does not affect the actual Java heap.
Returns its argument so as to have a value to return.
* @param {Long} size Size of allocation in bytes.
* @return {Long}
*/
ee.Fail.allocateMemory;
/**
* Never returns. For triggering timeouts cheaply.
*
* @return {Object}
*/
ee.Fail.hang;
/**
* Starts an infinite loop on a compute thread. For testing run-away requests.
*
* @return {Integer}
*/
ee.Fail.loop;
/**
* Fakes an out-of-memory error. Does not actually allocate.
* @param {Boolean} isUserQuota
* @return {Object}
*/
ee.Fail.outOfMemory;
/**
* Returns a Feature composed of the given geometry and metadata.
* @param {Geometry} geometry The geometry of the feature.
* @param {Dictionary<Object>} metadata The properties of the feature.
* @param {String} geometryKey Obsolete; has no effect.
* @return {Feature}
*/
ee.Feature;
/**
* Returns the area of the feature's default geometry. Area of points and line strings is 0, and the area of multi geometries is the sum of the areas of their componenets (intersecting areas are counted multiple times).
* @param {Element} feature The feature from which the geometry is taken.
* @param {ErrorMargin} maxError The maximum amount of error tolerated when performing any necessary reprojection.
* @param {Projection} proj If specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in square meters.
* @return {Float}
*/
ee.Feature.area;
/**
* Returns a feature containing the bounding box of the geometry of a given feature.
* @param {Element} feature The feature the bound of which is being calculated.
* @param {ErrorMargin} maxError The maximum amount of error tolerated when performing any necessary reprojection.
* @param {Projection} proj If specified, the result will be in this projection. Otherwise it will be in WGS84.
* @return {Feature}
*/
ee.Feature.bounds;
/**
* Returns the input buffered by a given distance. If the distance is positive, the geometry is expanded, and if the distance is negative, the geometry is contracted.
* @param {Element} feature The feature the geometry of which is being buffered.
* @param {Float} distance The distance of the buffering, which may be negative. If no projection is specified, the unit is meters. Otherwise the unit is in the coordinate system of the projection.
* @param {ErrorMargin} maxError The maximum amount of error tolerated when approximating the buffering circle and performing any necessary reprojection. If unspecified, defaults to 1% of the distance.
* @param {Projection} proj If specified, the buffering will be performed in this projection and the distance will be interpreted as units of the coordinate system of this projection. Otherwise the distance is interpereted as meters and the buffering is performed in a spherical coordinate system.
* @return {Feature}
*/
ee.Feature.buffer;
/**
* Returns a feature containing the point at the center of the highest-dimension components of the geometry of a feature. Lower-dimensional components are ignored, so the centroid of a geometry containing two polygons, three lines and a point is equivalent to the centroid of a geometry containing just the two polygons.
* @param {Element} feature Calculates the centroid of this feature's default geometry.
* @param {ErrorMargin} maxError The maximum amount of error tolerated when performing any necessary reprojection.
* @param {Projection} proj If specified, the result will be in this projection. Otherwise it will be in WGS84.
* @return {Feature}
*/
ee.Feature.centroid;
/**
* Returns true iff the geometry of one feature is contained in the geometry of another.
* @param {Element} left The feature containing the geometry used as the left operand of the operation.
* @param {Element} right The feature containing the geometry used as the right operand of the operation.
* @param {ErrorMargin} maxError The maximum amount of error tolerated when performing any necessary reprojection.
* @param {Projection} proj The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.
* @return {Boolean}
*/
ee.Feature.containedIn;
/**
* Returns true iff the geometry of one feature contains the geometry of another.
* @param {Element} left The feature containing the geometry used as the left operand of the operation.
* @param {Element} right The feature containing the geometry used as the right operand of the operation.
* @param {ErrorMargin} maxError The maximum amount of error tolerated when performing any necessary reprojection.
* @param {Projection} proj The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.
* @return {Boolean}
*/
ee.Feature.contains;
/**
* Returns the feature, with the geometry replaced by the convex hull of the original geometry. The convex hull of a single point is the point itself, the convex hull of collinear points is a line, and the convex hull of everything else is a polygon. Note that a degenerate polygon with all vertices on the same line will result in a line segment.
* @param {Element} feature The feature containing the geometry whole hull is being calculated.
* @param {ErrorMargin} maxError The maximum amount of error tolerated when performing any necessary reprojection.
* @param {Projection} proj The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.
* @return {Feature}
*/
ee.Feature.convexHull;
/**
* Converts LineStrings into a MultiLineString by cutting it in two at each distance along the length of the LineString.
* @param {Element} feature Cuts the lines of this feature's default geometry.
* @param {List<Float>} distances Distances along each LineString to cut the line into separate pieces, measured in units of the given proj, or meters if proj is unspecified.
* @param {ErrorMargin} maxError The maximum amount of error tolerated when performing any necessary reprojection.
* @param {Projection} proj Projection of the result and distance measurements, or WGS84 if unspecified.
* @return {Feature}
*/
ee.Feature.cutLines;
/**
* Returns a feature with the properties of the 'left' feature, and the geometry that results from subtracting the 'right' geometry from the 'left' geometry.
* @param {Element} left The feature containing the geometry used as the left operand of the operation. The properties of the result will be copied from this object.
* @param {Element} right The feature containing the geometry used as the right operand of the operation. The properties of this object are ignored.
* @param {ErrorMargin} maxError The maximum amount of error tolerated when performing any necessary reprojection.
* @param {Projection} proj The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.
* @return {Feature}
*/
ee.Feature.difference;
/**
* Returns true iff the feature geometries are disjoint.
* @param {Element} left The feature containing the geometry used as the left operand of the operation.
* @param {Element} right The feature containing the geometry used as the right operand of the operation.
* @param {ErrorMargin} maxError The maximum amount of error tolerated when performing any necessary reprojection.
* @param {Projection} proj The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.
* @return {Boolean}
*/
ee.Feature.disjoint;
/**
* Returns a feature containing the union of the geometry of a feature. This leaves single geometries untouched, and unions multi geometries.
* @param {Element} feature The feature the geometry of which is being unioned.
* @param {ErrorMargin} maxError The maximum amount of error tolerated when performing any necessary reprojection.
* @param {Projection} proj If specified, the union will be performed in this projection. Otherwise it will be performed in a spherical coordinate system.
* @return {Element}
*/
ee.Feature.dissolve;
/**
* Returns the minimum distance between the geometries of two features.
* @param {Element} left The feature containing the geometry used as the left operand of the operation.
* @param {Element} right The feature containing the geometry used as the right operand of the operation.
* @param {ErrorMargin} maxError The maximum amount of error tolerated when performing any necessary reprojection.
* @param {Projection} proj The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.
* @return {Float}
*/
ee.Feature.distance;
/**
* Returns the geometry of a given feature in a given projection.
* @param {Element} feature The feature from which the geometry is taken.
* @param {ErrorMargin} maxError The maximum amount of error tolerated when performing any necessary reprojection.
* @param {Projection} proj If specified, the geometry will be in this projection. If unspecified, the geometry will be in its default projection.
* @param {Boolean} geodesics If true, the geometry will have geodesic edges. If false, it will have edges as straight lines in the specified projection. If null, the edge interpretation will be the same as the original geometry. This argument is ignored if proj is not specified.
* @return {Geometry}
*/
ee.Feature.geometry;
/**
* Returns the ID of a given element within a collection. Objects outside collections are not guaranteed to have IDs.
* @param {Element} element The element from which the ID is taken.
* @return {String}
*/
ee.Feature.id;
/**
* Returns a feature containing the intersection of the geometries of two features, with the properties of the left feature.
* @param {Element} left The feature containing the geometry used as the left operand of the operation. The properties of the result will be copied from this object.
* @param {Element} right The feature containing the geometry used as the right operand of the operation. The properties of this object are ignored.
* @param {ErrorMargin} maxError The maximum amount of error tolerated when performing any necessary reprojection.
* @param {Projection} proj The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.
* @return {Feature}
*/
ee.Feature.intersection;
/**
* Returns true iff the feature geometries intersect.
* @param {Element} left The feature containing the geometry used as the left operand of the operation.
* @param {Element} right The feature containing the geometry used as the right operand of the operation.
* @param {ErrorMargin} maxError The maximum amount of error tolerated when performing any necessary reprojection.
* @param {Projection} proj The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.
* @return {Boolean}
*/
ee.Feature.intersects;
/**
* Returns the length of the linear parts of the geometry of a given feature. Polygonal parts are ignored. The length of multi geometries is the sum of the lengths of their components.
* @param {Element} feature The feature from which the geometry is taken.
* @param {ErrorMargin} maxError The maximum amount of error tolerated when performing any necessary reprojection.
* @param {Projection} proj If specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in meters.
* @return {Float}
*/
ee.Feature.length;
/**
* Returns the length of the perimeter of the polygonal parts of the geometry of a given feature. The perimeter of multi geometries is the sum of the perimeters of their components.
* @param {Element} feature The feature from which the geometry is taken.
* @param {ErrorMargin} maxError The maximum amount of error tolerated when performing any necessary reprojection.
* @param {Projection} proj If specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in meters.
* @return {Float}
*/
ee.Feature.perimeter;
/**
* Selects properties from a feature by name or RE2-compatible regex and optionally renames them.
* @param {Element} input The feature to select properties from.
* @param {List<String>} propertySelectors A list of names or regexes specifying the properties to select.
* @param {List<String>} newProperties Optional new names for the output properties. Must match the number of properties selected.
* @param {Boolean} retainGeometry When false, the result will have a NULL geometry.
* @return {Element}
*/
ee.Feature.select;
/**
* Returns the feature, with the geometry replaced by the specified geometry.
* @param {Element} feature The feature on which to set the geometry.
* @param {Geometry} geometry The geometry to set.
* @return {Element}
*/
ee.Feature.setGeometry;
/**
* Simplifies the geometry of a feature to within a given error margin. Note that this does not respect the error margin requested by the consumer of this algorithm, unless maxError is explicitly specified to be null.
This overrides the default Earth Engine policy for propagating error margins, so regardless of the geometry accuracy requested from the output, the inputs will be requested with the error margin specified in the arguments to this algorithm. This results in consistent rendering at all zoom levels of a rendered vector map, but at lower zoom levels (i.e. zoomed out), the geometry won't be simplified, which may harm performance.
* @param {Element} feature The feature whose geometry is being simplified.
* @param {ErrorMargin} maxError The maximum amount of error by which the result may differ from the input.
* @param {Projection} proj If specified, the result will be in this projection. Otherwise it will be in the same projection as the input. If the error margin is in projected units, the margin will be interpreted as units of this projection
* @return {Feature}
*/
ee.Feature.simplify;
/**
* Snaps the vertices of the default geometry to a regular cell grid with radius near but less than the given snap radius in meters. Snapping can reduce the number of vertices, close gaps in adjacent spatial features, and push degenerate elements to lower dimensional objects, e.g. a narrow polygon may collapse to a line. When applied to a GeometryCollection, overlap created between different elements is not removed.
* @param {Element} feature The feature whose geometry is being snapped.
* @param {ErrorMargin} snapRadius The max distance to move vertices during snapping. If in meters, 'proj' must not be specified, otherwise if in units, 'proj' must specified.
* @param {Projection} proj If unspecified the result will be in WGS84 with geodesic edges and the snap radius must be in meters, otherwise the snap radius must be in units and the result will be in this projection with planar edges.
* @return {Feature}
*/
ee.Feature.snap;
/**
* Returns a feature containing the symmetric difference between geometries of two features.
* @param {Element} left The feature containing the geometry used as the left operand of the operation. The properties of the result will be copied from this object.
* @param {Element} right The feature containing the geometry used as the right operand of the operation. The properties of this object are ignored.
* @param {ErrorMargin} maxError The maximum amount of error tolerated when performing any necessary reprojection.
* @param {Projection} proj The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.
* @return {Feature}
*/
ee.Feature.symmetricDifference;
/**
* Creates an array from the given properties of an object, which must all be numbers.
* @param {Feature} feature The object from which to select array properties.
* @param {List<String>} properties The property selectors for each array element.
* @return {Array}
*/
ee.Feature.prototype.toArray;
/**
* Transforms the geometry of a feature to a specific projection.
* @param {Element} feature The feature the geometry of which is being converted.
* @param {Projection} proj The target projection. Defaults to WGS84. If this has a geographic CRS, the edges of the geometry will be interpreted as geodesics. Otherwise they will be interpreted as straight lines in the projection.
* @param {ErrorMargin} maxError The maximum projection error.
* @return {Feature}
*/
ee.Feature.transform;
/**
* Returns a feature containing the union of the geometries of two features.
* @param {Element} left The feature containing the geometry used as the left operand of the operation. The properties of the result will be copied from this object.
* @param {Element} right The feature containing the geometry used as the right operand of the operation. The properties of this object are ignored.
* @param {ErrorMargin} maxError The maximum amount of error tolerated when performing any necessary reprojection.
* @param {Projection} proj The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.
* @return {Feature}
*/
ee.Feature.union;
/**
* Returns true iff the geometries of two features are within a specified distance.
* @param {Element} left The feature containing the geometry used as the left operand of the operation.
* @param {Element} right The feature containing the geometry used as the right operand of the operation.
* @param {Float} distance The distance threshold. If a projection is specified, the distance is in units of that projected coordinate system, otherwise it is in meters.
* @param {ErrorMargin} maxError The maximum amount of error tolerated when performing any necessary reprojection.
* @param {Projection} proj The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.
* @return {Boolean}
*/
ee.Feature.withinDistance;
/**
* Classifies each feature in a collection.
* @param {FeatureCollection} features The collection of features to classify. Each feature must contain all the properties in the classifier's schema.
* @param {Object} classifier The classifier to use.
* @param {String} outputName The name of the output property to be added.
* @return {FeatureCollection}
*/
ee.FeatureCollection.prototype.classify;
/**
* Clusters each feature in a collection, adding a new column to each feature containing the cluster number to which it has been assigned.
* @param {FeatureCollection} features The collection of features to cluster. Each feature must contain all the properties in the clusterer's schema.
* @param {Clusterer} clusterer The clusterer to use.
* @param {String} outputName The name of the output property to be added.
* @return {FeatureCollection}
*/
ee.FeatureCollection.prototype.cluster;
/**
* Returns an inverse-distance weighted estimate of the value at each pixel.
* @param {FeatureCollection} collection Feature collection to use as source data for the estimation.
* @param {Float} range Size of the interpolation window (in meters).
* @param {String} propertyName Name of the numeric property to be estimated.
* @param {Float} mean Global expected mean.
* @param {Float} stdDev Global standard deviation.
* @param {Float} gamma Determines how quickly the estimates tend towards the global mean.
* @param {Reducer} reducer Reducer used to collapse the 'propertyName' value of overlapping points into a single value.
* @return {Image}
*/
ee.FeatureCollection.prototype.inverseDistance;
/**
* Returns the results of sampling a Kriging estimator at each pixel.
* @param {FeatureCollection} collection Feature collection to use as source data for the estimation.
* @param {String} propertyName Property to be estimated (must be numeric).
* @param {String} shape Semivariogram shape (one of {exponential, gaussian, spherical}).
* @param {Float} range Semivariogram range.
* @param {Float} sill Semivariogram sill.
* @param {Float} nugget Semivariogram nugget.
* @param {Float} maxDistance Radius which determines which features are included in each pixel's computation. Defaults to the semivariogram's range.
* @param {Reducer} reducer Reducer used to collapse the 'propertyName' value of overlapping points into a single value.
* @return {Image}
*/
ee.FeatureCollection.prototype.kriging;
/**
* Returns the feature collection given its ID.
* @param {String} id The asset ID of the feature collection.
* @param {Long} version The version of the asset. -1 signifies the latest version.
* @return {FeatureCollection}
*/
ee.FeatureCollection.loadById;
/**
* Loads a FeatureCollection from a vector sstable.
* @param {String} filebase The base filename pattern.
* @param {Dictionary<Object>} properties Metadata properties of the asset.
* @return {FeatureCollection}
*/
ee.FeatureCollection.loadSSTable;
/**
* Add a 1-D Array to each feature in a collection by combining a list of properties for each feature into a 1-D Array. All of the properties must be numeric values. If a feature doesn't contain all of the named properties, or any of them aren't numeric, the feature will be dropped from the resulting collection.
* @param {FeatureCollection} collection The input collection from which properties will be selected.
* @param {List<String>} properties The properties to select.
* @param {String} name The name of the new array property.
* @return {FeatureCollection}
*/
ee.FeatureCollection.prototype.makeArray;
/**
* Returns a FeatureCollection containing the results of a Plx SQL query.
* @param {String} sql The PLX SQL query to execute.
* @param {String} queryEngine The name of the PLX query engine to use.
* @param {Long} minCacheTimestampMs Cached query results may be used if newer than the given time in milliseconds since the epoch (1970-01-01). If 0, the result cache may be used at the service's discretion. If -1, the result cache may not be used.
* @return {FeatureCollection}
*/
ee.FeatureCollection.plx;
/**
* Generates points that are uniformly random on the sphere, and within the given region.
* @param {Geometry} region The region to generate points for.
* @param {Integer} points The number of points to generate.
* @param {Long} seed A seed for the random number generator.
* @param {ErrorMargin} maxError The maximum amount of error tolerated when performing any necessary reprojection.
* @return {FeatureCollection}
*/
ee.FeatureCollection.randomPoints;
/**
* Returns a filter that passes if each of the component filters pass.
* @param {List<Filter>} filters The filters to conjunct.
* @return {Filter}
*/
ee.Filter.and;
/**
* Returns a filter that passes if the object's timestamp falls within the given range of a calendar field. The month, day_of_year, day_of_month, and day_of_week are 1-based. Times are assumed to be in UTC. Weeks are assumed to begin on Monday as day 1. If end < start then this tests for value >= start OR value <= end, to allow for wrapping.
* @param {Integer} start The start of the desired calendar field, inclusive.
* @param {Integer} end The end of the desired calendar field, inclusive. Defaults to the same value as start.
* @param {String} field The calendar field to filter over. Options are: 'year', 'month', 'hour', 'minute', 'day_of_year', 'day_of_month', and 'day_of_week'.
* @return {Filter}
*/
ee.Filter.calendarRange;
/**
* Creates a unary or binary filter that passes if the left geometry contains the right geometry (empty geometries are not contained in anything).
* @param {String} leftField A selector for the left operand. Should not be specified if leftValue is specified.
* @param {Object} rightValue The value of the right operand. Should not be specified if rightField is specified.
* @param {String} rightField A selector for the right operand. Should not be specified if rightValue is specified.
* @param {Object} leftValue The value of the left operand. Should not be specified if leftField is specified.
* @param {ErrorMargin} maxError The maximum reprojection error allowed during filter application.
* @return {Filter}
*/
ee.Filter.contains;
/**
* Creates a unary or binary filter that passes if the left operand, a date range, contains the right operand, a date.
* @param {String} leftField A selector for the left operand. Should not be specified if leftValue is specified.
* @param {Object} rightValue The value of the right operand. Should not be specified if rightField is specified.
* @param {String} rightField A selector for the right operand. Should not be specified if rightValue is specified.
* @param {Object} leftValue The value of the left operand. Should not be specified if leftField is specified.
* @return {Filter}
*/
ee.Filter.dateRangeContains;
/**
* Returns a filter that passes if the object's timestamp falls within the given day-of-year range.
* @param {Integer} start The start of the desired day range, inclusive.
* @param {Integer} end The end of the desired day range, exclusive.
* @return {Filter}
*/
ee.Filter.dayOfYear;
/**
* Creates a unary or binary filter that passes unless the left geometry intersects the right geometry.
* @param {String} leftField A selector for the left operand. Should not be specified if leftValue is specified.
* @param {Object} rightValue The value of the right operand. Should not be specified if rightField is specified.
* @param {String} rightField A selector for the right operand. Should not be specified if rightValue is specified.
* @param {Object} leftValue The value of the left operand. Should not be specified if leftField is specified.
* @param {ErrorMargin} maxError The maximum reprojection error allowed during filter application.
* @return {Filter}
*/
ee.Filter.disjoint;
/**
* Creates a unary or binary filter that passes if the two operands are equals.
* @param {String} leftField A selector for the left operand. Should not be specified if leftValue is specified.
* @param {Object} rightValue The value of the right operand. Should not be specified if rightField is specified.
* @param {String} rightField A selector for the right operand. Should not be specified if rightValue is specified.
* @param {Object} leftValue The value of the left operand. Should not be specified if leftField is specified.
* @return {Filter}
*/
ee.Filter.eq;
/**
* Creates a unary or binary filter that passes if the two operands are equals.
* @param {String} leftField A selector for the left operand. Should not be specified if leftValue is specified.
* @param {Object} rightValue The value of the right operand. Should not be specified if rightField is specified.
* @param {String} rightField A selector for the right operand. Should not be specified if rightValue is specified.
* @param {Object} leftValue The value of the left operand. Should not be specified if leftField is specified.
* @return {Filter}
*/
ee.Filter.equals;
/**
* Creates a unary or binary filter that passes if the left operand is greater than the right operand.
* @param {String} leftField A selector for the left operand. Should not be specified if leftValue is specified.
* @param {Object} rightValue The value of the right operand. Should not be specified if rightField is specified.
* @param {String} rightField A selector for the right operand. Should not be specified if rightValue is specified.
* @param {Object} leftValue The value of the left operand. Should not be specified if leftField is specified.
* @return {Filter}
*/
ee.Filter.greaterThan;
/**
* Creates a unary or binary filter that passes unless the left operand is less than the right operand.
* @param {String} leftField A selector for the left operand. Should not be specified if leftValue is specified.
* @param {Object} rightValue The value of the right operand. Should not be specified if rightField is specified.
* @param {String} rightField A selector for the right operand. Should not be specified if rightValue is specified.
* @param {Object} leftValue The value of the left operand. Should not be specified if leftField is specified.
* @return {Filter}
*/
ee.Filter.greaterThanOrEquals;
/**
* Creates a unary or binary filter that passes if the left operand is greater than the right operand.
* @param {String} leftField A selector for the left operand. Should not be specified if leftValue is specified.
* @param {Object} rightValue The value of the right operand. Should not be specified if rightField is specified.
* @param {String} rightField A selector for the right operand. Should not be specified if rightValue is specified.
* @param {Object} leftValue The value of the left operand. Should not be specified if leftField is specified.
* @return {Filter}
*/
ee.Filter.gt;
/**
* Creates a unary or binary filter that passes unless the left operand is less than the right operand.
* @param {String} leftField A selector for the left operand. Should not be specified if leftValue is specified.
* @param {Object} rightValue The value of the right operand. Should not be specified if rightField is specified.
* @param {String} rightField A selector for the right operand. Should not be specified if rightValue is specified.
* @param {Object} leftValue The value of the left operand. Should not be specified if leftField is specified.
* @return {Filter}
*/
ee.Filter.gte;
/**
* Creates a unary or binary filter that passes if the left operand, a list, contains the right operand.
* @param {String} leftField A selector for the left operand. Should not be specified if leftValue is specified.
* @param {Object} rightValue The value of the right operand. Should not be specified if rightField is specified.
* @param {String} rightField A selector for the right operand. Should not be specified if rightValue is specified.
* @param {Object} leftValue The value of the left operand. Should not be specified if leftField is specified.
* @return {Filter}
*/
ee.Filter.inList;
/**
* Creates a unary or binary filter that passes if the left geometry intersects the right geometry.
* @param {String} leftField A selector for the left operand. Should not be specified if leftValue is specified.
* @param {Object} rightValue The value of the right operand. Should not be specified if rightField is specified.
* @param {String} rightField A selector for the right operand. Should not be specified if rightValue is specified.
* @param {Object} leftValue The value of the left operand. Should not be specified if leftField is specified.
* @param {ErrorMargin} maxError The maximum reprojection error allowed during filter application.
* @return {Filter}
*/
ee.Filter.intersects;
/**
* Creates a unary or binary filter that passes if the right geometry contains the left geometry (empty geometries are not contained in anything).
* @param {String} leftField A selector for the left operand. Should not be specified if leftValue is specified.
* @param {Object} rightValue The value of the right operand. Should not be specified if rightField is specified.
* @param {String} rightField A selector for the right operand. Should not be specified if rightValue is specified.
* @param {Object} leftValue The value of the left operand. Should not be specified if leftField is specified.
* @param {ErrorMargin} maxError The maximum reprojection error allowed during filter application.
* @return {Filter}
*/
ee.Filter.isContained;
/**
* Creates a unary or binary filter that passes if the left operand is less than the right operand.
* @param {String} leftField A selector for the left operand. Should not be specified if leftValue is specified.
* @param {Object} rightValue The value of the right operand. Should not be specified if rightField is specified.
* @param {String} rightField A selector for the right operand. Should not be specified if rightValue is specified.
* @param {Object} leftValue The value of the left operand. Should not be specified if leftField is specified.
* @return {Filter}
*/
ee.Filter.lessThan;
/**
* Creates a unary or binary filter that passes unless the left operand is greater than the right operand.
* @param {String} leftField A selector for the left operand. Should not be specified if leftValue is specified.
* @param {Object} rightValue The value of the right operand. Should not be specified if rightField is specified.
* @param {String} rightField A selector for the right operand. Should not be specified if rightValue is specified.
* @param {Object} leftValue The value of the left operand. Should not be specified if leftField is specified.
* @return {Filter}
*/
ee.Filter.lessThanOrEquals;
/**
* Creates a unary or binary filter that passes if the left operand, a list, contains the right operand.
* @param {String} leftField A selector for the left operand. Should not be specified if leftValue is specified.
* @param {Object} rightValue The value of the right operand. Should not be specified if rightField is specified.
* @param {String} rightField A selector for the right operand. Should not be specified if rightValue is specified.
* @param {Object} leftValue The value of the left operand. Should not be specified if leftField is specified.
* @return {Filter}
*/
ee.Filter.listContains;
/**
* Creates a unary or binary filter that passes if the left operand is less than the right operand.
* @param {String} leftField A selector for the left operand. Should not be specified if leftValue is specified.
* @param {Object} rightValue The value of the right operand. Should not be specified if rightField is specified.
* @param {String} rightField A selector for the right operand. Should not be specified if rightValue is specified.
* @param {Object} leftValue The value of the left operand. Should not be specified if leftField is specified.
* @return {Filter}
*/
ee.Filter.lt;
/**
* Creates a unary or binary filter that passes unless the left operand is greater than the right operand.
* @param {String} leftField A selector for the left operand. Should not be specified if leftValue is specified.
* @param {Object} rightValue The value of the right operand. Should not be specified if rightField is specified.
* @param {String} rightField A selector for the right operand. Should not be specified if rightValue is specified.
* @param {Object} leftValue The value of the left operand. Should not be specified if leftField is specified.
* @return {Filter}
*/
ee.Filter.lte;
/**
* Creates a unary or binary filter that passes if the left and right operands, both numbers, are within a given maximum difference. If used as a join condition, this numeric difference is used as a join measure.
* @param {Float} difference The maximum difference for which the filter will return true.
* @param {String} leftField A selector for the left operand. Should not be specified if leftValue is specified.
* @param {Object} rightValue The value of the right operand. Should not be specified if rightField is specified.
* @param {String} rightField A selector for the right operand. Should not be specified if rightValue is specified.
* @param {Object} leftValue The value of the left operand. Should not be specified if leftField is specified.
* @return {Filter}
*/
ee.Filter.maxDifference;
/**
* Creates a unary or binary filter that passes unless the two operands are equals.
* @param {String} leftField A selector for the left operand. Should not be specified if leftValue is specified.
* @param {Object} rightValue The value of the right operand. Should not be specified if rightField is specified.
* @param {String} rightField A selector for the right operand. Should not be specified if rightValue is specified.
* @param {Object} leftValue The value of the left operand. Should not be specified if leftField is specified.
* @return {Filter}
*/
ee.Filter.neq;
/**
* Returns a filter that passes if the provided filter fails.
* @param {Filter} filter The filter to negate.
* @return {Filter}
*/
ee.Filter.prototype.not;
/**
* Creates a unary or binary filter that passes unless the two operands are equals.
* @param {String} leftField A selector for the left operand. Should not be specified if leftValue is specified.
* @param {Object} rightValue The value of the right operand. Should not be specified if rightField is specified.
* @param {String} rightField A selector for the right operand. Should not be specified if rightValue is specified.
* @param {Object} leftValue The value of the left operand. Should not be specified if leftField is specified.
* @return {Filter}
*/
ee.Filter.notEquals;
/**
* Creates a Filter.
* @param {List<String>} properties
* @return {Filter}
*/
ee.Filter.notNull;
/**
* Returns a filter that passes if any of the component filters pass.
* @param {List<Filter>} filters The filters to disjunct.
* @return {Filter}
*/
ee.Filter.or;
/**
* Returns a filter that passes if the value of the selected field is in the specified range (inclusive).
* @param {String} field A selector for the property being tested.
* @param {Object} minValue The lower bound of the range.
* @param {Object} maxValue The upper bound of the range.
* @return {Filter}
*/
ee.Filter.rangeContains;
/**
* Creates a unary or binary filter that passes if the left operand, a string, contains the right operand, also a string.
* @param {String} leftField A selector for the left operand. Should not be specified if leftValue is specified.
* @param {Object} rightValue The value of the right operand. Should not be specified if rightField is specified.
* @param {String} rightField A selector for the right operand. Should not be specified if rightValue is specified.
* @param {Object} leftValue The value of the left operand. Should not be specified if leftField is specified.
* @return {Filter}
*/
ee.Filter.stringContains;
/**
* Creates a unary or binary filter that passes if the left operand, a string, ends with the right operand, also a string.
* @param {String} leftField A selector for the left operand. Should not be specified if leftValue is specified.
* @param {Object} rightValue The value of the right operand. Should not be specified if rightField is specified.
* @param {String} rightField A selector for the right operand. Should not be specified if rightValue is specified.
* @param {Object} leftValue The value of the left operand. Should not be specified if leftField is specified.
* @return {Filter}
*/
ee.Filter.stringEndsWith;
/**
* Creates a unary or binary filter that passes if the left operand, a string, starts with the right operand, also a string.
* @param {String} leftField A selector for the left operand. Should not be specified if leftValue is specified.
* @param {Object} rightValue The value of the right operand. Should not be specified if rightField is specified.
* @param {String} rightField A selector for the right operand. Should not be specified if rightValue is specified.
* @param {Object} leftValue The value of the left operand. Should not be specified if leftField is specified.
* @return {Filter}
*/
ee.Filter.stringStartsWith;
/**
* Creates a unary or binary filter that passes if the left geometry is within a specified distance of the right geometry. If used as a join condition, this distance is used as a join measure.
* @param {Float} distance The maximum distance for which the filter will return true.
* @param {String} leftField A selector for the left operand. Should not be specified if leftValue is specified.
* @param {Object} rightValue The value of the right operand. Should not be specified if rightField is specified.
* @param {String} rightField A selector for the right operand. Should not be specified if rightValue is specified.
* @param {Object} leftValue The value of the left operand. Should not be specified if leftField is specified.
* @param {ErrorMargin} maxError The maximum reprojection error allowed during filter application.
* @return {Filter}
*/
ee.Filter.withinDistance;
/**
* Returns the area of the geometry. Area of points and line strings is 0, and the area of multi geometries is the sum of the areas of their componenets (intersecting areas are counted multiple times).
* @param {Geometry} geometry The geometry input.
* @param {ErrorMargin} maxError The maximum amount of error tolerated when performing any necessary reprojection.
* @param {Projection} proj If specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in square meters.
* @return {Float}
*/
ee.Geometry.prototype.area;
/**
* Returns the bounding rectangle of the geometry.
* @param {Geometry} geometry Return the bounding box of this geometry.
* @param {ErrorMargin} maxError The maximum amount of error tolerated when performing any necessary reprojection.
* @param {Projection} proj If specified, the result will be in this projection. Otherwise it will be in WGS84.
* @return {Geometry}
*/
ee.Geometry.prototype.bounds;
/**
* Returns the input buffered by a given distance. If the distance is positive, the geometry is expanded, and if the distance is negative, the geometry is contracted.
* @param {Geometry} geometry The geometry being buffered.
* @param {Float} distance The distance of the buffering, which may be negative. If no projection is specified, the unit is meters. Otherwise the unit is in the coordinate system of the projection.
* @param {ErrorMargin} maxError The maximum amount of error tolerated when approximating the buffering circle and performing any necessary reprojection. If unspecified, defaults to 1% of the distance.
* @param {Projection} proj If specified, the buffering will be performed in this projection and the distance will be interpreted as units of the coordinate system of this projection. Otherwise the distance is interpereted as meters and the buffering is performed in a spherical coordinate system.
* @return {Geometry}
*/
ee.Geometry.prototype.buffer;
/**
* Returns a point at the center of the highest-dimension components of the geometry. Lower-dimensional components are ignored, so the centroid of a geometry containing two polygons, three lines and a point is equivalent to the centroid of a geometry containing just the two polygons.
* @param {Geometry} geometry Calculates the centroid of this geometry.
* @param {ErrorMargin} maxError The maximum amount of error tolerated when performing any necessary reprojection.
* @param {Projection} proj If specified, the result will be in this projection. Otherwise it will be in WGS84.
* @return {Geometry}
*/
ee.Geometry.prototype.centroid;
/**
* Returns true iff one geometry is contained in the other.
* @param {Geometry} left The geometry used as the left operand of the operation.
* @param {Geometry} right The geometry used as the right operand of the operation.
* @param {ErrorMargin} maxError The maximum amount of error tolerated when performing any necessary reprojection.
* @param {Projection} proj The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.
* @return {Boolean}
*/
ee.Geometry.prototype.containedIn;
/**
* Returns true iff one geometry contains the other.
* @param {Geometry} left The geometry used as the left operand of the operation.
* @param {Geometry} right The geometry used as the right operand of the operation.
* @param {ErrorMargin} maxError The maximum amount of error tolerated when performing any necessary reprojection.
* @param {Projection} proj The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.
* @return {Boolean}
*/
ee.Geometry.prototype.contains;
/**
* Returns the convex hull of the given geometry. The convex hull of a single point is the point itself, the convex hull of collinear points is a line, and the convex hull of everything else is a polygon. Note that a degenerate polygon with all vertices on the same line will result in a line segment.
* @param {Geometry} geometry Calculates the convex hull of this geometry.
* @param {ErrorMargin} maxError The maximum amount of error tolerated when performing any necessary reprojection.
* @param {Projection} proj The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.
* @return {Geometry}
*/
ee.Geometry.prototype.convexHull;
/**
* Returns a GeoJSON-style list of the geometry's coordinates.
* @param {Geometry} geometry
* @return {List<Object>}
*/
ee.Geometry.prototype.coordinates;
/**
* Returns a collection of features that cover this geometry, where each feature is a rectangle in the grid defined by the given projection.
* @param {Geometry} geometry The result is the grid cells that intersect with this region.
* @param {Projection} proj The projection in which to construct the grid. A feature is generated for each grid cell that intersects 'geometry', where cell corners are at integer-valued positions in the projection. If the projection is scaled in meters, the points will be on a grid of that size at the point of true scale.
* @param {Float} scale Overrides the scale of the projection, if provided. May be required if the projection isn't already scaled.
* @return {FeatureCollection}
*/
ee.Geometry.prototype.coveringGrid;
/**
* Converts LineStrings into a MultiLineString by cutting it in two at each distance along the length of the LineString.
* @param {Geometry} geometry Cuts the lines of this geometry.
* @param {List<Float>} distances Distances along each LineString to cut the line into separate pieces, measured in units of the given proj, or meters if proj is unspecified.
* @param {ErrorMargin} maxError The maximum amount of error tolerated when performing any necessary reprojection.
* @param {Projection} proj Projection of the result and distance measurements, or WGS84 if unspecified.
* @return {Geometry}
*/
ee.Geometry.prototype.cutLines;
/**
* Returns the result of subtracting the 'right' geometry from the 'left' geometry.
* @param {Geometry} left The geometry used as the left operand of the operation.
* @param {Geometry} right The geometry used as the right operand of the operation.
* @param {ErrorMargin} maxError The maximum amount of error tolerated when performing any necessary reprojection.
* @param {Projection} proj The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.
* @return {Geometry}
*/
ee.Geometry.prototype.difference;
/**
* Returns true iff the geometries are disjoint.
* @param {Geometry} left The geometry used as the left operand of the operation.
* @param {Geometry} right The geometry used as the right operand of the operation.
* @param {ErrorMargin} maxError The maximum amount of error tolerated when performing any necessary reprojection.
* @param {Projection} proj The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.
* @return {Boolean}
*/
ee.Geometry.prototype.disjoint;
/**
* Returns the union of the geometry. This leaves single geometries untouched, and unions multi geometries.
* @param {Geometry} geometry The geometry to union.
* @param {ErrorMargin} maxError The maximum amount of error tolerated when performing any necessary reprojection.
* @param {Projection} proj If specified, the union will be performed in this projection. Otherwise it will be performed in a spherical coordinate system.
* @return {Geometry}
*/
ee.Geometry.prototype.dissolve;
/**
* Returns the minimum distance between two geometries.
* @param {Geometry} left The geometry used as the left operand of the operation.
* @param {Geometry} right The geometry used as the right operand of the operation.
* @param {ErrorMargin} maxError The maximum amount of error tolerated when performing any necessary reprojection.
* @param {Projection} proj The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.
* @return {Float}
*/
ee.Geometry.prototype.distance;
/**
* Returns true if the geometry edges, if any, are geodesics along a spherical model of the earth; if false, any edges are straight lines in the projection.
* @param {Geometry} geometry
* @return {Boolean}
*/
ee.Geometry.prototype.edgesAreGeodesics;
/**
* If false, edges are straight in the projection. If true, edges are curved to follow the shortest path on the surface of the Earth.
* @param {Geometry} geometry
* @return {Boolean}
*/
ee.Geometry.prototype.geodesic;
/**
* Returns the list of geometries in a GeometryCollection, or a singleton list of the geometry for single geometries.
* @param {Geometry} geometry
* @return {List<Geometry>}
*/
ee.Geometry.prototype.geometries;
/**
* Returns the intersection of the two geometries.
* @param {Geometry} left The geometry used as the left operand of the operation.
* @param {Geometry} right The geometry used as the right operand of the operation.
* @param {ErrorMargin} maxError The maximum amount of error tolerated when performing any necessary reprojection.
* @param {Projection} proj The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.
* @return {Geometry}
*/
ee.Geometry.prototype.intersection;
/**
* Returns true iff the geometries intersect.
* @param {Geometry} left The geometry used as the left operand of the operation.
* @param {Geometry} right The geometry used as the right operand of the operation.
* @param {ErrorMargin} maxError The maximum amount of error tolerated when performing any necessary reprojection.
* @param {Projection} proj The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.
* @return {Boolean}
*/
ee.Geometry.prototype.intersects;
/**
* Returns whether the geometry is unbounded.
* @param {Geometry} geometry
* @return {Boolean}
*/
ee.Geometry.prototype.isUnbounded;
/**
* Returns the length of the linear parts of the geometry. Polygonal parts are ignored. The length of multi geometries is the sum of the lengths of their components.
* @param {Geometry} geometry The input geometry.
* @param {ErrorMargin} maxError The maximum amount of error tolerated when performing any necessary reprojection.
* @param {Projection} proj If specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in meters.
* @return {Float}
*/
ee.Geometry.prototype.length;
/**
* Returns the length of the perimeter of the polygonal parts of the geometry. The perimeter of multi geometries is the sum of the perimeters of their components.
* @param {Geometry} geometry The input geometry.
* @param {ErrorMargin} maxError The maximum amount of error tolerated when performing any necessary reprojection.
* @param {Projection} proj If specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in meters.
* @return {Float}
*/
ee.Geometry.prototype.perimeter;
/**
* Returns the projection of the geometry.
* @param {Geometry} geometry
* @return {Projection}
*/
ee.Geometry.prototype.projection;
/**
* Constructs the Polygon corresponding to an S2 cell id.
* @param {Long} cellId The S2 cell id.
* @return {Geometry}
*/
ee.Geometry.s2Cell;
/**
* Simplifies the geometry to within a given error margin. Note that this does not respect the error margin requested by the consumer of this algorithm, unless maxError is explicitly specified to be null.
This overrides the default Earth Engine policy for propagating error margins, so regardless of the geometry accuracy requested from the output, the inputs will be requested with the error margin specified in the arguments to this algorithm. This results in consistent rendering at all zoom levels of a rendered vector map, but at lower zoom levels (i.e. zoomed out), the geometry won't be simplified, which may harm performance.
* @param {Geometry} geometry The geometry to simplify.
* @param {ErrorMargin} maxError The maximum amount of error by which the result may differ from the input.
* @param {Projection} proj If specified, the result will be in this projection. Otherwise it will be in the same projection as the input. If the error margin is in projected units, the margin will be interpreted as units of this projection
* @return {Geometry}
*/
ee.Geometry.prototype.simplify;
/**
* Snaps the vertices of the geometry to a regular cell grid with radius near but less than the given snap radius in meters. Snapping can reduce the number of vertices, close gaps in adjacent spatial features, and push degenerate elements to lower dimensional objects, e.g. a narrow polygon may collapse to a line. When applied to a GeometryCollection, overlap created between different elements is not removed.
* @param {Geometry} geometry The geometry to snap.
* @param {ErrorMargin} snapRadius The max distance to move vertices during snapping. If in meters, 'proj' must not be specified, otherwise if in units, 'proj' must specified.
* @param {Projection} proj If unspecified the result will be in WGS84 with geodesic edges and the snap radius must be in meters, otherwise the snap radius must be in units and the result will be in this projection with planar edges.
* @return {Geometry}
*/
ee.Geometry.prototype.snap;
/**
* Returns the symmetric difference between two geometries.
* @param {Geometry} left The geometry used as the left operand of the operation.
* @param {Geometry} right The geometry used as the right operand of the operation.
* @param {ErrorMargin} maxError The maximum amount of error tolerated when performing any necessary reprojection.
* @param {Projection} proj The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.
* @return {Geometry}
*/
ee.Geometry.prototype.symmetricDifference;
/**
* Transforms the geometry to a specific projection.
* @param {Geometry} geometry The geometry to reproject.
* @param {Projection} proj The target projection. Defaults to WGS84. If this has a geographic CRS, the edges of the geometry will be interpreted as geodesics. Otherwise they will be interpreted as straight lines in the projection.
* @param {ErrorMargin} maxError The maximum projection error.
* @return {Geometry}
*/
ee.Geometry.prototype.transform;
/**
* Returns the GeoJSON type of the geometry.
* @param {Geometry} geometry
* @return {String}
*/
ee.Geometry.prototype.type;
/**
* Returns the union of the two geometries.
* @param {Geometry} left The geometry used as the left operand of the operation.
* @param {Geometry} right The geometry used as the right operand of the operation.
* @param {ErrorMargin} maxError The maximum amount of error tolerated when performing any necessary reprojection.
* @param {Projection} proj The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.
* @return {Geometry}
*/
ee.Geometry.prototype.union;
/**
* Returns true iff the geometries are within a specified distance.
* @param {Geometry} left The geometry used as the left operand of the operation.
* @param {Geometry} right The geometry used as the right operand of the operation.
* @param {Float} distance The distance threshold. If a projection is specified, the distance is in units of that projected coordinate system, otherwise it is in meters.
* @param {ErrorMargin} maxError The maximum amount of error tolerated when performing any necessary reprojection.
* @param {Projection} proj The projection in which to perform the operation. If not specified, the operation will be performed in a spherical coordinate system, and linear distances will be in meters on the sphere.
* @return {Boolean}
*/
ee.Geometry.prototype.withinDistance;
/**
* Constructs a LineString from the given coordinates.
* @param {List<Object>} coordinates The list of Points or pairs of Numbers in x,y order.
* @param {Projection} crs The coordinate reference system of the coordinates. The default is the projection of the inputs, where Numbers are assumed to be EPSG:4326.
* @param {Boolean} geodesic If false, edges are straight in the projection. If true, edges are curved to follow the shortest path on the surface of the Earth. The default is the geodesic state of the inputs, or true if the inputs are numbers.
* @return {Geometry}
*/
ee.GeometryConstructors.LineString;
/**
* Constructs a LinearRing from the given coordinates, automatically adding the first point at the end if the ring is not explicitly closed.
* @param {List<Object>} coordinates The list of Points or pairs of Numbers in x,y order.
* @param {Projection} crs The coordinate reference system of the coordinates. The default is the projection of the inputs, where Numbers are assumed to be EPSG:4326.
* @param {Boolean} geodesic If false, edges are straight in the projection. If true, edges are curved to follow the shortest path on the surface of the Earth. The default is the geodesic state of the inputs, or true if the inputs are numbers.
* @return {Geometry}
*/
ee.GeometryConstructors.LinearRing;
/**
* Constructs a MultiGeometry from the given list of geometry elements.
* @param {List<Geometry>} geometries The list of geometries for the MultiGeometry.
* @param {Projection} crs The coordinate reference system of the coordinates. The default is the projection of the inputs, where Numbers are assumed to be EPSG:4326.
* @param {Boolean} geodesic If false, edges are straight in the projection. If true, edges are curved to follow the shortest path on the surface of the Earth. The default is the geodesic state of the inputs, or true if the inputs are numbers.
* @param {ErrorMargin} maxError Max error when input geometry must be reprojected to an explicitly requested result projection or geodesic state.
* @return {Geometry}
*/
ee.GeometryConstructors.MultiGeometry;
/**
* Constructs a MultiLineString from the given coordinates.
* @param {List<Object>} coordinates The list of LineStrings, or to wrap a single LineString, the list of Points or pairs of Numbers in x,y order.
* @param {Projection} crs The coordinate reference system of the coordinates. The default is the projection of the inputs, where Numbers are assumed to be EPSG:4326.
* @param {Boolean} geodesic If false, edges are straight in the projection. If true, edges are curved to follow the shortest path on the surface of the Earth. The default is the geodesic state of the inputs, or true if the inputs are numbers.
* @param {ErrorMargin} maxError Max error when input geometry must be reprojected to an explicitly requested result projection or geodesic state.
* @return {Geometry}
*/
ee.GeometryConstructors.MultiLineString;
/**
* Constructs a MultiPoint from the given coordinates.
* @param {List<Object>} coordinates The list of Points or pairs of Numbers in x,y order.
* @param {Projection} crs The coordinate reference system of the coordinates. The default is the projection of the inputs, where Numbers are assumed to be EPSG:4326.
* @return {Geometry}
*/
ee.GeometryConstructors.MultiPoint;
/**
* Constructs a MultiPolygon from the given coordinates.
* @param {List<Object>} coordinates A list of Polygons, or for one simple polygon, a list of Points or pairs of Numbers in x,y order.
* @param {Projection} crs The coordinate reference system of the coordinates. The default is the projection of the inputs, where Numbers are assumed to be EPSG:4326.
* @param {Boolean} geodesic If false, edges are straight in the projection. If true, edges are curved to follow the shortest path on the surface of the Earth. The default is the geodesic state of the inputs, or true if the inputs are numbers.
* @param {ErrorMargin} maxError Max error when input geometry must be reprojected to an explicitly requested result projection or geodesic state.
* @param {Boolean} evenOdd If true, polygon interiors will be determined by the even/odd rule, where a point is inside if it crosses an odd number of edges to reach a point at infinity. Otherwise polygons use the left-inside rule, where interiors are on the left side of the shell's edges when walking the vertices in the given order.
* @return {Geometry}
*/
ee.GeometryConstructors.MultiPolygon;
/**
* Constructs a new Point from the given x,y coordinates.
* @param {List<Number>} coordinates The coordinates of this Point in x,y order.
* @param {Projection} crs The coordinate reference system of the coordinates. The default is the projection of the inputs, where Numbers are assumed to be EPSG:4326.
* @return {Geometry}
*/
ee.GeometryConstructors.Point;
/**
* Constructs a Polygon from the given coordinates.
* @param {List<Object>} coordinates A list of LinearRings where the first is the shell and the rest are holes, or for a simple polygon, a list of Points or pairs of Numbers in x,y order.
* @param {Projection} crs The coordinate reference system of the coordinates. The default is the projection of the inputs, where Numbers are assumed to be EPSG:4326.
* @param {Boolean} geodesic If false, edges are straight in the projection. If true, edges are curved to follow the shortest path on the surface of the Earth. The default is the geodesic state of the inputs, or true if the inputs are numbers.
* @param {ErrorMargin} maxError Max error when input geometry must be reprojected to an explicitly requested result projection or geodesic state.
* @param {Boolean} evenOdd If true, polygon interiors will be determined by the even/odd rule, where a point is inside if it crosses an odd number of edges to reach a point at infinity. Otherwise polygons use the left-inside rule, where interiors are on the left side of the shell's edges when walking the vertices in the given order.
* @return {Geometry}
*/
ee.GeometryConstructors.Polygon;
/**
* Constructs a rectangular polygon from the given corner points.
* @param {List<Object>} coordinates The low and then high corners of the Rectangle, as a list of Points or pairs of Numbers in x,y order.
* @param {Projection} crs The coordinate reference system of the coordinates. The default is the projection of the inputs, where Numbers are assumed to be EPSG:4326.
* @param {Boolean} geodesic If false, edges are straight in the projection. If true, edges are curved to follow the shortest path on the surface of the Earth. The default is the geodesic state of the inputs, or true if the inputs are numbers.
* @param {Boolean} evenOdd If true, polygon interiors will be determined by the even/odd rule, where a point is inside if it crosses an odd number of edges to reach a point at infinity. Otherwise polygons use the left-inside rule, where interiors are on the left side of the shell's edges when walking the vertices in the given order.
* @return {Geometry}
*/
ee.GeometryConstructors.Rectangle;
/**
* Creates a shadow band, with output 1 where pixels are illumunated and 0 where they are shadowed. Takes as input an elevation band, azimuth and zenith of the light source in degrees, a neighborhood size, and whether or not to apply hysteresis when a shadow appears. Currently, this algorithm only works for Mercator projections, in which light rays are parallel.
* @param {Image} image The image to which to apply the shadow algorithm, in whicheach pixel should represent an elevation in meters.
* @param {Float} azimuth Azimuth in degrees.
* @param {Float} zenith Zenith in degrees.
* @param {Integer} neighborhoodSize Neighborhood size.
* @param {Boolean} hysteresis Use hysteresis. Less physically accurate, but may generate better images.
* @return {Image}
*/
ee.HillShadow;
/**
* Applies the Hough transform to an image. For every input band, outputs a band where lines are detected by thresholding the Hough transform with a value of lineThreshold. The output band is named [input]_lines, where [input] is the name of the original band. The defaults provided for the parameters are intended as a starting point for use with UINT8 images.
* @param {Image} image The image to which to apply the transform.
* @param {Integer} gridSize Grid size.
* @param {Float} inputThreshold Value threshold for input image. Pixels equal to or above this value are considered active.
* @param {Float} lineThreshold Threshold for line detection. Values equal to or above this threshold on the Hough transform are considered to be detected lines.
* @param {Boolean} smooth Whether to smooth the Hough transform before line detection.
* @return {Image}
*/
ee.HoughTransform;
/**
* Selects one of its inputs based on a condition, similar to an if-then-else construct.
* @param {Object} condition The condition that determines which result is returned. If this is not a boolean, it is interpreted as a boolean by the following rules:
- Numbers that are equal to 0 or a NaN are false.
- Empty strings, lists and dictionaries are false.
- Null is false.
- Everything else is true.
* @param {Object} trueCase The result to return if the condition is true.
* @param {Object} falseCase The result to return if the condition is false.
* @return {Object}
*/
ee.If;
/**
* Performs G-Means clustering on the input image. Iteratively applies k-means followed by a normality test to automatically determine the number of clusters to use. The output contains a 'clusters' band containing the integer ID of the cluster that each pixel belongs to. The algorithm can work either on a fixed grid of non-overlapping cells (gridSize, which can be smaller than a tile) or on tiles with overlap (neighborhoodSize). The default is to use tiles with no overlap. Clusters in one cell or tile are unrelated to clusters in another. Any cluster that spans a cell or tile boundary may receive two different labels in the two halves. Any input pixels with partial masks are fully masked in the output. This algorithm is only expected to perform well for images with a narrow dynamic range (i.e. bytes or shorts).
See: G. Hamerly and C. Elkan. 'Learning the k in k-means'. NIPS, 2003.
* @param {Image} image The input image for clustering.
* @param {Integer} numIterations Number of iterations. Default 10.
* @param {Float} pValue Significance level for normality test.
* @param {Integer} neighborhoodSize Neighborhood size. The amount to extend each tile (overlap) when computing the clusters. This option is mutually exclusive with gridSize.
* @param {Integer} gridSize Grid cell-size. If greater than 0, kMeans will be run independently on cells of this size. This has the effect of limiting the size of any cluster to be gridSize or smaller. This option is mutually exclusive with neighborhoodSize.
* @param {Boolean} uniqueLabels If true, clusters are assigned unique IDs. Otherwise, they repeat per tile or grid cell.
* @return {Image}
*/
ee.Image.Segmentation.GMeans;
/**
* Performs K-Means clustering on the input image. Outputs a 1-band image containing the ID of the cluster that each pixel belongs to. The algorithm can work either on a fixed grid of non-overlapping cells (gridSize, which can be smaller than a tile) or on tiles with overlap (neighborhoodSize). The default is to use tiles with no overlap. Clusters in one cell or tile are unrelated to clusters in another. Any cluster that spans a cell or tile boundary may receive two different labels in the two halves. Any input pixels with partial masks are fully masked in the output.
* @param {Image} image The input image for clustering.
* @param {Integer} numClusters Number of clusters.
* @param {Integer} numIterations Number of iterations.
* @param {Integer} neighborhoodSize Neighborhood size. The amount to extend each tile (overlap) when computing the clusters. This option is mutually exclusive with gridSize.
* @param {Integer} gridSize Grid cell-size. If greater than 0, kMeans will be run independently on cells of this size. This has the effect of limiting the size of any cluster to be gridSize or smaller. This option is mutually exclusive with neighborhoodSize.
* @param {Boolean} forceConvergence If true, an error is thrown if convergence is not achieved before numIterations.
* @param {Boolean} uniqueLabels If true, clusters are assigned unique IDs. Otherwise, they repeat per tile or grid cell.
* @return {Image}
*/
ee.Image.Segmentation.KMeans;
/**
* Superpixel clustering based on SNIC (Simple Non-Iterative Clustering). Outputs a band of cluster IDs and the per-cluster averages for each of the input bands. If the 'seeds' image isn't provided as input, the output will include a 'seeds' band containing the generated seed locations. See: Achanta, Radhakrishna and Susstrunk, Sabine, 'Superpixels and Polygons using Simple Non-Iterative Clustering', CVPR, 2017.
* @param {Image} image The input image for clustering.
* @param {Integer} size The superpixel seed location spacing, in pixels. If 'seeds' image is provided, no grid is produced.
* @param {Float} compactness Compactness factor. Larger values cause clusters to be more compact (square). Setting this to 0 disables spatial distance weighting.
* @param {Integer} connectivity Connectivity. Either 4 or 8.
* @param {Integer} neighborhoodSize Tile neighborhood size (to avoid tile boundary artifacts). Defaults to 2 * size.
* @param {Image} seeds If provided, any non-zero valued pixels are used as seed locations. Pixels that touch (as specified by 'connectivity') are considered to belong to the same cluster.
* @return {Image}
*/
ee.Image.Segmentation.SNIC;
/**
* Selects seed pixels for clustering.
* @param {Integer} size The superpixel seed location spacing, in pixels.
* @param {String} gridType Type of grid. One of 'square' or 'hex'.
* @return {Image}
*/
ee.Image.Segmentation.seedGrid;
/**
* Computes the absolute value of the input.
* @param {Image} value The image to which the operation is applied.
* @return {Image}
*/
ee.Image.abs;
/**
* Computes the arc cosine in radians of the input.
* @param {Image} value The image to which the operation is applied.
* @return {Image}
*/
ee.Image.acos;
/**
* Adds the first value to the second for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is the union of the input types.
* @param {Image} image1 The image from which the left operand bands are taken.
* @param {Image} image2 The image from which the right operand bands are taken.
* @return {Image}
*/
ee.Image.add;
/**
* Returns an image containing all bands copied from the first input and selected bands from the second input, optionally overwriting bands in the first image with the same name. The new image has the metadata and footprint from the first input image.
* @param {Image} dstImg An image into which to copy bands.
* @param {Image} srcImg An image containing bands to copy.
* @param {List<String>} names Optional list of band names to copy. If names is omitted, all bands from srcImg will be copied over.
* @param {Boolean} overwrite If true, bands from srcImg will override bands with the same names in dstImg. Otherwise the new band will be renamed with a numerical suffix ('foo' to 'foo_1' unless 'foo_1' exists, then 'foo_2' unless it exists, etc).
* @return {Image}
*/
ee.Image.addBands;
/**
* Returns 1 iff both values are non-zero for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is boolean.
* @param {Image} image1 The image from which the left operand bands are taken.
* @param {Image} image2 The image from which the right operand bands are taken.
* @return {Image}
*/
ee.Image.and;
/**
* Adds an Annotation to an image.
* @param {Image} image The input image.
* @param {Annotation} annotation The annotation to add to the image.
* @return {Image}
*/
ee.Image.annotate;
/**
* Accumulates elements of each array pixel along the given axis, by setting each element of the result array pixel to the reduction of elements in that pixel along the given axis, up to and including the current position on the axis. May be used to make a cumulative sum, a monotonically increasing sequence, etc.
* @param {Image} input Input image.
* @param {Integer} axis Axis along which to perform the cumulative sum.
* @param {Reducer} reducer Reducer to accumulate values. Default is SUM, to produce the cumulative sum of each vector along the given axis.
* @return {Image}
*/
ee.Image.arrayAccum;
/**
* Creates an array image by concatenating each array pixel along the given axis in each band.
* @param {Image} image1 First array image to concatenate.
* @param {Image} image2 Second array image to concatenate.
* @param {Integer} axis Axis to concatenate along.
* @return {Image}
*/
ee.Image.arrayCat;
/**
* Returns the number of dimensions in each array band, and 0 for scalar image bands.
* @param {Image} input Input image.
* @return {Image}
*/
ee.Image.arrayDimensions;
/**
* Computes the dot product of each pair of 1-D arrays in the bands of the input images.
* @param {Image} image1 First array image of 1-D vectors.
* @param {Image} image2 Second array image of 1-D vectors.
* @return {Image}
*/
ee.Image.arrayDotProduct;
/**
* Converts a single band image of equal-shape multidimensional pixels to an image of scalar pixels, with one band for each element of the array.
* @param {Image} image Image of multidimensional pixels to flatten.
* @param {List<List<String>>} coordinateLabels Name of each position along each axis. For example, 2x2 arrays with axes meaning 'day' and 'color' could have labels like [['monday', 'tuesday'], ['red', 'green']], resulting in band names'monday_red', 'monday_green', 'tuesday_red', and 'tuesday_green'.
* @param {String} separator Separator between array labels in each band name.
* @return {Image}
*/
ee.Image.arrayFlatten;
/**
* For each band, an output band of the same name is created with the value at the given position extracted from the input multidimensional pixel in that band.
* @param {Image} image Array to get an element from.
* @param {Image} position The coordinates of the element to get. There must be as many scalar bands as there are dimensions in the input image.
* @return {Image}
*/
ee.Image.arrayGet;
/**
* Returns the length of each pixel's array along the given axis.
* @param {Image} input Input image.
* @param {Integer} axis The axis along which to take the length.
* @return {Image}
*/
ee.Image.arrayLength;
/**
* Returns a 1D array image with the length of each array axis.
* @param {Image} input Input image.
* @return {Image}
*/
ee.Image.arrayLengths;
/**
* Creates an array image where each array-valued pixel is masked with another array-valued pixel, retaining only the elements where the mask is non-zero. If the mask image has one band it will be applied to all the bands of 'input', otherwise they must have the same number of bands.
* @param {Image} input Array image to mask.
* @param {Image} mask Array image to mask with.
* @return {Image}
*/
ee.Image.arrayMask;
/**
* Projects the array in each pixel to a lower dimensional space by specifying the axes to retain. Dropped axes must be at most length 1.
* @param {Image} input Input image.
* @param {List<Integer>} axes The axes to retain. Other axes will be discarded and must be at most length 1.
* @return {Image}
*/
ee.Image.arrayProject;
/**
* Reduces elements of each array pixel.
* @param {Image} input Input image.
* @param {Reducer} reducer The reducer to apply
* @param {List<Integer>} axes The list of array axes to reduce in each pixel. The output will have a length of 1 in all these axes.
* @param {Integer} fieldAxis The axis for the reducer's input and output fields. Only required if the reducer has multiple inputs or outputs.
* @return {Image}
*/
ee.Image.arrayReduce;
/**
* Repeats each array pixel along the given axis. Each output pixel will have the shape of the input pixel, except length along the repeated axis, which will be multiplied by the number of copies.
* @param {Image} input Image of array pixels to be repeated.
* @param {Integer} axis Axis along which to repeat each pixel's array.
* @param {Image} copies Number of copies of each pixel.
* @return {Image}
*/
ee.Image.arrayRepeat;
/**
* Creates a subarray by slicing out each position along the given axis from the 'start' (inclusive) to 'end' (exclusive) by increments of 'step'. The result will have as many dimensions as the input, and the same length in all directions except the slicing axis, where the length will be the number of positions from 'start' to 'end' by 'step' that are in range of the input array's length along 'axis'. This means the result can be length 0 along the given axis if start=end, or if the start or end values are entirely out of range.
* @param {Image} input Input array image.
* @param {Integer} axis Axis to subset.
* @param {Image} start The coordinate of the first slice (inclusive) along 'axis'. Negative numbers are used to position the start of slicing relative to the end of the array, where -1 starts at the last position on the axis, -2 starts at the next to last position, etc. There must one band for start indices, or one band per 'input' band. If this argument is not set or masked at some pixel, then the slice at that pixel will start at index 0.
* @param {Image} end The coordinate (exclusive) at which to stop taking slices. By default this will be the length of the given axis. Negative numbers are used to position the end of slicing relative to the end of the array, where -1 will exclude the last position, -2 will exclude the last two positions, etc. There must be one band for end indices, or one band per 'input' band. If this argument is not set or masked at some pixel, then the slice at that pixel will end just after the last index.
* @param {Integer} step The separation between slices along 'axis'; a slice will be taken at each whole multiple of 'step' from 'start' (inclusive) to 'end' (exclusive). Must be positive.
* @return {Image}
*/
ee.Image.arraySlice;
/**
* Sorts elements of each array pixel along one axis.
* @param {Image} image Array image to sort.
* @param {Image} keys Optional keys to sort by. If not provided, the values are used as the keys. The keys can only have multiple elements along one axis, which determines the direction to sort in.
* @return {Image}
*/
ee.Image.arraySort;
/**
* Transposes two dimensions of each array pixel.
* @param {Image} input Input image.
* @param {Integer} axis1 First axis to swap.
* @param {Integer} axis2 Second axis to swap.
* @return {Image}
*/
ee.Image.arrayTranspose;
/**
* Computes the arc sine in radians of the input.
* @param {Image} value The image to which the operation is applied.
* @return {Image}
*/
ee.Image.asin;
/**
* Computes the arc tangent in radians of the input.
* @param {Image} value The image to which the operation is applied.
* @return {Image}
*/
ee.Image.atan;
/**
* Calculates the angle formed by the 2D vector [x, y] for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is float.
* @param {Image} image1 The image from which the left operand bands are taken.
* @param {Image} image2 The image from which the right operand bands are taken.
* @return {Image}
*/
ee.Image.atan2;
/**
* Returns a list containing the names of the bands of an image.
* @param {Image} image The image from which to get band names.
* @return {List<Object>}
*/
ee.Image.bandNames;
/**
* Returns a dictionary of the image's band types.
* @param {Image} image The image from which to get band types.
* @return {Dictionary<Object>}
*/
ee.Image.bandTypes;
/**
* Calculates the number of one-bits in the 64-bit two's complement binary representation of the input.
* @param {Image} value The image to which the operation is applied.
* @return {Image}
*/
ee.Image.bitCount;
/**
* Turns the bits of an integer into a 1-D array. The array has a lengthup to the highest 'on' bit in the input.
* @param {Image} input Input image.
* @return {Image}
*/
ee.Image.bitsToArrayImage;
/**
* Calculates the bitwise AND of the input values for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is the union of the input types.
* @param {Image} image1 The image from which the left operand bands are taken.
* @param {Image} image2 The image from which the right operand bands are taken.
* @return {Image}
*/
ee.Image.bitwiseAnd;
/**
* Calculates the bitwise NOT of the input, in the smallest signed integer type that can hold the input.
* @param {Image} value The image to which the operation is applied.
* @return {Image}
*/
ee.Image.bitwiseNot;
/**
* Calculates the bitwise OR of the input values for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is the union of the input types.
* @param {Image} image1 The image from which the left operand bands are taken.
* @param {Image} image2 The image from which the right operand bands are taken.
* @return {Image}
*/
ee.Image.bitwiseOr;
/**
* Calculates the bitwise XOR of the input values for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is the union of the input types.
* @param {Image} image1 The image from which the left operand bands are taken.
* @param {Image} image2 The image from which the right operand bands are taken.
* @return {Image}
*/
ee.Image.bitwiseXor;
/**
* Calculates the bitwise AND of the input values for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is the union of the input types.
* @param {Image} image1 The image from which the left operand bands are taken.
* @param {Image} image2 The image from which the right operand bands are taken.
* @return {Image}
*/
ee.Image.bitwise_and;
/**
* Calculates the bitwise NOT of the input, in the smallest signed integer type that can hold the input.
* @param {Image} value The image to which the operation is applied.
* @return {Image}
*/
ee.Image.bitwise_not;
/**
* Calculates the bitwise OR of the input values for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is the union of the input types.
* @param {Image} image1 The image from which the left operand bands are taken.
* @param {Image} image2 The image from which the right operand bands are taken.
* @return {Image}
*/
ee.Image.bitwise_or;
/**
* Calculates the bitwise XOR of the input values for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is the union of the input types.
* @param {Image} image1 The image from which the left operand bands are taken.
* @param {Image} image2 The image from which the right operand bands are taken.
* @return {Image}
*/
ee.Image.bitwise_xor;
/**
* Overlays one image on top of another. The images are blended together using the masks as opacity. If either of images has only 1 band, it is replicated to match the number of bands in the other image.
* @param {Image} bottom The bottom image.
* @param {Image} top The top image.
* @return {Image}
*/
ee.Image.blend;
/**
* Casts the input value to an unsigned 8-bit integer.
* @param {Image} value The image to which the operation is applied.
* @return {Image}
*/
ee.Image.byte;
/**
* Casts some or all bands of an image to the specified types.
* @param {Image} image The image to cast.
* @param {Dictionary<Object>} bandTypes A dictionary from band name to band types. Types can be PixelTypes or strings. The valid strings are: 'int8', 'int16', 'int32', 'int64', 'uint8', 'uint16', 'uint32', 'byte', 'short', 'int', 'long', 'float' and 'double'. If bandTypes includes bands that are not already in the input image, they will be added to the image as transparent bands. If bandOrder isn't also specified, new bands will be appended in alphabetical order.
* @param {List<String>} bandOrder A list specifying the order of the bands in the result. If specified, must match the full list of bands in the result.
* @return {Image}
*/
ee.Image.cast;
/**
* Computes the cubic root of the input.
* @param {Image} value The image to which the operation is applied.
* @return {Image}
*/
ee.Image.cbrt;
/**
* Computes the smallest integer greater than or equal to the input.
* @param {Image} value The image to which the operation is applied.
* @return {Image}
*/
ee.Image.ceil;
/**
* Tweaks the projection of the input image, moving each pixel from its location in srcProj to the same coordinates in dstProj.
* @param {Image} input
* @param {Projection} srcProj The original projection.
* @param {Projection} dstProj The new projection.
* @return {Image}
*/
ee.Image.changeProj;
/**
* Clamps the values in all bands of an image to all lie within the specified range.
* @param {Image} input The image to clamp.
* @param {Float} low The minimum allowed value in the range.
* @param {Float} high The maximum allowed value in the range.
* @return {Image}
*/
ee.Image.clamp;
/**
* Classifies an image.
* @param {Image} image The image to classify. Bands are extracted from this image by name, and it must contain all the bands named in the classifier's schema.
* @param {Object} classifier The classifier to use.
* @param {String} outputName The name of the band to be added.
* @return {Image}
*/
ee.Image.classify;
/**
* Clips an image to a Geometry or Feature (use clipToCollection to clip an image to a FeatureCollection). The output bands correspond exactly the input bands, except data not covered by the geometry is masked. The output image retains the metadata of the input image.
* @param {Image} input The image to clip.
* @param {Object} geometry The Geometry or Feature to clip to.
* @return {Image}
*/
ee.Image.clip;
/**
* Clips an image to the bounds of a Geometry, and scales the clipped image to a particular size or scale.
* @param {Image} input The image to clip and scale.
* @param {Geometry} geometry The Geometry to clip the image to. The image will be clipped to the bounding box, in the image's projection, of this geometry.
* @param {Integer} width The width to scale the image to, in pixels. Must be provided along with "height". Exclusive with "maxDimension" and "scale".
* @param {Integer} height The height to scale the image to, in pixels. Must be provided along with "width". Exclusive with "maxDimension" and "scale".
* @param {Integer} maxDimension The maximum dimension to scale the image to, in pixels. Exclusive with "width", "height" and "scale".
* @param {Float} scale If scale is specified, then the projection is scaled by dividing the specified scale value by the nominal size of a meter in the image's projection. Exclusive with "width", "height" and "maxDimension".
* @return {Image}
*/
ee.Image.clipToBoundsAndScale;
/**
* Clips an image to a FeatureCollection. The output bands correspond exactly the input bands, except data not covered by the geometry of at least one feature from the collection is masked. The output image retains the metadata of the input image.
* @param {Image} input The image to clip.
* @param {Object} collection The FeatureCollection to clip to.
* @return {Image}
*/
ee.Image.clipToCollection;
/**
* Applies a clusterer to an image. Returns a new image with a single band containing values from 0 to N, indicating the cluster each pixel is assigned to.
* @param {Image} image The image to cluster. Must contain all the bands in the clusterer's schema.
* @param {Clusterer} clusterer The clusterer to use.
* @param {String} outputName The name of the output band.
* @return {Image}
*/
ee.Image.cluster;
/**
* Finds connected components with the same value of the first band of the input and labels them with a globally unique value. Connectedness is specified by the given kernel. Objects larger than maxSize are considered background, and are masked.
* @param {Image} image The image to label.
* @param {Kernel} connectedness Connectedness kernel.
* @param {Integer} maxSize Maximum size of objects to be labeled.
* @return {Image}
*/
ee.Image.connectedComponents;
/**
* Generate an image where each pixel contains the number of 4- or 8-connected neighbors (including itself).
* @param {Image} input The input image.
* @param {Integer} maxSize The maximum size of the neighborhood in pixels.
* @param {Boolean} eightConnected Whether to use 8-connected rather 4-connected rules.
* @return {Image}
*/
ee.Image.connectedPixelCount;
/**
* Generates an image containing a constant value everywhere.
* @param {Object} value The value of the pixels in the constant image. Must be a number or an Array or a list of numbers or Arrays.
* @return {Image}
*/
ee.Image.constant;
/**
* Convolves each band of an image with the given kernel.
* @param {Image} image The image to convolve.
* @param {Kernel} kernel The kernel to convolve with.
* @return {Image}
*/
ee.Image.convolve;
/**
* Copies metadata properties from one element to another.
* @param {Element} destination The object whose properties to override.
* @param {Element} source The object from which to copy the properties.
* @param {List<String>} properties The properties to copy. If omitted, all ordinary (i.e. non-system) properties are copied.
* @param {List<String>} exclude The list of properties to exclude when copying all properties. Must not be specified if properties is.
* @return {Element}
*/
ee.Image.copyProperties;
/**
* Computes the cosine of the input in radians.
* @param {Image} value The image to which the operation is applied.
* @return {Image}
*/
ee.Image.cos;
/**
* Computes the hyperbolic cosine of the input.
* @param {Image} value The image to which the operation is applied.
* @return {Image}
*/
ee.Image.cosh;
/**
* Computes a cumulative cost map based on an image containing costs to traverse each pixel and an image containing source locations.
* @param {Image} cost A single-band image representing the cost to traverse each pixel. Masked pixels can't be traversed.
* @param {Image} source A single-band image representing the sources. A pixel value different from 0 defines a source pixel.
* @param {Float} maxDistance Maximum distance for computation, in meters.
* @param {Boolean} geodeticDistance If true, geodetic distance along the curved surface is used, assuming a spherical Earth of radius 6378137.0. If false, euclidean distance in the 2D plane of the map projection is used (faster, but less accurate).
* @return {Image}
*/
ee.Image.cumulativeCost;
/**
* Returns the acquisition time of an image as a Date object. This helper function is equivalent to ee.Date(image.get('system:time_start')).
* @param {Image} image The image whose acquisition time to return.
* @return {Date}
*/
ee.Image.date;
/**
* Computes the X and Y discrete derivatives for each band in the input image, in pixel coordinates.
For each band of the input image, the output image will have two bands named with the suffixes '_x' and '_y', containing the respective derivatives.
* @param {Image} image The input image.
* @return {Image}
*/
ee.Image.derivative;
/**
* Computes the digamma function of the input.
* @param {Image} value The image to which the operation is applied.
* @return {Image}
*/
ee.Image.digamma;
/**
* Warps an image using an image of displacements.
* @param {Image} image The image to warp.
* @param {Image} displacement An image containing displacement values. The first band is interpreted as the 'X' displacement and the second as the 'Y' displacement. Each displacement pixel is a [dx,dy] vector added to the pixel location to determine the corresponding pixel location in 'image'. Displacements are interpreted as meters in the default projection of the displacement image.
* @param {String} mode The interpolation mode to use. One of 'nearest_neighbor', 'bilinear' or 'bicubic'.)
* @return {Image}
*/
ee.Image.displace;
/**
* Determines displacements required to register an image to a reference image while allowing local, rubber sheet deformations. Displacements are computed in the CRS of the reference image, at a scale dictated by the lowest resolution of the following three projections: input image projection, reference image projection, and requested projection. The displacements are then transformed into the user-specified projection for output.
* @param {Image} image The image to register.
* @param {Image} referenceImage The image to register to.
* @param {Float} maxOffset The maximum offset allowed when attempting to align the input images, in meters. Using a smaller value can reduce computation time significantly, but it must still be large enough to cover the greatest displacement within the entire image region.
* @param {Projection} projection The projection in which to output displacement values. The default is the projection of the first band of the reference image.
* @param {Float} patchWidth Patch size for detecting image offsets, in meters. This should be set large enough to capture texture, as well as large enough that ignorable objects are small within the patch. Default is null. Patch size will be determined automatically if not provided.
* @param {Float} stiffness Enforces a stiffness constraint on the solution. Valid values are in the range [0,10]. The stiffness is used for outlier rejection when determining displacements at adjacent grid points. Higher values move the solution towards a rigid transformation. Lower values allow more distortion or warping of the image during registration.
* @return {Image}
*/
ee.Image.displacement;
/**
* Computes the distance to the nearest non-zero pixel in each band, using the specified distance kernel.
* @param {Image} image The input image.
* @param {Kernel} kernel The distance kernel.
* @param {Boolean} skipMasked Mask output pixels if the corresponding input pixel is masked.
* @return {Image}
*/
ee.Image.distance;
/**
* Divides the first value by the second, returning 0 for division by 0 for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is the union of the input types.
* @param {Image} image1 The image from which the left operand bands are taken.
* @param {Image} image2 The image from which the right operand bands are taken.
* @return {Image}
*/
ee.Image.divide;
/**
* Casts the input value to a 64-bit float.
* @param {Image} value The image to which the operation is applied.
* @return {Image}
*/
ee.Image.double;
/**
* Computes the windowed entropy for each band using the specified kernel centered on each input pixel.
* @param {Image} image The image for which to compute the entropy.
* @param {Kernel} kernel A kernel specifying the window in which to compute.
* @return {Image}
*/
ee.Image.entropy;
/**
* Returns 1 iff the first value is equal to the second for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is boolean.
* @param {Image} image1 The image from which the left operand bands are taken.
* @param {Image} image2 The image from which the right operand bands are taken.
* @return {Image}
*/
ee.Image.eq;
/**
* Computes the error function of the input.
* @param {Image} value The image to which the operation is applied.
* @return {Image}
*/
ee.Image.erf;
/**
* Computes the inverse error function of the input.
* @param {Image} value The image to which the operation is applied.
* @return {Image}
*/
ee.Image.erfInv;
/**
* Computes the complementary error function of the input.
* @param {Image} value The image to which the operation is applied.
* @return {Image}
*/
ee.Image.erfc;
/**
* Computes the inverse complementary error function of the input.
* @param {Image} value The image to which the operation is applied.
* @return {Image}
*/
ee.Image.erfcInv;
/**
* Computes the Euler's number e raised to the power of the input.
* @param {Image} value The image to which the operation is applied.
* @return {Image}
*/
ee.Image.exp;
/**
* Returns the distance, as determined by the specified distance metric, to the nearest non-zero valued pixel in the input. The output contains values for all pixels within the given neighborhood size, regardless of the input's mask. Note: the default distance metric returns squared distance.
* @param {Image} image The input image.
* @param {Integer} neighborhood Neighborhood size in pixels.
* @param {String} units The units of the neighborhood, currently only 'pixels' are supported.
* @param {String} metric Distance metric to use: options are 'squared_euclidean', 'manhattan' or 'chebyshev'.
* @return {Image}
*/
ee.Image.fastDistanceTransform;
/**
* Applies an approximate Gaussian blurring operation to each band of an image.
This algorithm computes the convolution of the image with a Gaussian smoothing kernel with the given standard deviation. Equivalently, this algorithm applies a spatial low-pass filter with a cutoff at the given spatial wavelength.
The implementation uses an efficient, approximate method for large kernels: it will evaluate the input data at a reduced resolution, apply a smaller kernel to that data, and then bicubically resample the result.
NOTE: The kernel size is specified in meters, and this is converted to a kernel size in pixels based on the particular map projection in which this operation is being applied. As a result, the effective kernel size may vary if you apply this operation in a region away from the map projection's region of true scale. For example, if you are operating in a Mercator projection then the kernel size will be accurate near the equator but will become increasingly inaccurate at high latitudes.
* @param {Image} image The input image.
* @param {Float} sigma The standard deviation of the Gaussian kernel, in meters. Equivalently, the spatial wavelength of the low-pass filter.
* @return {Image}
*/
ee.Image.fastGaussianBlur;
/**
* Selects the value of the first value for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is the union of the input types.
* @param {Image} image1 The image from which the left operand bands are taken.
* @param {Image} image2 The image from which the right operand bands are taken.
* @return {Image}
*/
ee.Image.first;
/**
* Selects the first value if it is non-zero, and the second value otherwise for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is the union of the input types.
* @param {Image} image1 The image from which the left operand bands are taken.
* @param {Image} image2 The image from which the right operand bands are taken.
* @return {Image}
*/
ee.Image.firstNonZero;
/**
* Selects the first value if it is non-zero, and the second value otherwise for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is the union of the input types.
* @param {Image} image1 The image from which the left operand bands are taken.
* @param {Image} image2 The image from which the right operand bands are taken.
* @return {Image}
*/
ee.Image.first_nonzero;
/**
* Casts the input value to a 32-bit float.
* @param {Image} value The image to which the operation is applied.
* @return {Image}
*/
ee.Image.float;
/**
* Computes the largest integer less than or equal to the input.
* @param {Image} value The image to which the operation is applied.
* @return {Image}
*/
ee.Image.floor;
/**
* Computes the gamma function of the input.
* @param {Image} value The image to which the operation is applied.
* @return {Image}
*/
ee.Image.gamma;
/**
* Calculates the regularized lower incomplete Gamma function γ(x,a) for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is float.
* @param {Image} image1 The image from which the left operand bands are taken.
* @param {Image} image2 The image from which the right operand bands are taken.
* @return {Image}
*/
ee.Image.gammainc;
/**
* Returns the geometry of a given feature in a given projection.
* @param {Element} feature The feature from which the geometry is taken.
* @param {ErrorMargin} maxError The maximum amount of error tolerated when performing any necessary reprojection.
* @param {Projection} proj If specified, the geometry will be in this projection. If unspecified, the geometry will be in its default projection.
* @param {Boolean} geodesics If true, the geometry will have geodesic edges. If false, it will have edges as straight lines in the specified projection. If null, the edge interpretation will be the same as the original geometry. This argument is ignored if proj is not specified.
* @return {Geometry}
*/
ee.Image.geometry;
/**
* Computes texture metrics from the Gray Level Co-occurrence Matrix around each pixel of every band.
* @param {Image} image The image for which to compute texture metrics.
* @param {Integer} size The size of the neighborhood to include in each GLCM.
* @param {Kernel} kernel A kernel specifying the x and y offsets over which to compute the GLCMs. A GLCM is computed for each pixel in the kernel that is non-zero, except the center pixel and as long as a GLCM hasn't already been computed for the same direction and distance. For example, if either or both of the east and west pixels are set, only 1 (horizontal) GLCM is computed. Kernels are scanned from left to right and top to bottom. The default is a 3x3 square, resulting in 4 GLCMs with the offsets (-1, -1), (0, -1), (1, -1) and (-1, 0).
* @param {Boolean} average If true, the directional bands for each metric are averaged.
* @return {Image}
*/
ee.Image.glcmTexture;
/**
* Calculates the x and y gradient.
* @param {Image} input The input image.
* @return {Image}
*/
ee.Image.gradient;
/**
* Returns 1 iff the first value is greater than the second for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is boolean.
* @param {Image} image1 The image from which the left operand bands are taken.
* @param {Image} image2 The image from which the right operand bands are taken.
* @return {Image}
*/
ee.Image.gt;
/**
* Returns 1 iff the first value is greater than or equal to the second for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is boolean.
* @param {Image} image1 The image from which the left operand bands are taken.
* @param {Image} image2 The image from which the right operand bands are taken.
* @return {Image}
*/
ee.Image.gte;
/**
* Transforms the image from the HSV color space to the RGB color space. Produces three bands: red, green and blue, all floating point values in the range [0, 1].
* @param {Image} image The image to transform.
* @return {Image}
*/
ee.Image.hsvToRgb;
/**
* Calculates the magnitude of the 2D vector [x, y] for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is float.
* @param {Image} image1 The image from which the left operand bands are taken.
* @param {Image} image2 The image from which the right operand bands are taken.
* @return {Image}
*/
ee.Image.hypot;
/**
* Returns the ID of a given element within a collection. Objects outside collections are not guaranteed to have IDs.
* @param {Element} element The element from which the ID is taken.
* @return {String}
*/
ee.Image.id;
/**
* Casts the input value to a signed 32-bit integer.
* @param {Image} value The image to which the operation is applied.
* @return {Image}
*/
ee.Image.int;
/**
* Casts the input value to a signed 16-bit integer.
* @param {Image} value The image to which the operation is applied.
* @return {Image}
*/
ee.Image.int16;
/**
* Casts the input value to a signed 32-bit integer.
* @param {Image} value The image to which the operation is applied.
* @return {Image}
*/
ee.Image.int32;
/**
* Casts the input value to a signed 64-bit integer.
* @param {Image} value The image to which the operation is applied.
* @return {Image}
*/
ee.Image.int64;
/**
* Casts the input value to a signed 8-bit integer.
* @param {Image} value The image to which the operation is applied.
* @return {Image}
*/
ee.Image.int8;
/**
* Interpolates each point in the first band of the input image into the piecewise-linear function specified by the x and y arrays. The x values must be strictly increasing. If an input point is less than the first or greater than the last x value, then the output is specified by the "behavior" argument: "extrapolate" specifies the output value is extrapolated from the two nearest points, "clamp" specifies the output value is taken from the nearest point, "input" specifies the output value is copied from the input and "mask" specifies the output value is masked.
* @param {Image} image The image to which the interpolation is applied.
* @param {List<Float>} x The x axis (input) values in the piecewise function.
* @param {List<Float>} y The y axis (output) values in the piecewise function.
* @param {String} behavior The behavior for points that are outside of the range of the supplied function. Options are: 'extrapolate', 'clamp', 'mask' or 'input'.
* @return {Image}
*/
ee.Image.interpolate;
/**
* Computes lacunarity for each band in the input image, producing matching output bands.
The method used is the Differential Box-Counting algorithm, except that pixel values are not quantized into boxes, and the box and window may instead be arbitrary kernels.
* @param {Image} image The image to process.
* @param {Kernel} boxKernel The size and shape of the 'gliding box' is defined by the nonzero weights in this kernel.
* @param {Kernel} windowKernel The region of gliding box centers over which the distribution is computed to define lacunarity for each pixel of the output image. Weights in the kernel scale the contribution of each box to the distribution.
* @return {Image}
*/
ee.Image.lacunarity;
/**
* Computes the Lanczos approximation of the input.
* @param {Image} value The image to which the operation is applied.
* @return {Image}
*/
ee.Image.lanczos;
/**
* Calculates the left shift of v1 by v2 bits for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is the union of the input types.
* @param {Image} image1 The image from which the left operand bands are taken.
* @param {Image} image2 The image from which the right operand bands are taken.
* @return {Image}
*/
ee.Image.leftShift;
/**
* Calculates the left shift of v1 by v2 bits for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is the union of the input types.
* @param {Image} image1 The image from which the left operand bands are taken.
* @param {Image} image2 The image from which the right operand bands are taken.
* @return {Image}
*/
ee.Image.left_shift;
/**
* Returns the image given its ID.
* @param {String} id The asset ID of the image.
* @param {Long} version The version of the asset. -1 signifies the latest version.
* @return {Image}
*/
ee.Image.load;
/**
* Computes the natural logarithm of the input.
* @param {Image} value The image to which the operation is applied.
* @return {Image}
*/
ee.Image.log;
/**
* Computes the base-10 logarithm of the input.
* @param {Image} value The image to which the operation is applied.
* @return {Image}
*/
ee.Image.log10;
/**
* Casts the input value to a signed 64-bit integer.
* @param {Image} value The image to which the operation is applied.
* @return {Image}
*/
ee.Image.long;
/**
* Returns 1 iff the first value is less than the second for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is boolean.
* @param {Image} image1 The image from which the left operand bands are taken.
* @param {Image} image2 The image from which the right operand bands are taken.
* @return {Image}
*/
ee.Image.lt;
/**
* Returns 1 iff the first value is less than or equal to the second for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is boolean.
* @param {Image} image1 The image from which the left operand bands are taken.
* @param {Image} image2 The image from which the right operand bands are taken.
* @return {Image}
*/
ee.Image.lte;
/**
* Gets or sets an image's mask. The output image retains the metadata and footprint of the input image. Pixels where the mask changes from zero to another value will be filled with zeros, or the values closest to zero within the range of the pixel type.
Note: the version that sets a mask will be deprecated. To set a mask from an image on previously unmasked pixels, use Image.updateMask. To unmask previously masked pixels, use Image.unmask.
* @param {Image} image The input image.
* @param {Image} mask The mask image. If specified, the input image is copied to the output but given the mask by the values of this image. If this is a single band, it is used for all bands in the input image. If not specified, returns an image created from the mask of the input image, scaled to the range [0:1] (invalid = 0, valid = 1.0).
* @return {Image}
*/
ee.Image.mask;
/**
* Calculates the Cholesky decomposition of a matrix. The Cholesky decomposition is a decomposition into the form L*L' where L is a lower triangular matrix. The input must be a symmetric positive-definite matrix. Returns an image with 1 band named 'L'.
* @param {Image} image Image of 2-D matrices to be decomposed.
* @return {Image}
*/
ee.Image.matrixCholeskyDecomposition;
/**
* Computes the determinant of the matrix.
* @param {Image} value The image to which the operation is applied.
* @return {Image}
*/
ee.Image.matrixDeterminant;
/**
* Computes the diagonal of the matrix in a single column.
* @param {Image} value The image to which the operation is applied.
* @return {Image}
*/
ee.Image.matrixDiagonal;
/**
* Computes the Frobenius norm of the matrix.
* @param {Image} value The image to which the operation is applied.
* @return {Image}
*/
ee.Image.matrixFnorm;
/**
* Creates an image where each pixel is a 2D identity matrix of the given size.
* @param {Integer} size The length of each axis.
* @return {Image}
*/
ee.Image.matrixIdentity;
/**
* Computes the inverse of the matrix.
* @param {Image} value The image to which the operation is applied.
* @return {Image}
*/
ee.Image.matrixInverse;
/**
* Calculates the LU matrix decomposition such that P×input=L×U, where L is lower triangular (with unit diagonal terms), U is upper triangular and P is a partial pivot permutation matrix. The input matrix must be square. Returns an image with bands named 'L', 'U' and 'P'.
* @param {Image} image Image of 2-D matrices to be decomposed.
* @return {Image}
*/
ee.Image.matrixLUDecomposition;
/**
* Returns the matrix multiplication A*B for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is the union of the input types.
* @param {Image} image1 The image from which the left operand bands are taken.
* @param {Image} image2 The image from which the right operand bands are taken.
* @return {Image}
*/
ee.Image.matrixMultiply;
/**
* Computes the Moore-Penrose pseudoinverse of the matrix.
* @param {Image} value The image to which the operation is applied.
* @return {Image}
*/
ee.Image.matrixPseudoInverse;
/**
* Calculates the QR-decomposition of a matrix into two matrices Q and R such that input = QR, where Q is orthogonal, and R is upper triangular. Returns an image with bands named 'Q' and 'R'.
* @param {Image} image Image of 2-D matrices to be decomposed.
* @return {Image}
*/
ee.Image.matrixQRDecomposition;
/**
* Calculates the Singular Value Decomposition of the input matrix into U×S×V', such that U and V are orthogonal and S is diagonal. Returns an image with bands named 'U', 'S' and 'V'.
* @param {Image} image Image of 2-D matrices to be decomposed.
* @return {Image}
*/
ee.Image.matrixSingularValueDecomposition;
/**
* Solves for x in the matrix equation A*x=B, finding a least-squares solution if A is overdetermined for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is the union of the input types.
* @param {Image} image1 The image from which the left operand bands are taken.
* @param {Image} image2 The image from which the right operand bands are taken.
* @return {Image}
*/
ee.Image.matrixSolve;
/**
* Computes a square diagonal matrix from a single column matrix.
* @param {Image} value The image to which the operation is applied.
* @return {Image}
*/
ee.Image.matrixToDiag;
/**
* Computes the trace of the matrix.
* @param {Image} value The image to which the operation is applied.
* @return {Image}
*/
ee.Image.matrixTrace;
/**
* Transposes two dimensions of each array pixel.
* @param {Image} input Input image.
* @param {Integer} axis1 First axis to swap.
* @param {Integer} axis2 Second axis to swap.
* @return {Image}
*/
ee.Image.matrixTranspose;
/**
* Selects the maximum of the first and second values for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is the union of the input types.
* @param {Image} image1 The image from which the left operand bands are taken.
* @param {Image} image2 The image from which the right operand bands are taken.
* @return {Image}
*/
ee.Image.max;
/**
* Computes the discrete medial axis of the zero valued pixels of the first band of the input. Outputs 4 bands:
medial - the medial axis points, scaled by the distance.
coverage - the number of points supporting each medial axis point.
xlabel - the horizontal distance to the power point for each pixel.
ylabel - the vertical distance to the power point for each pixel.
* @param {Image} image The input image.
* @param {Integer} neighborhood Neighborhood size in pixels.
* @param {String} units The units of the neighborhood, currently only 'pixels' are supported.
* @return {Image}
*/
ee.Image.medialAxis;
/**
* Generates a constant image of type double from a metadata property.
* @param {Image} image The image from which to get the metadata
* @param {String} property The property from which to take the value.
* @param {String} name The name for the output band. If unspecified, it will be the same as the property name.
* @return {Image}
*/
ee.Image.metadata;
/**
* Selects the minimum of the first and second values for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is the union of the input types.
* @param {Image} image1 The image from which the left operand bands are taken.
* @param {Image} image2 The image from which the right operand bands are taken.
* @return {Image}
*/
ee.Image.min;
/**
* Calculates the remainder of the first value divided by the second for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is the union of the input types.
* @param {Image} image1 The image from which the left operand bands are taken.
* @param {Image} image2 The image from which the right operand bands are taken.
* @return {Image}
*/
ee.Image.mod;
/**
* Multiplies the first value by the second for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is the union of the input types.
* @param {Image} image1 The image from which the left operand bands are taken.
* @param {Image} image2 The image from which the right operand bands are taken.
* @return {Image}
*/
ee.Image.multiply;
/**
* Turns the neighborhood of each pixel in a scalar image into a 2D array. Axes 0 and 1 of the output array correspond to Y and X axes of the image, respectively. The output image will have as many bands as the input; each output band has the same mask as the corresponding input band. The footprint and metadata of the input image are preserved.
* @param {Image} image The image to get pixels from; must be scalar-valued.
* @param {Kernel} kernel The kernel specifying the shape of the neighborhood. Only fixed, square and rectangle kernels are supported. Weights are ignored; only the shape of the kernel is used.
* @param {Float} defaultValue The value to use in the output arrays to replace the invalid (masked) pixels of the input. If the band type is integral, the fractional part of this value is discarded; in all cases, the value is clamped to the value range of the band.
* @return {Image}
*/
ee.Image.neighborhoodToArray;
/**
* Turn the neighborhood of a pixel into a set of bands. The neighborhood is specified using a Kernel, and only non-zero-weight kernel values are used. The weights of the kernel is otherwise ignored.
Each input band produces x * y output bands. Each output band is named 'input_x_y' where x and y indicate the pixel's location in the kernel. For example, a 3x3 kernel operating on a 2-band image produces 18 output bands.
* @param {Image} image The image to get pixels from.
* @param {Kernel} kernel The kernel specifying the neighborhood. Zero-weight values are ignored.
* @return {Image}
*/
ee.Image.neighborhoodToBands;
/**
* Returns 1 iff the first value is not equal to the second for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is boolean.
* @param {Image} image1 The image from which the left operand bands are taken.
* @param {Image} image2 The image from which the right operand bands are taken.
* @return {Image}
*/
ee.Image.neq;
/**
* Computes the normalized difference between two bands. If the bands to use are not specified, uses the first two bands. The normalized difference is computed as (first − second) / (first + second).
* @param {Image} input The input image.
* @param {List<String>} bandNames A list of names specifying the bands to use. If not specified, the first and second bands are used.
* @return {Image}
*/
ee.Image.normalizedDifference;
/**
* Returns 0 if the input is non-zero, and 1 otherwise.
* @param {Image} value The image to which the operation is applied.
* @return {Image}
*/
ee.Image.not;
/**
* Returns 1 iff either input value is non-zero for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is boolean.
* @param {Image} image1 The image from which the left operand bands are taken.
* @param {Image} image2 The image from which the right operand bands are taken.
* @return {Image}
*/
ee.Image.or;
/**
* Paints the geometries of a collection onto an image.
* @param {Image} image The image on which the collection is painted.
* @param {FeatureCollection} featureCollection The collection painted onto the image.
* @param {Object} color Either the name of a color property or a number.
* @param {Object} width Either the name of a line-width property or a number.
* @return {Image}
*/
ee.Image.paint;
/**
* Generate an image in which the value of each pixel is the area of that pixel in square meters.
*
* @return {Image}
*/
ee.Image.pixelArea;
/**
* Creates a two band image containing the x and y coordinates of each pixel in the given projection.
* @param {Projection} projection The projection in which to provide pixel.
* @return {Image}
*/
ee.Image.pixelCoordinates;
/**
* Creates an image with two bands named 'longitude' and 'latitude', containing the longitude and latitude at each pixel, in degrees.
*
* @return {Image}
*/
ee.Image.pixelLonLat;
/**
* Compute a polynomial at each pixel using the given coefficients.
* @param {Image} image The input image.
* @param {List<Float>} coefficients The polynomial coefficients in increasing order of degree starting with the constant term.
* @return {Image}
*/
ee.Image.polynomial;
/**
* Raises the first value to the power of the second for each matched pair of bands in image1 and image2. If either image1 or image2 has only 1 band, then it is used against all the bands in the other image. If the images have the same number of bands, but not the same names, they're used pairwise in the natural order. The output bands are named for the longer of the two inputs, or if they're equal in length, in image1's order. The type of the output pixels is float.
* @param {Image} image1 The image from which the left operand bands are taken.
* @param {Image} image2 The image from which the right operand bands are taken.
* @return {Image}
*/
ee.Image.pow;
/**
* Returns the default projection of an Image. Throws an error if the bands of the image don't all have the same projection.
* @param {Image} image The image from which to get the projection.
* @return {Projection}
*/
ee.Image.projection;
/**
* Generates a uniform random number at each pixel location, in the range of 0 to 1.
* @param {Long} seed Seed for the random number generator.
* @return {Image}
*/
ee.Image.random;
/**
* Creates a vizualization image by assigning a random color to each unique value of the pixels of the first band. The first three bands of the output image will contan 8-bit R, G and B values, followed by all bands of the input image.
* @param {Image} image Image with at least one band.
* @return {Image}
*/
ee.Image.randomVisualizer;
/**
* Applies a reducer to all of the bands of an image.
The reducer must have a single input and will be called at each pixel to reduce the stack of band values.
The output image will have one band for each reducer output.
* @param {Image} image The image to reduce.
* @param {Reducer} reducer The reducer to apply to the given image.
* @return {Image}
*/
ee.Image.reduce;
/**
* Applies a reducer to all of the pixels inside of each 'object'. Pixels are considered to belong to an object if they are connected (8-way) and have the same value in the 'label' band. The label band is only used to identify the connectedness; the rest are provided as inputs to the reducer.
* @param {Image} image The input image.
* @param {Reducer} reducer The reducer to apply to pixels within the connected component.
* @param {String} labelBand The name of the band to use to detect connectedness. If unspecified, the first band is used.
* @param {Integer} maxSize Size of the neighborhood to consider when aggregating values. Any objects larger than maxSize in either the horizontal or vertical dimension will be masked, since portions of the object might be outside of the neighborhood.
* @return {Image}
*/
ee.Image.reduceConnectedComponents;
/**
* Applies the given reducer to the neighborhood around each pixel, as determined by the given kernel. If the reducer has a single input, it will be applied separately to each band of the collection; otherwise it must have the same number of inputs as the input image has bands.
The reducer output names determine the names of the output bands: reducers with multiple inputs will use the output names directly, while reducers with a single input will prefix the output name with the input band name (e.g. '10_mean', '20_mean', etc.).
Reducers with weighted inputs can have the input weight based on the input mask, the kernel value, or the smaller of those two.
* @param {Image} image The input image.
* @param {Reducer} reducer The reducer to apply to pixels within the neighborhood.
* @param {Kernel} kernel The kernel defining the neighborhood.
* @param {String} inputWeight One of 'mask', 'kernel', or 'min'.
* @param {Boolean} skipMasked Mask output pixels if the corresponding input pixel is masked.
* @param {String} optimization Optimization strategy. Options are 'boxcar' and 'window'. The 'boxcar' method is a fast method for computing count, sum or mean. It requires a homogeneous kernel, a single-input reducer and either MASK, KERNEL or no weighting. The 'window' method uses a running window, and has the same requirements as 'boxcar', but can use any single input reducer. Both methods require considerable additional memory.
* @return {Image}
*/
ee.Image.reduceNeighborhood;
/**
* Apply a reducer to all the pixels in a specific region.
Either the reducer must have the same number of inputs as the input image has bands, or it must have a single input and will be repeated for each band.
Returns a dictionary of the reducer's outputs.
* @param {Image} image The image to reduce.
* @param {Reducer} reducer The reducer to apply.
* @param {Geometry} geometry The region over which to reduce data. Defaults to the footprint of the image's first band.
* @param {Float} scale A nominal scale in meters of the projection to work in.
* @param {Projection} crs The projection to work in. If unspecified, the projection of the image's first band is used. If specified in addition to scale, rescaled to the specified scale.
* @param {List<Float>} crsTransform The list o
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment