Skip to content

Instantly share code, notes, and snippets.

@donmccurdy
Last active April 2, 2019 18:35
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
Star You must be signed in to star a gist
Save donmccurdy/1e7e15e019e6c60c87b57170882b8ad0 to your computer and use it in GitHub Desktop.
Generate JSDoc from Earth Engine algorithm descriptors.
Display the source blob
Display the rendered blob
Raw
Sorry, something went wrong. Reload?
Sorry, we cannot display this file.
Sorry, this file is invalid so it cannot be displayed.
/**
* 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);
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.
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment