Single-Page API Reference

Stay organized with collections Save and categorize content based on your preferences.

ee.Algorithms.CannyEdgeDetector

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.
UsageReturns
ee.Algorithms.CannyEdgeDetector(image, threshold, sigma)Image
ArgumentTypeDetails
imageImageThe image on which to apply edge detection.
thresholdFloatThreshold value. The pixel is only considered for edge detection if the gradient magnitude is higher than this threshold.
sigmaFloat, default: 1Sigma value for a gaussian filter applied before edge detection. 0 means apply no filtering.

ee.Algorithms.Collection

Returns a Collection containing the specified features.
UsageReturns
ee.Algorithms.Collection(features)FeatureCollection
ArgumentTypeDetails
featuresListThe features comprising the collection.

ee.Algorithms.CrossCorrelation

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].
UsageReturns
ee.Algorithms.CrossCorrelation(imageA, imageB, maxGap, windowSize, maxMaskedFrac)Image
ArgumentTypeDetails
imageAImageFirst image, with N bands.
imageBImageSecond image, must have the same number of bands as imageA.
maxGapIntegerThe greatest distance a pixel may shift in either X or Y.
windowSizeIntegerSize of the window to be compared.
maxMaskedFracFloat, default: 0The 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 output pixel for which the correlation is being computed is considered invalid, and will be masked.

ee.Algorithms.Date

Creates a Date.
UsageReturns
ee.Algorithms.Date(value, timeZone)Date
ArgumentTypeDetails
valueObjectA 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'.
timeZoneString, default: nullThe time zone (e.g. 'America/Los_Angeles'); defaults to UTC.

ee.Algorithms.Describe

Describes an object using a simple JSON-compatible structure.
UsageReturns
ee.Algorithms.Describe(input)Object
ArgumentTypeDetails
inputObjectThe object to describe.

ee.Algorithms.Dictionary

Constructs a dictionary.
UsageReturns
ee.Algorithms.Dictionary(input)Dictionary
ArgumentTypeDetails
inputObject, default: nullAn object to convert to a dictionary. Either a JSON dictionary or a list of alternating key/value pairs. Keys must be strings.

ee.Algorithms.FMask.fillMinima

Fills local minima. Only works on INT types.
UsageReturns
ee.Algorithms.FMask.fillMinima(image, borderValue, neighborhood)Image
ArgumentTypeDetails
imageImageThe image to fill.
borderValueLong, default: nullThe border value.
neighborhoodInteger, default: 50The size of the neighborhood to compute over.

ee.Algorithms.FMask.matchClouds

Runs the FMask cloud and shadow matching. Outputs a single band ('csm'), containing the computed cloud and shadow masks.
UsageReturns
ee.Algorithms.FMask.matchClouds(input, cloud, shadow, btemp, sceneLow, sceneHigh, neighborhood)Image
ArgumentTypeDetails
inputImageThe scene for which to compute cloud and shadow masks.
cloudImagePotential cloud mask image. Expected to contain 1s for cloudy pixels and masked pixels everywhere else.
shadowImagePotential shadow mask image. Expected to contain 1s for shadow pixels and masked pixels everywhere else.
btempImageBrightness temperature image, in Celsius.
sceneLowFloatThe 0.175 percentile brightness temperature of the scene.
sceneHighFloatThe 0.825 percentile brightness temperature of the scene.
neighborhoodInteger, default: 50The neighborhood to pad around each tile.

ee.Algorithms.Feature

Returns a Feature composed of the given geometry and metadata.
UsageReturns
ee.Algorithms.Feature(geometry, metadata, geometryKey)Feature
ArgumentTypeDetails
geometryGeometry, default: nullThe geometry of the feature.
metadataDictionary, default: {}The properties of the feature.
geometryKeyString, default: nullObsolete; has no effect.

ee.Algorithms.GeometryConstructors.BBox

Constructs a rectangle whose edges are lines of latitude and longitude. The result is a planar WGS84 rectangle. If (east - west) ≥ 360 then the longitude range will be normalized to -180 to +180; otherwise they will be treated as designating points on a circle (e.g. east may be numerically less than west).
UsageReturns
ee.Algorithms.GeometryConstructors.BBox(west, south, east, north)Geometry
ArgumentTypeDetails
westFloatThe westernmost enclosed longitude. Will be adjusted to lie in the range -180 to 180.
southFloatThe southernmost enclosed latitude. If less than -90 (south pole), will be treated as -90.
eastFloatThe easternmost enclosed longitude.
northFloatThe northernmost enclosed longitude. If greater than +90 (north pole), will be treated as +90.

ee.Algorithms.GeometryConstructors.LineString

Constructs a LineString from the given coordinates.
UsageReturns
ee.Algorithms.GeometryConstructors.LineString(coordinates, crs, geodesic)Geometry
ArgumentTypeDetails
coordinatesListThe list of Points or pairs of Numbers in x,y order.
crsProjection, default: nullThe coordinate reference system of the coordinates. The default is the projection of the inputs, where Numbers are assumed to be EPSG:4326.
geodesicBoolean, default: nullIf 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.

ee.Algorithms.GeometryConstructors.LinearRing

Constructs a LinearRing from the given coordinates, automatically adding the first point at the end if the ring is not explicitly closed.
UsageReturns
ee.Algorithms.GeometryConstructors.LinearRing(coordinates, crs, geodesic)Geometry
ArgumentTypeDetails
coordinatesListThe list of Points or pairs of Numbers in x,y order.
crsProjection, default: nullThe coordinate reference system of the coordinates. The default is the projection of the inputs, where Numbers are assumed to be EPSG:4326.
geodesicBoolean, default: nullIf 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.

ee.Algorithms.GeometryConstructors.MultiGeometry

Constructs a MultiGeometry from the given list of geometry elements.
UsageReturns
ee.Algorithms.GeometryConstructors.MultiGeometry(geometries, crs, geodesic, maxError)Geometry
ArgumentTypeDetails
geometriesListThe list of geometries for the MultiGeometry.
crsProjection, default: nullThe coordinate reference system of the coordinates. The default is the projection of the inputs, where Numbers are assumed to be EPSG:4326.
geodesicBoolean, default: nullIf 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.
maxErrorErrorMargin, default: nullMax error when input geometry must be reprojected to an explicitly requested result projection or geodesic state.

ee.Algorithms.GeometryConstructors.MultiLineString

Constructs a MultiLineString from the given coordinates.
UsageReturns
ee.Algorithms.GeometryConstructors.MultiLineString(coordinates, crs, geodesic, maxError)Geometry
ArgumentTypeDetails
coordinatesListThe list of LineStrings, or to wrap a single LineString, the list of Points or pairs of Numbers in x,y order.
crsProjection, default: nullThe coordinate reference system of the coordinates. The default is the projection of the inputs, where Numbers are assumed to be EPSG:4326.
geodesicBoolean, default: nullIf 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.
maxErrorErrorMargin, default: nullMax error when input geometry must be reprojected to an explicitly requested result projection or geodesic state.

ee.Algorithms.GeometryConstructors.MultiPoint

Constructs a MultiPoint from the given coordinates.
UsageReturns
ee.Algorithms.GeometryConstructors.MultiPoint(coordinates, crs)Geometry
ArgumentTypeDetails
coordinatesListThe list of Points or pairs of Numbers in x,y order.
crsProjection, default: nullThe coordinate reference system of the coordinates. The default is the projection of the inputs, where Numbers are assumed to be EPSG:4326.

ee.Algorithms.GeometryConstructors.MultiPolygon

Constructs a MultiPolygon from the given coordinates.
UsageReturns
ee.Algorithms.GeometryConstructors.MultiPolygon(coordinates, crs, geodesic, maxError, evenOdd)Geometry
ArgumentTypeDetails
coordinatesListA list of Polygons, or for one simple polygon, a list of Points or pairs of Numbers in x,y order.
crsProjection, default: nullThe coordinate reference system of the coordinates. The default is the projection of the inputs, where Numbers are assumed to be EPSG:4326.
geodesicBoolean, default: nullIf 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.
maxErrorErrorMargin, default: nullMax error when input geometry must be reprojected to an explicitly requested result projection or geodesic state.
evenOddBoolean, default: trueIf 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.

ee.Algorithms.GeometryConstructors.Point

Constructs a new Point from the given x,y coordinates.
UsageReturns
ee.Algorithms.GeometryConstructors.Point(coordinates, crs)Geometry
ArgumentTypeDetails
coordinatesListThe coordinates of this Point in x,y order.
crsProjection, default: nullThe coordinate reference system of the coordinates. The default is the projection of the inputs, where Numbers are assumed to be EPSG:4326.

ee.Algorithms.GeometryConstructors.Polygon

Constructs a Polygon from the given coordinates.
UsageReturns
ee.Algorithms.GeometryConstructors.Polygon(coordinates, crs, geodesic, maxError, evenOdd)Geometry
ArgumentTypeDetails
coordinatesListA 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.
crsProjection, default: nullThe coordinate reference system of the coordinates. The default is the projection of the inputs, where Numbers are assumed to be EPSG:4326.
geodesicBoolean, default: nullIf 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.
maxErrorErrorMargin, default: nullMax error when input geometry must be reprojected to an explicitly requested result projection or geodesic state.
evenOddBoolean, default: trueIf 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.

ee.Algorithms.GeometryConstructors.Rectangle

Constructs a rectangular polygon from the given corner points.
UsageReturns
ee.Algorithms.GeometryConstructors.Rectangle(coordinates, crs, geodesic, evenOdd)Geometry
ArgumentTypeDetails
coordinatesListThe low and then high corners of the Rectangle, as a list of Points or pairs of Numbers in x,y order.
crsProjection, default: nullThe coordinate reference system of the coordinates. The default is the projection of the inputs, where Numbers are assumed to be EPSG:4326.
geodesicBoolean, default: nullIf 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.
evenOddBoolean, default: trueIf 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.

ee.Algorithms.HillShadow

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.
UsageReturns
ee.Algorithms.HillShadow(image, azimuth, zenith, neighborhoodSize, hysteresis)Image
ArgumentTypeDetails
imageImageThe image to which to apply the shadow algorithm, in which each pixel should represent an elevation in meters.
azimuthFloatAzimuth in degrees.
zenithFloatZenith in degrees.
neighborhoodSizeInteger, default: 0Neighborhood size.
hysteresisBoolean, default: falseUse hysteresis. Less physically accurate, but may generate better images.

ee.Algorithms.HoughTransform

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.
UsageReturns
ee.Algorithms.HoughTransform(image, gridSize, inputThreshold, lineThreshold, smooth)Image
ArgumentTypeDetails
imageImageThe image to which to apply the transform.
gridSizeInteger, default: 256The size of the grid over which to perform the computation.
inputThresholdFloat, default: 64Value threshold for input image. Pixels equal to or above this value are considered active.
lineThresholdFloat, default: 72Threshold for line detection. Values equal to or above this threshold on the Hough transform are considered to be detected lines.
smoothBoolean, default: trueWhether to smooth the Hough transform before line detection.

ee.Algorithms.If

Selects one of its inputs based on a condition, similar to an if-then-else construct.
UsageReturns
ee.Algorithms.If(condition, trueCase, falseCase)Object
ArgumentTypeDetails
conditionObject, default: nullThe 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.
trueCaseObject, default: nullThe result to return if the condition is true.
falseCaseObject, default: nullThe result to return if the condition is false.

ee.Algorithms.Image.Segmentation.GMeans

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.
UsageReturns
ee.Algorithms.Image.Segmentation.GMeans(image, numIterations, pValue, neighborhoodSize, gridSize, uniqueLabels)Image
ArgumentTypeDetails
imageImageThe input image for clustering.
numIterationsInteger, default: 10Number of iterations. Default 10.
pValueFloat, default: 50Significance level for normality test.
neighborhoodSizeInteger, default: 0Neighborhood size. The amount to extend each tile (overlap) when computing the clusters. This option is mutually exclusive with gridSize.
gridSizeInteger, default: nullGrid 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.
uniqueLabelsBoolean, default: trueIf true, clusters are assigned unique IDs. Otherwise, they repeat per tile or grid cell.

ee.Algorithms.Image.Segmentation.KMeans

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.
UsageReturns
ee.Algorithms.Image.Segmentation.KMeans(image, numClusters, numIterations, neighborhoodSize, gridSize, forceConvergence, uniqueLabels)Image
ArgumentTypeDetails
imageImageThe input image for clustering.
numClustersInteger, default: 8Number of clusters.
numIterationsInteger, default: 20Number of iterations.
neighborhoodSizeInteger, default: 0Neighborhood size. The amount to extend each tile (overlap) when computing the clusters. This option is mutually exclusive with gridSize.
gridSizeInteger, default: nullGrid 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.
forceConvergenceBoolean, default: falseIf true, an error is thrown if convergence is not achieved before numIterations.
uniqueLabelsBoolean, default: trueIf true, clusters are assigned unique IDs. Otherwise, they repeat per tile or grid cell.

ee.Algorithms.Image.Segmentation.SNIC

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.
UsageReturns
ee.Algorithms.Image.Segmentation.SNIC(image, size, compactness, connectivity, neighborhoodSize, seeds)Image
ArgumentTypeDetails
imageImageThe input image for clustering.
sizeInteger, default: 5The superpixel seed location spacing, in pixels. If 'seeds' image is provided, no grid is produced.
compactnessFloat, default: 1Compactness factor. Larger values cause clusters to be more compact (square). Setting this to 0 disables spatial distance weighting.
connectivityInteger, default: 8Connectivity. Either 4 or 8.
neighborhoodSizeInteger, default: nullTile neighborhood size (to avoid tile boundary artifacts). Defaults to 2 * size.
seedsImage, default: nullIf 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.

ee.Algorithms.Image.Segmentation.seedGrid

Selects seed pixels for clustering.
UsageReturns
ee.Algorithms.Image.Segmentation.seedGrid(size, gridType)Image
ArgumentTypeDetails
sizeInteger, default: 5The superpixel seed location spacing, in pixels.
gridTypeString, default: "square"Type of grid. One of 'square' or 'hex'.

ee.Algorithms.IsEqual

Returns whether two objects are equal.
UsageReturns
ee.Algorithms.IsEqual(left, right)Boolean
ArgumentTypeDetails
leftObject, default: null
rightObject, default: null

ee.Algorithms.Landsat.TOA

Calibrates Landsat DN to TOA reflectance and brightness temperature for Landsat and similar data. For recently-acquired scenes calibration coefficients are extracted from the image metadata; for older scenes the coefficients are derived from:  Chander, Gyanesh, Brian L. Markham, and Dennis L. Helder. "Summary of current radiometric calibration coefficients for Landsat MSS, TM, ETM+, and EO-1 ALI sensors." Remote sensing of environment 113.5 (2009): 893-903.
UsageReturns
ee.Algorithms.Landsat.TOA(input)Image
ArgumentTypeDetails
inputImageThe Landsat image to process.

ee.Algorithms.Landsat.calibratedRadiance

Calibrates each band of an image by applying linear transformation with slope `RADIANCE_MULT_BAND_N` and y-intercept `RADIANCE_ADD_BAND_N`; these values are extracted from the image metadata.
UsageReturns
ee.Algorithms.Landsat.calibratedRadiance(image)Image
ArgumentTypeDetails
imageImageThe input Landsat image.

ee.Algorithms.Landsat.pathRowLimit

Limits requests to an ImageCollection of Landsat scenes to return a controllable number of the best scenes for each request. This is intended for use with statistical algorithms like median composites that need a certain amount of good data to perform well, but that do not benefit substantially from additional data beyond that while becoming needlessly expensive. The default arguments select approximately one year's worth of good data. Note that in rare circumstances, when the tile boundary aligns with a Landsat WRS cell boundary, queries for adjacent tiles may yield conflicting results. This is why it is important that this algorithm only be used with statistical methods that can tolerate these inconsistencies.
UsageReturns
ee.Algorithms.Landsat.pathRowLimit(collection, maxScenesPerPathRow, maxScenesTotal)ImageCollection
ArgumentTypeDetails
collectionImageCollectionThe Landsat ImageCollection to limit.
maxScenesPerPathRowInteger, default: 25The max number of scenes to return per path/row.
maxScenesTotalInteger, default: 100The max number of scenes to return per request total.

ee.Algorithms.Landsat.simpleCloudScore

Computes a simple cloud-likelihood score in the range [0,100] using a combination of brightness, temperature, and NDSI. This is not a robust cloud detector, and is intended mainly to compare multiple looks at the same point for *relative* cloud likelihood.
UsageReturns
ee.Algorithms.Landsat.simpleCloudScore(image)Image
ArgumentTypeDetails
imageImageThe Landsat TOA image to process.

ee.Algorithms.Landsat.simpleComposite

Computes a Landsat TOA composite from a collection of raw Landsat scenes. It applies standard TOA calibration and then assigns a cloud score to each pixel using the SimpleLandsatCloudScore algorithm. It selects the lowest possible range of cloud scores at each point and then computes per-band percentile values from the accepted pixels. This algorithm also uses the LandsatPathRowLimit algorithm to select only the least-cloudy scenes in regions where more than maxDepth input scenes are available.
UsageReturns
ee.Algorithms.Landsat.simpleComposite(collection, percentile, cloudScoreRange, maxDepth, asFloat)Image
ArgumentTypeDetails
collectionImageCollectionThe raw Landsat ImageCollection to composite.
percentileInteger, default: 50The percentile value to use when compositing each band.
cloudScoreRangeInteger, default: 10The size of the range of cloud scores to accept per pixel.
maxDepthInteger, default: 40An approximate limit on the maximum number of scenes used to compute each pixel.
asFloatBoolean, default: falseIf true, output bands are in the same units as the Landsat.TOA algorithm; if false, TOA values are converted to uint8 by multiplying by 255 (reflective bands) or subtracting 100 (thermal bands) and rounding to the nearest integer.

ee.Algorithms.ObjectType

Returns a string representing the type of the given object.
UsageReturns
ee.Algorithms.ObjectType(value)String
ArgumentTypeDetails
valueObject, default: nullThe object to get the type of.

ee.Algorithms.ProjectionTransform

Transforms the geometry of a feature to a specific projection.
UsageReturns
ee.Algorithms.ProjectionTransform(feature, proj, maxError)Feature
ArgumentTypeDetails
featureElementThe feature the geometry of which is being converted.
projProjection, optionalThe 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.
maxErrorErrorMargin, default: nullThe maximum projection error.

ee.Algorithms.Sentinel2.CDI

Computes the Cloud Displacement Index (CDI) from a Sentinel-2 Level 1C image. CDI is a measure of the optical separation in elevated objects due to sensor parallax. Returns a floating point band named "cdi".  See Frantz, D., Hass, E., Uhl, A., Stoffels, J., & Hill, J. (2018). Improvement of the Fmask algorithm for Sentinel-2 images: Separating clouds from bright surfaces based on parallax effects. Remote sensing of environment, 215, 471-481.
UsageReturns
ee.Algorithms.Sentinel2.CDI(source)Image
ArgumentTypeDetails
sourceImageThe source image.

ee.Algorithms.String

Converts the input to a string.
UsageReturns
ee.Algorithms.String(input)String
ArgumentTypeDetails
inputObjectThe object to convert.

ee.Algorithms.TemporalSegmentation.Ccdc

Implements the Continuous Change Detection and Classification temporal breakpoint algorithm. This algorithm finds temporal breakpoints in an image collection by iteratively fitting harmonic functions to the data. Fit coefficients are produced for all input bands, but the bands used for breakpoint detection can be specified with the 'breakpointBands' argument.  For more details, see Zhu, Z. and Woodcock, C.E., 2014. Continuous change detection and classification of land cover using all available Landsat data. Remote sensing of Environment, 144, pp.152-171.
UsageReturns
ee.Algorithms.TemporalSegmentation.Ccdc(collection, breakpointBands, tmaskBands, minObservations, chiSquareProbability, minNumOfYearsScaler, dateFormat, lambda, maxIterations)Image
ArgumentTypeDetails
collectionImageCollectionCollection of images on which to run CCDC.
breakpointBandsList, default: nullThe name or index of the bands to use for change detection. If unspecified, all bands are used.
tmaskBandsList, default: nullThe name or index of the bands to use for iterative TMask cloud detection. These are typically the green band and the SWIR1 band. If unspecified, TMask is not used. If specified, 'tmaskBands' must be included in 'breakpointBands'.
minObservationsInteger, default: 6The number of observations required to flag a change.
chiSquareProbabilityFloat, default: 0.99The chi-square probability threshold for change detection in the range of [0, 1]
minNumOfYearsScalerFloat, default: 1.33Factors of minimum number of years to apply new fitting.
dateFormatInteger, default: 0The time representation to use during fitting: 0 = jDays, 1 = fractional years, 2 = unix time in milliseconds. The start, end and break times for each temporal segment will be encoded this way.
lambdaFloat, default: 20Lambda for LASSO regression fitting. If set to 0, regular OLS is used instead of LASSO.
maxIterationsInteger, default: 25000Maximum number of runs for LASSO regression convergence. If set to 0, regular OLS is used instead of LASSO.

ee.Algorithms.TemporalSegmentation.Ewmacd

Exponentially Weighted Moving Average Change Detection. This algorithm computes a harmonic model for the 'training' portion of the input data and subtracts that from the original results. The residuals are then subjected to Shewhart X-bar charts and an exponentially weighted moving average. Disturbed pixels are indicated when the charts signal a deviation from the given control limits.  The output is a 5 band image containing the bands:     ewma: a 1D array of the EWMA score for each input image. Negative values represent disturbance and positive values represent recovery.     harmonicCoefficients: A 1-D array of the computed harmonic coefficient pairs. The coefficients are ordered as [constant, sin0, cos0, sin1, cos1...]     rmse: the RMSE from the harmonic regression.     rSquared: r-squared value from the harmonic regression.     residuals: 1D array of residuals from the harmonic regression. See: Brooks, E.B., Wynne, R.H., Thomas, V.A., Blinn, C.E. and Coulston, J.W., 2014. On-the-fly massively multitemporal change detection using statistical quality control charts and Landsat data. IEEE Transactions on Geoscience and Remote Sensing, 52(6), pp.3316-3332.
UsageReturns
ee.Algorithms.TemporalSegmentation.Ewmacd(timeSeries, vegetationThreshold, trainingStartYear, trainingEndYear, harmonicCount, xBarLimit1, xBarLimit2, lambda, lambdasigs, rounding, persistence)Image
ArgumentTypeDetails
timeSeriesImageCollectionCollection from which to extract EWMA. This collection is expected to contain 1 image for each year and be sorted temporally.
vegetationThresholdFloatThreshold for vegetation. Values below this are considered non-vegetation.
trainingStartYearIntegerStart year of training period, inclusive.
trainingEndYearIntegerEnd year of training period, exclusive.
harmonicCountInteger, default: 2Number of harmonic function pairs (sine and cosine) used.
xBarLimit1Float, default: 1.5Threshold for initial training xBar limit.
xBarLimit2Integer, default: 20Threshold for running xBar limit.
lambdaFloat, default: 0.3The 'lambda' tuning parameter weighting new years vs the running average.
lambdasigsFloat, default: 3EWMA control bounds, in units of standard deviations.
roundingBoolean, default: trueShould rounding be performed for EWMA
persistenceInteger, default: 3Minimum number of observations needed to consider a change.

ee.Algorithms.TemporalSegmentation.LandTrendr

Landsat-based detection of Trends in Disturbance and Recovery: temporally segments a time-series of images by extracting the spectral trajectories of change over time. The first band of each image is used to find breakpoints, and those breakpoints are used to perform fitting on all subsequent bands. The breakpoints are returned as a 2-D matrix of 4 rows and as many columns as images. The first two rows are the original X and Y values. The third row contains the Y values fitted to the estimated segments, and the 4th row contains a 1 if the corresponding point was used as a segment vertex or 0 if not. Any additional fitted bands are appended as rows in the output. Breakpoint fitting assumes that increasing values represent disturbance and decreasing values represent recovery. See: Kennedy, R.E., Yang, Z. and Cohen, W.B., 2010. Detecting trends in forest disturbance and recovery using yearly Landsat time series: 1. LandTrendr - Temporal segmentation algorithms. Remote Sensing of Environment, 114(12), pp.2897-2910.
UsageReturns
ee.Algorithms.TemporalSegmentation.LandTrendr(timeSeries, maxSegments, spikeThreshold, vertexCountOvershoot, preventOneYearRecovery, recoveryThreshold, pvalThreshold, bestModelProportion, minObservationsNeeded)Image
ArgumentTypeDetails
timeSeriesImageCollectionYearly time-series from which to extract breakpoints. The first band is usedto find breakpoints, and all subsequent bands are fitted using those breakpoints.
maxSegmentsIntegerMaximum number of segments to be fitted on the time series.
spikeThresholdFloat, default: 0.9Threshold for dampening the spikes (1.0 means no dampening).
vertexCountOvershootInteger, default: 3The initial model can overshoot the maxSegments + 1 vertices by this amount. Later, it will be pruned down to maxSegments + 1.
preventOneYearRecoveryBoolean, default: falsePrevent segments that represent one year recoveries.
recoveryThresholdFloat, default: 0.25If a segment has a recovery rate faster than 1/recoveryThreshold (in years), then the segment is disallowed.
pvalThresholdFloat, default: 0.1If the p-value of the fitted model exceeds this threshold, then the current model is discarded and another one is fitted using the Levenberg-Marquardt optimizer.
bestModelProportionFloat, default: 0.75Allows models with more vertices to be chosen if their p-value is no more than (2 - bestModelProportion) times the p-value of the best model.
minObservationsNeededInteger, default: 6Min observations needed to perform output fitting.

ee.Algorithms.TemporalSegmentation.LandTrendrFit

Interpolates a time series using a set of LandTrendr breakpoint years. For each input band in the timeSeries, outputs a new 1D array-valued band containing the input values interpolated between the breakpoint times identified by the vertices image. See the LandTrendr Algorithm for more details.
UsageReturns
ee.Algorithms.TemporalSegmentation.LandTrendrFit(timeSeries, vertices, spikeThreshold, minObservationsNeeded)Image
ArgumentTypeDetails
timeSeriesImageCollectionTime series to interpolate.
verticesImageVertices image. A 1D array of LandTrendr breakpoint years.
spikeThresholdFloat, default: 0.9Threshold for dampening input spikes (1.0 means no dampening).
minObservationsNeededInteger, default: 6Min observations needed.

ee.Algorithms.TemporalSegmentation.StructuralChangeBreakpoints

Runs breakpoint detection, similar to R's strucchange::breakpoints function. Each pixel is fit by a piecewise linear/harmonic model, of the form Y = A + B * t + C * cos(2 * pi * season(t)) + D * sin(2 * pi * season(t)) + E * cos(4 * pi * season(t)) + F * sin(4 * pi * season(t)) + ... In this equation, 't' is the start time of the image in the format specified by 'dateFormat', and 'season(t)' is the fractional year of that start time (see the description of dateFormat for details). The maximum order of the harmonic terms is determined by 'seasonalModelOrder'. The result is an image containing two bands, plus two bands per band in the input: `tStart`, `tEnd`: each of these holds a 1D array, with one entry per segment in the piecewise linear fit; each entry contains the start time of the first or last images in that segment. By default the values here are in fractional years, for easy use with the coefficients. `coefs_BANDNAME`: there will be one such output band per input band. Each of these holds a 2D array, with one row per segment. The values in that row are the coefficients of the linear fit for that segment - that is, the values of A, B, C, ... for that segment. As described above, the values here are affected by 'dateFormat' .`rmse_BANDNAME`: there will be one such output band per input band. This holds a 1D array, with one entry per segment. The value for each segment is the RMSE for the linear fit residuals for that segment.
UsageReturns
ee.Algorithms.TemporalSegmentation.StructuralChangeBreakpoints(collection, breakpointBand, seasonalModelOrder, minSpacing, maxBreaks, dateFormat)Image
ArgumentTypeDetails
collectionImageCollectionCollection of images on which to detect breakpoints.
breakpointBandString, default: nullThe name of the band to use for breakpoint detection. Optional only if the images have only a single band.
seasonalModelOrderInteger, default: 3The order of the harmonic seasonal model.
minSpacingFloat, default: 0.15The minimum spacing between breakpoints. If this is between 0 and 1 (exclusive), it will be interpreted as a fraction of the number of images in the collection. Otherwise, it will be interpreted as a number of samples.
maxBreaksInteger, default: 0The maximum number of breakpoints.
dateFormatInteger, default: 1The time representation to use in the results: 1 = fractional years, 2 = unix time in milliseconds. This affects the values in the tStart and tEnd bands and the 't' values used in the harmonic model. The fractional years used here and in that model are defined as the fractional number of 365.25-day years since 1 Jan 1970.

ee.Algorithms.TemporalSegmentation.VCT

Vegetation Change Tracker, an automated approach for reconstructing recent forest disturbance history using dense Landsat time series stacks. The output is a 2D array per pixel containing 6 rows x N years. The output rows contain: input years, VCT landcover mask, magnitude in term of the UD composite, magnitude of distubance in B4, magnitude of distubance in NDVI, magnitude of distubance in dNBR. See: Huang, C., Goward, S.N., Masek, J.G., Thomas, N., Zhu, Z. and Vogelmann, J.E., 2010. An automated approach for reconstructing recent forest disturbance history using dense Landsat time series stacks. Remote Sensing of Environment, 114(1), pp.183-198.
UsageReturns
ee.Algorithms.TemporalSegmentation.VCT(timeSeries, landCover, maxUd, minNdvi, forThrMax, nYears)Image
ArgumentTypeDetails
timeSeriesImageCollectionCollection from which to extract VCT disturbances, containing the bands: B3, B4, B5, B7, thermal, NDVI, DNBR and COMP. This collection is expected to contain 1 image for each year, sorted by time.
landCoverImageCollectionCollection from which to extract VCT masks. This collection is expected to contain 1 image for each image in the timeSeries, sorted by time.
maxUdFloat, default: 4Maximum Z-score composite value for detecting forest.
minNdviFloat, default: 0.45Minimum NDVI value for forest.
forThrMaxFloat, default: 3Maximum threshold for forest.
nYearsInteger, default: 30Maximum number of years.

ee.Algorithms.TemporalSegmentation.Verdet

Vegetation Regeneration and Disturbance Estimates through Time, forest change detection algorithm. This algorithm generates a yearly clear-sky composite from satellite imagery, calculates a spectral vegetation index for each pixel in that composite, spatially segments the vegetation index image into patches, temporally divides the time series into differently sloped segments, and then labels those segments as disturbed, stable, or regenerating. Segmentation at both the spatial and temporal steps are performed using total variation regularization. The output consists of a 1D array per pixel containing the slope of fitted trend lines. Negative values indicate disturbance and positive values regeneration. See: Hughes, M.J., Kaylor, S.D. and Hayes, D.J., 2017. Patch-based forest change detection from Landsat time series. Forests, 8(5), p.166.
UsageReturns
ee.Algorithms.TemporalSegmentation.Verdet(timeSeries, tolerance, alpha, nRuns)Image
ArgumentTypeDetails
timeSeriesImageCollectionCollection from which to extract VeRDET scores. This collection is expected to contain 1 image for each year, sorted temporally.
toleranceFloat, default: 0.0001Convergence tolerance.
alphaFloat, default: 0.03333333333333333Regularization parameter for segmentation.
nRunsInteger, default: 100Maximum number of runs for convergence.

ee.Algorithms.Terrain

Calculates slope, aspect, and a simple hillshade from a terrain DEM. Expects an image containing either a single band of elevation, measured in meters, or if there's more than one band, one named 'elevation'. Adds output bands named 'slope' and 'aspect' measured in degrees plus an unsigned byte output band named 'hillshade' for visualization. All other bands and metadata are copied from the input image. The local gradient is computed using the 4-connected neighbors of each pixel, so missing values will occur around the edges of an image.
UsageReturns
ee.Algorithms.Terrain(input)Image
ArgumentTypeDetails
inputImageAn elevation image, in meters.

ee.Array

Returns an array with the given coordinates.
UsageReturns
ee.Array(values, pixelType)Array
ArgumentTypeDetails
valuesObjectAn 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.
pixelTypePixelType, default: nullThe 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.

ee.Array.abs

On an element-wise basis, computes the absolute value of the input.
UsageReturns
Array.abs()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.accum

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.
UsageReturns
Array.accum(axis, reducer)Array
ArgumentTypeDetails
this: arrayArrayArray to accumulate.
axisIntegerAxis along which to perform the accumulation.
reducerReducer, default: nullReducer to accumulate values. Default is SUM, to produce the cumulative sum of each vector along the given axis.

ee.Array.acos

On an element-wise basis, computes the arc cosine in radians of the input.
UsageReturns
Array.acos()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.add

On an element-wise basis, adds the first value to the second.
UsageReturns
Array.add(right)Array
ArgumentTypeDetails
this: leftArrayThe left-hand value.
rightArrayThe right-hand value.

ee.Array.and

On an element-wise basis, returns 1 iff both values are non-zero.
UsageReturns
Array.and(right)Array
ArgumentTypeDetails
this: leftArrayThe left-hand value.
rightArrayThe right-hand value.

ee.Array.argmax

Returns the position, as a list of indices in each array axis, of the maximum value in an array, or null if the array is empty. If there are multiple occurrences of the maximum, returns the position of the first.
UsageReturns
Array.argmax()List
ArgumentTypeDetails
this: arrayArray

ee.Array.asin

On an element-wise basis, computes the arc sine in radians of the input.
UsageReturns
Array.asin()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.atan

On an element-wise basis, computes the arc tangent in radians of the input.
UsageReturns
Array.atan()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.atan2

On an element-wise basis, calculates the angle formed by the 2D vector [x, y].
UsageReturns
Array.atan2(right)Array
ArgumentTypeDetails
this: leftArrayThe left-hand value.
rightArrayThe right-hand value.

ee.Array.bitCount

On an element-wise basis, calculates the number of one-bits in the 64-bit two's complement binary representation of the input.
UsageReturns
Array.bitCount()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.bitsToArray

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.
UsageReturns
ee.Array.bitsToArray(input)Array
ArgumentTypeDetails
inputNumber

ee.Array.bitwiseAnd

On an element-wise basis, calculates the bitwise AND of the input values.
UsageReturns
Array.bitwiseAnd(right)Array
ArgumentTypeDetails
this: leftArrayThe left-hand value.
rightArrayThe right-hand value.

ee.Array.bitwiseNot

On an element-wise basis, calculates the bitwise NOT of the input, in the smallest signed integer type that can hold the input.
UsageReturns
Array.bitwiseNot()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.bitwiseOr

On an element-wise basis, calculates the bitwise OR of the input values.
UsageReturns
Array.bitwiseOr(right)Array
ArgumentTypeDetails
this: leftArrayThe left-hand value.
rightArrayThe right-hand value.

ee.Array.bitwiseXor

On an element-wise basis, calculates the bitwise XOR of the input values.
UsageReturns
Array.bitwiseXor(right)Array
ArgumentTypeDetails
this: leftArrayThe left-hand value.
rightArrayThe right-hand value.

ee.Array.byte

On an element-wise basis, casts the input value to an unsigned 8-bit integer.
UsageReturns
Array.byte()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.cat

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.
UsageReturns
ee.Array.cat(arrays, axis)Array
ArgumentTypeDetails
arraysListArrays to concatenate.
axisInteger, default: 0Axis to concatenate along.

ee.Array.cbrt

On an element-wise basis, computes the cubic root of the input.
UsageReturns
Array.cbrt()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.ceil

On an element-wise basis, computes the smallest integer greater than or equal to the input.
UsageReturns
Array.ceil()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.cos

On an element-wise basis, computes the cosine of the input in radians.
UsageReturns
Array.cos()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.cosh

On an element-wise basis, computes the hyperbolic cosine of the input.
UsageReturns
Array.cosh()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.cut

Cut an array along one or more axes.
UsageReturns
Array.cut(position)Array
ArgumentTypeDetails
this: arrayArrayThe array to cut.
positionListCut 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.

ee.Array.digamma

On an element-wise basis, computes the digamma function of the input.
UsageReturns
Array.digamma()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.divide

On an element-wise basis, divides the first value by the second, returning 0 for division by 0.
UsageReturns
Array.divide(right)Array
ArgumentTypeDetails
this: leftArrayThe left-hand value.
rightArrayThe right-hand value.

ee.Array.dotProduct

Compute the dot product between two 1-D arrays.
UsageReturns
Array.dotProduct(array2)Number
ArgumentTypeDetails
this: array1ArrayThe first 1-D array.
array2ArrayThe second 1-D array.

ee.Array.double

On an element-wise basis, casts the input value to a 64-bit float.
UsageReturns
Array.double()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.eigen

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.  This implementation uses DecompositionFactory.eig() from https://ejml.org.
UsageReturns
Array.eigen()Array
ArgumentTypeDetails
this: inputArrayA square, 2D array from which to compute the eigenvalue decomposition.

ee.Array.eq

On an element-wise basis, returns 1 iff the first value is equal to the second.
UsageReturns
Array.eq(right)Array
ArgumentTypeDetails
this: leftArrayThe left-hand value.
rightArrayThe right-hand value.

ee.Array.erf

On an element-wise basis, computes the error function of the input.
UsageReturns
Array.erf()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.erfInv

On an element-wise basis, computes the inverse error function of the input.
UsageReturns
Array.erfInv()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.erfc

On an element-wise basis, computes the complementary error function of the input.
UsageReturns
Array.erfc()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.erfcInv

On an element-wise basis, computes the inverse complementary error function of the input.
UsageReturns
Array.erfcInv()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.exp

On an element-wise basis, computes the Euler's number e raised to the power of the input.
UsageReturns
Array.exp()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.first

On an element-wise basis, selects the value of the first value.
UsageReturns
Array.first(right)Array
ArgumentTypeDetails
this: leftArrayThe left-hand value.
rightArrayThe right-hand value.

ee.Array.firstNonZero

On an element-wise basis, selects the first value if it is non-zero, and the second value otherwise.
UsageReturns
Array.firstNonZero(right)Array
ArgumentTypeDetails
this: leftArrayThe left-hand value.
rightArrayThe right-hand value.

ee.Array.float

On an element-wise basis, casts the input value to a 32-bit float.
UsageReturns
Array.float()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.floor

On an element-wise basis, computes the largest integer less than or equal to the input.
UsageReturns
Array.floor()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.gamma

On an element-wise basis, computes the gamma function of the input.
UsageReturns
Array.gamma()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.gammainc

On an element-wise basis, calculates the regularized lower incomplete Gamma function γ(x,a).
UsageReturns
Array.gammainc(right)Array
ArgumentTypeDetails
this: leftArrayThe left-hand value.
rightArrayThe right-hand value.

ee.Array.get

Extracts the value at the given position from the input array.
UsageReturns
Array.get(position)Number
ArgumentTypeDetails
this: arrayArrayThe array to extract from.
positionListThe coordinates of the element to get.

ee.Array.gt

On an element-wise basis, returns 1 iff the first value is greater than the second.
UsageReturns
Array.gt(right)Array
ArgumentTypeDetails
this: leftArrayThe left-hand value.
rightArrayThe right-hand value.

ee.Array.gte

On an element-wise basis, returns 1 iff the first value is greater than or equal to the second.
UsageReturns
Array.gte(right)Array
ArgumentTypeDetails
this: leftArrayThe left-hand value.
rightArrayThe right-hand value.

ee.Array.hypot

On an element-wise basis, calculates the magnitude of the 2D vector [x, y].
UsageReturns
Array.hypot(right)Array
ArgumentTypeDetails
this: leftArrayThe left-hand value.
rightArrayThe right-hand value.

ee.Array.identity

Creates a 2D identity matrix of the given size.
UsageReturns
ee.Array.identity(size)Array
ArgumentTypeDetails
sizeIntegerThe length of each axis.

ee.Array.int

On an element-wise basis, casts the input value to a signed 32-bit integer.
UsageReturns
Array.int()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.int16

On an element-wise basis, casts the input value to a signed 16-bit integer.
UsageReturns
Array.int16()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.int32

On an element-wise basis, casts the input value to a signed 32-bit integer.
UsageReturns
Array.int32()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.int64

On an element-wise basis, casts the input value to a signed 64-bit integer.
UsageReturns
Array.int64()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.int8

On an element-wise basis, casts the input value to a signed 8-bit integer.
UsageReturns
Array.int8()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.lanczos

On an element-wise basis, computes the Lanczos approximation of the input.
UsageReturns
Array.lanczos()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.leftShift

On an element-wise basis, calculates the left shift of v1 by v2 bits.
UsageReturns
Array.leftShift(right)Array
ArgumentTypeDetails
this: leftArrayThe left-hand value.
rightArrayThe right-hand value.

ee.Array.length

Returns a 1-D ee.Array containing the length of each dimension of the given ee.Array.
UsageReturns
Array.length()Array
ArgumentTypeDetails
this: arrayArrayThe array from which to extract the axis lengths.

ee.Array.log

On an element-wise basis, computes the natural logarithm of the input.
UsageReturns
Array.log()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.log10

On an element-wise basis, computes the base-10 logarithm of the input.
UsageReturns
Array.log10()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.long

On an element-wise basis, casts the input value to a signed 64-bit integer.
UsageReturns
Array.long()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.lt

On an element-wise basis, returns 1 iff the first value is less than the second.
UsageReturns
Array.lt(right)Array
ArgumentTypeDetails
this: leftArrayThe left-hand value.
rightArrayThe right-hand value.

ee.Array.lte

On an element-wise basis, returns 1 iff the first value is less than or equal to the second.
UsageReturns
Array.lte(right)Array
ArgumentTypeDetails
this: leftArrayThe left-hand value.
rightArrayThe right-hand value.

ee.Array.mask

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.
UsageReturns
Array.mask(mask)Array
ArgumentTypeDetails
this: inputArrayArray to mask.
maskArrayMask array.

ee.Array.matrixCholeskyDecomposition

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'.
UsageReturns
Array.matrixCholeskyDecomposition()Dictionary
ArgumentTypeDetails
this: arrayArrayThe array to decompose.

ee.Array.matrixDeterminant

Computes the determinant of the matrix.
UsageReturns
Array.matrixDeterminant()Number
ArgumentTypeDetails
this: inputArrayThe array to compute on.

ee.Array.matrixDiagonal

Computes the diagonal of the matrix in a single column.
UsageReturns
Array.matrixDiagonal()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.matrixFnorm

Computes the Frobenius norm of the matrix.
UsageReturns
Array.matrixFnorm()Number
ArgumentTypeDetails
this: inputArrayThe array to compute on.

ee.Array.matrixInverse

Computes the inverse of the matrix.
UsageReturns
Array.matrixInverse()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.matrixLUDecomposition

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'.
UsageReturns
Array.matrixLUDecomposition()Dictionary
ArgumentTypeDetails
this: arrayArrayThe array to decompose.

ee.Array.matrixMultiply

Returns the matrix multiplication A * B.
UsageReturns
Array.matrixMultiply(right)Array
ArgumentTypeDetails
this: leftArrayThe left-hand value.
rightArrayThe right-hand value.

ee.Array.matrixPseudoInverse

Computes the Moore-Penrose pseudoinverse of the matrix.
UsageReturns
Array.matrixPseudoInverse()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.matrixQRDecomposition

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'.
UsageReturns
Array.matrixQRDecomposition()Dictionary
ArgumentTypeDetails
this: arrayArrayThe array to decompose.

ee.Array.matrixSingularValueDecomposition

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'.
UsageReturns
Array.matrixSingularValueDecomposition()Dictionary
ArgumentTypeDetails
this: arrayArrayThe array to decompose.

ee.Array.matrixSolve

Solves for x in the matrix equation A * x = B, finding a least-squares solution if A is overdetermined.
UsageReturns
Array.matrixSolve(right)Array
ArgumentTypeDetails
this: leftArrayThe left-hand value.
rightArrayThe right-hand value.

ee.Array.matrixToDiag

Computes a square diagonal matrix from a single column matrix.
UsageReturns
Array.matrixToDiag()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.matrixTrace

Computes the trace of the matrix.
UsageReturns
Array.matrixTrace()Number
ArgumentTypeDetails
this: inputArrayThe array to compute on.

ee.Array.matrixTranspose

Transposes two dimensions of an array.
UsageReturns
Array.matrixTranspose(axis1, axis2)Array
ArgumentTypeDetails
this: arrayArrayArray to transpose.
axis1Integer, default: 0First axis to swap.
axis2Integer, default: 1Second axis to swap.

ee.Array.max

On an element-wise basis, selects the maximum of the first and second values.
UsageReturns
Array.max(right)Array
ArgumentTypeDetails
this: leftArrayThe left-hand value.
rightArrayThe right-hand value.

ee.Array.min

On an element-wise basis, selects the minimum of the first and second values.
UsageReturns
Array.min(right)Array
ArgumentTypeDetails
this: leftArrayThe left-hand value.
rightArrayThe right-hand value.

ee.Array.mod

On an element-wise basis, calculates the remainder of the first value divided by the second.
UsageReturns
Array.mod(right)Array
ArgumentTypeDetails
this: leftArrayThe left-hand value.
rightArrayThe right-hand value.

ee.Array.multiply

On an element-wise basis, multiplies the first value by the second.
UsageReturns
Array.multiply(right)Array
ArgumentTypeDetails
this: leftArrayThe left-hand value.
rightArrayThe right-hand value.

ee.Array.neq

On an element-wise basis, returns 1 iff the first value is not equal to the second.
UsageReturns
Array.neq(right)Array
ArgumentTypeDetails
this: leftArrayThe left-hand value.
rightArrayThe right-hand value.

ee.Array.not

On an element-wise basis, returns 0 if the input is non-zero, and 1 otherwise.
UsageReturns
Array.not()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.or

On an element-wise basis, returns 1 iff either input value is non-zero.
UsageReturns
Array.or(right)Array
ArgumentTypeDetails
this: leftArrayThe left-hand value.
rightArrayThe right-hand value.

ee.Array.pad

Pad an array to a given length. The pad value will be repeatedly appended to the array to extend it to given length along each axis. If the array is already as large or larger than a given length, it will remain unchanged along that axis.
UsageReturns
Array.pad(lengths, pad)Array
ArgumentTypeDetails
this: arrayArrayArray to pad.
lengthsListA list of new lengths for each axis.
padNumber, default: 0The value with which to pad the array.

ee.Array.pow

On an element-wise basis, raises the first value to the power of the second.
UsageReturns
Array.pow(right)Array
ArgumentTypeDetails
this: leftArrayThe left-hand value.
rightArrayThe right-hand value.

ee.Array.project

Projects an array to a lower dimensional space by specifying the axes to retain. Dropped axes must be at most length 1.
UsageReturns
Array.project(axes)Array
ArgumentTypeDetails
this: arrayArrayArray to project.
axesListThe axes to project onto. Other axes will be discarded, and must be at most length 1.

ee.Array.reduce

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. The output always has the same dimensionality as the input, and the individual axes are affected as follows: - The axes specified in the 'axes' parameter have their length reduced to 1 (by applying the reducer). - If the reducer has multiple inputs or multiple outputs, the axis specified in 'fieldAxis' will be used to provide the reducer's inputs and store the reducer's outputs. - All other axes are unaffected (independent reductions are performed).
UsageReturns
Array.reduce(reducer, axes, fieldAxis)Array
ArgumentTypeDetails
this: arrayArrayThe array.
reducerReducerThe reducer to apply. Each of its outputs must be a number, not an array or other type.
axesListThe list of axes over which to reduce. The output will have a length of 1 in all these axes.
fieldAxisInteger, default: nullThe axis to use as the reducer's input and output fields. Only required if the reducer has multiple inputs or multiple outputs, in which case the axis must have length equal to the number of reducer inputs, and in the result it will have length equal to the number of reducer outputs.

ee.Array.repeat

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.
UsageReturns
Array.repeat(axis, copies)Array
ArgumentTypeDetails
this: arrayArrayArray to repeat.
axisInteger, default: 0The axis along which to repeat the array.
copiesInteger, default: 2The number of copies of this array to concatenate along the given axis.

ee.Array.reshape

Reshapes an array to a new list of dimension lengths.
UsageReturns
Array.reshape(shape)Array
ArgumentTypeDetails
this: arrayArrayArray to reshape.
shapeArrayNew shape to which arrays are converted. If one component of the shape is the special value -1, the size of that dimension is computed so that the total size remains constant. In particular, a shape of [-1] flattens into 1-D. At most one component of shape can be -1.

ee.Array.rightShift

On an element-wise basis, calculates the signed right shift of v1 by v2 bits.
UsageReturns
Array.rightShift(right)Array
ArgumentTypeDetails
this: leftArrayThe left-hand value.
rightArrayThe right-hand value.

ee.Array.round

On an element-wise basis, computes the integer nearest to the input.
UsageReturns
Array.round()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.short

On an element-wise basis, casts the input value to a signed 16-bit integer.
UsageReturns
Array.short()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.signum

On an element-wise basis, computes the signum function (sign) of the input; zero if the input is zero, 1 if the input is greater than zero, -1 if the input is less than zero.
UsageReturns
Array.signum()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.sin

On an element-wise basis, computes the sine of the input in radians.
UsageReturns
Array.sin()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.sinh

On an element-wise basis, computes the hyperbolic sine of the input.
UsageReturns
Array.sinh()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.slice

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.
UsageReturns
Array.slice(axis, start, end, step)Array
ArgumentTypeDetails
this: arrayArrayArray to slice.
axisInteger, default: 0The axis to slice on.
startInteger, default: 0The 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.
endInteger, default: nullThe 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.
stepInteger, default: 1The 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.

ee.Array.sort

Sorts elements of the array along one axis.
UsageReturns
Array.sort(keys)Array
ArgumentTypeDetails
this: arrayArrayArray image to sort.
keysArray, default: nullOptional 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.

ee.Array.sqrt

On an element-wise basis, computes the square root of the input.
UsageReturns
Array.sqrt()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.subtract

On an element-wise basis, subtracts the second value from the first.
UsageReturns
Array.subtract(right)Array
ArgumentTypeDetails
this: leftArrayThe left-hand value.
rightArrayThe right-hand value.

ee.Array.tan

On an element-wise basis, computes the tangent of the input in radians.
UsageReturns
Array.tan()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.tanh

On an element-wise basis, computes the hyperbolic tangent of the input.
UsageReturns
Array.tanh()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.toByte

On an element-wise basis, casts the input value to an unsigned 8-bit integer.
UsageReturns
Array.toByte()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.toDouble

On an element-wise basis, casts the input value to a 64-bit float.
UsageReturns
Array.toDouble()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.toFloat

On an element-wise basis, casts the input value to a 32-bit float.
UsageReturns
Array.toFloat()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.toInt

On an element-wise basis, casts the input value to a signed 32-bit integer.
UsageReturns
Array.toInt()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.toInt16

On an element-wise basis, casts the input value to a signed 16-bit integer.
UsageReturns
Array.toInt16()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.toInt32

On an element-wise basis, casts the input value to a signed 32-bit integer.
UsageReturns
Array.toInt32()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.toInt64

On an element-wise basis, casts the input value to a signed 64-bit integer.
UsageReturns
Array.toInt64()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.toInt8

On an element-wise basis, casts the input value to a signed 8-bit integer.
UsageReturns
Array.toInt8()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.toList

Turns an Array into a list of lists of numbers.
UsageReturns
Array.toList()List
ArgumentTypeDetails
this: arrayArrayArray to convert.

ee.Array.toLong

On an element-wise basis, casts the input value to a signed 64-bit integer.
UsageReturns
Array.toLong()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.toShort

On an element-wise basis, casts the input value to a signed 16-bit integer.
UsageReturns
Array.toShort()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.toUint16

On an element-wise basis, casts the input value to an unsigned 16-bit integer.
UsageReturns
Array.toUint16()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.toUint32

On an element-wise basis, casts the input value to an unsigned 32-bit integer.
UsageReturns
Array.toUint32()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.toUint8

On an element-wise basis, casts the input value to an unsigned 8-bit integer.
UsageReturns
Array.toUint8()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.transpose

Transposes two dimensions of an array.
UsageReturns
Array.transpose(axis1, axis2)Array
ArgumentTypeDetails
this: arrayArrayArray to transpose.
axis1Integer, default: 0First axis to swap.
axis2Integer, default: 1Second axis to swap.

ee.Array.trigamma

On an element-wise basis, computes the trigamma function of the input.
UsageReturns
Array.trigamma()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.uint16

On an element-wise basis, casts the input value to an unsigned 16-bit integer.
UsageReturns
Array.uint16()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.uint32

On an element-wise basis, casts the input value to an unsigned 32-bit integer.
UsageReturns
Array.uint32()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Array.uint8

On an element-wise basis, casts the input value to an unsigned 8-bit integer.
UsageReturns
Array.uint8()Array
ArgumentTypeDetails
this: inputArrayThe input array.

ee.Blob

Loads a Blob from a Google Cloud Storage URL.
UsageReturns
ee.Blob(url)Blob
ArgumentTypeDetails
urlStringThe Blob's Google Cloud Storage URL.

ee.Blob.string

Returns the contents of the blob as a String.
UsageReturns
Blob.string(encoding)String
ArgumentTypeDetails
this: blobBlob
encodingString, default: null

ee.Blob.url

Returns the Blob's Google Cloud Storage URL.
UsageReturns
Blob.url()String
ArgumentTypeDetails
this: blobBlob

ee.Classifier.amnhMaxent

Creates a Maximum Entropy classifier. Maxent is used to model species distribution probabilities using environmental data for locations of known presence and for a large number of 'background' locations. For more information and to cite, see: https://biodiversityinformatics.amnh.org/open_source/maxent/ and the reference publication: Phillips, et. al., 2004 A maximum entropy approach to species distribution modeling, Proceedings of the Twenty-First International Conference on Machine Learning. The output is a single band named 'probability', containing the modeled probability, and an additional band named 'clamp' when the 'writeClampGrid' argument is true.
UsageReturns
ee.Classifier.amnhMaxent(categoricalNames, outputFormat, autoFeature, linear, quadratic, product, threshold, hinge, hingeThreshold, l2lqThreshold, lq2lqptThreshold, addSamplesToBackground, addAllSamplesToBackground, betaMultiplier, betaHinge, betaLqp, betaCategorical, betaThreshold, extrapolate, doClamp, writeClampGrid, randomTestPoints, seed)Classifier
ArgumentTypeDetails
categoricalNamesList, default: nullA list of the names of the categorical inputs. Any inputs not listed in this argument are considered to be continuous.
outputFormatString, default: "cloglog"Representation of probabilities in output.
autoFeatureBoolean, default: trueAutomatically select which feature classes to use, based on number of training samples.
linearBoolean, default: trueAllow linear features to be used. Ignored when autofeature is true.
quadraticBoolean, default: trueAllow quadratic features to be used. Ignored when autofeature is true.
productBoolean, default: trueAllow product features to be used. Ignored when autofeature is true.
thresholdBoolean, default: falseAllow threshold features to be used. Ignored when autofeature is true.
hingeBoolean, default: trueAllow hinge features to be used. Ignored when autofeature is true.
hingeThresholdInteger, default: 15Number of samples at which hinge features start being used. Ignored when autofeature is false.
l2lqThresholdInteger, default: 10Number of samples at which quadratic features start being used. Ignored when autofeature is false.
lq2lqptThresholdInteger, default: 80Number of samples at which product and threshold features start being used. Ignored when autofeature is false.
addSamplesToBackgroundBoolean, default: trueAdd to the background any sample for which has a combination of environmental values that isn't already present in the background.
addAllSamplesToBackgroundBoolean, default: falseAdd all samples to the background, even if they have combinations of environmental values that are already present in the background.
betaMultiplierFloat, default: 1Regularization multiplier. Multiply all automatic regularization parameters by this number. A higher number gives a more spread-out distribution.
betaHingeFloat, default: -1Regularization parameter to be applied to all hinge features; negative value enables automatic setting.
betaLqpFloat, default: -1Regularization parameter to be applied to all linear, quadratic and product features; negative value enables automatic setting.
betaCategoricalFloat, default: -1Regularization parameter to be applied to all categorical features; negative value enables automatic setting.
betaThresholdFloat, default: -1Regularization parameter to be applied to all threshold features; negative value enables automatic setting.
extrapolateBoolean, default: trueExtrapolate. Predict to regions of environmental space outside the limits encountered during training.
doClampBoolean, default: trueApply clamping to output.
writeClampGridBoolean, default: trueAdds a band to the output ('clamp') showing the spatial distribution of clamping. At each point, the value is the absolute difference between prediction values with and without clamping.
randomTestPointsInteger, default: 0Random test percentage. The percentage of training points to hold aside as test points, used to compute AUX, omission, etc.
seedLong, default: 0A seed used when generating random numbers.

ee.Classifier.confusionMatrix

Computes a 2D confusion matrix for a classifier based on its training data (ie: resubstitution error). Axis 0 of the matrix corresponds to the input classes, and axis 1 corresponds 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.
UsageReturns
Classifier.confusionMatrix()ConfusionMatrix
ArgumentTypeDetails
this: classifierClassifierThe classifier to use.

ee.Classifier.decisionTree

Creates a classifier that applies the given decision tree.
UsageReturns
ee.Classifier.decisionTree(treeString)Classifier
ArgumentTypeDetails
treeStringStringThe decision tree, specified in the text format generated by R and other similar tools.

ee.Classifier.decisionTreeEnsemble

Creates a classifier that applies the given decision trees.
UsageReturns
ee.Classifier.decisionTreeEnsemble(treeStrings)Classifier
ArgumentTypeDetails
treeStringsListThe decision trees, specified in the text format generated by R and other similar tools. Each item in the list should contain one or more trees in text format.

ee.Classifier.explain

Describe the results of a trained classifier.
UsageReturns
Classifier.explain()Dictionary
ArgumentTypeDetails
this: classifierClassifierThe classifier to describe.

ee.Classifier.libsvm

Creates an empty Support Vector Machine classifier.
UsageReturns
ee.Classifier.libsvm(decisionProcedure, svmType, kernelType, shrinking, degree, gamma, coef0, cost, nu, terminationEpsilon, lossEpsilon, oneClass)Classifier
ArgumentTypeDetails
decisionProcedureString, default: "Voting"The decision procedure to use for classification. Either 'Voting' or 'Margin'. Not used for regression.
svmTypeString, default: "C_SVC"The SVM type. One of `C_SVC`, `NU_SVC`, `ONE_CLASS`, `EPSILON_SVR` or `NU_SVR`.
kernelTypeString, default: "LINEAR"The kernel type. One of LINEAR (u′×v), POLY ((γ×u′×v + coef₀)ᵈᵉᵍʳᵉᵉ), RBF (exp(-γ×|u-v|²)) or SIGMOID (tanh(γ×u′×v + coef₀)).
shrinkingBoolean, default: trueWhether to use shrinking heuristics.
degreeInteger, default: nullThe degree of polynomial. Valid for POLY kernels.
gammaFloat, default: nullThe gamma value in the kernel function. Defaults to the reciprocal of the number of features. Valid for POLY, RBF and SIGMOID kernels.
coef0Float, default: nullThe coef₀ value in the kernel function. Defaults to 0. Valid for POLY and SIGMOID kernels.
costFloat, default: nullThe cost (C) parameter. Defaults to 1. Only valid for C-SVC, epsilon-SVR, and nu-SVR.
nuFloat, default: nullThe nu parameter. Defaults to 0.5. Only valid for nu-SVC, one-class SVM, and nu-SVR.
terminationEpsilonFloat, default: nullThe termination criterion tolerance (e). Defaults to 0.001. Only valid for epsilon-SVR.
lossEpsilonFloat, default: nullThe epsilon in the loss function (p). Defaults to 0.1. Only valid for epsilon-SVR.
oneClassInteger, default: nullThe 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.

ee.Classifier.minimumDistance

Creates a minimum distance classifier for the given distance metric. In CLASSIFICATION mode, the nearest class is returned. In REGRESSION mode, the distance to the nearest class center is returned. In RAW mode, the distance to every class center is returned.
UsageReturns
ee.Classifier.minimumDistance(metric, kNearest)Classifier
ArgumentTypeDetails
metricString, default: "euclidean"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.
kNearestInteger, default: 1If greater than 1, the result will contain an array of the k nearest neighbors or distances, based on the output mode setting. if kNearest is greater than the total number of classes, it will be set equal to the number of classes.

ee.Classifier.mode

Returns the classifier mode: `CLASSIFICATION`, `REGRESSION`, `PROBABILITY`, `MULTIPROBABILITY`, `RAW` or `RAW_REGRESSION`.
UsageReturns
Classifier.mode()String
ArgumentTypeDetails
this: classifierClassifier

ee.Classifier.schema

Returns the names of the inputs used by this classifier, or null if this classifier has not had any training data added yet.
UsageReturns
Classifier.schema()List
ArgumentTypeDetails
this: classifierClassifier

ee.Classifier.setOutputMode

Sets the output mode.
UsageReturns
Classifier.setOutputMode(mode)Classifier
ArgumentTypeDetails
this: classifierClassifierAn input classifier.
modeStringThe 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.   - MULTIPROBABILITY: The output is an array of probabilities that each class is correct ordered by classes seen.   - RAW: The output is an array of the internal representation of the classification process. For example, the raw votes in multi-decision tree models.   - RAW_REGRESSION: The output is an array of the internal representation of the regression process. For example, the raw predictions of multiple regression trees. Not all classifiers support modes other than CLASSIFICATION.

ee.Classifier.smileCart

Creates an empty CART classifier. See:   "Classification and Regression Trees,"   L. Breiman, J. Friedman, R. Olshen, C. Stone   Chapman and Hall, 1984.
UsageReturns
ee.Classifier.smileCart(maxNodes, minLeafPopulation)Classifier
ArgumentTypeDetails
maxNodesInteger, default: nullThe maximum number of leaf nodes in each tree. If unspecified, defaults to no limit.
minLeafPopulationInteger, default: 1Only create nodes whose training set contains at least this many points.

ee.Classifier.smileGradientTreeBoost

Creates an empty Gradient Tree Boost classifier.
UsageReturns
ee.Classifier.smileGradientTreeBoost(numberOfTrees, shrinkage, samplingRate, maxNodes, loss, seed)Classifier
ArgumentTypeDetails
numberOfTreesIntegerThe number of decision trees to create.
shrinkageFloat, default: 0.005The shrinkage parameter in (0, 1] controls the learning rate of procedure.
samplingRateFloat, default: 0.7The sampling rate for stochastic tree boosting.
maxNodesInteger, default: nullThe maximum number of leaf nodes in each tree. If unspecified, defaults to no limit.
lossString, default: "LeastAbsoluteDeviation"Loss function for regression. One of: LeastSquares, LeastAbsoluteDeviation, Huber.
seedInteger, default: 0The randomization seed.

ee.Classifier.smileNaiveBayes

Creates an empty Naive Bayes classifier. This classifier assumes that the feature vector consists of positive integers, and negative inputs are discarded.
UsageReturns
ee.Classifier.smileNaiveBayes(lambda)Classifier
ArgumentTypeDetails
lambdaFloat, default: 0.000001A smoothing lambda. Used to avoid assigning zero probability to classes not seen during training, instead using lambda / (lambda * nFeatures).

ee.Classifier.smileRandomForest

Creates an empty Random Forest classifier.
UsageReturns
ee.Classifier.smileRandomForest(numberOfTrees, variablesPerSplit, minLeafPopulation, bagFraction, maxNodes, seed)Classifier
ArgumentTypeDetails
numberOfTreesIntegerThe number of decision trees to create.
variablesPerSplitInteger, default: nullThe number of variables per split. If unspecified, uses the square root of the number of variables.
minLeafPopulationInteger, default: 1Only create nodes whose training set contains at least this many points.
bagFractionFloat, default: 0.5The fraction of input to bag per tree.
maxNodesInteger, default: nullThe maximum number of leaf nodes in each tree. If unspecified, defaults to no limit.
seedInteger, default: 0The randomization seed.

ee.Classifier.spectralRegion

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.
UsageReturns
ee.Classifier.spectralRegion(coordinates, schema)Classifier
ArgumentTypeDetails
coordinatesListThe 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.
schemaList, default: nullThe 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'].

ee.Classifier.train

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.
UsageReturns
Classifier.train(features, classProperty, inputProperties, subsampling, subsamplingSeed)Classifier
ArgumentTypeDetails
this: classifierClassifierAn input classifier.
featuresFeatureCollectionThe collection to train on.
classPropertyStringThe name of the property containing the class value. Each feature must have this property, and its value must be numeric.
inputPropertiesList, default: nullThe 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).
subsamplingFloat, default: 1An optional subsampling factor, within (0, 1].
subsamplingSeedInteger, default: 0A randomization seed to use for subsampling.

ee.Clusterer.schema

Returns the names of the inputs used by this Clusterer, or null if this Clusterer has not had any training data added yet.
UsageReturns
Clusterer.schema()List
ArgumentTypeDetails
this: clustererClusterer

ee.Clusterer.train

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.
UsageReturns
Clusterer.train(features, inputProperties, subsampling, subsamplingSeed)Clusterer
ArgumentTypeDetails
this: clustererClustererAn input Clusterer.
featuresFeatureCollectionThe collection to train on.
inputPropertiesList, default: nullThe 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).
subsamplingFloat, default: 1An optional subsampling factor, within (0, 1].
subsamplingSeedInteger, default: 0A randomization seed to use for subsampling.

ee.Clusterer.wekaCascadeKMeans

Cascade simple k-means, selects the best k according to the Calinski-Harabasz criterion. For more information see: Calinski, T. and J. Harabasz. 1974. A dendrite method for cluster analysis. Commun. Stat. 3: 1-27.
UsageReturns
ee.Clusterer.wekaCascadeKMeans(minClusters, maxClusters, restarts, manual, init, distanceFunction, maxIterations)Clusterer
ArgumentTypeDetails
minClustersInteger, default: 2Min number of clusters.
maxClustersInteger, default: 10Max number of clusters.
restartsInteger, default: 10Number of restarts.
manualBoolean, default: falseManually select the number of clusters.
initBoolean, default: falseSet 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).
distanceFunctionString, default: "Euclidean"Distance function to use. Options are: Euclidean & Manhattan
maxIterationsInteger, default: nullMaximum number of iterations for k-means.

ee.Clusterer.wekaCobweb

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.
UsageReturns
ee.Clusterer.wekaCobweb(acuity, cutoff, seed)Clusterer
ArgumentTypeDetails
acuityFloat, default: 1Acuity (minimum standard deviation).
cutoffFloat, default: 0.002Cutoff (minimum category utility).
seedInteger, default: 42Random number seed.

ee.Clusterer.wekaKMeans

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 careful seeding. In: Proceedings of the eighteenth annual ACM-SIAM symposium on Discrete algorithms, 1027-1035, 2007.
UsageReturns
ee.Clusterer.wekaKMeans(nClusters, init, canopies, maxCandidates, periodicPruning, minDensity, t1, t2, distanceFunction, maxIterations, preserveOrder, fast, seed)Clusterer
ArgumentTypeDetails
nClustersIntegerNumber of clusters.
initInteger, default: 0Initialization method to use.0 = random, 1 = k-means++, 2 = canopy, 3 = farthest first.
canopiesBoolean, default: falseUse canopies to reduce the number of distance calculations.
maxCandidatesInteger, default: 100Maximum 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.
periodicPruningInteger, default: 10000How often to prune low density canopies when using canopy clustering.
minDensityInteger, default: 2Minimum canopy density, when using canopy clustering, below which a canopy will be pruned during periodic pruning.
t1Float, default: -1.5The T1 distance to use when using canopy clustering. A value < 0 is taken as a positive multiplier for T2.
t2Float, default: -1The T2 distance to use when using canopy clustering. Values < 0 cause a heuristic based on attribute std. deviation to be used.
distanceFunctionString, default: "Euclidean"Distance function to use. Options are: Euclidean & Manhattan
maxIterationsInteger, default: nullMaximum number of iterations.
preserveOrderBoolean, default: falsePreserve order of instances.
fastBoolean, default: falseEnables faster distance calculations, using cut-off values. Disables the calculation/output of squared errors/distances
seedInteger, default: 10The randomization seed.

ee.Clusterer.wekaLVQ

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.
UsageReturns
ee.Clusterer.wekaLVQ(numClusters, learningRate, epochs, normalizeInput)Clusterer
ArgumentTypeDetails
numClustersInteger, default: 7The number of clusters.
learningRateFloat, default: 1The learning rate for the training algorithm. (Value should be greaterthan 0 and less or equal to 1).
epochsInteger, default: 1000Number of training epochs. (Value should be greater than or equal to 1).
normalizeInputBoolean, default: falseSkip normalizing the attributes.

ee.Clusterer.wekaXMeans

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.
UsageReturns
ee.Clusterer.wekaXMeans(minClusters, maxClusters, maxIterations, maxKMeans, maxForChildren, useKD, cutoffFactor, distanceFunction, seed)Clusterer
ArgumentTypeDetails
minClustersInteger, default: 2Minimum number of clusters.
maxClustersInteger, default: 8Maximum number of clusters.
maxIterationsInteger, default: 3Maximum number of overall iterations.
maxKMeansInteger, default: 1000The maximum number of iterations to perform in KMeans.
maxForChildrenInteger, default: 1000The maximum number of iterations in KMeans that is performed on the child centers.
useKDBoolean, default: falseUse a KDTree.
cutoffFactorFloat, default: 0Takes the given percentage of the split centroids if none of the children win.
distanceFunctionString, default: "Euclidean"Distance function to use. Options are: Chebyshev, Euclidean & Manhattan.
seedInteger, default: 10The randomization seed.

ee.ConfusionMatrix

Creates a confusion matrix. Axis 0 (the rows) of the matrix correspond to the actual values, and Axis 1 (the columns) to the predicted values.
UsageReturns
ee.ConfusionMatrix(array, order)ConfusionMatrix
ArgumentTypeDetails
arrayObjectA square, 2D array of integers, representing the confusion matrix.
orderList, default: nullThe row and column size and order, for non-contiguous or non-zero based matrices.

ee.ConfusionMatrix.accuracy

Computes the overall accuracy of a confusion matrix defined as correct / total.
UsageReturns
ConfusionMatrix.accuracy()Float
ArgumentTypeDetails
this: confusionMatrixConfusionMatrix

ee.ConfusionMatrix.array

Returns a confusion matrix as an Array.
UsageReturns
ConfusionMatrix.array()Array
ArgumentTypeDetails
this: confusionMatrixConfusionMatrix

ee.ConfusionMatrix.consumersAccuracy

Computes the consumer's accuracy (reliability) of a confusion matrix defined as (correct / total) for each row.
UsageReturns
ConfusionMatrix.consumersAccuracy()Array
ArgumentTypeDetails
this: confusionMatrixConfusionMatrix

ee.ConfusionMatrix.fscore

Computes the Fβ-score for the confusion matrix.
UsageReturns
ConfusionMatrix.fscore(beta)Array
ArgumentTypeDetails
this: confusionMatrixConfusionMatrix
betaFloat, default: 1A factor indicating how much more important recall is than precision. The standard F-score is equivalent to setting β to one.

ee.ConfusionMatrix.kappa

Computes the Kappa statistic for the confusion matrix.
UsageReturns
ConfusionMatrix.kappa()Float
ArgumentTypeDetails
this: confusionMatrixConfusionMatrix

ee.ConfusionMatrix.order

Returns the name and order of the rows and columns of the matrix.
UsageReturns
ConfusionMatrix.order()List
ArgumentTypeDetails
this: confusionMatrixConfusionMatrix

ee.ConfusionMatrix.producersAccuracy

Computes the producer's accuracy of a confusion matrix defined as (correct / total) for each column.
UsageReturns
ConfusionMatrix.producersAccuracy()Array
ArgumentTypeDetails
this: confusionMatrixConfusionMatrix

ee.Date

Constructs a new Date object.
UsageReturns
ee.Date(date, tz)Date
ArgumentTypeDetails
dateComputedObject|Date|Number|StringThe date to convert, one of: a number (number of milliseconds since the epoch), an ISO Date string, a JavaScript Date or a ComputedObject.
tzString, optionalAn optional timezone only to be used with a string date.

ee.Date.advance

Create a new Date by adding the specified units to the given Date.
UsageReturns
Date.advance(delta, unit, timeZone)Date
ArgumentTypeDetails
this: dateDate
deltaFloat
unitStringOne of 'year', 'month' 'week', 'day', 'hour', 'minute', or 'second'.
timeZoneString, default: nullThe time zone (e.g. 'America/Los_Angeles'); defaults to UTC.

ee.Date.aside

Calls a function passing this object as the first argument, and returning itself. Convenient e.g. when debugging: var c = ee.ImageCollection('foo').aside(print) .filterDate('2001-01-01', '2002-01-01').aside(print, 'In 2001') .filterBounds(geom).aside(print, 'In region') .aside(Map.addLayer, {min: 0, max: 142}, 'Filtered') .select('a', 'b'); Returns the same object, for chaining.
UsageReturns
Date.aside(func, var_args)ComputedObject
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
funcFunctionThe function to call.
var_argsVarArgsAny extra arguments to pass to the function.

ee.Date.difference

Returns the difference between two Dates in the specified units; the result is floating-point and based on the average length of the unit.
UsageReturns
Date.difference(start, unit)Float
ArgumentTypeDetails
this: dateDate
startDate
unitStringOne of 'year', 'month' 'week', 'day', 'hour', 'minute', or 'second'.

ee.Date.evaluate

Asynchronously retrieves the value of this object from the server and passes it to the provided callback function.
UsageReturns
Date.evaluate(callback)
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
callbackFunctionA function of the form function(success, failure), called when the server returns an answer. If the request succeeded, the success argument contains the evaluated result. If the request failed, the failure argument will contains an error message.

ee.Date.format

Convert a date to string.
UsageReturns
Date.format(format, timeZone)String
ArgumentTypeDetails
this: dateDate
formatString, default: nullA pattern, as described at http://joda-time.sourceforge.net/apidocs/org/joda/time/format/DateTimeFormat.html; if omitted will use ISO standard date formatting.
timeZoneString, default: nullThe time zone (e.g. 'America/Los_Angeles'); defaults to UTC.

ee.Date.fromYMD

Returns a Date given year, month, day.
UsageReturns
ee.Date.fromYMD(year, month, day, timeZone)Date
ArgumentTypeDetails
yearInteger
monthInteger
dayInteger
timeZoneString, default: nullThe time zone (e.g. 'America/Los_Angeles'); defaults to UTC.

ee.Date.get

Returns the specified unit of this date.
UsageReturns
Date.get(unit, timeZone)Long
ArgumentTypeDetails
this: dateDate
unitStringOne of 'year', 'month' (returns 1-12), 'week' (1-53), 'day' (1-31), 'hour' (0-23), 'minute' (0-59), or 'second' (0-59).
timeZoneString, default: nullThe time zone (e.g. 'America/Los_Angeles'); defaults to UTC.

ee.Date.getFraction

Returns this date's elapsed fraction of the specified unit (between 0 and 1).
UsageReturns
Date.getFraction(unit, timeZone)Float
ArgumentTypeDetails
this: dateDate
unitStringOne of 'year', 'month' 'week', 'day', 'hour', 'minute', or 'second'.
timeZoneString, default: nullThe time zone (e.g. 'America/Los_Angeles'); defaults to UTC.

ee.Date.getInfo

Retrieves the value of this object from the server. If no callback function is provided, the request is made synchronously. If a callback is provided, the request is made asynchronously. The asynchronous mode is preferred because the synchronous mode stops all other code (for example, the EE Code Editor UI) while waiting for the server. To make an asynchronous request, evaluate() is preferred over getInfo(). Returns the computed value of this object.
UsageReturns
Date.getInfo(callback)Object
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
callbackFunction, optionalAn optional callback. If not supplied, the call is made synchronously.

ee.Date.getRange

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').
UsageReturns
Date.getRange(unit, timeZone)DateRange
ArgumentTypeDetails
this: dateDate
unitStringOne of 'year', 'month' 'week', 'day', 'hour', 'minute', or 'second'.
timeZoneString, default: nullThe time zone (e.g. 'America/Los_Angeles'); defaults to UTC.

ee.Date.getRelative

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.
UsageReturns
Date.getRelative(unit, inUnit, timeZone)Long
ArgumentTypeDetails
this: dateDate
unitStringOne of 'month' 'week', 'day', 'hour', 'minute', or 'second'.
inUnitStringOne of 'year', 'month' 'week', 'day', 'hour', or 'minute'.
timeZoneString, default: nullThe time zone (e.g. 'America/Los_Angeles'); defaults to UTC.

ee.Date.millis

The number of milliseconds since 1970-01-01T00:00:00Z.
UsageReturns
Date.millis()Long
ArgumentTypeDetails
this: dateDate

ee.Date.parse

Parse a date string, given a string describing its format.
UsageReturns
ee.Date.parse(format, date, timeZone)Date
ArgumentTypeDetails
formatStringA pattern, as described at http://joda-time.sourceforge.net/apidocs/org/joda/time/format/DateTimeFormat.html.
dateStringA string matching the given pattern.
timeZoneString, default: nullThe time zone (e.g. 'America/Los_Angeles'); defaults to UTC.

ee.Date.serialize

Returns the serialized representation of this object.
UsageReturns
Date.serialize(legacy)String
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
legacyBoolean, optionalEnables legacy format.

ee.Date.unitRatio

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'.
UsageReturns
ee.Date.unitRatio(numerator, denominator)Float
ArgumentTypeDetails
numeratorString
denominatorString

ee.Date.update

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.
UsageReturns
Date.update(year, month, day, hour, minute, second, timeZone)Date
ArgumentTypeDetails
this: dateDate
yearInteger, default: null
monthInteger, default: null
dayInteger, default: null
hourInteger, default: null
minuteInteger, default: null
secondNumber, default: null
timeZoneString, default: nullThe time zone (e.g. 'America/Los_Angeles'); defaults to UTC.

ee.DateRange

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.
UsageReturns
ee.DateRange(start, end, timeZone)DateRange
ArgumentTypeDetails
startObject
endObject, default: null
timeZoneString, default: nullIf start and/or end are provided as strings, the time zone in which to interpret them; defaults to UTC.

ee.DateRange.contains

Returns true if the given Date or DateRange is within this DateRange.
UsageReturns
DateRange.contains(other)Boolean
ArgumentTypeDetails
this: dateRangeDateRange
otherObject

ee.DateRange.end

Returns the (exclusive) end of this DateRange.
UsageReturns
DateRange.end()Date
ArgumentTypeDetails
this: dateRangeDateRange

ee.DateRange.intersection

Returns a DateRange that contains all points in the intersection of this DateRange and another.
UsageReturns
DateRange.intersection(other)DateRange
ArgumentTypeDetails
this: dateRangeDateRange
otherDateRange

ee.DateRange.intersects

Returns true if the given DateRange has at least one point in common with this DateRange.
UsageReturns
DateRange.intersects(other)Boolean
ArgumentTypeDetails
this: dateRangeDateRange
otherDateRange

ee.DateRange.isEmpty

Returns true if this DateRange contains no dates (i.e. start >= end).
UsageReturns
DateRange.isEmpty()Boolean
ArgumentTypeDetails
this: dateRangeDateRange

ee.DateRange.isUnbounded

Returns true if this DateRange contains all dates.
UsageReturns
DateRange.isUnbounded()Boolean
ArgumentTypeDetails
this: dateRangeDateRange

ee.DateRange.start

Returns the (inclusive) start of this DateRange.
UsageReturns
DateRange.start()Date
ArgumentTypeDetails
this: dateRangeDateRange

ee.DateRange.unbounded

Returns a DateRange that includes all possible dates.
UsageReturns
ee.DateRange.unbounded()DateRange

No arguments.

ee.DateRange.union

Returns a DateRange that contains all points in the union of this DateRange and another.
UsageReturns
DateRange.union(other)DateRange
ArgumentTypeDetails
this: dateRangeDateRange
otherDateRange

ee.Dictionary

Constructs a new Dictionary.
UsageReturns
ee.Dictionary(dict)Dictionary
ArgumentTypeDetails
dictComputedObject|Object, optionalAn object to convert to a dictionary. This constructor accepts the following types: 1) Another dictionary. 2) A list of key/value pairs. 3) A null or no argument (producing an empty dictionary)

ee.Dictionary.aside

Calls a function passing this object as the first argument, and returning itself. Convenient e.g. when debugging: var c = ee.ImageCollection('foo').aside(print) .filterDate('2001-01-01', '2002-01-01').aside(print, 'In 2001') .filterBounds(geom).aside(print, 'In region') .aside(Map.addLayer, {min: 0, max: 142}, 'Filtered') .select('a', 'b'); Returns the same object, for chaining.
UsageReturns
Dictionary.aside(func, var_args)ComputedObject
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
funcFunctionThe function to call.
var_argsVarArgsAny extra arguments to pass to the function.

ee.Dictionary.combine

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.
UsageReturns
Dictionary.combine(second, overwrite)Dictionary
ArgumentTypeDetails
this: firstDictionary
secondDictionary
overwriteBoolean, default: true

ee.Dictionary.contains

Returns true if the dictionary contains the given key.
UsageReturns
Dictionary.contains(key)Boolean
ArgumentTypeDetails
this: dictionaryDictionary
keyString, default: null

ee.Dictionary.evaluate

Asynchronously retrieves the value of this object from the server and passes it to the provided callback function.
UsageReturns
Dictionary.evaluate(callback)
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
callbackFunctionA function of the form function(success, failure), called when the server returns an answer. If the request succeeded, the success argument contains the evaluated result. If the request failed, the failure argument will contains an error message.

ee.Dictionary.fromLists

Construct a dictionary from two parallel lists of keys and values.
UsageReturns
ee.Dictionary.fromLists(keys, values)Dictionary
ArgumentTypeDetails
keysList
valuesList

ee.Dictionary.get

Extracts a named value from a dictionary. If the dictionary does not contain the given key, then defaultValue is returned, unless it is null.
UsageReturns
Dictionary.get(key, defaultValue)Object
ArgumentTypeDetails
this: dictionaryDictionary
keyString
defaultValueObject, default: null

ee.Dictionary.getArray

Extracts a named array value from a dictionary.
UsageReturns
Dictionary.getArray(key)Array
ArgumentTypeDetails
this: dictionaryDictionary
keyString

ee.Dictionary.getGeometry

Extracts a named geometry value from a dictionary.
UsageReturns
Dictionary.getGeometry(key)Geometry
ArgumentTypeDetails
this: dictionaryDictionary
keyString

ee.Dictionary.getInfo

Retrieves the value of this object from the server. If no callback function is provided, the request is made synchronously. If a callback is provided, the request is made asynchronously. The asynchronous mode is preferred because the synchronous mode stops all other code (for example, the EE Code Editor UI) while waiting for the server. To make an asynchronous request, evaluate() is preferred over getInfo(). Returns the computed value of this object.
UsageReturns
Dictionary.getInfo(callback)Object
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
callbackFunction, optionalAn optional callback. If not supplied, the call is made synchronously.

ee.Dictionary.getNumber

Extracts a named number value from a dictionary.
UsageReturns
Dictionary.getNumber(key)Number
ArgumentTypeDetails
this: dictionaryDictionary
keyString

ee.Dictionary.getString

Extracts a named string value from a dictionary.
UsageReturns
Dictionary.getString(key)String
ArgumentTypeDetails
this: dictionaryDictionary
keyString

ee.Dictionary.keys

Retrieve the keys of a dictionary as a list. The keys will be sorted in natural order.
UsageReturns
Dictionary.keys()List
ArgumentTypeDetails
this: dictionaryDictionary

ee.Dictionary.map

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.
UsageReturns
Dictionary.map(baseAlgorithm)Dictionary
ArgumentTypeDetails
this: dictionaryDictionary
baseAlgorithmAlgorithm

ee.Dictionary.remove

Returns a dictionary with the specified keys removed.
UsageReturns
Dictionary.remove(selectors, ignoreMissing)Dictionary
ArgumentTypeDetails
this: dictionaryDictionary
selectorsListA list of keys names or regular expressions of key names to remove.
ignoreMissingBoolean, default: falseIgnore selectors that don't match at least 1 key.

ee.Dictionary.rename

Rename elements in a dictionary.
UsageReturns
Dictionary.rename(from, to, overwrite)Dictionary
ArgumentTypeDetails
this: dictionaryDictionary
fromListA list of keys to be renamed.
toListA list of the new names for the keys listed in the 'from' parameter. Must have the same length as the 'from' list.
overwriteBoolean, default: falseAllow overwriting existing properties with the same name.

ee.Dictionary.select

Returns a dictionary with only the specified keys.
UsageReturns
Dictionary.select(selectors, ignoreMissing)Dictionary
ArgumentTypeDetails
this: dictionaryDictionary
selectorsListA list of keys or regular expressions to select.
ignoreMissingBoolean, default: falseIgnore selectors that don't match at least 1 key.

ee.Dictionary.serialize

Returns the serialized representation of this object.
UsageReturns
Dictionary.serialize(legacy)String
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
legacyBoolean, optionalEnables legacy format.

ee.Dictionary.set

Set a value in a dictionary.
UsageReturns
Dictionary.set(key, value)Dictionary
ArgumentTypeDetails
this: dictionaryDictionary
keyString
valueObject

ee.Dictionary.size

Returns the number of entries in a dictionary.
UsageReturns
Dictionary.size()Integer
ArgumentTypeDetails
this: dictionaryDictionary

ee.Dictionary.toArray

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.
UsageReturns
Dictionary.toArray(keys, axis)Array
ArgumentTypeDetails
this: dictionaryDictionary
keysList, default: null
axisInteger, default: 0

ee.Dictionary.toImage

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.
UsageReturns
Dictionary.toImage(names)Image
ArgumentTypeDetails
this: dictionaryDictionaryThe dictionary to convert.
namesList, default: nullThe order of the output bands.

ee.Dictionary.values

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.
UsageReturns
Dictionary.values(keys)List
ArgumentTypeDetails
this: dictionaryDictionary
keysList, default: null

ee.ErrorMargin

Returns an ErrorMargin of the given type with the given value.
UsageReturns
ee.ErrorMargin(value, unit)ErrorMargin
ArgumentTypeDetails
valueFloat, default: nullThe maximum error value allowed by the margin. Ignored if the unit is 'infinite'.
unitString, default: "meters"The unit of this margin: 'meters', 'projected' or 'infinite'.

ee.Feature

Features can be constructed from one of the following arguments plus an optional dictionary of properties:   - An ee.Geometry.   - A GeoJSON Geometry.   - A GeoJSON Feature.   - A computed object: reinterpreted as a geometry if properties are specified, and as a feature if they aren't.
UsageReturns
ee.Feature(geometry, properties)Feature
ArgumentTypeDetails
geometryComputedObject|Feature|Geometry|ObjectA geometry or feature.
propertiesObject, optionalA dictionary of metadata properties. If the first parameter is a Feature (instead of a geometry), this is unused.

ee.Feature.area

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 components (intersecting areas are counted multiple times).
UsageReturns
Feature.area(maxError, proj)Float
ArgumentTypeDetails
this: featureElementThe feature from which the geometry is taken.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in square meters.

ee.Feature.aside

Calls a function passing this object as the first argument, and returning itself. Convenient e.g. when debugging: var c = ee.ImageCollection('foo').aside(print) .filterDate('2001-01-01', '2002-01-01').aside(print, 'In 2001') .filterBounds(geom).aside(print, 'In region') .aside(Map.addLayer, {min: 0, max: 142}, 'Filtered') .select('a', 'b'); Returns the same object, for chaining.
UsageReturns
Feature.aside(func, var_args)ComputedObject
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
funcFunctionThe function to call.
var_argsVarArgsAny extra arguments to pass to the function.

ee.Feature.bounds

Returns a feature containing the bounding box of the geometry of a given feature.
UsageReturns
Feature.bounds(maxError, proj)Feature
ArgumentTypeDetails
this: featureElementThe feature the bound of which is being calculated.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in this projection. Otherwise it will be in WGS84.

ee.Feature.buffer

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.
UsageReturns
Feature.buffer(distance, maxError, proj)Feature
ArgumentTypeDetails
this: featureElementThe feature the geometry of which is being buffered.
distanceFloatThe 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.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when approximating the buffering circle and performing any necessary reprojection. If unspecified, defaults to 1% of the distance.
projProjection, default: nullIf 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.

ee.Feature.centroid

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.
UsageReturns
Feature.centroid(maxError, proj)Feature
ArgumentTypeDetails
this: featureElementCalculates the centroid of this feature's default geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in this projection. Otherwise it will be in WGS84.

ee.Feature.containedIn

Returns true iff the geometry of one feature is contained in the geometry of another.
UsageReturns
Feature.containedIn(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftElementThe feature containing the geometry used as the left operand of the operation.
rightElementThe feature containing the geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Feature.contains

Returns true iff the geometry of one feature contains the geometry of another.
UsageReturns
Feature.contains(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftElementThe feature containing the geometry used as the left operand of the operation.
rightElementThe feature containing the geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Feature.convexHull

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.
UsageReturns
Feature.convexHull(maxError, proj)Feature
ArgumentTypeDetails
this: featureElementThe feature containing the geometry whole hull is being calculated.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Feature.copyProperties

Copies metadata properties from one element to another.
UsageReturns
Feature.copyProperties(source, properties, exclude)Element
ArgumentTypeDetails
this: destinationElement, default: nullThe object whose properties to override.
sourceElement, default: nullThe object from which to copy the properties.
propertiesList, default: nullThe properties to copy. If omitted, all ordinary (i.e. non-system) properties are copied.
excludeList, default: nullThe list of properties to exclude when copying all properties. Must not be specified if properties is.

ee.Feature.cutLines

Converts LineString, MultiLineString, and LinearRing geometries into a MultiLineString by cutting them into parts no longer than the given distance along their length. All other geometry types will be converted to an empty MultiLineString.
UsageReturns
Feature.cutLines(distances, maxError, proj)Feature
ArgumentTypeDetails
this: featureElementCuts the lines of this feature's default geometry.
distancesListDistances along each LineString to cut the line into separate pieces, measured in units of the given proj, or meters if proj is unspecified.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullProjection of the result and distance measurements, or WGS84 if unspecified.

ee.Feature.difference

Returns a feature with the properties of the 'left' feature, and the geometry that results from subtracting the 'right' geometry from the 'left' geometry.
UsageReturns
Feature.difference(right, maxError, proj)Feature
ArgumentTypeDetails
this: leftElementThe feature containing the geometry used as the left operand of the operation. The properties of the result will be copied from this object.
rightElementThe feature containing the geometry used as the right operand of the operation. The properties of this object are ignored.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Feature.disjoint

Returns true iff the feature geometries are disjoint.
UsageReturns
Feature.disjoint(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftElementThe feature containing the geometry used as the left operand of the operation.
rightElementThe feature containing the geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Feature.dissolve

Returns a feature containing the union of the geometry of a feature. This leaves single geometries untouched, and unions multi geometries.
UsageReturns
Feature.dissolve(maxError, proj)Element
ArgumentTypeDetails
this: featureElementThe feature the geometry of which is being unioned.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the union will be performed in this projection. Otherwise it will be performed in a spherical coordinate system.

ee.Feature.distance

Returns the minimum distance between the geometries of two features.
UsageReturns
Feature.distance(right, maxError, proj)Float
ArgumentTypeDetails
this: leftElementThe feature containing the geometry used as the left operand of the operation.
rightElementThe feature containing the geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Feature.evaluate

Asynchronously retrieves the value of this object from the server and passes it to the provided callback function.
UsageReturns
Feature.evaluate(callback)
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
callbackFunctionA function of the form function(success, failure), called when the server returns an answer. If the request succeeded, the success argument contains the evaluated result. If the request failed, the failure argument will contains an error message.

ee.Feature.get

Extract a property from a feature.
UsageReturns
Feature.get(property)
ArgumentTypeDetails
this: objectElementThe feature to extract the property from.
propertyStringThe property to extract.

ee.Feature.getArray

Extract a property from a feature.
UsageReturns
Feature.getArray(property)Array
ArgumentTypeDetails
this: objectElementThe feature to extract the property from.
propertyStringThe property to extract.

ee.Feature.getInfo

An imperative function that returns information about this feature via an AJAX call. Returns a description of the feature.
UsageReturns
Feature.getInfo(callback)GeoJSONFeature
ArgumentTypeDetails
this: featureFeatureThe Feature instance.
callbackFunction, optionalAn optional callback. If not supplied, the call is made synchronously. If supplied, will be called with the first parameter if successful and the second if unsuccessful.

ee.Feature.getMap

An imperative function that returns a map ID and optional token, suitable for generating a Map overlay. Returns an object which may be passed to ee.data.getTileUrl or ui.Map.addLayer, including an additional 'image' field, containing a Collection.draw image wrapping a FeatureCollection containing this feature. Undefined if a callback was specified.
UsageReturns
Feature.getMap(visParams, callback)MapId|Object
ArgumentTypeDetails
this: featureFeatureThe Feature instance.
visParamsObject, optionalThe visualization parameters. Currently only one parameter, 'color', containing an RGB color string is user. If vis_params is null, black ("000000") is used.
callbackFunction, optionalAn async callback.

ee.Feature.getNumber

Extract a property from a feature.
UsageReturns
Feature.getNumber(property)Number
ArgumentTypeDetails
this: objectElementThe feature to extract the property from.
propertyStringThe property to extract.

ee.Feature.getString

Extract a property from a feature.
UsageReturns
Feature.getString(property)String
ArgumentTypeDetails
this: objectElementThe feature to extract the property from.
propertyStringThe property to extract.

ee.Feature.hersDescriptor

Creates a dictionary of Histogram Error Ring Statistic (HERS) descriptor arrays from square array properties of an element. The HERS radius is taken to be the array's (side_length - 1) / 2.
UsageReturns
Feature.hersDescriptor(selectors, buckets, peakWidthScale)Dictionary
ArgumentTypeDetails
this: elementElementThe element with array properties.
selectorsList, default: nullThe array properties for which descriptors will be created. Selected array properties must be square, floating point arrays. Defaults to all array properties.
bucketsInteger, default: 100The number of HERS buckets. Defaults to 100.
peakWidthScaleFloat, default: 1The HERS peak width scale. Defaults to 1.0.

ee.Feature.id

Returns the ID of a given element within a collection. Objects outside collections are not guaranteed to have IDs.
UsageReturns
Feature.id()String
ArgumentTypeDetails
this: elementElementThe element from which the ID is taken.

ee.Feature.intersection

Returns a feature containing the intersection of the geometries of two features, with the properties of the left feature.
UsageReturns
Feature.intersection(right, maxError, proj)Feature
ArgumentTypeDetails
this: leftElementThe feature containing the geometry used as the left operand of the operation. The properties of the result will be copied from this object.
rightElementThe feature containing the geometry used as the right operand of the operation. The properties of this object are ignored.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Feature.intersects

Returns true iff the feature geometries intersect.
UsageReturns
Feature.intersects(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftElementThe feature containing the geometry used as the left operand of the operation.
rightElementThe feature containing the geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Feature.length

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.
UsageReturns
Feature.length(maxError, proj)Float
ArgumentTypeDetails
this: featureElementThe feature from which the geometry is taken.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in meters.

ee.Feature.perimeter

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.
UsageReturns
Feature.perimeter(maxError, proj)Float
ArgumentTypeDetails
this: featureElementThe feature from which the geometry is taken.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in meters.

ee.Feature.propertyNames

Returns the names of properties on this element.
UsageReturns
Feature.propertyNames()List
ArgumentTypeDetails
this: elementElement

ee.Feature.select

Selects properties from a feature by name or RE2-compatible regex and optionally renames them.
UsageReturns
Feature.select(propertySelectors, newProperties, retainGeometry)Element
ArgumentTypeDetails
this: inputElementThe feature to select properties from.
propertySelectorsListA list of names or regexes specifying the properties to select.
newPropertiesList, default: nullOptional new names for the output properties. Must match the number of properties selected.
retainGeometryBoolean, default: trueWhen false, the result will have a NULL geometry.

ee.Feature.serialize

Returns the serialized representation of this object.
UsageReturns
Feature.serialize(legacy)String
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
legacyBoolean, optionalEnables legacy format.

ee.Feature.set

Overrides one or more metadata properties of an Element. Returns the element with the specified properties overridden.
UsageReturns
Feature.set(var_args)Element
ArgumentTypeDetails
this: elementElementThe Element instance.
var_argsVarArgsEither a dictionary of properties, or a vararg sequence of properties, e.g. key1, value1, key2, value2, ...

ee.Feature.setGeometry

Returns the feature, with the geometry replaced by the specified geometry.
UsageReturns
Feature.setGeometry(geometry)Element
ArgumentTypeDetails
this: featureElementThe feature on which to set the geometry.
geometryGeometry, default: nullThe geometry to set.

ee.Feature.simplify

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.
UsageReturns
Feature.simplify(maxError, proj)Feature
ArgumentTypeDetails
this: featureElementThe feature whose geometry is being simplified.
maxErrorErrorMarginThe maximum amount of error by which the result may differ from the input.
projProjection, default: nullIf 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

ee.Feature.symmetricDifference

Returns a feature containing the symmetric difference between geometries of two features.
UsageReturns
Feature.symmetricDifference(right, maxError, proj)Feature
ArgumentTypeDetails
this: leftElementThe feature containing the geometry used as the left operand of the operation. The properties of the result will be copied from this object.
rightElementThe feature containing the geometry used as the right operand of the operation. The properties of this object are ignored.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Feature.toArray

Creates an array from the given properties of an object, which must all be numbers.
UsageReturns
Feature.toArray(properties)Array
ArgumentTypeDetails
this: featureFeatureThe object from which to select array properties.
propertiesListThe property selectors for each array element.

ee.Feature.toDictionary

Extract properties from a feature as a dictionary.
UsageReturns
Feature.toDictionary(properties)Dictionary
ArgumentTypeDetails
this: elementElementThe feature to extract the property from.
propertiesList, default: nullThe list of properties to extract. Defaults to all non-system properties.

ee.Feature.transform

Transforms the geometry of a feature to a specific projection.
UsageReturns
Feature.transform(proj, maxError)Feature
ArgumentTypeDetails
this: featureElementThe feature the geometry of which is being converted.
projProjection, optionalThe 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.
maxErrorErrorMargin, default: nullThe maximum projection error.

ee.Feature.union

Returns a feature containing the union of the geometries of two features.
UsageReturns
Feature.union(right, maxError, proj)Feature
ArgumentTypeDetails
this: leftElementThe feature containing the geometry used as the left operand of the operation. The properties of the result will be copied from this object.
rightElementThe feature containing the geometry used as the right operand of the operation. The properties of this object are ignored.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Feature.withinDistance

Returns true iff the geometries of two features are within a specified distance.
UsageReturns
Feature.withinDistance(right, distance, maxError, proj)Boolean
ArgumentTypeDetails
this: leftElementThe feature containing the geometry used as the left operand of the operation.
rightElementThe feature containing the geometry used as the right operand of the operation.
distanceFloatThe distance threshold. If a projection is specified, the distance is in units of that projected coordinate system, otherwise it is in meters.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.FeatureCollection

FeatureCollections can be constructed from the following arguments:   - A string: assumed to be the name of a collection.   - A single geometry.   - A single feature.   - A list of features.   - A GeoJSON FeatureCollection   - A computed object: reinterpreted as a collection.
UsageReturns
ee.FeatureCollection(args, column)FeatureCollection
ArgumentTypeDetails
argsComputedObject|Feature|FeatureCollection|Geometry|ListThe constructor arguments.
columnString, optionalThe name of the geometry column to use. Only useful when working with a named collection.

ee.FeatureCollection.aggregate_array

Aggregates over a given property of the objects in a collection, calculating a list of all the values of the selected property.
UsageReturns
FeatureCollection.aggregate_array(property)List
ArgumentTypeDetails
this: collectionFeatureCollectionThe collection to aggregate over.
propertyStringThe property to use from each element of the collection.

ee.FeatureCollection.aggregate_count

Aggregates over a given property of the objects in a collection, calculating the number of non-null values of the property.
UsageReturns
FeatureCollection.aggregate_count(property)Number
ArgumentTypeDetails
this: collectionFeatureCollectionThe collection to aggregate over.
propertyStringThe property to use from each element of the collection.

ee.FeatureCollection.aggregate_count_distinct

Aggregates over a given property of the objects in a collection, calculating the number of distinct values for the selected property.
UsageReturns
FeatureCollection.aggregate_count_distinct(property)Number
ArgumentTypeDetails
this: collectionFeatureCollectionThe collection to aggregate over.
propertyStringThe property to use from each element of the collection.

ee.FeatureCollection.aggregate_first

Aggregates over a given property of the objects in a collection, calculating the property value of the first object in the collection.
UsageReturns
FeatureCollection.aggregate_first(property)
ArgumentTypeDetails
this: collectionFeatureCollectionThe collection to aggregate over.
propertyStringThe property to use from each element of the collection.

ee.FeatureCollection.aggregate_histogram

Aggregates over a given property of the objects in a collection, calculating a histogram of the selected property.
UsageReturns
FeatureCollection.aggregate_histogram(property)Dictionary
ArgumentTypeDetails
this: collectionFeatureCollectionThe collection to aggregate over.
propertyStringThe property to use from each element of the collection.

ee.FeatureCollection.aggregate_max

Aggregates over a given property of the objects in a collection, calculating the maximum of the values of the selected property.
UsageReturns
FeatureCollection.aggregate_max(property)
ArgumentTypeDetails
this: collectionFeatureCollectionThe collection to aggregate over.
propertyStringThe property to use from each element of the collection.

ee.FeatureCollection.aggregate_mean

Aggregates over a given property of the objects in a collection, calculating the mean of the selected property.
UsageReturns
FeatureCollection.aggregate_mean(property)Number
ArgumentTypeDetails
this: collectionFeatureCollectionThe collection to aggregate over.
propertyStringThe property to use from each element of the collection.

ee.FeatureCollection.aggregate_min

Aggregates over a given property of the objects in a collection, calculating the minimum of the values of the selected property.
UsageReturns
FeatureCollection.aggregate_min(property)
ArgumentTypeDetails
this: collectionFeatureCollectionThe collection to aggregate over.
propertyStringThe property to use from each element of the collection.

ee.FeatureCollection.aggregate_product

Aggregates over a given property of the objects in a collection, calculating the product of the values of the selected property.
UsageReturns
FeatureCollection.aggregate_product(property)Number
ArgumentTypeDetails
this: collectionFeatureCollectionThe collection to aggregate over.
propertyStringThe property to use from each element of the collection.

ee.FeatureCollection.aggregate_sample_sd

Aggregates over a given property of the objects in a collection, calculating the sample std. deviation of the values of the selected property.
UsageReturns
FeatureCollection.aggregate_sample_sd(property)Number
ArgumentTypeDetails
this: collectionFeatureCollectionThe collection to aggregate over.
propertyStringThe property to use from each element of the collection.

ee.FeatureCollection.aggregate_sample_var

Aggregates over a given property of the objects in a collection, calculating the sample variance of the values of the selected property.
UsageReturns
FeatureCollection.aggregate_sample_var(property)Number
ArgumentTypeDetails
this: collectionFeatureCollectionThe collection to aggregate over.
propertyStringThe property to use from each element of the collection.

ee.FeatureCollection.aggregate_stats

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.
UsageReturns
FeatureCollection.aggregate_stats(property)Dictionary
ArgumentTypeDetails
this: collectionFeatureCollectionThe collection to aggregate over.
propertyStringThe property to use from each element of the collection.

ee.FeatureCollection.aggregate_sum

Aggregates over a given property of the objects in a collection, calculating the sum of the values of the selected property.
UsageReturns
FeatureCollection.aggregate_sum(property)Number
ArgumentTypeDetails
this: collectionFeatureCollectionThe collection to aggregate over.
propertyStringThe property to use from each element of the collection.

ee.FeatureCollection.aggregate_total_sd

Aggregates over a given property of the objects in a collection, calculating the total std. deviation of the values of the selected property.
UsageReturns
FeatureCollection.aggregate_total_sd(property)Number
ArgumentTypeDetails
this: collectionFeatureCollectionThe collection to aggregate over.
propertyStringThe property to use from each element of the collection.

ee.FeatureCollection.aggregate_total_var

Aggregates over a given property of the objects in a collection, calculating the total variance of the values of the selected property.
UsageReturns
FeatureCollection.aggregate_total_var(property)Number
ArgumentTypeDetails
this: collectionFeatureCollectionThe collection to aggregate over.
propertyStringThe property to use from each element of the collection.

ee.FeatureCollection.aside

Calls a function passing this object as the first argument, and returning itself. Convenient e.g. when debugging: var c = ee.ImageCollection('foo').aside(print) .filterDate('2001-01-01', '2002-01-01').aside(print, 'In 2001') .filterBounds(geom).aside(print, 'In region') .aside(Map.addLayer, {min: 0, max: 142}, 'Filtered') .select('a', 'b'); Returns the same object, for chaining.
UsageReturns
FeatureCollection.aside(func, var_args)ComputedObject
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
funcFunctionThe function to call.
var_argsVarArgsAny extra arguments to pass to the function.

ee.FeatureCollection.classify

Classifies each feature in a collection.
UsageReturns
FeatureCollection.classify(classifier, outputName)FeatureCollection
ArgumentTypeDetails
this: featuresFeatureCollectionThe collection of features to classify. Each feature must contain all the properties in the classifier's schema.
classifierClassifierThe classifier to use.
outputNameString, default: "classification"The name of the output property to be added. This argument is ignored if the classifier has more than one output.

ee.FeatureCollection.cluster

Clusters each feature in a collection, adding a new column to each feature containing the cluster number to which it has been assigned.
UsageReturns
FeatureCollection.cluster(clusterer, outputName)FeatureCollection
ArgumentTypeDetails
this: featuresFeatureCollectionThe collection of features to cluster. Each feature must contain all the properties in the clusterer's schema.
clustererClustererThe clusterer to use.
outputNameString, default: "cluster"The name of the output property to be added.

ee.FeatureCollection.copyProperties

Copies metadata properties from one element to another.
UsageReturns
FeatureCollection.copyProperties(source, properties, exclude)Element
ArgumentTypeDetails
this: destinationElement, default: nullThe object whose properties to override.
sourceElement, default: nullThe object from which to copy the properties.
propertiesList, default: nullThe properties to copy. If omitted, all ordinary (i.e. non-system) properties are copied.
excludeList, default: nullThe list of properties to exclude when copying all properties. Must not be specified if properties is.

ee.FeatureCollection.distance

Produces a DOUBLE image where each pixel is the distance in meters from the pixel center to the nearest Point, LineString, or polygonal boundary in the collection. Note distance is also measured within interiors of polygons. 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.
UsageReturns
FeatureCollection.distance(searchRadius, maxError)Image
ArgumentTypeDetails
this: featuresFeatureCollectionFeature collection from which to get features used to compute pixel distances.
searchRadiusFloat, default: 100000Maximum distance in meters from each pixel to look for edges. Pixels will be masked unless there are edges within this distance.
maxErrorFloat, default: 100Maximum 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.

ee.FeatureCollection.distinct

Removes duplicates from a collection. Note that duplicates are determined using a strong hash over the serialized form of the selected properties.
UsageReturns
FeatureCollection.distinct(properties)FeatureCollection
ArgumentTypeDetails
this: collectionFeatureCollectionThe input collection from which objects will be selected.
propertiesObjectA property name or a list of property names to use for comparison. The '.geo' property can be included to compare object geometries.

ee.FeatureCollection.draw

Paints a vector collection for visualization. Not intended for use as input to other algorithms.
UsageReturns
FeatureCollection.draw(color, pointRadius, strokeWidth)Image
ArgumentTypeDetails
this: collectionFeatureCollectionThe collection to draw.
colorStringA hex string in the format RRGGBB specifying the color to use for drawing the features.
pointRadiusInteger, default: 3The radius in pixels of the point markers.
strokeWidthInteger, default: 2The width in pixels of lines and polygon borders.

ee.FeatureCollection.errorMatrix

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.
UsageReturns
FeatureCollection.errorMatrix(actual, predicted, order)ConfusionMatrix
ArgumentTypeDetails
this: collectionFeatureCollectionThe input collection.
actualStringThe name of the property containing the actual value.
predictedStringThe name of the property containing the predicted value.
orderList, default: nullA 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.

ee.FeatureCollection.evaluate

Asynchronously retrieves the value of this object from the server and passes it to the provided callback function.
UsageReturns
FeatureCollection.evaluate(callback)
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
callbackFunctionA function of the form function(success, failure), called when the server returns an answer. If the request succeeded, the success argument contains the evaluated result. If the request failed, the failure argument will contains an error message.

ee.FeatureCollection.filter

Apply a filter to this collection. Returns the filtered collection.
UsageReturns
FeatureCollection.filter(filter)Collection
ArgumentTypeDetails
this: collectionCollectionThe Collection instance.
filterFilterA filter to apply to this collection.

ee.FeatureCollection.filterBounds

Shortcut to filter a collection by intersection with geometry. Items in the collection with a footprint that fails to intersect the given geometry will be excluded. This is equivalent to this.filter(ee.Filter.bounds(...)). Caution: providing a large or complex collection as the `geometry` argument can result in poor performance. Collating the geometry of collections does not scale well; use the smallest collection (or geometry) that is required to achieve the desired outcome. Returns the filtered collection.
UsageReturns
FeatureCollection.filterBounds(geometry)Collection
ArgumentTypeDetails
this: collectionCollectionThe Collection instance.
geometryComputedObject|FeatureCollection|GeometryThe geometry, feature or collection to intersect with.

ee.FeatureCollection.filterDate

Shortcut to filter a collection by a date range. The start and end may be Dates, numbers (interpreted as milliseconds since 1970-01-01T00:00:00Z), or strings (such as '1996-01-01T08:00'). Based on 'system:time_start'. This is equivalent to this.filter(ee.Filter.date(...)); see the ee.Filter type for other date filtering options. Returns the filtered collection.
UsageReturns
FeatureCollection.filterDate(start, end)Collection
ArgumentTypeDetails
this: collectionCollectionThe Collection instance.
startDate|Number|StringThe start date (inclusive).
endDate|Number|String, optionalThe end date (exclusive). Optional. If not specified, a 1-millisecond range starting at 'start' is created.

ee.FeatureCollection.first

Returns the first entry from a given collection.
UsageReturns
FeatureCollection.first()Element
ArgumentTypeDetails
this: collectionFeatureCollectionThe collection from which to select the first entry.

ee.FeatureCollection.flatten

Flattens collections of collections.
UsageReturns
FeatureCollection.flatten()FeatureCollection
ArgumentTypeDetails
this: collectionFeatureCollectionThe input collection of collections.

ee.FeatureCollection.geometry

Extracts and merges the geometries of a collection. Requires that all the geometries in the collection share the projection and edge interpretation. Caution: providing a large or complex collection as input can result in poor performance. Collating the geometry of collections does not scale well; use the smallest collection that is required to achieve the desired outcome.
UsageReturns
FeatureCollection.geometry(maxError)Geometry
ArgumentTypeDetails
this: collectionFeatureCollectionThe collection whose geometries will be extracted.
maxErrorErrorMargin, optionalAn error margin to use when merging geometries.

ee.FeatureCollection.get

Extract a property from a feature.
UsageReturns
FeatureCollection.get(property)
ArgumentTypeDetails
this: objectElementThe feature to extract the property from.
propertyStringThe property to extract.

ee.FeatureCollection.getArray

Extract a property from a feature.
UsageReturns
FeatureCollection.getArray(property)Array
ArgumentTypeDetails
this: objectElementThe feature to extract the property from.
propertyStringThe property to extract.

ee.FeatureCollection.getDownloadURL

Gets a download URL. When the URL is accessed, the FeatureCollection is downloaded in one of several formats. Returns a download URL or undefined if a callback was specified.
UsageReturns
FeatureCollection.getDownloadURL(format, selectors, filename, callback)Object|String
ArgumentTypeDetails
this: featurecollectionFeatureCollectionThe FeatureCollection instance.
formatString, optionalThe format of download, one of: "csv", "json", "geojson", "kml", "kmz" ("json" outputs GeoJSON). If unspecified, defaults to "csv".
selectorsList, optionalFeature property names used to select the attributes to be downloaded. If unspecified, all properties are included.
filenameString, optionalName of the file to be downloaded; extension is appended by default. If unspecified, defaults to "table".
callbackFunction, optionalAn optional callback. If not supplied, the call is made synchronously.

ee.FeatureCollection.getInfo

An imperative function that returns all the known information about this collection via an AJAX call. Returns a collection description whose fields include:   - features: a list containing metadata about the features in the collection.   - properties: an optional dictionary containing the collection's metadata properties.
UsageReturns
FeatureCollection.getInfo(callback)FeatureCollectionDescription
ArgumentTypeDetails
this: featurecollectionFeatureCollectionThe FeatureCollection instance.
callbackFunction, optionalAn optional callback. If not supplied, the call is made synchronously. If supplied, will be called with the first parameter if successful and the second if unsuccessful.

ee.FeatureCollection.getMap

An imperative function that returns a map id and token, suitable for generating a Map overlay. Returns an object which may be passed to ee.data.getTileUrl or ui.Map.addLayer, including an additional 'image' field, containing a Collection.draw image wrapping a FeatureCollection containing this feature. Undefined if a callback was specified.
UsageReturns
FeatureCollection.getMap(visParams, callback)MapId|Object
ArgumentTypeDetails
this: featurecollectionFeatureCollectionThe FeatureCollection instance.
visParamsObject, optionalThe visualization parameters. Currently only one parameter, 'color', containing an RGB color string is allowed. If vis_params isn't specified, then the color #000000 is used.
callbackFunction, optionalAn async callback. If not supplied, the call is made synchronously.

ee.FeatureCollection.getNumber

Extract a property from a feature.
UsageReturns
FeatureCollection.getNumber(property)Number
ArgumentTypeDetails
this: objectElementThe feature to extract the property from.
propertyStringThe property to extract.

ee.FeatureCollection.getString

Extract a property from a feature.
UsageReturns
FeatureCollection.getString(property)String
ArgumentTypeDetails
this: objectElementThe feature to extract the property from.
propertyStringThe property to extract.

ee.FeatureCollection.inverseDistance

Returns an inverse-distance weighted estimate of the value at each pixel.
UsageReturns
FeatureCollection.inverseDistance(range, propertyName, mean, stdDev, gamma, reducer)Image
ArgumentTypeDetails
this: collectionFeatureCollectionFeature collection to use as source data for the estimation.
rangeFloatSize of the interpolation window (in meters).
propertyNameStringName of the numeric property to be estimated.
meanFloatGlobal expected mean.
stdDevFloatGlobal standard deviation.
gammaFloat, default: 1Determines how quickly the estimates tend towards the global mean.
reducerReducer, default: nullReducer used to collapse the 'propertyName' value of overlapping points into a single value.

ee.FeatureCollection.iterate

Applies a user-supplied function to each element of a collection. The user-supplied function is given two arguments: the current element, and the value returned by the previous call to iterate() or the first argument, for the first iteration. The result is the value returned by the final call to the user-supplied function. Returns the result of the Collection.iterate() call.
UsageReturns
FeatureCollection.iterate(algorithm, first)ComputedObject
ArgumentTypeDetails
this: collectionCollectionThe Collection instance.
algorithmFunctionThe function to apply to each element. Must take two arguments: an element of the collection and the value from the previous iteration.
firstObject, optionalThe initial state.

ee.FeatureCollection.kriging

Returns the results of sampling a Kriging estimator at each pixel.
UsageReturns
FeatureCollection.kriging(propertyName, shape, range, sill, nugget, maxDistance, reducer)Image
ArgumentTypeDetails
this: collectionFeatureCollectionFeature collection to use as source data for the estimation.
propertyNameStringProperty to be estimated (must be numeric).
shapeStringSemivariogram shape (one of {exponential, gaussian, spherical}).
rangeFloatSemivariogram range, in meters.
sillFloatSemivariogram sill.
nuggetFloatSemivariogram nugget.
maxDistanceFloat, default: nullRadius which determines which features are included in each pixel's computation, in meters. Defaults to the semivariogram's range.
reducerReducer, default: nullReducer used to collapse the 'propertyName' value of overlapping points into a single value.

ee.FeatureCollection.limit

Limit a collection to the specified number of elements, optionally sorting them by a specified property first. Returns the limited collection.
UsageReturns
FeatureCollection.limit(max, property, ascending)Collection
ArgumentTypeDetails
this: collectionCollectionThe Collection instance.
maxNumberThe number to limit the collection to.
propertyString, optionalThe property to sort by, if sorting.
ascendingBoolean, optionalWhether to sort in ascending or descending order. The default is true (ascending).

ee.FeatureCollection.makeArray

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.
UsageReturns
FeatureCollection.makeArray(properties, name)FeatureCollection
ArgumentTypeDetails
this: collectionFeatureCollectionThe input collection from which properties will be selected.
propertiesListThe properties to select.
nameString, default: "array"The name of the new array property.

ee.FeatureCollection.map

Maps an algorithm over a collection. Returns the mapped collection.
UsageReturns
FeatureCollection.map(algorithm, dropNulls)Collection
ArgumentTypeDetails
this: collectionCollectionThe Collection instance.
algorithmFunctionThe operation to map over the images or features of the collection. A JavaScript function that receives an image or features and returns one. The function is called only once and the result is captured as a description, so it cannot perform imperative operations or rely on external state.
dropNullsBoolean, optionalIf true, the mapped algorithm is allowed to return nulls, and the elements for which it returns nulls will be dropped.

ee.FeatureCollection.merge

Merges two collections into one. The result has all the elements that were in either collection. Elements from the first collection will have IDs prefixed with "1_" and elements from the second collection will have IDs prefixed with "2_". Note: If many collections need to be merged, consider placing them all in a collection and using FeatureCollection.flatten() instead. Repeated use of FeatureCollection.merge() will result in increasingly long element IDs and reduced performance.
UsageReturns
FeatureCollection.merge(collection2)FeatureCollection
ArgumentTypeDetails
this: collection1FeatureCollectionThe first collection to merge.
collection2FeatureCollectionThe second collection to merge.

ee.FeatureCollection.propertyNames

Returns the names of properties on this element.
UsageReturns
FeatureCollection.propertyNames()List
ArgumentTypeDetails
this: elementElement

ee.FeatureCollection.randomColumn

Adds a column of deterministic pseudorandom numbers to a collection. The outputs are double-precision floating point numbers. When using the 'uniform' distribution (default), outputs are in the range of [0, 1). Using the 'normal' distribution, outputs have μ=0, 𝛔=1, but have no explicit limits.
UsageReturns
FeatureCollection.randomColumn(columnName, seed, distribution)FeatureCollection
ArgumentTypeDetails
this: collectionFeatureCollectionThe input collection to which to add a random column.
columnNameString, default: "random"The name of the column to add.
seedLong, default: 0A seed used when generating the random numbers.
distributionString, default: "uniform"The distribution type of random numbers to produce; one of 'uniform' or 'normal'.

ee.FeatureCollection.randomPoints

Generates points that are uniformly random on the sphere, and within the given region.
UsageReturns
ee.FeatureCollection.randomPoints(region, points, seed, maxError)FeatureCollection
ArgumentTypeDetails
regionGeometryThe region to generate points for.
pointsInteger, default: 1000The number of points to generate.
seedLong, default: 0A seed for the random number generator.
maxErrorErrorMargin, optionalThe maximum amount of error tolerated when performing any necessary reprojection.

ee.FeatureCollection.reduceColumns

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.
UsageReturns
FeatureCollection.reduceColumns(reducer, selectors, weightSelectors)Dictionary
ArgumentTypeDetails
this: collectionFeatureCollectionThe collection to aggregate over.
reducerReducerThe reducer to apply.
selectorsListA selector for each input of the reducer.
weightSelectorsList, default: nullA selector for each weighted input of the reducer.

ee.FeatureCollection.reduceToImage

Creates an image from a feature collection by applying a reducer over the selected properties of all the features that intersect each pixel.
UsageReturns
FeatureCollection.reduceToImage(properties, reducer)Image
ArgumentTypeDetails
this: collectionFeatureCollectionFeature collection to intersect with each output pixel.
propertiesListProperties to select from each feature and pass into the reducer.
reducerReducerA Reducer to combine the properties of each intersecting feature into a final result to store in the pixel.

ee.FeatureCollection.remap

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.
UsageReturns
FeatureCollection.remap(lookupIn, lookupOut, columnName)FeatureCollection
ArgumentTypeDetails
this: collectionFeatureCollectionThe collection to be modified.
lookupInListThe input mapping values. Restricted to strings and integers.
lookupOutListThe output mapping values. Must be the same size as lookupIn.
columnNameStringThe name of the property to remap.

ee.FeatureCollection.select

Select properties from each Feature in a collection. It is also possible to call this function with only string arguments; they will be all be interpreted as propertySelectors (varargs). Returns the feature collection with selected properties.
UsageReturns
FeatureCollection.select(propertySelectors, newProperties, retainGeometry)FeatureCollection
ArgumentTypeDetails
this: featurecollectionFeatureCollectionThe FeatureCollection instance.
propertySelectorsListA list of names or regexes specifying the attributes to select.
newPropertiesList, optionalA list of new names for the output properties. Must match the number of properties selected.
retainGeometryBoolean, optionalWhen false, the result will have a NULL geometry. Defaults to true.

ee.FeatureCollection.serialize

Returns the serialized representation of this object.
UsageReturns
FeatureCollection.serialize(legacy)String
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
legacyBoolean, optionalEnables legacy format.

ee.FeatureCollection.set

Overrides one or more metadata properties of an Element. Returns the element with the specified properties overridden.
UsageReturns
FeatureCollection.set(var_args)Element
ArgumentTypeDetails
this: elementElementThe Element instance.
var_argsVarArgsEither a dictionary of properties, or a vararg sequence of properties, e.g. key1, value1, key2, value2, ...

ee.FeatureCollection.size

Returns the number of elements in the collection.
UsageReturns
FeatureCollection.size()Integer
ArgumentTypeDetails
this: collectionFeatureCollectionThe collection to count.

ee.FeatureCollection.sort

Sort a collection by the specified property. Returns the sorted collection.
UsageReturns
FeatureCollection.sort(property, ascending)Collection
ArgumentTypeDetails
this: collectionCollectionThe Collection instance.
propertyStringThe property to sort by.
ascendingBoolean, optionalWhether to sort in ascending or descending order. The default is true (ascending).

ee.FeatureCollection.style

Draw a vector collection for visualization using a simple style language.
UsageReturns
FeatureCollection.style(color, pointSize, pointShape, width, fillColor, styleProperty, neighborhood, lineType)Image
ArgumentTypeDetails
this: collectionFeatureCollectionThe collection to draw.
colorString, default: "black"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).
pointSizeInteger, default: 3The default size in pixels of the point markers.
pointShapeString, default: "circle"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`, `<`, `>`.
widthFloat, default: 2The default line width for lines and outlines for polygons and point shapes.
fillColorString, default: nullThe color for filling polygons and point shapes. Defaults to 'color' at 0.66 opacity.
stylePropertyString, default: nullA per-feature property expected to contain a dictionary. Values in the dictionary override any default values for that feature.
neighborhoodInteger, default: 5If 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.
lineTypeString, default: "solid"The default line style for lines and outlines of polygons and point shapes. Defaults to 'solid'. One of: solid, dotted, dashed.

ee.FeatureCollection.toDictionary

Extract properties from a feature as a dictionary.
UsageReturns
FeatureCollection.toDictionary(properties)Dictionary
ArgumentTypeDetails
this: elementElementThe feature to extract the property from.
propertiesList, default: nullThe list of properties to extract. Defaults to all non-system properties.

ee.FeatureCollection.toList

Returns the elements of a collection as a list.
UsageReturns
FeatureCollection.toList(count, offset)List
ArgumentTypeDetails
this: collectionFeatureCollectionThe input collection to fetch.
countIntegerThe maximum number of elements to fetch.
offsetInteger, default: 0The number of elements to discard from the start. If set, (offset + count) elements will be fetched and the first offset elements will be discarded.

ee.FeatureCollection.union

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.
UsageReturns
FeatureCollection.union(maxError)FeatureCollection
ArgumentTypeDetails
this: collectionFeatureCollectionThe collection being merged.
maxErrorErrorMargin, default: nullThe maximum error allowed when performing any necessary reprojections. If not specified, defaults to the error margin requested from the output.

ee.Filter

Constructs a new filter. This constructor accepts the following args:   - Another filter.   - A list of filters (which are implicitly ANDed together).   - A ComputedObject returning a filter. Users shouldn't be making these; they're produced by the generator functions below.
UsageReturns
ee.Filter(filter)Filter
ArgumentTypeDetails
filterFilter|List, optionalOptional filter to add.

ee.Filter.and

Combine two or more filters using boolean AND. Returns the constructed filter.
UsageReturns
ee.Filter.and(var_args)Filter
ArgumentTypeDetails
var_argsVarArgsThe filters to combine.

ee.Filter.aside

Calls a function passing this object as the first argument, and returning itself. Convenient e.g. when debugging: var c = ee.ImageCollection('foo').aside(print) .filterDate('2001-01-01', '2002-01-01').aside(print, 'In 2001') .filterBounds(geom).aside(print, 'In region') .aside(Map.addLayer, {min: 0, max: 142}, 'Filtered') .select('a', 'b'); Returns the same object, for chaining.
UsageReturns
Filter.aside(func, var_args)ComputedObject
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
funcFunctionThe function to call.
var_argsVarArgsAny extra arguments to pass to the function.

ee.Filter.bounds

Creates a filter that passes if the object's geometry intersects the given geometry. Caution: providing a large or complex collection as the `geometry` argument can result in poor performance. Collating the geometry of collections does not scale well; use the smallest collection (or geometry) that is required to achieve the desired outcome. Returns the constructed filter.
UsageReturns
ee.Filter.bounds(geometry, errorMargin)Filter
ArgumentTypeDetails
geometryComputedObject|FeatureCollection|GeometryThe geometry, feature or collection to intersect with.
errorMarginComputedObject|Number, optionalAn optional error margin. If a number, interpreted as sphere surface meters.

ee.Filter.calendarRange

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.
UsageReturns
ee.Filter.calendarRange(start, end, field)Filter
ArgumentTypeDetails
startIntegerThe start of the desired calendar field, inclusive.
endInteger, default: nullThe end of the desired calendar field, inclusive. Defaults to the same value as start.
fieldString, default: "day_of_year"The calendar field to filter over. Options are: `year`, `month`, `hour`, `minute`, `day_of_year`, `day_of_month`, and `day_of_week`.

ee.Filter.contains

Creates a unary or binary filter that passes if the left geometry contains the right geometry (empty geometries are not contained in anything).
UsageReturns
ee.Filter.contains(leftField, rightValue, rightField, leftValue, maxError)Filter
ArgumentTypeDetails
leftFieldString, default: nullA selector for the left operand. Should not be specified if leftValue is specified.
rightValueObject, default: nullThe value of the right operand. Should not be specified if rightField is specified.
rightFieldString, default: nullA selector for the right operand. Should not be specified if rightValue is specified.
leftValueObject, default: nullThe value of the left operand. Should not be specified if leftField is specified.
maxErrorErrorMargin, optionalThe maximum reprojection error allowed during filter application.

ee.Filter.date

Filter a collection by date range. The start and end may be Dates, numbers (interpreted as milliseconds since 1970-01-01T00:00:00Z), or strings (such as '1996-01-01T08:00'). Based on 'system:time_start' property. Returns the constructed filter.
UsageReturns
ee.Filter.date(start, end)Filter
ArgumentTypeDetails
startDate|Number|StringThe start date (inclusive).
endDate|Number|String, optionalThe end date (exclusive). Optional. If not specified, a 1-millisecond range starting at 'start' is created.

ee.Filter.dateRangeContains

Creates a unary or binary filter that passes if the left operand, a date range, contains the right operand, a date.
UsageReturns
ee.Filter.dateRangeContains(leftField, rightValue, rightField, leftValue)Filter
ArgumentTypeDetails
leftFieldString, default: nullA selector for the left operand. Should not be specified if leftValue is specified.
rightValueObject, default: nullThe value of the right operand. Should not be specified if rightField is specified.
rightFieldString, default: nullA selector for the right operand. Should not be specified if rightValue is specified.
leftValueObject, default: nullThe value of the left operand. Should not be specified if leftField is specified.

ee.Filter.dayOfYear

Returns a filter that passes if the object's timestamp falls within the given day-of-year range.
UsageReturns
ee.Filter.dayOfYear(start, end)Filter
ArgumentTypeDetails
startIntegerThe start of the desired day range, inclusive.
endIntegerThe end of the desired day range, inclusive.

ee.Filter.disjoint

Creates a unary or binary filter that passes unless the left geometry intersects the right geometry.
UsageReturns
ee.Filter.disjoint(leftField, rightValue, rightField, leftValue, maxError)Filter
ArgumentTypeDetails
leftFieldString, default: nullA selector for the left operand. Should not be specified if leftValue is specified.
rightValueObject, default: nullThe value of the right operand. Should not be specified if rightField is specified.
rightFieldString, default: nullA selector for the right operand. Should not be specified if rightValue is specified.
leftValueObject, default: nullThe value of the left operand. Should not be specified if leftField is specified.
maxErrorErrorMargin, optionalThe maximum reprojection error allowed during filter application.

ee.Filter.eq

Filter to metadata equal to the given value. Returns the constructed filter.
UsageReturns
ee.Filter.eq(name, value)Filter
ArgumentTypeDetails
nameStringThe property name to filter on.
valueObjectThe value to compare against.

ee.Filter.equals

Creates a unary or binary filter that passes if the two operands are equals.
UsageReturns
ee.Filter.equals(leftField, rightValue, rightField, leftValue)Filter
ArgumentTypeDetails
leftFieldString, default: nullA selector for the left operand. Should not be specified if leftValue is specified.
rightValueObject, default: nullThe value of the right operand. Should not be specified if rightField is specified.
rightFieldString, default: nullA selector for the right operand. Should not be specified if rightValue is specified.
leftValueObject, default: nullThe value of the left operand. Should not be specified if leftField is specified.

ee.Filter.evaluate

Asynchronously retrieves the value of this object from the server and passes it to the provided callback function.
UsageReturns
Filter.evaluate(callback)
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
callbackFunctionA function of the form function(success, failure), called when the server returns an answer. If the request succeeded, the success argument contains the evaluated result. If the request failed, the failure argument will contains an error message.

ee.Filter.expression

Constructs a filter tree from a string.
UsageReturns
ee.Filter.expression(expression)Filter
ArgumentTypeDetails
expressionStringA string to be parsed into a Filter object (e.g.: "property > value"). Supported operators include: >, >=, <, <=, ==, !=, (), !, && and ||.

ee.Filter.getInfo

Retrieves the value of this object from the server. If no callback function is provided, the request is made synchronously. If a callback is provided, the request is made asynchronously. The asynchronous mode is preferred because the synchronous mode stops all other code (for example, the EE Code Editor UI) while waiting for the server. To make an asynchronous request, evaluate() is preferred over getInfo(). Returns the computed value of this object.
UsageReturns
Filter.getInfo(callback)Object
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
callbackFunction, optionalAn optional callback. If not supplied, the call is made synchronously.

ee.Filter.greaterThan

Creates a unary or binary filter that passes if the left operand is greater than the right operand.
UsageReturns
ee.Filter.greaterThan(leftField, rightValue, rightField, leftValue)Filter
ArgumentTypeDetails
leftFieldString, default: nullA selector for the left operand. Should not be specified if leftValue is specified.
rightValueObject, default: nullThe value of the right operand. Should not be specified if rightField is specified.
rightFieldString, default: nullA selector for the right operand. Should not be specified if rightValue is specified.
leftValueObject, default: nullThe value of the left operand. Should not be specified if leftField is specified.

ee.Filter.greaterThanOrEquals

Creates a unary or binary filter that passes unless the left operand is less than the right operand.
UsageReturns
ee.Filter.greaterThanOrEquals(leftField, rightValue, rightField, leftValue)Filter
ArgumentTypeDetails
leftFieldString, default: nullA selector for the left operand. Should not be specified if leftValue is specified.
rightValueObject, default: nullThe value of the right operand. Should not be specified if rightField is specified.
rightFieldString, default: nullA selector for the right operand. Should not be specified if rightValue is specified.
leftValueObject, default: nullThe value of the left operand. Should not be specified if leftField is specified.

ee.Filter.gt

Filter on metadata greater than the given value. Returns the constructed filter.
UsageReturns
ee.Filter.gt(name, value)Filter
ArgumentTypeDetails
nameStringThe property name to filter on.
valueObjectThe value to compare against.

ee.Filter.gte

Filter on metadata greater than or equal to the given value. Returns the constructed filter.
UsageReturns
ee.Filter.gte(name, value)Filter
ArgumentTypeDetails
nameStringThe property name to filter on.
valueObjectThe value to compare against.

ee.Filter.hasType

Creates a unary or binary filter that passes if the left operand has the type, or is a subtype of the type named in the right operand.
UsageReturns
ee.Filter.hasType(leftField, rightValue, rightField, leftValue)Filter
ArgumentTypeDetails
leftFieldString, default: nullA selector for the left operand. Should not be specified if leftValue is specified.
rightValueObject, default: nullThe value of the right operand. Should not be specified if rightField is specified.
rightFieldString, default: nullA selector for the right operand. Should not be specified if rightValue is specified.
leftValueObject, default: nullThe value of the left operand. Should not be specified if leftField is specified.

ee.Filter.inList

Filter on metadata contained in a list. Returns the constructed filter.
UsageReturns
ee.Filter.inList(leftField, rightValue, rightField, leftValue)Filter
ArgumentTypeDetails
leftFieldString, optionalA selector for the left operand. Should not be specified if leftValue is specified.
rightValueList, optionalThe value of the right operand. Should not be specified if rightField is specified.
rightFieldString, optionalA selector for the right operand. Should not be specified if rightValue is specified.
leftValueList, optionalThe value of the left operand. Should not be specified if leftField is specified.

ee.Filter.intersects

Creates a unary or binary filter that passes if the left geometry intersects the right geometry.
UsageReturns
ee.Filter.intersects(leftField, rightValue, rightField, leftValue, maxError)Filter
ArgumentTypeDetails
leftFieldString, default: nullA selector for the left operand. Should not be specified if leftValue is specified.
rightValueObject, default: nullThe value of the right operand. Should not be specified if rightField is specified.
rightFieldString, default: nullA selector for the right operand. Should not be specified if rightValue is specified.
leftValueObject, default: nullThe value of the left operand. Should not be specified if leftField is specified.
maxErrorErrorMargin, optionalThe maximum reprojection error allowed during filter application.

ee.Filter.isContained

Creates a unary or binary filter that passes if the right geometry contains the left geometry (empty geometries are not contained in anything).
UsageReturns
ee.Filter.isContained(leftField, rightValue, rightField, leftValue, maxError)Filter
ArgumentTypeDetails
leftFieldString, default: nullA selector for the left operand. Should not be specified if leftValue is specified.
rightValueObject, default: nullThe value of the right operand. Should not be specified if rightField is specified.
rightFieldString, default: nullA selector for the right operand. Should not be specified if rightValue is specified.
leftValueObject, default: nullThe value of the left operand. Should not be specified if leftField is specified.
maxErrorErrorMargin, optionalThe maximum reprojection error allowed during filter application.

ee.Filter.lessThan

Creates a unary or binary filter that passes if the left operand is less than the right operand.
UsageReturns
ee.Filter.lessThan(leftField, rightValue, rightField, leftValue)Filter
ArgumentTypeDetails
leftFieldString, default: nullA selector for the left operand. Should not be specified if leftValue is specified.
rightValueObject, default: nullThe value of the right operand. Should not be specified if rightField is specified.
rightFieldString, default: nullA selector for the right operand. Should not be specified if rightValue is specified.
leftValueObject, default: nullThe value of the left operand. Should not be specified if leftField is specified.

ee.Filter.lessThanOrEquals

Creates a unary or binary filter that passes unless the left operand is greater than the right operand.
UsageReturns
ee.Filter.lessThanOrEquals(leftField, rightValue, rightField, leftValue)Filter
ArgumentTypeDetails
leftFieldString, default: nullA selector for the left operand. Should not be specified if leftValue is specified.
rightValueObject, default: nullThe value of the right operand. Should not be specified if rightField is specified.
rightFieldString, default: nullA selector for the right operand. Should not be specified if rightValue is specified.
leftValueObject, default: nullThe value of the left operand. Should not be specified if leftField is specified.

ee.Filter.listContains

Creates a unary or binary filter that passes if the left operand, a list, contains the right operand.
UsageReturns
ee.Filter.listContains(leftField, rightValue, rightField, leftValue)Filter
ArgumentTypeDetails
leftFieldString, default: nullA selector for the left operand. Should not be specified if leftValue is specified.
rightValueObject, default: nullThe value of the right operand. Should not be specified if rightField is specified.
rightFieldString, default: nullA selector for the right operand. Should not be specified if rightValue is specified.
leftValueObject, default: nullThe value of the left operand. Should not be specified if leftField is specified.

ee.Filter.lt

Filter to metadata less than the given value. Returns the constructed filter.
UsageReturns
ee.Filter.lt(name, value)Filter
ArgumentTypeDetails
nameStringThe property name to filter on.
valueObjectThe value to compare against.

ee.Filter.lte

Filter on metadata less than or equal to the given value. Returns the constructed filter.
UsageReturns
ee.Filter.lte(name, value)Filter
ArgumentTypeDetails
nameStringThe property name to filter on.
valueObjectThe value to compare against.

ee.Filter.maxDifference

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.
UsageReturns
ee.Filter.maxDifference(difference, leftField, rightValue, rightField, leftValue)Filter
ArgumentTypeDetails
differenceFloatThe maximum difference for which the filter will return true.
leftFieldString, default: nullA selector for the left operand. Should not be specified if leftValue is specified.
rightValueObject, default: nullThe value of the right operand. Should not be specified if rightField is specified.
rightFieldString, default: nullA selector for the right operand. Should not be specified if rightValue is specified.
leftValueObject, default: nullThe value of the left operand. Should not be specified if leftField is specified.

ee.Filter.neq

Filter to metadata not equal to the given value. Returns the constructed filter.
UsageReturns
ee.Filter.neq(name, value)Filter
ArgumentTypeDetails
nameStringThe property name to filter on.
valueObjectThe value to compare against.

ee.Filter.not

Returns the opposite of the input filter, i.e. the resulting filter will match if and only if the input filter doesn't match.
UsageReturns
Filter.not()Filter
ArgumentTypeDetails
this: filterFilterThe Filter instance.

ee.Filter.notEquals

Creates a unary or binary filter that passes unless the two operands are equals.
UsageReturns
ee.Filter.notEquals(leftField, rightValue, rightField, leftValue)Filter
ArgumentTypeDetails
leftFieldString, default: nullA selector for the left operand. Should not be specified if leftValue is specified.
rightValueObject, default: nullThe value of the right operand. Should not be specified if rightField is specified.
rightFieldString, default: nullA selector for the right operand. Should not be specified if rightValue is specified.
leftValueObject, default: nullThe value of the left operand. Should not be specified if leftField is specified.

ee.Filter.notNull

Returns a filter that passes if all the named properties are not null.
UsageReturns
ee.Filter.notNull(properties)Filter
ArgumentTypeDetails
propertiesList

ee.Filter.or

Combine two or more filters using boolean OR. Returns the constructed filter.
UsageReturns
ee.Filter.or(var_args)Filter
ArgumentTypeDetails
var_argsVarArgsThe filters to combine.

ee.Filter.rangeContains

Returns a filter that passes if the value of the selected field is in the specified range (inclusive).
UsageReturns
ee.Filter.rangeContains(field, minValue, maxValue)Filter
ArgumentTypeDetails
fieldStringA selector for the property being tested.
minValueObjectThe lower bound of the range.
maxValueObjectThe upper bound of the range.

ee.Filter.serialize

Returns the serialized representation of this object.
UsageReturns
Filter.serialize(legacy)String
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
legacyBoolean, optionalEnables legacy format.

ee.Filter.stringContains

Creates a unary or binary filter that passes if the left operand, a string, contains the right operand, also a string.
UsageReturns
ee.Filter.stringContains(leftField, rightValue, rightField, leftValue)Filter
ArgumentTypeDetails
leftFieldString, default: nullA selector for the left operand. Should not be specified if leftValue is specified.
rightValueObject, default: nullThe value of the right operand. Should not be specified if rightField is specified.
rightFieldString, default: nullA selector for the right operand. Should not be specified if rightValue is specified.
leftValueObject, default: nullThe value of the left operand. Should not be specified if leftField is specified.

ee.Filter.stringEndsWith

Creates a unary or binary filter that passes if the left operand, a string, ends with the right operand, also a string.
UsageReturns
ee.Filter.stringEndsWith(leftField, rightValue, rightField, leftValue)Filter
ArgumentTypeDetails
leftFieldString, default: nullA selector for the left operand. Should not be specified if leftValue is specified.
rightValueObject, default: nullThe value of the right operand. Should not be specified if rightField is specified.
rightFieldString, default: nullA selector for the right operand. Should not be specified if rightValue is specified.
leftValueObject, default: nullThe value of the left operand. Should not be specified if leftField is specified.

ee.Filter.stringStartsWith

Creates a unary or binary filter that passes if the left operand, a string, starts with the right operand, also a string.
UsageReturns
ee.Filter.stringStartsWith(leftField, rightValue, rightField, leftValue)Filter
ArgumentTypeDetails
leftFieldString, default: nullA selector for the left operand. Should not be specified if leftValue is specified.
rightValueObject, default: nullThe value of the right operand. Should not be specified if rightField is specified.
rightFieldString, default: nullA selector for the right operand. Should not be specified if rightValue is specified.
leftValueObject, default: nullThe value of the left operand. Should not be specified if leftField is specified.

ee.Filter.withinDistance

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.
UsageReturns
ee.Filter.withinDistance(distance, leftField, rightValue, rightField, leftValue, maxError)Filter
ArgumentTypeDetails
distanceFloatThe maximum distance for which the filter will return true.
leftFieldString, default: nullA selector for the left operand. Should not be specified if leftValue is specified.
rightValueObject, default: nullThe value of the right operand. Should not be specified if rightField is specified.
rightFieldString, default: nullA selector for the right operand. Should not be specified if rightValue is specified.
leftValueObject, default: nullThe value of the left operand. Should not be specified if leftField is specified.
maxErrorErrorMargin, optionalThe maximum reprojection error allowed during filter application.

ee.Geometry

Creates a geometry.
UsageReturns
ee.Geometry(geoJson, proj, geodesic, evenOdd)Geometry
ArgumentTypeDetails
geoJsonObjectThe GeoJSON object describing the geometry or a ComputedObject to be reinterpreted as a Geometry. Supports CRS specifications as per the GeoJSON spec, but only allows named (rather than "linked" CRSs). If this includes a 'geodesic' field, and opt_geodesic is not specified, it will be used as opt_geodesic.
projProjection, optionalAn optional projection specification, either as a CRS ID code or as a WKT string. If specified, overrides any CRS found in the geoJson parameter. If unspecified and the geoJson does not declare a CRS, defaults to "EPSG:4326" (x=longitude, y=latitude).
geodesicBoolean, optionalWhether line segments should be interpreted as spherical geodesics. If false, indicates that line segments should be interpreted as planar lines in the specified CRS. If absent, defaults to true if the CRS is geographic (including the default EPSG:4326), or to false if the CRS is projected.
evenOddBoolean, optionalIf 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. If unspecified, defaults to true.

ee.Geometry.BBox

Constructs a rectangle whose edges are lines of latitude and longitude. The result is a planar WGS84 rectangle. If (east - west) ≥ 360 then the longitude range will be normalized to -180 to   +180; otherwise they will be treated as designating points on a circle (e.g. east may be numerically less than west).
UsageReturns
ee.Geometry.BBox(west, south, east, north)Geometry.BBox
ArgumentTypeDetails
westNumberThe westernmost enclosed longitude. Will be adjusted to lie in the range -180° to 180°.
southNumberThe southernmost enclosed latitude. If less than -90° (south pole), will be treated as -90°.
eastNumberThe easternmost enclosed longitude.
northNumberThe northernmost enclosed longitude. If greater than   +90° (north pole), will be treated as +90°.

ee.Geometry.BBox.area

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 components (intersecting areas are counted multiple times).
UsageReturns
BBox.area(maxError, proj)Float
ArgumentTypeDetails
this: geometryGeometryThe geometry input.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in square meters.

ee.Geometry.BBox.aside

Calls a function passing this object as the first argument, and returning itself. Convenient e.g. when debugging: var c = ee.ImageCollection('foo').aside(print) .filterDate('2001-01-01', '2002-01-01').aside(print, 'In 2001') .filterBounds(geom).aside(print, 'In region') .aside(Map.addLayer, {min: 0, max: 142}, 'Filtered') .select('a', 'b'); Returns the same object, for chaining.
UsageReturns
BBox.aside(func, var_args)ComputedObject
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
funcFunctionThe function to call.
var_argsVarArgsAny extra arguments to pass to the function.

ee.Geometry.BBox.bounds

Returns the bounding rectangle of the geometry.
UsageReturns
BBox.bounds(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryReturn the bounding box of this geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in this projection. Otherwise it will be in WGS84.

ee.Geometry.BBox.buffer

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.
UsageReturns
BBox.buffer(distance, maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryThe geometry being buffered.
distanceFloatThe 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.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when approximating the buffering circle and performing any necessary reprojection. If unspecified, defaults to 1% of the distance.
projProjection, default: nullIf 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.

ee.Geometry.BBox.centroid

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.
UsageReturns
BBox.centroid(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryCalculates the centroid of this geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in this projection. Otherwise it will be in WGS84.

ee.Geometry.BBox.containedIn

Returns true iff one geometry is contained in the other.
UsageReturns
BBox.containedIn(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.BBox.contains

Returns true iff one geometry contains the other.
UsageReturns
BBox.contains(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.BBox.convexHull

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.
UsageReturns
BBox.convexHull(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryCalculates the convex hull of this geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.BBox.coordinates

Returns a GeoJSON-style list of the geometry's coordinates.
UsageReturns
BBox.coordinates()List
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.BBox.coveringGrid

Returns a collection of features that cover this geometry, where each feature is a rectangle in the grid defined by the given projection.
UsageReturns
BBox.coveringGrid(proj, scale)FeatureCollection
ArgumentTypeDetails
this: geometryGeometryThe result is the grid cells that intersect with this region.
projProjectionThe 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.
scaleFloat, default: nullOverrides the scale of the projection, if provided. May be required if the projection isn't already scaled.

ee.Geometry.BBox.cutLines

Converts LineString, MultiLineString, and LinearRing geometries into a MultiLineString by cutting them into parts no longer than the given distance along their length. All other geometry types will be converted to an empty MultiLineString.
UsageReturns
BBox.cutLines(distances, maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryCuts the lines of this geometry.
distancesListDistances along each LineString to cut the line into separate pieces, measured in units of the given proj, or meters if proj is unspecified.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullProjection of the result and distance measurements, or WGS84 if unspecified.

ee.Geometry.BBox.difference

Returns the result of subtracting the 'right' geometry from the 'left' geometry.
UsageReturns
BBox.difference(right, maxError, proj)Geometry
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.BBox.disjoint

Returns true iff the geometries are disjoint.
UsageReturns
BBox.disjoint(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.BBox.dissolve

Returns the union of the geometry. This leaves single geometries untouched, and unions multi geometries.
UsageReturns
BBox.dissolve(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryThe geometry to union.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the union will be performed in this projection. Otherwise it will be performed in a spherical coordinate system.

ee.Geometry.BBox.distance

Returns the minimum distance between two geometries.
UsageReturns
BBox.distance(right, maxError, proj)Float
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.BBox.edgesAreGeodesics

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.
UsageReturns
BBox.edgesAreGeodesics()Boolean
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.BBox.evaluate

Asynchronously retrieves the value of this object from the server and passes it to the provided callback function.
UsageReturns
BBox.evaluate(callback)
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
callbackFunctionA function of the form function(success, failure), called when the server returns an answer. If the request succeeded, the success argument contains the evaluated result. If the request failed, the failure argument will contains an error message.

ee.Geometry.BBox.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.
UsageReturns
BBox.geodesic()Boolean
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.BBox.geometries

Returns the list of geometries in a GeometryCollection, or a singleton list of the geometry for single geometries.
UsageReturns
BBox.geometries()List
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.BBox.getInfo

Retrieves the value of this object from the server. If no callback function is provided, the request is made synchronously. If a callback is provided, the request is made asynchronously. The asynchronous mode is preferred because the synchronous mode stops all other code (for example, the EE Code Editor UI) while waiting for the server. To make an asynchronous request, evaluate() is preferred over getInfo(). Returns the computed value of this object.
UsageReturns
BBox.getInfo(callback)Object
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
callbackFunction, optionalAn optional callback. If not supplied, the call is made synchronously.

ee.Geometry.BBox.intersection

Returns the intersection of the two geometries.
UsageReturns
BBox.intersection(right, maxError, proj)Geometry
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.BBox.intersects

Returns true iff the geometries intersect.
UsageReturns
BBox.intersects(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.BBox.isUnbounded

Returns whether the geometry is unbounded.
UsageReturns
BBox.isUnbounded()Boolean
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.BBox.length

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.
UsageReturns
BBox.length(maxError, proj)Float
ArgumentTypeDetails
this: geometryGeometryThe input geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in meters.

ee.Geometry.BBox.perimeter

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.
UsageReturns
BBox.perimeter(maxError, proj)Float
ArgumentTypeDetails
this: geometryGeometryThe input geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in meters.

ee.Geometry.BBox.projection

Returns the projection of the geometry.
UsageReturns
BBox.projection()Projection
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.BBox.serialize

Returns the serialized representation of this object.
UsageReturns
BBox.serialize(legacy)String
ArgumentTypeDetails
this: geometryGeometryThe Geometry instance.
legacyBoolean, optionalEnables legacy format.

ee.Geometry.BBox.simplify

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.
UsageReturns
BBox.simplify(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryThe geometry to simplify.
maxErrorErrorMarginThe maximum amount of error by which the result may differ from the input.
projProjection, default: nullIf 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

ee.Geometry.BBox.symmetricDifference

Returns the symmetric difference between two geometries.
UsageReturns
BBox.symmetricDifference(right, maxError, proj)Geometry
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.BBox.toGeoJSON

Returns a GeoJSON representation of the geometry.
UsageReturns
BBox.toGeoJSON()GeoJSONGeometry
ArgumentTypeDetails
this: geometryGeometryThe Geometry instance.

ee.Geometry.BBox.toGeoJSONString

Returns a GeoJSON string representation of the geometry.
UsageReturns
BBox.toGeoJSONString()String
ArgumentTypeDetails
this: geometryGeometryThe Geometry instance.

ee.Geometry.BBox.transform

Transforms the geometry to a specific projection.
UsageReturns
BBox.transform(proj, maxError)Geometry
ArgumentTypeDetails
this: geometryGeometryThe geometry to reproject.
projProjection, optionalThe 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.
maxErrorErrorMargin, default: nullThe maximum projection error.

ee.Geometry.BBox.type

Returns the GeoJSON type of the geometry.
UsageReturns
BBox.type()String
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.BBox.union

Returns the union of the two geometries.
UsageReturns
BBox.union(right, maxError, proj)Geometry
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.BBox.withinDistance

Returns true iff the geometries are within a specified distance.
UsageReturns
BBox.withinDistance(right, distance, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
distanceFloatThe distance threshold. If a projection is specified, the distance is in units of that projected coordinate system, otherwise it is in meters.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.LineString

Constructs an ee.Geometry describing a LineString. For convenience, varargs may be used when all arguments are numbers. This allows creating geodesic EPSG:4326 LineStrings given an even number of arguments, e.g. ee.Geometry.LineString(aLng, aLat, bLng, bLat, ...).
UsageReturns
ee.Geometry.LineString(coords, proj, geodesic, maxError)Geometry.LineString
ArgumentTypeDetails
coordsListA list of at least two points. May be a list of coordinates in the GeoJSON 'LineString' format, a list of at least two ee.Geometry objects describing a point, or a list of at least four numbers defining the [x,y] coordinates of at least two points.
projProjection, optionalThe projection of this geometry. If unspecified, the default is the projection of the input ee.Geometry, or EPSG:4326 if there are no ee.Geometry inputs.
geodesicBoolean, optionalIf 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.
maxErrorErrorMargin, optionalMax error when input geometry must be reprojected to an explicitly requested result projection or geodesic state.

ee.Geometry.LineString.area

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 components (intersecting areas are counted multiple times).
UsageReturns
LineString.area(maxError, proj)Float
ArgumentTypeDetails
this: geometryGeometryThe geometry input.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in square meters.

ee.Geometry.LineString.aside

Calls a function passing this object as the first argument, and returning itself. Convenient e.g. when debugging: var c = ee.ImageCollection('foo').aside(print) .filterDate('2001-01-01', '2002-01-01').aside(print, 'In 2001') .filterBounds(geom).aside(print, 'In region') .aside(Map.addLayer, {min: 0, max: 142}, 'Filtered') .select('a', 'b'); Returns the same object, for chaining.
UsageReturns
LineString.aside(func, var_args)ComputedObject
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
funcFunctionThe function to call.
var_argsVarArgsAny extra arguments to pass to the function.

ee.Geometry.LineString.bounds

Returns the bounding rectangle of the geometry.
UsageReturns
LineString.bounds(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryReturn the bounding box of this geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in this projection. Otherwise it will be in WGS84.

ee.Geometry.LineString.buffer

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.
UsageReturns
LineString.buffer(distance, maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryThe geometry being buffered.
distanceFloatThe 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.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when approximating the buffering circle and performing any necessary reprojection. If unspecified, defaults to 1% of the distance.
projProjection, default: nullIf 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.

ee.Geometry.LineString.centroid

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.
UsageReturns
LineString.centroid(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryCalculates the centroid of this geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in this projection. Otherwise it will be in WGS84.

ee.Geometry.LineString.containedIn

Returns true iff one geometry is contained in the other.
UsageReturns
LineString.containedIn(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.LineString.contains

Returns true iff one geometry contains the other.
UsageReturns
LineString.contains(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.LineString.convexHull

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.
UsageReturns
LineString.convexHull(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryCalculates the convex hull of this geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.LineString.coordinates

Returns a GeoJSON-style list of the geometry's coordinates.
UsageReturns
LineString.coordinates()List
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.LineString.coveringGrid

Returns a collection of features that cover this geometry, where each feature is a rectangle in the grid defined by the given projection.
UsageReturns
LineString.coveringGrid(proj, scale)FeatureCollection
ArgumentTypeDetails
this: geometryGeometryThe result is the grid cells that intersect with this region.
projProjectionThe 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.
scaleFloat, default: nullOverrides the scale of the projection, if provided. May be required if the projection isn't already scaled.

ee.Geometry.LineString.cutLines

Converts LineString, MultiLineString, and LinearRing geometries into a MultiLineString by cutting them into parts no longer than the given distance along their length. All other geometry types will be converted to an empty MultiLineString.
UsageReturns
LineString.cutLines(distances, maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryCuts the lines of this geometry.
distancesListDistances along each LineString to cut the line into separate pieces, measured in units of the given proj, or meters if proj is unspecified.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullProjection of the result and distance measurements, or WGS84 if unspecified.

ee.Geometry.LineString.difference

Returns the result of subtracting the 'right' geometry from the 'left' geometry.
UsageReturns
LineString.difference(right, maxError, proj)Geometry
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.LineString.disjoint

Returns true iff the geometries are disjoint.
UsageReturns
LineString.disjoint(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.LineString.dissolve

Returns the union of the geometry. This leaves single geometries untouched, and unions multi geometries.
UsageReturns
LineString.dissolve(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryThe geometry to union.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the union will be performed in this projection. Otherwise it will be performed in a spherical coordinate system.

ee.Geometry.LineString.distance

Returns the minimum distance between two geometries.
UsageReturns
LineString.distance(right, maxError, proj)Float
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.LineString.edgesAreGeodesics

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.
UsageReturns
LineString.edgesAreGeodesics()Boolean
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.LineString.evaluate

Asynchronously retrieves the value of this object from the server and passes it to the provided callback function.
UsageReturns
LineString.evaluate(callback)
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
callbackFunctionA function of the form function(success, failure), called when the server returns an answer. If the request succeeded, the success argument contains the evaluated result. If the request failed, the failure argument will contains an error message.

ee.Geometry.LineString.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.
UsageReturns
LineString.geodesic()Boolean
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.LineString.geometries

Returns the list of geometries in a GeometryCollection, or a singleton list of the geometry for single geometries.
UsageReturns
LineString.geometries()List
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.LineString.getInfo

Retrieves the value of this object from the server. If no callback function is provided, the request is made synchronously. If a callback is provided, the request is made asynchronously. The asynchronous mode is preferred because the synchronous mode stops all other code (for example, the EE Code Editor UI) while waiting for the server. To make an asynchronous request, evaluate() is preferred over getInfo(). Returns the computed value of this object.
UsageReturns
LineString.getInfo(callback)Object
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
callbackFunction, optionalAn optional callback. If not supplied, the call is made synchronously.

ee.Geometry.LineString.intersection

Returns the intersection of the two geometries.
UsageReturns
LineString.intersection(right, maxError, proj)Geometry
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.LineString.intersects

Returns true iff the geometries intersect.
UsageReturns
LineString.intersects(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.LineString.isUnbounded

Returns whether the geometry is unbounded.
UsageReturns
LineString.isUnbounded()Boolean
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.LineString.length

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.
UsageReturns
LineString.length(maxError, proj)Float
ArgumentTypeDetails
this: geometryGeometryThe input geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in meters.

ee.Geometry.LineString.perimeter

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.
UsageReturns
LineString.perimeter(maxError, proj)Float
ArgumentTypeDetails
this: geometryGeometryThe input geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in meters.

ee.Geometry.LineString.projection

Returns the projection of the geometry.
UsageReturns
LineString.projection()Projection
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.LineString.serialize

Returns the serialized representation of this object.
UsageReturns
LineString.serialize(legacy)String
ArgumentTypeDetails
this: geometryGeometryThe Geometry instance.
legacyBoolean, optionalEnables legacy format.

ee.Geometry.LineString.simplify

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.
UsageReturns
LineString.simplify(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryThe geometry to simplify.
maxErrorErrorMarginThe maximum amount of error by which the result may differ from the input.
projProjection, default: nullIf 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

ee.Geometry.LineString.symmetricDifference

Returns the symmetric difference between two geometries.
UsageReturns
LineString.symmetricDifference(right, maxError, proj)Geometry
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.LineString.toGeoJSON

Returns a GeoJSON representation of the geometry.
UsageReturns
LineString.toGeoJSON()GeoJSONGeometry
ArgumentTypeDetails
this: geometryGeometryThe Geometry instance.

ee.Geometry.LineString.toGeoJSONString

Returns a GeoJSON string representation of the geometry.
UsageReturns
LineString.toGeoJSONString()String
ArgumentTypeDetails
this: geometryGeometryThe Geometry instance.

ee.Geometry.LineString.transform

Transforms the geometry to a specific projection.
UsageReturns
LineString.transform(proj, maxError)Geometry
ArgumentTypeDetails
this: geometryGeometryThe geometry to reproject.
projProjection, optionalThe 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.
maxErrorErrorMargin, default: nullThe maximum projection error.

ee.Geometry.LineString.type

Returns the GeoJSON type of the geometry.
UsageReturns
LineString.type()String
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.LineString.union

Returns the union of the two geometries.
UsageReturns
LineString.union(right, maxError, proj)Geometry
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.LineString.withinDistance

Returns true iff the geometries are within a specified distance.
UsageReturns
LineString.withinDistance(right, distance, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
distanceFloatThe distance threshold. If a projection is specified, the distance is in units of that projected coordinate system, otherwise it is in meters.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.LinearRing

Constructs an ee.Geometry describing a LinearRing. If the last point is not equal to the first, a duplicate of the first point will be added at the end. For convenience, varargs may be used when all arguments are numbers. This allows creating geodesic EPSG:4326 LinearRings given an even number of arguments, e.g. ee.Geometry.LinearRing(aLng, aLat, bLng, bLat, ..., aLng, aLat).
UsageReturns
ee.Geometry.LinearRing(coords, proj, geodesic, maxError)Geometry.LinearRing
ArgumentTypeDetails
coordsListA list of points in the ring. May be a list of coordinates in the GeoJSON 'LinearRing' format, a list of at least three ee.Geometry objects describing a point, or a list of at least six numbers defining the [x,y] coordinates of at least three points.
projProjection, optionalThe projection of this geometry. If unspecified, the default is the projection of the input ee.Geometry, or EPSG:4326 if there are no ee.Geometry inputs.
geodesicBoolean, optionalIf 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.
maxErrorErrorMargin, optionalMax error when input geometry must be reprojected to an explicitly requested result projection or geodesic state.

ee.Geometry.LinearRing.area

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 components (intersecting areas are counted multiple times).
UsageReturns
LinearRing.area(maxError, proj)Float
ArgumentTypeDetails
this: geometryGeometryThe geometry input.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in square meters.

ee.Geometry.LinearRing.aside

Calls a function passing this object as the first argument, and returning itself. Convenient e.g. when debugging: var c = ee.ImageCollection('foo').aside(print) .filterDate('2001-01-01', '2002-01-01').aside(print, 'In 2001') .filterBounds(geom).aside(print, 'In region') .aside(Map.addLayer, {min: 0, max: 142}, 'Filtered') .select('a', 'b'); Returns the same object, for chaining.
UsageReturns
LinearRing.aside(func, var_args)ComputedObject
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
funcFunctionThe function to call.
var_argsVarArgsAny extra arguments to pass to the function.

ee.Geometry.LinearRing.bounds

Returns the bounding rectangle of the geometry.
UsageReturns
LinearRing.bounds(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryReturn the bounding box of this geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in this projection. Otherwise it will be in WGS84.

ee.Geometry.LinearRing.buffer

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.
UsageReturns
LinearRing.buffer(distance, maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryThe geometry being buffered.
distanceFloatThe 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.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when approximating the buffering circle and performing any necessary reprojection. If unspecified, defaults to 1% of the distance.
projProjection, default: nullIf 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.

ee.Geometry.LinearRing.centroid

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.
UsageReturns
LinearRing.centroid(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryCalculates the centroid of this geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in this projection. Otherwise it will be in WGS84.

ee.Geometry.LinearRing.containedIn

Returns true iff one geometry is contained in the other.
UsageReturns
LinearRing.containedIn(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.LinearRing.contains

Returns true iff one geometry contains the other.
UsageReturns
LinearRing.contains(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.LinearRing.convexHull

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.
UsageReturns
LinearRing.convexHull(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryCalculates the convex hull of this geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.LinearRing.coordinates

Returns a GeoJSON-style list of the geometry's coordinates.
UsageReturns
LinearRing.coordinates()List
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.LinearRing.coveringGrid

Returns a collection of features that cover this geometry, where each feature is a rectangle in the grid defined by the given projection.
UsageReturns
LinearRing.coveringGrid(proj, scale)FeatureCollection
ArgumentTypeDetails
this: geometryGeometryThe result is the grid cells that intersect with this region.
projProjectionThe 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.
scaleFloat, default: nullOverrides the scale of the projection, if provided. May be required if the projection isn't already scaled.

ee.Geometry.LinearRing.cutLines

Converts LineString, MultiLineString, and LinearRing geometries into a MultiLineString by cutting them into parts no longer than the given distance along their length. All other geometry types will be converted to an empty MultiLineString.
UsageReturns
LinearRing.cutLines(distances, maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryCuts the lines of this geometry.
distancesListDistances along each LineString to cut the line into separate pieces, measured in units of the given proj, or meters if proj is unspecified.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullProjection of the result and distance measurements, or WGS84 if unspecified.

ee.Geometry.LinearRing.difference

Returns the result of subtracting the 'right' geometry from the 'left' geometry.
UsageReturns
LinearRing.difference(right, maxError, proj)Geometry
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.LinearRing.disjoint

Returns true iff the geometries are disjoint.
UsageReturns
LinearRing.disjoint(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.LinearRing.dissolve

Returns the union of the geometry. This leaves single geometries untouched, and unions multi geometries.
UsageReturns
LinearRing.dissolve(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryThe geometry to union.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the union will be performed in this projection. Otherwise it will be performed in a spherical coordinate system.

ee.Geometry.LinearRing.distance

Returns the minimum distance between two geometries.
UsageReturns
LinearRing.distance(right, maxError, proj)Float
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.LinearRing.edgesAreGeodesics

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.
UsageReturns
LinearRing.edgesAreGeodesics()Boolean
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.LinearRing.evaluate

Asynchronously retrieves the value of this object from the server and passes it to the provided callback function.
UsageReturns
LinearRing.evaluate(callback)
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
callbackFunctionA function of the form function(success, failure), called when the server returns an answer. If the request succeeded, the success argument contains the evaluated result. If the request failed, the failure argument will contains an error message.

ee.Geometry.LinearRing.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.
UsageReturns
LinearRing.geodesic()Boolean
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.LinearRing.geometries

Returns the list of geometries in a GeometryCollection, or a singleton list of the geometry for single geometries.
UsageReturns
LinearRing.geometries()List
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.LinearRing.getInfo

Retrieves the value of this object from the server. If no callback function is provided, the request is made synchronously. If a callback is provided, the request is made asynchronously. The asynchronous mode is preferred because the synchronous mode stops all other code (for example, the EE Code Editor UI) while waiting for the server. To make an asynchronous request, evaluate() is preferred over getInfo(). Returns the computed value of this object.
UsageReturns
LinearRing.getInfo(callback)Object
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
callbackFunction, optionalAn optional callback. If not supplied, the call is made synchronously.

ee.Geometry.LinearRing.intersection

Returns the intersection of the two geometries.
UsageReturns
LinearRing.intersection(right, maxError, proj)Geometry
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.LinearRing.intersects

Returns true iff the geometries intersect.
UsageReturns
LinearRing.intersects(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.LinearRing.isUnbounded

Returns whether the geometry is unbounded.
UsageReturns
LinearRing.isUnbounded()Boolean
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.LinearRing.length

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.
UsageReturns
LinearRing.length(maxError, proj)Float
ArgumentTypeDetails
this: geometryGeometryThe input geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in meters.

ee.Geometry.LinearRing.perimeter

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.
UsageReturns
LinearRing.perimeter(maxError, proj)Float
ArgumentTypeDetails
this: geometryGeometryThe input geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in meters.

ee.Geometry.LinearRing.projection

Returns the projection of the geometry.
UsageReturns
LinearRing.projection()Projection
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.LinearRing.serialize

Returns the serialized representation of this object.
UsageReturns
LinearRing.serialize(legacy)String
ArgumentTypeDetails
this: geometryGeometryThe Geometry instance.
legacyBoolean, optionalEnables legacy format.

ee.Geometry.LinearRing.simplify

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.
UsageReturns
LinearRing.simplify(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryThe geometry to simplify.
maxErrorErrorMarginThe maximum amount of error by which the result may differ from the input.
projProjection, default: nullIf 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

ee.Geometry.LinearRing.symmetricDifference

Returns the symmetric difference between two geometries.
UsageReturns
LinearRing.symmetricDifference(right, maxError, proj)Geometry
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.LinearRing.toGeoJSON

Returns a GeoJSON representation of the geometry.
UsageReturns
LinearRing.toGeoJSON()GeoJSONGeometry
ArgumentTypeDetails
this: geometryGeometryThe Geometry instance.

ee.Geometry.LinearRing.toGeoJSONString

Returns a GeoJSON string representation of the geometry.
UsageReturns
LinearRing.toGeoJSONString()String
ArgumentTypeDetails
this: geometryGeometryThe Geometry instance.

ee.Geometry.LinearRing.transform

Transforms the geometry to a specific projection.
UsageReturns
LinearRing.transform(proj, maxError)Geometry
ArgumentTypeDetails
this: geometryGeometryThe geometry to reproject.
projProjection, optionalThe 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.
maxErrorErrorMargin, default: nullThe maximum projection error.

ee.Geometry.LinearRing.type

Returns the GeoJSON type of the geometry.
UsageReturns
LinearRing.type()String
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.LinearRing.union

Returns the union of the two geometries.
UsageReturns
LinearRing.union(right, maxError, proj)Geometry
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.LinearRing.withinDistance

Returns true iff the geometries are within a specified distance.
UsageReturns
LinearRing.withinDistance(right, distance, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
distanceFloatThe distance threshold. If a projection is specified, the distance is in units of that projected coordinate system, otherwise it is in meters.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.MultiLineString

Constructs an ee.Geometry describing a MultiLineString. For convenience, varargs may be used when all arguments are numbers. This allows creating geodesic EPSG:4326 MultiLineStrings with a single LineString, given an even number of arguments, e.g. ee.Geometry.MultiLineString(aLng, aLat, bLng, bLat, ...).
UsageReturns
ee.Geometry.MultiLineString(coords, proj, geodesic, maxError)Geometry.MultiLineString
ArgumentTypeDetails
coordsListA list of linestrings. May be a list of coordinates in the GeoJSON 'MultiLineString' format, a list of at least two ee.Geometry objects describing a LineString, or a list of numbers defining a single linestring.
projProjection, optionalThe projection of this geometry. If unspecified, the default is the projection of the input ee.Geometry, or EPSG:4326 if there are no ee.Geometry inputs.
geodesicBoolean, optionalIf 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.
maxErrorErrorMargin, optionalMax error when input geometry must be reprojected to an explicitly requested result projection or geodesic state.

ee.Geometry.MultiLineString.area

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 components (intersecting areas are counted multiple times).
UsageReturns
MultiLineString.area(maxError, proj)Float
ArgumentTypeDetails
this: geometryGeometryThe geometry input.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in square meters.

ee.Geometry.MultiLineString.aside

Calls a function passing this object as the first argument, and returning itself. Convenient e.g. when debugging: var c = ee.ImageCollection('foo').aside(print) .filterDate('2001-01-01', '2002-01-01').aside(print, 'In 2001') .filterBounds(geom).aside(print, 'In region') .aside(Map.addLayer, {min: 0, max: 142}, 'Filtered') .select('a', 'b'); Returns the same object, for chaining.
UsageReturns
MultiLineString.aside(func, var_args)ComputedObject
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
funcFunctionThe function to call.
var_argsVarArgsAny extra arguments to pass to the function.

ee.Geometry.MultiLineString.bounds

Returns the bounding rectangle of the geometry.
UsageReturns
MultiLineString.bounds(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryReturn the bounding box of this geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in this projection. Otherwise it will be in WGS84.

ee.Geometry.MultiLineString.buffer

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.
UsageReturns
MultiLineString.buffer(distance, maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryThe geometry being buffered.
distanceFloatThe 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.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when approximating the buffering circle and performing any necessary reprojection. If unspecified, defaults to 1% of the distance.
projProjection, default: nullIf 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.

ee.Geometry.MultiLineString.centroid

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.
UsageReturns
MultiLineString.centroid(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryCalculates the centroid of this geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in this projection. Otherwise it will be in WGS84.

ee.Geometry.MultiLineString.containedIn

Returns true iff one geometry is contained in the other.
UsageReturns
MultiLineString.containedIn(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.MultiLineString.contains

Returns true iff one geometry contains the other.
UsageReturns
MultiLineString.contains(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.MultiLineString.convexHull

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.
UsageReturns
MultiLineString.convexHull(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryCalculates the convex hull of this geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.MultiLineString.coordinates

Returns a GeoJSON-style list of the geometry's coordinates.
UsageReturns
MultiLineString.coordinates()List
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.MultiLineString.coveringGrid

Returns a collection of features that cover this geometry, where each feature is a rectangle in the grid defined by the given projection.
UsageReturns
MultiLineString.coveringGrid(proj, scale)FeatureCollection
ArgumentTypeDetails
this: geometryGeometryThe result is the grid cells that intersect with this region.
projProjectionThe 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.
scaleFloat, default: nullOverrides the scale of the projection, if provided. May be required if the projection isn't already scaled.

ee.Geometry.MultiLineString.cutLines

Converts LineString, MultiLineString, and LinearRing geometries into a MultiLineString by cutting them into parts no longer than the given distance along their length. All other geometry types will be converted to an empty MultiLineString.
UsageReturns
MultiLineString.cutLines(distances, maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryCuts the lines of this geometry.
distancesListDistances along each LineString to cut the line into separate pieces, measured in units of the given proj, or meters if proj is unspecified.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullProjection of the result and distance measurements, or WGS84 if unspecified.

ee.Geometry.MultiLineString.difference

Returns the result of subtracting the 'right' geometry from the 'left' geometry.
UsageReturns
MultiLineString.difference(right, maxError, proj)Geometry
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.MultiLineString.disjoint

Returns true iff the geometries are disjoint.
UsageReturns
MultiLineString.disjoint(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.MultiLineString.dissolve

Returns the union of the geometry. This leaves single geometries untouched, and unions multi geometries.
UsageReturns
MultiLineString.dissolve(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryThe geometry to union.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the union will be performed in this projection. Otherwise it will be performed in a spherical coordinate system.

ee.Geometry.MultiLineString.distance

Returns the minimum distance between two geometries.
UsageReturns
MultiLineString.distance(right, maxError, proj)Float
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.MultiLineString.edgesAreGeodesics

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.
UsageReturns
MultiLineString.edgesAreGeodesics()Boolean
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.MultiLineString.evaluate

Asynchronously retrieves the value of this object from the server and passes it to the provided callback function.
UsageReturns
MultiLineString.evaluate(callback)
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
callbackFunctionA function of the form function(success, failure), called when the server returns an answer. If the request succeeded, the success argument contains the evaluated result. If the request failed, the failure argument will contains an error message.

ee.Geometry.MultiLineString.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.
UsageReturns
MultiLineString.geodesic()Boolean
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.MultiLineString.geometries

Returns the list of geometries in a GeometryCollection, or a singleton list of the geometry for single geometries.
UsageReturns
MultiLineString.geometries()List
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.MultiLineString.getInfo

Retrieves the value of this object from the server. If no callback function is provided, the request is made synchronously. If a callback is provided, the request is made asynchronously. The asynchronous mode is preferred because the synchronous mode stops all other code (for example, the EE Code Editor UI) while waiting for the server. To make an asynchronous request, evaluate() is preferred over getInfo(). Returns the computed value of this object.
UsageReturns
MultiLineString.getInfo(callback)Object
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
callbackFunction, optionalAn optional callback. If not supplied, the call is made synchronously.

ee.Geometry.MultiLineString.intersection

Returns the intersection of the two geometries.
UsageReturns
MultiLineString.intersection(right, maxError, proj)Geometry
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.MultiLineString.intersects

Returns true iff the geometries intersect.
UsageReturns
MultiLineString.intersects(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.MultiLineString.isUnbounded

Returns whether the geometry is unbounded.
UsageReturns
MultiLineString.isUnbounded()Boolean
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.MultiLineString.length

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.
UsageReturns
MultiLineString.length(maxError, proj)Float
ArgumentTypeDetails
this: geometryGeometryThe input geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in meters.

ee.Geometry.MultiLineString.perimeter

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.
UsageReturns
MultiLineString.perimeter(maxError, proj)Float
ArgumentTypeDetails
this: geometryGeometryThe input geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in meters.

ee.Geometry.MultiLineString.projection

Returns the projection of the geometry.
UsageReturns
MultiLineString.projection()Projection
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.MultiLineString.serialize

Returns the serialized representation of this object.
UsageReturns
MultiLineString.serialize(legacy)String
ArgumentTypeDetails
this: geometryGeometryThe Geometry instance.
legacyBoolean, optionalEnables legacy format.

ee.Geometry.MultiLineString.simplify

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.
UsageReturns
MultiLineString.simplify(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryThe geometry to simplify.
maxErrorErrorMarginThe maximum amount of error by which the result may differ from the input.
projProjection, default: nullIf 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

ee.Geometry.MultiLineString.symmetricDifference

Returns the symmetric difference between two geometries.
UsageReturns
MultiLineString.symmetricDifference(right, maxError, proj)Geometry
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.MultiLineString.toGeoJSON

Returns a GeoJSON representation of the geometry.
UsageReturns
MultiLineString.toGeoJSON()GeoJSONGeometry
ArgumentTypeDetails
this: geometryGeometryThe Geometry instance.

ee.Geometry.MultiLineString.toGeoJSONString

Returns a GeoJSON string representation of the geometry.
UsageReturns
MultiLineString.toGeoJSONString()String
ArgumentTypeDetails
this: geometryGeometryThe Geometry instance.

ee.Geometry.MultiLineString.transform

Transforms the geometry to a specific projection.
UsageReturns
MultiLineString.transform(proj, maxError)Geometry
ArgumentTypeDetails
this: geometryGeometryThe geometry to reproject.
projProjection, optionalThe 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.
maxErrorErrorMargin, default: nullThe maximum projection error.

ee.Geometry.MultiLineString.type

Returns the GeoJSON type of the geometry.
UsageReturns
MultiLineString.type()String
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.MultiLineString.union

Returns the union of the two geometries.
UsageReturns
MultiLineString.union(right, maxError, proj)Geometry
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.MultiLineString.withinDistance

Returns true iff the geometries are within a specified distance.
UsageReturns
MultiLineString.withinDistance(right, distance, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
distanceFloatThe distance threshold. If a projection is specified, the distance is in units of that projected coordinate system, otherwise it is in meters.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.MultiPoint

Constructs an ee.Geometry describing a MultiPoint. For convenience, varargs may be used when all arguments are numbers. This allows creating EPSG:4326 MultiPoints given an even number of arguments, e.g. ee.Geometry.MultiPoint(aLng, aLat, bLng, bLat, ...).
UsageReturns
ee.Geometry.MultiPoint(coords, proj)Geometry.MultiPoint
ArgumentTypeDetails
coordsListA list of points, each in the GeoJSON 'coordinates' format of a Point, or a list of the x,y coordinates in the given projection, or an ee.Geometry describing a point.
projProjection, optionalThe projection of this geometry. If unspecified, the default is the projection of the input ee.Geometry, or EPSG:4326 if there are no ee.Geometry inputs.

ee.Geometry.MultiPoint.area

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 components (intersecting areas are counted multiple times).
UsageReturns
MultiPoint.area(maxError, proj)Float
ArgumentTypeDetails
this: geometryGeometryThe geometry input.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in square meters.

ee.Geometry.MultiPoint.aside

Calls a function passing this object as the first argument, and returning itself. Convenient e.g. when debugging: var c = ee.ImageCollection('foo').aside(print) .filterDate('2001-01-01', '2002-01-01').aside(print, 'In 2001') .filterBounds(geom).aside(print, 'In region') .aside(Map.addLayer, {min: 0, max: 142}, 'Filtered') .select('a', 'b'); Returns the same object, for chaining.
UsageReturns
MultiPoint.aside(func, var_args)ComputedObject
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
funcFunctionThe function to call.
var_argsVarArgsAny extra arguments to pass to the function.

ee.Geometry.MultiPoint.bounds

Returns the bounding rectangle of the geometry.
UsageReturns
MultiPoint.bounds(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryReturn the bounding box of this geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in this projection. Otherwise it will be in WGS84.

ee.Geometry.MultiPoint.buffer

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.
UsageReturns
MultiPoint.buffer(distance, maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryThe geometry being buffered.
distanceFloatThe 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.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when approximating the buffering circle and performing any necessary reprojection. If unspecified, defaults to 1% of the distance.
projProjection, default: nullIf 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.

ee.Geometry.MultiPoint.centroid

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.
UsageReturns
MultiPoint.centroid(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryCalculates the centroid of this geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in this projection. Otherwise it will be in WGS84.

ee.Geometry.MultiPoint.containedIn

Returns true iff one geometry is contained in the other.
UsageReturns
MultiPoint.containedIn(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.MultiPoint.contains

Returns true iff one geometry contains the other.
UsageReturns
MultiPoint.contains(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.MultiPoint.convexHull

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.
UsageReturns
MultiPoint.convexHull(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryCalculates the convex hull of this geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.MultiPoint.coordinates

Returns a GeoJSON-style list of the geometry's coordinates.
UsageReturns
MultiPoint.coordinates()List
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.MultiPoint.coveringGrid

Returns a collection of features that cover this geometry, where each feature is a rectangle in the grid defined by the given projection.
UsageReturns
MultiPoint.coveringGrid(proj, scale)FeatureCollection
ArgumentTypeDetails
this: geometryGeometryThe result is the grid cells that intersect with this region.
projProjectionThe 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.
scaleFloat, default: nullOverrides the scale of the projection, if provided. May be required if the projection isn't already scaled.

ee.Geometry.MultiPoint.cutLines

Converts LineString, MultiLineString, and LinearRing geometries into a MultiLineString by cutting them into parts no longer than the given distance along their length. All other geometry types will be converted to an empty MultiLineString.
UsageReturns
MultiPoint.cutLines(distances, maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryCuts the lines of this geometry.
distancesListDistances along each LineString to cut the line into separate pieces, measured in units of the given proj, or meters if proj is unspecified.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullProjection of the result and distance measurements, or WGS84 if unspecified.

ee.Geometry.MultiPoint.difference

Returns the result of subtracting the 'right' geometry from the 'left' geometry.
UsageReturns
MultiPoint.difference(right, maxError, proj)Geometry
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.MultiPoint.disjoint

Returns true iff the geometries are disjoint.
UsageReturns
MultiPoint.disjoint(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.MultiPoint.dissolve

Returns the union of the geometry. This leaves single geometries untouched, and unions multi geometries.
UsageReturns
MultiPoint.dissolve(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryThe geometry to union.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the union will be performed in this projection. Otherwise it will be performed in a spherical coordinate system.

ee.Geometry.MultiPoint.distance

Returns the minimum distance between two geometries.
UsageReturns
MultiPoint.distance(right, maxError, proj)Float
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.MultiPoint.edgesAreGeodesics

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.
UsageReturns
MultiPoint.edgesAreGeodesics()Boolean
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.MultiPoint.evaluate

Asynchronously retrieves the value of this object from the server and passes it to the provided callback function.
UsageReturns
MultiPoint.evaluate(callback)
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
callbackFunctionA function of the form function(success, failure), called when the server returns an answer. If the request succeeded, the success argument contains the evaluated result. If the request failed, the failure argument will contains an error message.

ee.Geometry.MultiPoint.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.
UsageReturns
MultiPoint.geodesic()Boolean
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.MultiPoint.geometries

Returns the list of geometries in a GeometryCollection, or a singleton list of the geometry for single geometries.
UsageReturns
MultiPoint.geometries()List
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.MultiPoint.getInfo

Retrieves the value of this object from the server. If no callback function is provided, the request is made synchronously. If a callback is provided, the request is made asynchronously. The asynchronous mode is preferred because the synchronous mode stops all other code (for example, the EE Code Editor UI) while waiting for the server. To make an asynchronous request, evaluate() is preferred over getInfo(). Returns the computed value of this object.
UsageReturns
MultiPoint.getInfo(callback)Object
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
callbackFunction, optionalAn optional callback. If not supplied, the call is made synchronously.

ee.Geometry.MultiPoint.intersection

Returns the intersection of the two geometries.
UsageReturns
MultiPoint.intersection(right, maxError, proj)Geometry
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.MultiPoint.intersects

Returns true iff the geometries intersect.
UsageReturns
MultiPoint.intersects(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.MultiPoint.isUnbounded

Returns whether the geometry is unbounded.
UsageReturns
MultiPoint.isUnbounded()Boolean
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.MultiPoint.length

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.
UsageReturns
MultiPoint.length(maxError, proj)Float
ArgumentTypeDetails
this: geometryGeometryThe input geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in meters.

ee.Geometry.MultiPoint.perimeter

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.
UsageReturns
MultiPoint.perimeter(maxError, proj)Float
ArgumentTypeDetails
this: geometryGeometryThe input geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in meters.

ee.Geometry.MultiPoint.projection

Returns the projection of the geometry.
UsageReturns
MultiPoint.projection()Projection
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.MultiPoint.serialize

Returns the serialized representation of this object.
UsageReturns
MultiPoint.serialize(legacy)String
ArgumentTypeDetails
this: geometryGeometryThe Geometry instance.
legacyBoolean, optionalEnables legacy format.

ee.Geometry.MultiPoint.simplify

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.
UsageReturns
MultiPoint.simplify(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryThe geometry to simplify.
maxErrorErrorMarginThe maximum amount of error by which the result may differ from the input.
projProjection, default: nullIf 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

ee.Geometry.MultiPoint.symmetricDifference

Returns the symmetric difference between two geometries.
UsageReturns
MultiPoint.symmetricDifference(right, maxError, proj)Geometry
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.MultiPoint.toGeoJSON

Returns a GeoJSON representation of the geometry.
UsageReturns
MultiPoint.toGeoJSON()GeoJSONGeometry
ArgumentTypeDetails
this: geometryGeometryThe Geometry instance.

ee.Geometry.MultiPoint.toGeoJSONString

Returns a GeoJSON string representation of the geometry.
UsageReturns
MultiPoint.toGeoJSONString()String
ArgumentTypeDetails
this: geometryGeometryThe Geometry instance.

ee.Geometry.MultiPoint.transform

Transforms the geometry to a specific projection.
UsageReturns
MultiPoint.transform(proj, maxError)Geometry
ArgumentTypeDetails
this: geometryGeometryThe geometry to reproject.
projProjection, optionalThe 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.
maxErrorErrorMargin, default: nullThe maximum projection error.

ee.Geometry.MultiPoint.type

Returns the GeoJSON type of the geometry.
UsageReturns
MultiPoint.type()String
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.MultiPoint.union

Returns the union of the two geometries.
UsageReturns
MultiPoint.union(right, maxError, proj)Geometry
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.MultiPoint.withinDistance

Returns true iff the geometries are within a specified distance.
UsageReturns
MultiPoint.withinDistance(right, distance, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
distanceFloatThe distance threshold. If a projection is specified, the distance is in units of that projected coordinate system, otherwise it is in meters.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.MultiPolygon

Constructs an ee.Geometry describing a MultiPolygon. For convenience, varargs may be used when all arguments are numbers. This allows creating geodesic EPSG:4326 MultiPolygons with a single Polygon with a single LinearRing given an even number of arguments, e.g. ee.Geometry.MultiPolygon(aLng, aLat, bLng, bLat, ..., aLng, aLat).
UsageReturns
ee.Geometry.MultiPolygon(coords, proj, geodesic, maxError, evenOdd)Geometry.MultiPolygon
ArgumentTypeDetails
coordsListA list of polygons. May be a list of coordinates in the GeoJSON 'MultiPolygon' format, a list of ee.Geometry objects describing a Polygon, or a list of numbers defining a single polygon boundary.
projProjection, optionalThe projection of this geometry. The default is the projection of the inputs, where Numbers are assumed to be EPSG:4326.
geodesicBoolean, optionalIf 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.
maxErrorErrorMargin, optionalMax error when input geometry must be reprojected to an explicitly requested result projection or geodesic state.
evenOddBoolean, optionalIf 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. If unspecified, defaults to true.

ee.Geometry.MultiPolygon.area

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 components (intersecting areas are counted multiple times).
UsageReturns
MultiPolygon.area(maxError, proj)Float
ArgumentTypeDetails
this: geometryGeometryThe geometry input.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in square meters.

ee.Geometry.MultiPolygon.aside

Calls a function passing this object as the first argument, and returning itself. Convenient e.g. when debugging: var c = ee.ImageCollection('foo').aside(print) .filterDate('2001-01-01', '2002-01-01').aside(print, 'In 2001') .filterBounds(geom).aside(print, 'In region') .aside(Map.addLayer, {min: 0, max: 142}, 'Filtered') .select('a', 'b'); Returns the same object, for chaining.
UsageReturns
MultiPolygon.aside(func, var_args)ComputedObject
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
funcFunctionThe function to call.
var_argsVarArgsAny extra arguments to pass to the function.

ee.Geometry.MultiPolygon.bounds

Returns the bounding rectangle of the geometry.
UsageReturns
MultiPolygon.bounds(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryReturn the bounding box of this geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in this projection. Otherwise it will be in WGS84.

ee.Geometry.MultiPolygon.buffer

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.
UsageReturns
MultiPolygon.buffer(distance, maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryThe geometry being buffered.
distanceFloatThe 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.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when approximating the buffering circle and performing any necessary reprojection. If unspecified, defaults to 1% of the distance.
projProjection, default: nullIf 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.

ee.Geometry.MultiPolygon.centroid

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.
UsageReturns
MultiPolygon.centroid(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryCalculates the centroid of this geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in this projection. Otherwise it will be in WGS84.

ee.Geometry.MultiPolygon.containedIn

Returns true iff one geometry is contained in the other.
UsageReturns
MultiPolygon.containedIn(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.MultiPolygon.contains

Returns true iff one geometry contains the other.
UsageReturns
MultiPolygon.contains(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.MultiPolygon.convexHull

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.
UsageReturns
MultiPolygon.convexHull(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryCalculates the convex hull of this geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.MultiPolygon.coordinates

Returns a GeoJSON-style list of the geometry's coordinates.
UsageReturns
MultiPolygon.coordinates()List
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.MultiPolygon.coveringGrid

Returns a collection of features that cover this geometry, where each feature is a rectangle in the grid defined by the given projection.
UsageReturns
MultiPolygon.coveringGrid(proj, scale)FeatureCollection
ArgumentTypeDetails
this: geometryGeometryThe result is the grid cells that intersect with this region.
projProjectionThe 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.
scaleFloat, default: nullOverrides the scale of the projection, if provided. May be required if the projection isn't already scaled.

ee.Geometry.MultiPolygon.cutLines

Converts LineString, MultiLineString, and LinearRing geometries into a MultiLineString by cutting them into parts no longer than the given distance along their length. All other geometry types will be converted to an empty MultiLineString.
UsageReturns
MultiPolygon.cutLines(distances, maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryCuts the lines of this geometry.
distancesListDistances along each LineString to cut the line into separate pieces, measured in units of the given proj, or meters if proj is unspecified.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullProjection of the result and distance measurements, or WGS84 if unspecified.

ee.Geometry.MultiPolygon.difference

Returns the result of subtracting the 'right' geometry from the 'left' geometry.
UsageReturns
MultiPolygon.difference(right, maxError, proj)Geometry
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.MultiPolygon.disjoint

Returns true iff the geometries are disjoint.
UsageReturns
MultiPolygon.disjoint(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.MultiPolygon.dissolve

Returns the union of the geometry. This leaves single geometries untouched, and unions multi geometries.
UsageReturns
MultiPolygon.dissolve(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryThe geometry to union.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the union will be performed in this projection. Otherwise it will be performed in a spherical coordinate system.

ee.Geometry.MultiPolygon.distance

Returns the minimum distance between two geometries.
UsageReturns
MultiPolygon.distance(right, maxError, proj)Float
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.MultiPolygon.edgesAreGeodesics

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.
UsageReturns
MultiPolygon.edgesAreGeodesics()Boolean
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.MultiPolygon.evaluate

Asynchronously retrieves the value of this object from the server and passes it to the provided callback function.
UsageReturns
MultiPolygon.evaluate(callback)
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
callbackFunctionA function of the form function(success, failure), called when the server returns an answer. If the request succeeded, the success argument contains the evaluated result. If the request failed, the failure argument will contains an error message.

ee.Geometry.MultiPolygon.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.
UsageReturns
MultiPolygon.geodesic()Boolean
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.MultiPolygon.geometries

Returns the list of geometries in a GeometryCollection, or a singleton list of the geometry for single geometries.
UsageReturns
MultiPolygon.geometries()List
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.MultiPolygon.getInfo

Retrieves the value of this object from the server. If no callback function is provided, the request is made synchronously. If a callback is provided, the request is made asynchronously. The asynchronous mode is preferred because the synchronous mode stops all other code (for example, the EE Code Editor UI) while waiting for the server. To make an asynchronous request, evaluate() is preferred over getInfo(). Returns the computed value of this object.
UsageReturns
MultiPolygon.getInfo(callback)Object
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
callbackFunction, optionalAn optional callback. If not supplied, the call is made synchronously.

ee.Geometry.MultiPolygon.intersection

Returns the intersection of the two geometries.
UsageReturns
MultiPolygon.intersection(right, maxError, proj)Geometry
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.MultiPolygon.intersects

Returns true iff the geometries intersect.
UsageReturns
MultiPolygon.intersects(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.MultiPolygon.isUnbounded

Returns whether the geometry is unbounded.
UsageReturns
MultiPolygon.isUnbounded()Boolean
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.MultiPolygon.length

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.
UsageReturns
MultiPolygon.length(maxError, proj)Float
ArgumentTypeDetails
this: geometryGeometryThe input geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in meters.

ee.Geometry.MultiPolygon.perimeter

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.
UsageReturns
MultiPolygon.perimeter(maxError, proj)Float
ArgumentTypeDetails
this: geometryGeometryThe input geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in meters.

ee.Geometry.MultiPolygon.projection

Returns the projection of the geometry.
UsageReturns
MultiPolygon.projection()Projection
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.MultiPolygon.serialize

Returns the serialized representation of this object.
UsageReturns
MultiPolygon.serialize(legacy)String
ArgumentTypeDetails
this: geometryGeometryThe Geometry instance.
legacyBoolean, optionalEnables legacy format.

ee.Geometry.MultiPolygon.simplify

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.
UsageReturns
MultiPolygon.simplify(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryThe geometry to simplify.
maxErrorErrorMarginThe maximum amount of error by which the result may differ from the input.
projProjection, default: nullIf 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

ee.Geometry.MultiPolygon.symmetricDifference

Returns the symmetric difference between two geometries.
UsageReturns
MultiPolygon.symmetricDifference(right, maxError, proj)Geometry
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.MultiPolygon.toGeoJSON

Returns a GeoJSON representation of the geometry.
UsageReturns
MultiPolygon.toGeoJSON()GeoJSONGeometry
ArgumentTypeDetails
this: geometryGeometryThe Geometry instance.

ee.Geometry.MultiPolygon.toGeoJSONString

Returns a GeoJSON string representation of the geometry.
UsageReturns
MultiPolygon.toGeoJSONString()String
ArgumentTypeDetails
this: geometryGeometryThe Geometry instance.

ee.Geometry.MultiPolygon.transform

Transforms the geometry to a specific projection.
UsageReturns
MultiPolygon.transform(proj, maxError)Geometry
ArgumentTypeDetails
this: geometryGeometryThe geometry to reproject.
projProjection, optionalThe 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.
maxErrorErrorMargin, default: nullThe maximum projection error.

ee.Geometry.MultiPolygon.type

Returns the GeoJSON type of the geometry.
UsageReturns
MultiPolygon.type()String
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.MultiPolygon.union

Returns the union of the two geometries.
UsageReturns
MultiPolygon.union(right, maxError, proj)Geometry
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.MultiPolygon.withinDistance

Returns true iff the geometries are within a specified distance.
UsageReturns
MultiPolygon.withinDistance(right, distance, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
distanceFloatThe distance threshold. If a projection is specified, the distance is in units of that projected coordinate system, otherwise it is in meters.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.Point

Constructs an ee.Geometry describing a point. For convenience, varargs may be used when all arguments are numbers. This allows creating EPSG:4326 points, e.g. ee.Geometry.Point(lng, lat).
UsageReturns
ee.Geometry.Point(coords, proj)Geometry.Point
ArgumentTypeDetails
coordsListA list of two [x,y] coordinates in the given projection.
projProjection, optionalThe projection of this geometry, or EPSG:4326 if unspecified.

ee.Geometry.Point.area

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 components (intersecting areas are counted multiple times).
UsageReturns
Point.area(maxError, proj)Float
ArgumentTypeDetails
this: geometryGeometryThe geometry input.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in square meters.

ee.Geometry.Point.aside

Calls a function passing this object as the first argument, and returning itself. Convenient e.g. when debugging: var c = ee.ImageCollection('foo').aside(print) .filterDate('2001-01-01', '2002-01-01').aside(print, 'In 2001') .filterBounds(geom).aside(print, 'In region') .aside(Map.addLayer, {min: 0, max: 142}, 'Filtered') .select('a', 'b'); Returns the same object, for chaining.
UsageReturns
Point.aside(func, var_args)ComputedObject
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
funcFunctionThe function to call.
var_argsVarArgsAny extra arguments to pass to the function.

ee.Geometry.Point.bounds

Returns the bounding rectangle of the geometry.
UsageReturns
Point.bounds(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryReturn the bounding box of this geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in this projection. Otherwise it will be in WGS84.

ee.Geometry.Point.buffer

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.
UsageReturns
Point.buffer(distance, maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryThe geometry being buffered.
distanceFloatThe 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.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when approximating the buffering circle and performing any necessary reprojection. If unspecified, defaults to 1% of the distance.
projProjection, default: nullIf 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.

ee.Geometry.Point.centroid

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.
UsageReturns
Point.centroid(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryCalculates the centroid of this geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in this projection. Otherwise it will be in WGS84.

ee.Geometry.Point.containedIn

Returns true iff one geometry is contained in the other.
UsageReturns
Point.containedIn(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.Point.contains

Returns true iff one geometry contains the other.
UsageReturns
Point.contains(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.Point.convexHull

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.
UsageReturns
Point.convexHull(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryCalculates the convex hull of this geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.Point.coordinates

Returns a GeoJSON-style list of the geometry's coordinates.
UsageReturns
Point.coordinates()List
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.Point.coveringGrid

Returns a collection of features that cover this geometry, where each feature is a rectangle in the grid defined by the given projection.
UsageReturns
Point.coveringGrid(proj, scale)FeatureCollection
ArgumentTypeDetails
this: geometryGeometryThe result is the grid cells that intersect with this region.
projProjectionThe 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.
scaleFloat, default: nullOverrides the scale of the projection, if provided. May be required if the projection isn't already scaled.

ee.Geometry.Point.cutLines

Converts LineString, MultiLineString, and LinearRing geometries into a MultiLineString by cutting them into parts no longer than the given distance along their length. All other geometry types will be converted to an empty MultiLineString.
UsageReturns
Point.cutLines(distances, maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryCuts the lines of this geometry.
distancesListDistances along each LineString to cut the line into separate pieces, measured in units of the given proj, or meters if proj is unspecified.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullProjection of the result and distance measurements, or WGS84 if unspecified.

ee.Geometry.Point.difference

Returns the result of subtracting the 'right' geometry from the 'left' geometry.
UsageReturns
Point.difference(right, maxError, proj)Geometry
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.Point.disjoint

Returns true iff the geometries are disjoint.
UsageReturns
Point.disjoint(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.Point.dissolve

Returns the union of the geometry. This leaves single geometries untouched, and unions multi geometries.
UsageReturns
Point.dissolve(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryThe geometry to union.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the union will be performed in this projection. Otherwise it will be performed in a spherical coordinate system.

ee.Geometry.Point.distance

Returns the minimum distance between two geometries.
UsageReturns
Point.distance(right, maxError, proj)Float
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.Point.edgesAreGeodesics

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.
UsageReturns
Point.edgesAreGeodesics()Boolean
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.Point.evaluate

Asynchronously retrieves the value of this object from the server and passes it to the provided callback function.
UsageReturns
Point.evaluate(callback)
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
callbackFunctionA function of the form function(success, failure), called when the server returns an answer. If the request succeeded, the success argument contains the evaluated result. If the request failed, the failure argument will contains an error message.

ee.Geometry.Point.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.
UsageReturns
Point.geodesic()Boolean
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.Point.geometries

Returns the list of geometries in a GeometryCollection, or a singleton list of the geometry for single geometries.
UsageReturns
Point.geometries()List
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.Point.getInfo

Retrieves the value of this object from the server. If no callback function is provided, the request is made synchronously. If a callback is provided, the request is made asynchronously. The asynchronous mode is preferred because the synchronous mode stops all other code (for example, the EE Code Editor UI) while waiting for the server. To make an asynchronous request, evaluate() is preferred over getInfo(). Returns the computed value of this object.
UsageReturns
Point.getInfo(callback)Object
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
callbackFunction, optionalAn optional callback. If not supplied, the call is made synchronously.

ee.Geometry.Point.intersection

Returns the intersection of the two geometries.
UsageReturns
Point.intersection(right, maxError, proj)Geometry
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.Point.intersects

Returns true iff the geometries intersect.
UsageReturns
Point.intersects(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.Point.isUnbounded

Returns whether the geometry is unbounded.
UsageReturns
Point.isUnbounded()Boolean
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.Point.length

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.
UsageReturns
Point.length(maxError, proj)Float
ArgumentTypeDetails
this: geometryGeometryThe input geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in meters.

ee.Geometry.Point.perimeter

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.
UsageReturns
Point.perimeter(maxError, proj)Float
ArgumentTypeDetails
this: geometryGeometryThe input geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in meters.

ee.Geometry.Point.projection

Returns the projection of the geometry.
UsageReturns
Point.projection()Projection
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.Point.serialize

Returns the serialized representation of this object.
UsageReturns
Point.serialize(legacy)String
ArgumentTypeDetails
this: geometryGeometryThe Geometry instance.
legacyBoolean, optionalEnables legacy format.

ee.Geometry.Point.simplify

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.
UsageReturns
Point.simplify(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryThe geometry to simplify.
maxErrorErrorMarginThe maximum amount of error by which the result may differ from the input.
projProjection, default: nullIf 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

ee.Geometry.Point.symmetricDifference

Returns the symmetric difference between two geometries.
UsageReturns
Point.symmetricDifference(right, maxError, proj)Geometry
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.Point.toGeoJSON

Returns a GeoJSON representation of the geometry.
UsageReturns
Point.toGeoJSON()GeoJSONGeometry
ArgumentTypeDetails
this: geometryGeometryThe Geometry instance.

ee.Geometry.Point.toGeoJSONString

Returns a GeoJSON string representation of the geometry.
UsageReturns
Point.toGeoJSONString()String
ArgumentTypeDetails
this: geometryGeometryThe Geometry instance.

ee.Geometry.Point.transform

Transforms the geometry to a specific projection.
UsageReturns
Point.transform(proj, maxError)Geometry
ArgumentTypeDetails
this: geometryGeometryThe geometry to reproject.
projProjection, optionalThe 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.
maxErrorErrorMargin, default: nullThe maximum projection error.

ee.Geometry.Point.type

Returns the GeoJSON type of the geometry.
UsageReturns
Point.type()String
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.Point.union

Returns the union of the two geometries.
UsageReturns
Point.union(right, maxError, proj)Geometry
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.Point.withinDistance

Returns true iff the geometries are within a specified distance.
UsageReturns
Point.withinDistance(right, distance, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
distanceFloatThe distance threshold. If a projection is specified, the distance is in units of that projected coordinate system, otherwise it is in meters.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.Polygon

Constructs an ee.Geometry describing a polygon. For convenience, varargs may be used when all arguments are numbers. This allows creating geodesic EPSG:4326 Polygons with a single LinearRing given an even number of arguments, e.g. ee.Geometry.Polygon(aLng, aLat, bLng, bLat, ..., aLng, aLat).
UsageReturns
ee.Geometry.Polygon(coords, proj, geodesic, maxError, evenOdd)Geometry.Polygon
ArgumentTypeDetails
coordsListA list of rings defining the boundaries of the polygon. May be a list of coordinates in the GeoJSON 'Polygon' format, a list of ee.Geometry objects describing a LinearRing, or a list of numbers defining a single polygon boundary.
projProjection, optionalThe projection of this geometry. The default is the projection of the inputs, where Numbers are assumed to be EPSG:4326.
geodesicBoolean, optionalIf 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.
maxErrorErrorMargin, optionalMax error when input geometry must be reprojected to an explicitly requested result projection or geodesic state.
evenOddBoolean, optionalIf 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. If unspecified, defaults to true.

ee.Geometry.Polygon.area

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 components (intersecting areas are counted multiple times).
UsageReturns
Polygon.area(maxError, proj)Float
ArgumentTypeDetails
this: geometryGeometryThe geometry input.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in square meters.

ee.Geometry.Polygon.aside

Calls a function passing this object as the first argument, and returning itself. Convenient e.g. when debugging: var c = ee.ImageCollection('foo').aside(print) .filterDate('2001-01-01', '2002-01-01').aside(print, 'In 2001') .filterBounds(geom).aside(print, 'In region') .aside(Map.addLayer, {min: 0, max: 142}, 'Filtered') .select('a', 'b'); Returns the same object, for chaining.
UsageReturns
Polygon.aside(func, var_args)ComputedObject
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
funcFunctionThe function to call.
var_argsVarArgsAny extra arguments to pass to the function.

ee.Geometry.Polygon.bounds

Returns the bounding rectangle of the geometry.
UsageReturns
Polygon.bounds(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryReturn the bounding box of this geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in this projection. Otherwise it will be in WGS84.

ee.Geometry.Polygon.buffer

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.
UsageReturns
Polygon.buffer(distance, maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryThe geometry being buffered.
distanceFloatThe 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.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when approximating the buffering circle and performing any necessary reprojection. If unspecified, defaults to 1% of the distance.
projProjection, default: nullIf 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.

ee.Geometry.Polygon.centroid

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.
UsageReturns
Polygon.centroid(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryCalculates the centroid of this geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in this projection. Otherwise it will be in WGS84.

ee.Geometry.Polygon.containedIn

Returns true iff one geometry is contained in the other.
UsageReturns
Polygon.containedIn(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.Polygon.contains

Returns true iff one geometry contains the other.
UsageReturns
Polygon.contains(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.Polygon.convexHull

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.
UsageReturns
Polygon.convexHull(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryCalculates the convex hull of this geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.Polygon.coordinates

Returns a GeoJSON-style list of the geometry's coordinates.
UsageReturns
Polygon.coordinates()List
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.Polygon.coveringGrid

Returns a collection of features that cover this geometry, where each feature is a rectangle in the grid defined by the given projection.
UsageReturns
Polygon.coveringGrid(proj, scale)FeatureCollection
ArgumentTypeDetails
this: geometryGeometryThe result is the grid cells that intersect with this region.
projProjectionThe 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.
scaleFloat, default: nullOverrides the scale of the projection, if provided. May be required if the projection isn't already scaled.

ee.Geometry.Polygon.cutLines

Converts LineString, MultiLineString, and LinearRing geometries into a MultiLineString by cutting them into parts no longer than the given distance along their length. All other geometry types will be converted to an empty MultiLineString.
UsageReturns
Polygon.cutLines(distances, maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryCuts the lines of this geometry.
distancesListDistances along each LineString to cut the line into separate pieces, measured in units of the given proj, or meters if proj is unspecified.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullProjection of the result and distance measurements, or WGS84 if unspecified.

ee.Geometry.Polygon.difference

Returns the result of subtracting the 'right' geometry from the 'left' geometry.
UsageReturns
Polygon.difference(right, maxError, proj)Geometry
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.Polygon.disjoint

Returns true iff the geometries are disjoint.
UsageReturns
Polygon.disjoint(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.Polygon.dissolve

Returns the union of the geometry. This leaves single geometries untouched, and unions multi geometries.
UsageReturns
Polygon.dissolve(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryThe geometry to union.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the union will be performed in this projection. Otherwise it will be performed in a spherical coordinate system.

ee.Geometry.Polygon.distance

Returns the minimum distance between two geometries.
UsageReturns
Polygon.distance(right, maxError, proj)Float
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.Polygon.edgesAreGeodesics

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.
UsageReturns
Polygon.edgesAreGeodesics()Boolean
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.Polygon.evaluate

Asynchronously retrieves the value of this object from the server and passes it to the provided callback function.
UsageReturns
Polygon.evaluate(callback)
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
callbackFunctionA function of the form function(success, failure), called when the server returns an answer. If the request succeeded, the success argument contains the evaluated result. If the request failed, the failure argument will contains an error message.

ee.Geometry.Polygon.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.
UsageReturns
Polygon.geodesic()Boolean
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.Polygon.geometries

Returns the list of geometries in a GeometryCollection, or a singleton list of the geometry for single geometries.
UsageReturns
Polygon.geometries()List
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.Polygon.getInfo

Retrieves the value of this object from the server. If no callback function is provided, the request is made synchronously. If a callback is provided, the request is made asynchronously. The asynchronous mode is preferred because the synchronous mode stops all other code (for example, the EE Code Editor UI) while waiting for the server. To make an asynchronous request, evaluate() is preferred over getInfo(). Returns the computed value of this object.
UsageReturns
Polygon.getInfo(callback)Object
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
callbackFunction, optionalAn optional callback. If not supplied, the call is made synchronously.

ee.Geometry.Polygon.intersection

Returns the intersection of the two geometries.
UsageReturns
Polygon.intersection(right, maxError, proj)Geometry
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.Polygon.intersects

Returns true iff the geometries intersect.
UsageReturns
Polygon.intersects(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.Polygon.isUnbounded

Returns whether the geometry is unbounded.
UsageReturns
Polygon.isUnbounded()Boolean
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.Polygon.length

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.
UsageReturns
Polygon.length(maxError, proj)Float
ArgumentTypeDetails
this: geometryGeometryThe input geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in meters.

ee.Geometry.Polygon.perimeter

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.
UsageReturns
Polygon.perimeter(maxError, proj)Float
ArgumentTypeDetails
this: geometryGeometryThe input geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in meters.

ee.Geometry.Polygon.projection

Returns the projection of the geometry.
UsageReturns
Polygon.projection()Projection
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.Polygon.serialize

Returns the serialized representation of this object.
UsageReturns
Polygon.serialize(legacy)String
ArgumentTypeDetails
this: geometryGeometryThe Geometry instance.
legacyBoolean, optionalEnables legacy format.

ee.Geometry.Polygon.simplify

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.
UsageReturns
Polygon.simplify(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryThe geometry to simplify.
maxErrorErrorMarginThe maximum amount of error by which the result may differ from the input.
projProjection, default: nullIf 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

ee.Geometry.Polygon.symmetricDifference

Returns the symmetric difference between two geometries.
UsageReturns
Polygon.symmetricDifference(right, maxError, proj)Geometry
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.Polygon.toGeoJSON

Returns a GeoJSON representation of the geometry.
UsageReturns
Polygon.toGeoJSON()GeoJSONGeometry
ArgumentTypeDetails
this: geometryGeometryThe Geometry instance.

ee.Geometry.Polygon.toGeoJSONString

Returns a GeoJSON string representation of the geometry.
UsageReturns
Polygon.toGeoJSONString()String
ArgumentTypeDetails
this: geometryGeometryThe Geometry instance.

ee.Geometry.Polygon.transform

Transforms the geometry to a specific projection.
UsageReturns
Polygon.transform(proj, maxError)Geometry
ArgumentTypeDetails
this: geometryGeometryThe geometry to reproject.
projProjection, optionalThe 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.
maxErrorErrorMargin, default: nullThe maximum projection error.

ee.Geometry.Polygon.type

Returns the GeoJSON type of the geometry.
UsageReturns
Polygon.type()String
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.Polygon.union

Returns the union of the two geometries.
UsageReturns
Polygon.union(right, maxError, proj)Geometry
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.Polygon.withinDistance

Returns true iff the geometries are within a specified distance.
UsageReturns
Polygon.withinDistance(right, distance, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
distanceFloatThe distance threshold. If a projection is specified, the distance is in units of that projected coordinate system, otherwise it is in meters.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.Rectangle

Constructs an ee.Geometry describing a rectangular polygon. For convenience, varargs may be used when all arguments are numbers. This allows creating EPSG:4326 Polygons given exactly four coordinates, e.g. ee.Geometry.Rectangle(minLng, minLat, maxLng, maxLat).
UsageReturns
ee.Geometry.Rectangle(coords, proj, geodesic, evenOdd)Geometry.Rectangle
ArgumentTypeDetails
coordsListThe minimum and maximum corners of the rectangle, as a list of two points each in the format of GeoJSON 'Point' coordinates, or a list of two ee.Geometry objects describing a point, or a list of four numbers in the order xMin, yMin, xMax, yMax.
projProjection, optionalThe projection of this geometry. If unspecified, the default is the projection of the input ee.Geometry, or EPSG:4326 if there are no ee.Geometry inputs.
geodesicBoolean, optionalIf 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.
evenOddBoolean, optionalIf 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. If unspecified, defaults to true.

ee.Geometry.Rectangle.area

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 components (intersecting areas are counted multiple times).
UsageReturns
Rectangle.area(maxError, proj)Float
ArgumentTypeDetails
this: geometryGeometryThe geometry input.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in square meters.

ee.Geometry.Rectangle.aside

Calls a function passing this object as the first argument, and returning itself. Convenient e.g. when debugging: var c = ee.ImageCollection('foo').aside(print) .filterDate('2001-01-01', '2002-01-01').aside(print, 'In 2001') .filterBounds(geom).aside(print, 'In region') .aside(Map.addLayer, {min: 0, max: 142}, 'Filtered') .select('a', 'b'); Returns the same object, for chaining.
UsageReturns
Rectangle.aside(func, var_args)ComputedObject
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
funcFunctionThe function to call.
var_argsVarArgsAny extra arguments to pass to the function.

ee.Geometry.Rectangle.bounds

Returns the bounding rectangle of the geometry.
UsageReturns
Rectangle.bounds(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryReturn the bounding box of this geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in this projection. Otherwise it will be in WGS84.

ee.Geometry.Rectangle.buffer

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.
UsageReturns
Rectangle.buffer(distance, maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryThe geometry being buffered.
distanceFloatThe 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.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when approximating the buffering circle and performing any necessary reprojection. If unspecified, defaults to 1% of the distance.
projProjection, default: nullIf 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.

ee.Geometry.Rectangle.centroid

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.
UsageReturns
Rectangle.centroid(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryCalculates the centroid of this geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in this projection. Otherwise it will be in WGS84.

ee.Geometry.Rectangle.containedIn

Returns true iff one geometry is contained in the other.
UsageReturns
Rectangle.containedIn(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.Rectangle.contains

Returns true iff one geometry contains the other.
UsageReturns
Rectangle.contains(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.Rectangle.convexHull

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.
UsageReturns
Rectangle.convexHull(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryCalculates the convex hull of this geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.Rectangle.coordinates

Returns a GeoJSON-style list of the geometry's coordinates.
UsageReturns
Rectangle.coordinates()List
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.Rectangle.coveringGrid

Returns a collection of features that cover this geometry, where each feature is a rectangle in the grid defined by the given projection.
UsageReturns
Rectangle.coveringGrid(proj, scale)FeatureCollection
ArgumentTypeDetails
this: geometryGeometryThe result is the grid cells that intersect with this region.
projProjectionThe 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.
scaleFloat, default: nullOverrides the scale of the projection, if provided. May be required if the projection isn't already scaled.

ee.Geometry.Rectangle.cutLines

Converts LineString, MultiLineString, and LinearRing geometries into a MultiLineString by cutting them into parts no longer than the given distance along their length. All other geometry types will be converted to an empty MultiLineString.
UsageReturns
Rectangle.cutLines(distances, maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryCuts the lines of this geometry.
distancesListDistances along each LineString to cut the line into separate pieces, measured in units of the given proj, or meters if proj is unspecified.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullProjection of the result and distance measurements, or WGS84 if unspecified.

ee.Geometry.Rectangle.difference

Returns the result of subtracting the 'right' geometry from the 'left' geometry.
UsageReturns
Rectangle.difference(right, maxError, proj)Geometry
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.Rectangle.disjoint

Returns true iff the geometries are disjoint.
UsageReturns
Rectangle.disjoint(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.Rectangle.dissolve

Returns the union of the geometry. This leaves single geometries untouched, and unions multi geometries.
UsageReturns
Rectangle.dissolve(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryThe geometry to union.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the union will be performed in this projection. Otherwise it will be performed in a spherical coordinate system.

ee.Geometry.Rectangle.distance

Returns the minimum distance between two geometries.
UsageReturns
Rectangle.distance(right, maxError, proj)Float
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.Rectangle.edgesAreGeodesics

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.
UsageReturns
Rectangle.edgesAreGeodesics()Boolean
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.Rectangle.evaluate

Asynchronously retrieves the value of this object from the server and passes it to the provided callback function.
UsageReturns
Rectangle.evaluate(callback)
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
callbackFunctionA function of the form function(success, failure), called when the server returns an answer. If the request succeeded, the success argument contains the evaluated result. If the request failed, the failure argument will contains an error message.

ee.Geometry.Rectangle.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.
UsageReturns
Rectangle.geodesic()Boolean
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.Rectangle.geometries

Returns the list of geometries in a GeometryCollection, or a singleton list of the geometry for single geometries.
UsageReturns
Rectangle.geometries()List
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.Rectangle.getInfo

Retrieves the value of this object from the server. If no callback function is provided, the request is made synchronously. If a callback is provided, the request is made asynchronously. The asynchronous mode is preferred because the synchronous mode stops all other code (for example, the EE Code Editor UI) while waiting for the server. To make an asynchronous request, evaluate() is preferred over getInfo(). Returns the computed value of this object.
UsageReturns
Rectangle.getInfo(callback)Object
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
callbackFunction, optionalAn optional callback. If not supplied, the call is made synchronously.

ee.Geometry.Rectangle.intersection

Returns the intersection of the two geometries.
UsageReturns
Rectangle.intersection(right, maxError, proj)Geometry
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.Rectangle.intersects

Returns true iff the geometries intersect.
UsageReturns
Rectangle.intersects(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.Rectangle.isUnbounded

Returns whether the geometry is unbounded.
UsageReturns
Rectangle.isUnbounded()Boolean
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.Rectangle.length

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.
UsageReturns
Rectangle.length(maxError, proj)Float
ArgumentTypeDetails
this: geometryGeometryThe input geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in meters.

ee.Geometry.Rectangle.perimeter

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.
UsageReturns
Rectangle.perimeter(maxError, proj)Float
ArgumentTypeDetails
this: geometryGeometryThe input geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in meters.

ee.Geometry.Rectangle.projection

Returns the projection of the geometry.
UsageReturns
Rectangle.projection()Projection
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.Rectangle.serialize

Returns the serialized representation of this object.
UsageReturns
Rectangle.serialize(legacy)String
ArgumentTypeDetails
this: geometryGeometryThe Geometry instance.
legacyBoolean, optionalEnables legacy format.

ee.Geometry.Rectangle.simplify

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.
UsageReturns
Rectangle.simplify(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryThe geometry to simplify.
maxErrorErrorMarginThe maximum amount of error by which the result may differ from the input.
projProjection, default: nullIf 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

ee.Geometry.Rectangle.symmetricDifference

Returns the symmetric difference between two geometries.
UsageReturns
Rectangle.symmetricDifference(right, maxError, proj)Geometry
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.Rectangle.toGeoJSON

Returns a GeoJSON representation of the geometry.
UsageReturns
Rectangle.toGeoJSON()GeoJSONGeometry
ArgumentTypeDetails
this: geometryGeometryThe Geometry instance.

ee.Geometry.Rectangle.toGeoJSONString

Returns a GeoJSON string representation of the geometry.
UsageReturns
Rectangle.toGeoJSONString()String
ArgumentTypeDetails
this: geometryGeometryThe Geometry instance.

ee.Geometry.Rectangle.transform

Transforms the geometry to a specific projection.
UsageReturns
Rectangle.transform(proj, maxError)Geometry
ArgumentTypeDetails
this: geometryGeometryThe geometry to reproject.
projProjection, optionalThe 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.
maxErrorErrorMargin, default: nullThe maximum projection error.

ee.Geometry.Rectangle.type

Returns the GeoJSON type of the geometry.
UsageReturns
Rectangle.type()String
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.Rectangle.union

Returns the union of the two geometries.
UsageReturns
Rectangle.union(right, maxError, proj)Geometry
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.Rectangle.withinDistance

Returns true iff the geometries are within a specified distance.
UsageReturns
Rectangle.withinDistance(right, distance, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
distanceFloatThe distance threshold. If a projection is specified, the distance is in units of that projected coordinate system, otherwise it is in meters.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.area

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 components (intersecting areas are counted multiple times).
UsageReturns
Geometry.area(maxError, proj)Float
ArgumentTypeDetails
this: geometryGeometryThe geometry input.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in square meters.

ee.Geometry.aside

Calls a function passing this object as the first argument, and returning itself. Convenient e.g. when debugging: var c = ee.ImageCollection('foo').aside(print) .filterDate('2001-01-01', '2002-01-01').aside(print, 'In 2001') .filterBounds(geom).aside(print, 'In region') .aside(Map.addLayer, {min: 0, max: 142}, 'Filtered') .select('a', 'b'); Returns the same object, for chaining.
UsageReturns
Geometry.aside(func, var_args)ComputedObject
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
funcFunctionThe function to call.
var_argsVarArgsAny extra arguments to pass to the function.

ee.Geometry.bounds

Returns the bounding rectangle of the geometry.
UsageReturns
Geometry.bounds(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryReturn the bounding box of this geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in this projection. Otherwise it will be in WGS84.

ee.Geometry.buffer

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.
UsageReturns
Geometry.buffer(distance, maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryThe geometry being buffered.
distanceFloatThe 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.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when approximating the buffering circle and performing any necessary reprojection. If unspecified, defaults to 1% of the distance.
projProjection, default: nullIf 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.

ee.Geometry.centroid

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.
UsageReturns
Geometry.centroid(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryCalculates the centroid of this geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in this projection. Otherwise it will be in WGS84.

ee.Geometry.containedIn

Returns true iff one geometry is contained in the other.
UsageReturns
Geometry.containedIn(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.contains

Returns true iff one geometry contains the other.
UsageReturns
Geometry.contains(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.convexHull

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.
UsageReturns
Geometry.convexHull(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryCalculates the convex hull of this geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.coordinates

Returns a GeoJSON-style list of the geometry's coordinates.
UsageReturns
Geometry.coordinates()List
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.coveringGrid

Returns a collection of features that cover this geometry, where each feature is a rectangle in the grid defined by the given projection.
UsageReturns
Geometry.coveringGrid(proj, scale)FeatureCollection
ArgumentTypeDetails
this: geometryGeometryThe result is the grid cells that intersect with this region.
projProjectionThe 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.
scaleFloat, default: nullOverrides the scale of the projection, if provided. May be required if the projection isn't already scaled.

ee.Geometry.cutLines

Converts LineString, MultiLineString, and LinearRing geometries into a MultiLineString by cutting them into parts no longer than the given distance along their length. All other geometry types will be converted to an empty MultiLineString.
UsageReturns
Geometry.cutLines(distances, maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryCuts the lines of this geometry.
distancesListDistances along each LineString to cut the line into separate pieces, measured in units of the given proj, or meters if proj is unspecified.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullProjection of the result and distance measurements, or WGS84 if unspecified.

ee.Geometry.difference

Returns the result of subtracting the 'right' geometry from the 'left' geometry.
UsageReturns
Geometry.difference(right, maxError, proj)Geometry
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.disjoint

Returns true iff the geometries are disjoint.
UsageReturns
Geometry.disjoint(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.dissolve

Returns the union of the geometry. This leaves single geometries untouched, and unions multi geometries.
UsageReturns
Geometry.dissolve(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryThe geometry to union.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the union will be performed in this projection. Otherwise it will be performed in a spherical coordinate system.

ee.Geometry.distance

Returns the minimum distance between two geometries.
UsageReturns
Geometry.distance(right, maxError, proj)Float
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.edgesAreGeodesics

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.
UsageReturns
Geometry.edgesAreGeodesics()Boolean
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.evaluate

Asynchronously retrieves the value of this object from the server and passes it to the provided callback function.
UsageReturns
Geometry.evaluate(callback)
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
callbackFunctionA function of the form function(success, failure), called when the server returns an answer. If the request succeeded, the success argument contains the evaluated result. If the request failed, the failure argument will contains an error message.

ee.Geometry.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.
UsageReturns
Geometry.geodesic()Boolean
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.geometries

Returns the list of geometries in a GeometryCollection, or a singleton list of the geometry for single geometries.
UsageReturns
Geometry.geometries()List
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.getInfo

Retrieves the value of this object from the server. If no callback function is provided, the request is made synchronously. If a callback is provided, the request is made asynchronously. The asynchronous mode is preferred because the synchronous mode stops all other code (for example, the EE Code Editor UI) while waiting for the server. To make an asynchronous request, evaluate() is preferred over getInfo(). Returns the computed value of this object.
UsageReturns
Geometry.getInfo(callback)Object
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
callbackFunction, optionalAn optional callback. If not supplied, the call is made synchronously.

ee.Geometry.intersection

Returns the intersection of the two geometries.
UsageReturns
Geometry.intersection(right, maxError, proj)Geometry
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.intersects

Returns true iff the geometries intersect.
UsageReturns
Geometry.intersects(right, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.isUnbounded

Returns whether the geometry is unbounded.
UsageReturns
Geometry.isUnbounded()Boolean
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.length

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.
UsageReturns
Geometry.length(maxError, proj)Float
ArgumentTypeDetails
this: geometryGeometryThe input geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in meters.

ee.Geometry.perimeter

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.
UsageReturns
Geometry.perimeter(maxError, proj)Float
ArgumentTypeDetails
this: geometryGeometryThe input geometry.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullIf specified, the result will be in the units of the coordinate system of this projection. Otherwise it will be in meters.

ee.Geometry.projection

Returns the projection of the geometry.
UsageReturns
Geometry.projection()Projection
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.serialize

Returns the serialized representation of this object.
UsageReturns
Geometry.serialize(legacy)String
ArgumentTypeDetails
this: geometryGeometryThe Geometry instance.
legacyBoolean, optionalEnables legacy format.

ee.Geometry.simplify

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.
UsageReturns
Geometry.simplify(maxError, proj)Geometry
ArgumentTypeDetails
this: geometryGeometryThe geometry to simplify.
maxErrorErrorMarginThe maximum amount of error by which the result may differ from the input.
projProjection, default: nullIf 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

ee.Geometry.symmetricDifference

Returns the symmetric difference between two geometries.
UsageReturns
Geometry.symmetricDifference(right, maxError, proj)Geometry
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.toGeoJSON

Returns a GeoJSON representation of the geometry.
UsageReturns
Geometry.toGeoJSON()GeoJSONGeometry
ArgumentTypeDetails
this: geometryGeometryThe Geometry instance.

ee.Geometry.toGeoJSONString

Returns a GeoJSON string representation of the geometry.
UsageReturns
Geometry.toGeoJSONString()String
ArgumentTypeDetails
this: geometryGeometryThe Geometry instance.

ee.Geometry.transform

Transforms the geometry to a specific projection.
UsageReturns
Geometry.transform(proj, maxError)Geometry
ArgumentTypeDetails
this: geometryGeometryThe geometry to reproject.
projProjection, optionalThe 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.
maxErrorErrorMargin, default: nullThe maximum projection error.

ee.Geometry.type

Returns the GeoJSON type of the geometry.
UsageReturns
Geometry.type()String
ArgumentTypeDetails
this: geometryGeometry

ee.Geometry.union

Returns the union of the two geometries.
UsageReturns
Geometry.union(right, maxError, proj)Geometry
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Geometry.withinDistance

Returns true iff the geometries are within a specified distance.
UsageReturns
Geometry.withinDistance(right, distance, maxError, proj)Boolean
ArgumentTypeDetails
this: leftGeometryThe geometry used as the left operand of the operation.
rightGeometryThe geometry used as the right operand of the operation.
distanceFloatThe distance threshold. If a projection is specified, the distance is in units of that projected coordinate system, otherwise it is in meters.
maxErrorErrorMargin, default: nullThe maximum amount of error tolerated when performing any necessary reprojection.
projProjection, default: nullThe 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.

ee.Image

An object to represent an Earth Engine image. This constructor accepts a variety of arguments:   - A string: an EarthEngine asset id,   - A string and a number: an EarthEngine asset id and version,   - A number or ee.Array: creates a constant image,   - A list: creates an image out of each list element and combines them into a single image,   - An ee.Image: returns the argument,   - Nothing: results in an empty transparent image.
UsageReturns
ee.Image(args)Image
ArgumentTypeDetails
argsImage|List, optionalConstructor argument.

ee.Image.abs

Computes the absolute value of the input.
UsageReturns
Image.abs()Image
ArgumentTypeDetails
this: valueImageThe image to which the operation is applied.

ee.Image.acos

Computes the arc cosine in radians of the input.
UsageReturns
Image.acos()Image
ArgumentTypeDetails
this: valueImageThe image to which the operation is applied.

ee.Image.add

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.
UsageReturns
Image.add(image2)Image
ArgumentTypeDetails
this: image1ImageThe image from which the left operand bands are taken.
image2ImageThe image from which the right operand bands are taken.

ee.Image.addBands

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.
UsageReturns
Image.addBands(srcImg, names, overwrite)Image
ArgumentTypeDetails
this: dstImgImageAn image into which to copy bands.
srcImgImageAn image containing bands to copy.
namesList, default: nullOptional list of band names to copy. If names is omitted, all bands from srcImg will be copied over.
overwriteBoolean, default: falseIf 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).

ee.Image.and

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.
UsageReturns
Image.and(image2)Image
ArgumentTypeDetails
this: image1ImageThe image from which the left operand bands are taken.
image2ImageThe image from which the right operand bands are taken.

ee.Image.arrayAccum

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.
UsageReturns
Image.arrayAccum(axis, reducer)Image
ArgumentTypeDetails
this: inputImageInput image.
axisIntegerAxis along which to perform the cumulative sum.
reducerReducer, default: nullReducer to accumulate values. Default is SUM, to produce the cumulative sum of each vector along the given axis.

ee.Image.arrayArgmax

Computes the positional indices of the maximum value in image of array values. If there are multiple occurrences of the maximum, the indices reflect the first.
UsageReturns
Image.arrayArgmax()Image
ArgumentTypeDetails
this: imageImageThe input image.

ee.Image.arrayCat

Creates an array image by concatenating each array pixel along the given axis in each band.
UsageReturns
Image.arrayCat(image2, axis)Image
ArgumentTypeDetails
this: image1ImageFirst array image to concatenate.
image2ImageSecond array image to concatenate.
axisIntegerAxis to concatenate along.

ee.Image.arrayDimensions

Returns the number of dimensions in each array band, and 0 for scalar image bands.
UsageReturns
Image.arrayDimensions()Image
ArgumentTypeDetails
this: inputImageInput image.

ee.Image.arrayDotProduct

Computes the dot product of each pair of 1-D arrays in the bands of the input images.
UsageReturns
Image.arrayDotProduct(image2)Image
ArgumentTypeDetails
this: image1ImageFirst array image of 1-D vectors.
image2ImageSecond array image of 1-D vectors.

ee.Image.arrayFlatten

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.
UsageReturns
Image.arrayFlatten(coordinateLabels, separator)Image
ArgumentTypeDetails
this: imageImageImage of multidimensional pixels to flatten.
coordinateLabelsListName 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'.
separatorString, default: "_"Separator between array labels in each band name.

ee.Image.arrayGet

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.
UsageReturns
Image.arrayGet(position)Image
ArgumentTypeDetails
this: imageImageArray to get an element from.
positionImageThe coordinates of the element to get. There must be as many scalar bands as there are dimensions in the input image.

ee.Image.arrayLength

Returns the length of each pixel's array along the given axis.
UsageReturns
Image.arrayLength(axis)Image
ArgumentTypeDetails
this: inputImageInput image.
axisIntegerThe axis along which to take the length.

ee.Image.arrayLengths

Returns a 1D array image with the length of each array axis.
UsageReturns
Image.arrayLengths()Image
ArgumentTypeDetails
this: inputImageInput image.

ee.Image.arrayMask

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.
UsageReturns
Image.arrayMask(mask)Image
ArgumentTypeDetails
this: inputImageArray image to mask.
maskImageArray image to mask with.

ee.Image.arrayPad

Pads the array values in each pixel to be a fixed length. The pad value will be appended to each array to extend it to given length along each axis. All bands of the image must be array-valued and have the same dimensions.
UsageReturns
Image.arrayPad(lengths, pad)Image
ArgumentTypeDetails
this: imageImageArray image to pad.
lengthsListA list of desired lengths for each axis in the output arrays. Arrays are already as large or larger than the given length will be unchanged along that axis
padNumber, default: 0The value to pad with.

ee.Image.arrayProject

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.
UsageReturns
Image.arrayProject(axes)Image
ArgumentTypeDetails
this: inputImageInput image.
axesListThe axes to retain. Other axes will be discarded and must be at most length 1.

ee.Image.arrayReduce

Reduces elements of each array pixel.
UsageReturns
Image.arrayReduce(reducer, axes, fieldAxis)Image
ArgumentTypeDetails
this: inputImageInput image.
reducerReducerThe reducer to apply
axesListThe list of array axes to reduce in each pixel. The output will have a length of 1 in all these axes.
fieldAxisInteger, default: nullThe axis for the reducer's input and output fields. Only required if the reducer has multiple inputs or outputs.

ee.Image.arrayRepeat

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.
UsageReturns
Image.arrayRepeat(axis, copies)Image
ArgumentTypeDetails
this: inputImageImage of array pixels to be repeated.
axisIntegerAxis along which to repeat each pixel's array.
copiesImageNumber of copies of each pixel.

ee.Image.arrayReshape

Converts array bands of an image with equally-shaped, possibly multidimensional pixels to an image of arrays with a new shape.
UsageReturns
Image.arrayReshape(lengths, dimensions)Image
ArgumentTypeDetails
this: imageImageThe image of arrays to reshape.
lengthsImageA 1 band image specifying the new lengths of each axis of the input image specified as a 1-D array per pixel. There should be 'dimensions' lengths values in each shape' array. If one of the lengths is -1, then the corresponding length for that axis will be computed such that the total size remains constant. In particular, a shape of [-1] flattens into 1-D. At most one component of shape can be -1.
dimensionsIntegerThe number of dimensions shared by all output array pixels.

ee.Image.arraySlice

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.
UsageReturns
Image.arraySlice(axis, start, end, step)Image
ArgumentTypeDetails
this: inputImageInput array image.
axisInteger, default: 0Axis to subset.
startImage, default: nullThe 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.
endImage, default: nullThe 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.
stepInteger, default: 1The 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.

ee.Image.arraySort

Sorts elements of each array pixel along one axis.
UsageReturns
Image.arraySort(keys)Image
ArgumentTypeDetails
this: imageImageArray image to sort.
keysImage, default: nullOptional 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.

ee.Image.arrayTranspose

Transposes two dimensions of each array pixel.
UsageReturns
Image.arrayTranspose(axis1, axis2)Image
ArgumentTypeDetails
this: inputImageInput image.
axis1Integer, default: 0First axis to swap.
axis2Integer, default: 1Second axis to swap.

ee.Image.aside

Calls a function passing this object as the first argument, and returning itself. Convenient e.g. when debugging: var c = ee.ImageCollection('foo').aside(print) .filterDate('2001-01-01', '2002-01-01').aside(print, 'In 2001') .filterBounds(geom).aside(print, 'In region') .aside(Map.addLayer, {min: 0, max: 142}, 'Filtered') .select('a', 'b'); Returns the same object, for chaining.
UsageReturns
Image.aside(func, var_args)ComputedObject
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
funcFunctionThe function to call.
var_argsVarArgsAny extra arguments to pass to the function.

ee.Image.asin

Computes the arc sine in radians of the input.
UsageReturns
Image.asin()Image
ArgumentTypeDetails
this: valueImageThe image to which the operation is applied.

ee.Image.atan

Computes the arc tangent in radians of the input.
UsageReturns
Image.atan()Image
ArgumentTypeDetails
this: valueImageThe image to which the operation is applied.

ee.Image.atan2

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.
UsageReturns
Image.atan2(image2)Image
ArgumentTypeDetails
this: image1ImageThe image from which the left operand bands are taken.
image2ImageThe image from which the right operand bands are taken.

ee.Image.bandNames

Returns a list containing the names of the bands of an image.
UsageReturns
Image.bandNames()List
ArgumentTypeDetails
this: imageImageThe image from which to get band names.

ee.Image.bandTypes

Returns a dictionary of the image's band types.
UsageReturns
Image.bandTypes()Dictionary
ArgumentTypeDetails
this: imageImageThe image from which to get band types.

ee.Image.bitCount

Calculates the number of one-bits in the 64-bit two's complement binary representation of the input.
UsageReturns
Image.bitCount()Image
ArgumentTypeDetails
this: valueImageThe image to which the operation is applied.

ee.Image.bitsToArrayImage

Turns the bits of an integer into a 1-D array. The array has a lengthup to the highest 'on' bit in the input.
UsageReturns
Image.bitsToArrayImage()Image
ArgumentTypeDetails
this: inputImageInput image.

ee.Image.bitwiseAnd

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.
UsageReturns
Image.bitwiseAnd(image2)Image
ArgumentTypeDetails
this: image1ImageThe image from which the left operand bands are taken.
image2ImageThe image from which the right operand bands are taken.

ee.Image.bitwiseNot

Calculates the bitwise NOT of the input, in the smallest signed integer type that can hold the input.
UsageReturns
Image.bitwiseNot()Image
ArgumentTypeDetails
this: valueImageThe image to which the operation is applied.

ee.Image.bitwiseOr

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.
UsageReturns
Image.bitwiseOr(image2)Image
ArgumentTypeDetails
this: image1ImageThe image from which the left operand bands are taken.
image2ImageThe image from which the right operand bands are taken.

ee.Image.bitwiseXor

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.
UsageReturns
Image.bitwiseXor(image2)Image
ArgumentTypeDetails
this: image1ImageThe image from which the left operand bands are taken.
image2ImageThe image from which the right operand bands are taken.

ee.Image.blend

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.
UsageReturns
Image.blend(top)Image
ArgumentTypeDetails
this: bottomImageThe bottom image.
topImageThe top image.

ee.Image.byte

Casts the input value to an unsigned 8-bit integer.
UsageReturns
Image.byte()Image
ArgumentTypeDetails
this: valueImageThe image to which the operation is applied.

ee.Image.cast

Casts some or all bands of an image to the specified types.
UsageReturns
Image.cast(bandTypes, bandOrder)Image
ArgumentTypeDetails
this: imageImageThe image to cast.
bandTypesDictionaryA 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.
bandOrderList, default: nullA list specifying the order of the bands in the result. If specified, must match the full list of bands in the result.

ee.Image.cat

Combines the given images into a single image which contains all bands from all of the images. If two or more bands share a name, they are suffixed with an incrementing index. The resulting image will have the metadata from the first input image, only. This function will promote constant values into constant images. Returns the combined image.
UsageReturns
ee.Image.cat(var_args)Image
ArgumentTypeDetails
var_argsVarArgsThe images to be combined.

ee.Image.cbrt

Computes the cubic root of the input.
UsageReturns
Image.cbrt()Image
ArgumentTypeDetails
this: valueImageThe image to which the operation is applied.

ee.Image.ceil

Computes the smallest integer greater than or equal to the input.
UsageReturns
Image.ceil()Image
ArgumentTypeDetails
this: valueImageThe image to which the operation is applied.

ee.Image.changeProj

Tweaks the projection of the input image, moving each pixel from its location in srcProj to the same coordinates in dstProj.
UsageReturns
Image.changeProj(srcProj, dstProj)Image
ArgumentTypeDetails
this: inputImage
srcProjProjectionThe original projection.
dstProjProjectionThe new projection.

ee.Image.clamp

Clamps the values in all bands of an image to all lie within the specified range.
UsageReturns
Image.clamp(low, high)Image
ArgumentTypeDetails
this: inputImageThe image to clamp.
lowFloatThe minimum allowed value in the range.
highFloatThe maximum allowed value in the range.

ee.Image.classify

Classifies an image.
UsageReturns
Image.classify(classifier, outputName)Image
ArgumentTypeDetails
this: imageImageThe image to classify. Bands are extracted from this image by name, and it must contain all the bands named in the classifier's schema.
classifierClassifierThe classifier to use.
outputNameString, default: "classification"The name of the band to be added. If the classifier produces more than 1 output, this name is ignored.

ee.Image.clip

Clips an image to a Geometry or Feature. The output bands correspond exactly to the input bands, except data not covered by the geometry is masked. The output image retains the metadata of the input image. Use clipToCollection to clip an image to a FeatureCollection. Returns the clipped image.
UsageReturns
Image.clip(geometry)Image
ArgumentTypeDetails
this: imageImageThe Image instance.
geometryFeature|Geometry|ObjectThe Geometry or Feature to clip to.

ee.Image.clipToBoundsAndScale

Clips an image to the bounds of a Geometry, and scales the clipped image to a particular size or scale. Caution: providing a large or complex collection as the `geometry` argument can result in poor performance. Collating the geometry of collections does not scale well; use the smallest collection (or geometry) that is required to achieve the desired outcome.
UsageReturns
Image.clipToBoundsAndScale(geometry, width, height, maxDimension, scale)Image
ArgumentTypeDetails
this: inputImageThe image to clip and scale.
geometryGeometry, default: nullThe Geometry to clip the image to. The image will be clipped to the bounding box, in the image's projection, of this geometry.
widthInteger, default: nullThe width to scale the image to, in pixels. Must be provided along with "height". Exclusive with "maxDimension" and "scale".
heightInteger, default: nullThe height to scale the image to, in pixels. Must be provided along with "width". Exclusive with "maxDimension" and "scale".
maxDimensionInteger, default: nullThe maximum dimension to scale the image to, in pixels. Exclusive with "width", "height" and "scale".
scaleFloat, default: nullIf 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".

ee.Image.clipToCollection

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.
UsageReturns
Image.clipToCollection(collection)Image
ArgumentTypeDetails
this: inputImageThe image to clip.
collectionObjectThe FeatureCollection to clip to.

ee.Image.cluster

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.
UsageReturns
Image.cluster(clusterer, outputName)Image
ArgumentTypeDetails
this: imageImageThe image to cluster. Must contain all the bands in the clusterer's schema.
clustererClustererThe clusterer to use.
outputNameString, default: "cluster"The name of the output band.

ee.Image.connectedComponents

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.
UsageReturns
Image.connectedComponents(connectedness, maxSize)Image
ArgumentTypeDetails
this: imageImageThe image to label.
connectednessKernelConnectedness kernel.
maxSizeIntegerMaximum size of objects to be labeled.

ee.Image.connectedPixelCount

Generate an image where each pixel contains the number of 4- or 8-connected neighbors (including itself).
UsageReturns
Image.connectedPixelCount(maxSize, eightConnected)Image
ArgumentTypeDetails
this: inputImageThe input image.
maxSizeInteger, default: 100The maximum size of the neighborhood in pixels.
eightConnectedBoolean, default: trueWhether to use 8-connected rather 4-connected rules.

ee.Image.constant

Generates an image containing a constant value everywhere.
UsageReturns
ee.Image.constant(value)Image
ArgumentTypeDetails
valueObjectThe value of the pixels in the constant image. Must be a number or an Array or a list of numbers or Arrays.

ee.Image.convolve

Convolves each band of an image with the given kernel.
UsageReturns
Image.convolve(kernel)Image
ArgumentTypeDetails
this: imageImageThe image to convolve.
kernelKernelThe kernel to convolve with.

ee.Image.cos

Computes the cosine of the input in radians.
UsageReturns
Image.cos()Image
ArgumentTypeDetails
this: valueImageThe image to which the operation is applied.

ee.Image.cosh

Computes the hyperbolic cosine of the input.
UsageReturns
Image.cosh()Image
ArgumentTypeDetails
this: valueImageThe image to which the operation is applied.

ee.Image.cumulativeCost

Computes a cumulative cost map based on an image containing costs to traverse each pixel and an image containing source locations.
UsageReturns
Image.cumulativeCost(source, maxDistance, geodeticDistance)Image
ArgumentTypeDetails
this: costImageAn image representing the cost to traverse each pixel. Masked pixels can't be traversed.
sourceImageA single-band image representing the sources. A pixel value different from 0 defines a source pixel.
maxDistanceFloatMaximum distance for computation, in meters.
geodeticDistanceBoolean, default: trueIf 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).

ee.Image.date

Returns the acquisition time of an image as a Date object. This helper function is equivalent to `ee.Date(image.get('system:time_start'))`.
UsageReturns
Image.date()Date
ArgumentTypeDetails
this: imageImageThe image whose acquisition time to return.

ee.Image.derivative

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.
UsageReturns
Image.derivative()Image
ArgumentTypeDetails
this: imageImageThe input image.

ee.Image.digamma

Computes the digamma function of the input.
UsageReturns
Image.digamma()Image
ArgumentTypeDetails
this: valueImageThe image to which the operation is applied.

ee.Image.directionalDistanceTransform

For each zero-valued pixel in the source, get the distance to the nearest non-zero pixels in the given direction. Returns a band of floating point distances called "distance".
UsageReturns
Image.directionalDistanceTransform(angle, maxDistance, labelBand)Image
ArgumentTypeDetails
this: sourceImageThe source image.
angleFloatThe angle, in degrees, at which to search for non-zero pixels.
maxDistanceIntegerThe maximum distance, in pixels, over which to search.
labelBandString, default: nullIf provided, multi-band inputs are permitted and only this band is used for searching. All other bands are returned and populated with the per-band values found at the searched non-zero pixels in the label band.

ee.Image.displace

Warps an image using an image of displacements.
UsageReturns
Image.displace(displacement, mode, maxOffset)Image
ArgumentTypeDetails
this: imageImageThe image to warp.
displacementImageAn 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.
modeString, default: "bicubic"The interpolation mode to use. One of 'nearest_neighbor', 'bilinear' or 'bicubic'.
maxOffsetFloat, default: nullThe maximum absolute offset in the displacement image. Providing this may improve processing performance.

ee.Image.displacement

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.
UsageReturns
Image.displacement(referenceImage, maxOffset, projection, patchWidth, stiffness)Image
ArgumentTypeDetails
this: imageImageThe image to register.
referenceImageImageThe image to register to.
maxOffsetFloatThe 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.
projectionProjection, default: nullThe projection in which to output displacement values. The default is the projection of the first band of the reference image.
patchWidthFloat, default: nullPatch 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.
stiffnessFloat, default: 5Enforces 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.

ee.Image.distance

Computes the distance to the nearest non-zero pixel in each band, using the specified distance kernel.
UsageReturns
Image.distance(kernel, skipMasked)Image
ArgumentTypeDetails
this: imageImageThe input image.
kernelKernel, default: nullThe distance kernel. One of chebyshev, euclidean, or manhattan.
skipMaskedBoolean, default: trueMask output pixels if the corresponding input pixel is masked.

ee.Image.divide

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.
UsageReturns
Image.divide(image2)Image
ArgumentTypeDetails
this: image1ImageThe image from which the left operand bands are taken.
image2ImageThe image from which the right operand bands are taken.

ee.Image.double

Casts the input value to a 64-bit float.
UsageReturns
Image.double()Image
ArgumentTypeDetails
this: valueImageThe image to which the operation is applied.

ee.Image.entropy

Computes the windowed entropy for each band using the specified kernel centered on each input pixel. Entropy is computed as -sum(p * log2(p)), where p is the normalized probability of occurrence of the values encountered in each window.
UsageReturns
Image.entropy(kernel)Image
ArgumentTypeDetails
this: imageImageThe image for which to compute the entropy.
kernelKernelA kernel specifying the window in which to compute.

ee.Image.eq

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.
UsageReturns
Image.eq(image2)Image
ArgumentTypeDetails
this: image1ImageThe image from which the left operand bands are taken.
image2ImageThe image from which the right operand bands are taken.

ee.Image.erf

Computes the error function of the input.
UsageReturns
Image.erf()Image
ArgumentTypeDetails
this: valueImageThe image to which the operation is applied.

ee.Image.erfInv

Computes the inverse error function of the input.
UsageReturns
Image.erfInv()Image
ArgumentTypeDetails
this: valueImageThe image to which the operation is applied.

ee.Image.erfc

Computes the complementary error function of the input.
UsageReturns
Image.erfc()Image
ArgumentTypeDetails
this: valueImageThe image to which the operation is applied.

ee.Image.erfcInv

Computes the inverse complementary error function of the input.
UsageReturns
Image.erfcInv()Image
ArgumentTypeDetails
this: valueImageThe image to which the operation is applied.

ee.Image.evaluate

Asynchronously retrieves the value of this object from the server and passes it to the provided callback function.
UsageReturns
Image.evaluate(callback)
ArgumentTypeDetails
this: computedobjectComputedObjectThe ComputedObject instance.
callbackFunctionA function of the form function(success, failure), called when the server returns an answer. If the request succeeded, the success argument contains the evaluated result. If the request failed, the failure argument will contains an error message.

ee.Image.exp

Computes the Euler's number e raised to the power of the input.
UsageReturns
Image.exp()Image
ArgumentTypeDetails
this: valueImageThe image to which the operation is applied.

ee.Image.expression

Evaluates an arithmetic expression on an image, possibly involving additional images. The bands of the primary input image are available using the built-in function b(), as b(0) or b('band_name'). Variables in the expression are interpreted as additional image parameters which must be supplied in opt_map. The bands of each such image can be accessed like image.band_name or image[0]. Both b() and image[] allow multiple arguments, to specify multiple bands, such as b(1, 'name', 3). Calling b() with no arguments, or using a variable by itself, returns all bands of the image. If the result of an expression is a single band, it can be assigned a name using the '=' operator (e.g.: x = a + b). Returns the image computed by the provided expression.
UsageReturns
Image.expression(expression, map)Image
ArgumentTypeDetails
this: imageImageThe Image instance.
expressionStringThe expression to evaluate.
mapDictionary, optionalA map of input images available by name.

ee.Image.fastDistanceTransform

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.
UsageReturns
Image.fastDistanceTransform(neighborhood, units, metric)Image
ArgumentTypeDetails
this: imageImageThe input image.
neighborhoodInteger, default: 256Neighborhood size in pixels.
unitsString, default: "pixels"The units of the neighborhood, currently only 'pixels' are supported.
metricString, default: "squared_euclidean"Distance metric to use: options are `squared_euclidean`, `manhattan` or `chebyshev`.

ee.Image.first

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.
UsageReturns
Image.first(image2)Image
ArgumentTypeDetails
this: image1ImageThe image from which the left operand bands are taken.
image2ImageThe image from which the right operand bands are taken.

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.
UsageReturns
Image.firstNonZero(image2)Image
ArgumentTypeDetails
this: image1ImageThe image from which the left operand bands are taken.
image2ImageThe image from which the right operand bands are taken.

ee.Image.float

Casts the input value to a 32-bit float.
UsageReturns
Image.float()Image
ArgumentTypeDetails
this: valueImageThe image to which the operation is applied.

ee.Image.floor

Computes the largest integer less than or equal to the input.
UsageReturns
Image.floor()Image
ArgumentTypeDetails
this: valueImageThe image to which the operation is applied.

ee.Image.focalMax

Applies a morphological reducer() filter to each band of an image using a named or custom kernel.
UsageReturns
Image.focalMax(radius, kernelType, units, iterations, kernel)Image
ArgumentTypeDetails
this: imageImageThe image to which to apply the operations.
radiusFloat, default: 1.5The radius of the kernel to use.
kernelTypeString, default: "circle"The type of kernel to use. Options include: 'circle', 'square', 'cross', 'plus', octagon' and 'diamond'.
unitsString, default: "pixels"If a kernel is not specified, this determines whether the kernel is in meters or pixels.
iterationsInteger, default: 1The number of times to apply the given kernel.
kernelKernel, default: nullA custom kernel. If used, kernelType and radius are ignored.

ee.Image.focalMean

Applies a morphological mean filter to each band of an image using a named or custom kernel.
UsageReturns
Image.focalMean(radius, kernelType, units, iterations, kernel)Image
ArgumentTypeDetails
this: imageImageThe image to which to apply the operations.
radiusFloat, default: 1.5The radius of the kernel to use.
kernelTypeString, default: "circle"The type of kernel to use. Options include: 'circle', 'square', 'cross', 'plus', octagon' and 'diamond'.
unitsString, default: "pixels"If a kernel is not specified, this determines whether the kernel is in meters or pixels.
iterationsInteger, default: 1The number of times to apply the given kernel.
kernelKernel, default: nullA custom kernel. If used, kernelType and radius are ignored.

ee.Image.focalMedian

Applies a morphological reducer() filter to each band of an image using a named or custom kernel.
UsageReturns
Image.focalMedian(radius, kernelType, units, iterations, kernel)Image
ArgumentTypeDetails
this: imageImageThe image to which to apply the operations.
radiusFloat, default: 1.5The radius of the kernel to use.
kernelTypeString, default: "circle"The type of kernel to use. Options include: 'circle', 'square', 'cross', 'plus', octagon' and 'diamond'.
unitsString, default: "pixels"If a kernel is not specified, this determines whether the kernel is in meters or pixels.
iterationsInteger, default: 1The number of times to apply the given kernel.
kernelKernel, default: nullA custom kernel. If used, kernelType and radius are ignored.

ee.Image.focalMin

Applies a morphological reducer() filter to each band of an image using a named or custom kernel.
UsageReturns
Image.focalMin(radius, kernelType, units, iterations, kernel)Image
ArgumentTypeDetails
this: imageImageThe image to which to apply the operations.
radiusFloat, default: 1.5The radius of the kernel to use.
kernelTypeString, default: "circle"The type of kernel to use. Options include: 'circle', 'square', 'cross', 'plus', octagon' and 'diamond'.
unitsString, default: "pixels"If a kernel is not specified, this determines whether the kernel is in meters or pixels.
iterationsInteger, default: 1The number of times to apply the given kernel.
kernelKernel, default: nullA custom kernel. If used, kernelType and radius are ignored.

ee.Image.focalMode

Applies a morphological reducer() filter to each band of an image using a named or custom kernel.
UsageReturns
Image.focalMode(radius, kernelType, units, iterations, kernel)Image
ArgumentTypeDetails
this: imageImageThe image to which to apply the operations.
radiusFloat, default: 1.5The radius of the kernel to use.
kernelTypeString, default: "circle"The type of kernel to use. Options include: 'circle', 'square', 'cross', 'plus', octagon' and 'diamond'.
unitsString, default: "pixels"If a kernel is not specified, this determines whether the kernel is in meters or pixels.
iterationsInteger, default: 1The number of times to apply the given kernel.
kernelKernel, default: nullA custom kernel. If used, kernelType and radius are ignored.

ee.Image.gamma

Computes the gamma function of the input.
UsageReturns
Image.gamma()Image
ArgumentTypeDetails
this: valueImageThe image to which the operation is applied.

ee.Image.gammainc

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.
UsageReturns
Image.gammainc(image2)Image
ArgumentTypeDetails
this: image1ImageThe image from which the left operand bands are taken.
image2ImageThe image from which the right operand bands are taken.

ee.Image.get

Extract a property from a feature.
UsageReturns
Image.get(property)
ArgumentTypeDetails
this: objectElementThe feature to extract the property from.
propertyStringThe property to extract.

ee.Image.getArray

Extract a property from a feature.
UsageReturns
Image.getArray(property)Array
ArgumentTypeDetails
this: objectElementThe feature to extract the property from.
propertyStringThe property to extract.

ee.Image.getDownloadURL

Get a download URL for small chunks of image data in GeoTIFF or NumPy format. Maximum request size is 32 MB, maximum grid dimension is 10000. Use getThumbURL for RGB visualization formats PNG and JPG. Returns returns a download URL, or undefined if a callback was specified.
UsageReturns
Image.getDownloadURL(params, callback)Object|String
ArgumentTypeDetails
this: imageImageThe Image instance.
paramsObjectAn object containing download options with the following possible values:   - name: a base name to use when constructing filenames. Only applicable when format is "ZIPPED_GEO_TIFF" (default) or filePerBand is true. Defaults to the image id (or "download" for computed images) when format is "ZIPPED_GEO_TIFF" or filePerBand is true, otherwise a random character string is generated. Band names are appended when filePerBand is true.   - bands: a description of the bands to download. Must be an array of band names or an array of dictionaries, each with the following keys (optional parameters apply only when filePerBand is true):     + id: the name of the band, a string, required.     + crs: an optional CRS string defining the band projection.     + crs_transform: an optional array of 6 numbers specifying an affine transform from the specified CRS, in row-major order: [xScale, xShearing, xTranslation, yShearing, yScale, yTranslation]     + dimensions: an optional array of two integers defining the width and height to which the band is cropped.     + scale: an optional number, specifying the scale in meters of the band; ignored if crs and crs_transform are specified.   - crs: a default CRS string to use for any bands that do not explicitly specify one.   - crs_transform: a default affine transform to use for any bands that do not specify one, of the same format as the crs_transform of bands.   - dimensions: default image cropping dimensions to use for any bands that do not specify them.   - scale: a default scale to use for any bands that do not specify one; ignored if crs and crs_transform are specified.   - region: a polygon specifying a region to download; ignored if crs and crs_transform is specified.   - filePerBand: whether to produce a separate GeoTIFF per band (boolean). Defaults to true. If false, a single GeoTIFF is produced and all band-level transformations will be ignored.   - format: the download format. One of: "ZIPPED_GEO_TIFF" (GeoTIFF file(s) wrapped in a zip file, default), "GEO_TIFF" (GeoTIFF file), "NPY" (NumPy binary format). If "GEO_TIFF" or "NPY", filePerBand and all band-level transformations will be ignored. Loading a NumPy output results in a structured array.
callbackFunction, optionalAn optional callback. If not supplied, the call is made synchronously.

ee.Image.getInfo

An imperative function that returns information about this image via an AJAX call. Returns a description of the image. Includes:   - bands - a list containing metadata about the bands in the collection.   - properties - a dictionary containing the image's metadata properties.
UsageReturns
Image.getInfo(callback)ImageDescription
ArgumentTypeDetails
this: imageImageThe Image instance.
callbackFunction, optionalAn optional callback. If not supplied, the call is made synchronously. If supplied, will be called with the first parameter if successful and the second if unsuccessful.

ee.Image.getMap

An imperative function that returns a map id and optional token, suitable for generating a Map overlay. Returns an object which may be passed to ee.data.getTileUrl or ui.Map.addLayer. Undefined if a callback was specified.
UsageReturns
Image.getMap(visParams, callback)MapId|Object
ArgumentTypeDetails
this: imageImageThe Image instance.
visParamsImageVisualizationParameters, optionalThe visualization parameters.
callbackFunction, optionalAn async callback. If not supplied, the call is made synchronously.

ee.Image.getNumber

Extract a property from a feature.
UsageReturns
Image.getNumber(property)Number
ArgumentTypeDetails
this: objectElementThe feature to extract the property from.
propertyStringThe property to extract.

ee.Image.getString

Extract a property from a feature.
UsageReturns
Image.getString(property)String
ArgumentTypeDetails
this: objectElementThe feature to extract the property from.
propertyStringThe property to extract.

ee.Image.getThumbId

Applies transformations and returns the thumbId. Returns the thumb ID and optional token, or null if a callback is specified.
UsageReturns
Image.getThumbId(params, callback)ThumbnailId
ArgumentTypeDetails
this: imageImageThe Image instance.
paramsObjectParameters identical to ee.data.getMapId, plus, optionally:   - dimensions (a number or pair of numbers in format WIDTHxHEIGHT) Maximum dimensions of the thumbnail to render, in pixels. If only one number is passed, it is used as the maximum, and the other dimension is computed by proportional scaling.   - region Geospatial region of the image to render, it may be an ee.Geometry, GeoJSON, or an array of lat/lon points (E,S,W,N). If not set the default is the bounds image.
callbackFunction, optionalAn optional callback. If not supplied, the call is made synchronously.

ee.Image.getThumbURL

Get a thumbnail URL for this image. Returns a thumbnail URL, or undefined if a callback was specified.
UsageReturns
Image.getThumbURL(params, callback)Object|String
ArgumentTypeDetails
this: imageImageThe Image instance.
paramsObjectParameters identical to ee.data.getMapId, plus, optionally:   - dimensions (a number or pair of numbers in format WIDTHxHEIGHT) Maximum dimensions of the thumbnail to render, in pixels. If only one number is passed, it is used as the maximum, and the other dimension is computed by proportional scaling.   - region Geospatial region of the image to render, it may be an ee.Geometry, GeoJSON, or an array of lat/lon points (E,S,W,N). If not set the default is the bounds image.   - format (string) Either 'png' or 'jpg'.
callbackFunction, optionalAn optional callback. If not supplied, the call is made synchronously.

ee.Image.glcmTexture

Computes texture metrics from the Gray Level Co-occurrence Matrix around each pixel of every band. The GLCM is a tabulation of how often different combinations of pixel brightness values (grey levels) occur in an image. It counts the number of times a pixel of value X lies next to a pixel of value Y, in a particular direction and distance. and then derives statistics from this tabulation. This implementation computes the 14 GLCM metrics proposed by Haralick, and 4 additional metrics from Conners. Inputs are required to be integer valued. The output consists of 18 bands per input band if directional averaging is on and 18 bands per directional pair in the kernel, if not: ASM: f1, Angular Second Moment; measures the number of repeated pairs CONTRAST: f2, Contrast; measures the local contrast of an image CORR: f3, Correlation; measures the correlation between pairs of pixels VAR: f4, Variance; measures how spread out the distribution of gray-levels is IDM: f5, Inverse Difference Moment; measures the homogeneity SAVG: f6, Sum Average SVAR: f7, Sum Variance SENT: f8, Sum Entropy ENT: f9, Entropy. Measures the randomness of a gray-level distribution DVAR: f10, Difference variance DENT: f11, Difference entropy IMCORR1: f12, Information Measure of Corr. 1 IMCORR2: f13, Information Measure of Corr. 2 MAXCORR: f14, Max Corr. Coefficient. (not computed) DISS: Dissimilarity INERTIA: Inertia SHADE: Cluster Shade PROM: Cluster prominence More information can be found in the two papers: Haralick et. al, 'Textural Features for Image Classification', http://doi.org/10.1109/TSMC.1973.4309314 and Conners, et al, Segmentation of a high-resolution urban scene using texture operators', http://doi.org/10.1016/0734-189X(84)90197-X.
UsageReturns
Image.glcmTexture(size, kernel, average)Image
ArgumentTypeDetails
this: imageImageThe image for which to compute texture metrics.
sizeInteger, default: 1The size of the neighborhood to include in each GLCM.
kernelKernel, default: nullA 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).
averageBoolean, default: trueIf true, the directional bands for each metric are averaged.

ee.Image.gradient

Calculates the x and y gradient.
UsageReturns
Image.gradient()Image
ArgumentTypeDetails
this: inputImageThe input image.

ee.Image.gt

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.
UsageReturns
Image.gt(image2)Image
ArgumentTypeDetails
this: image1ImageThe image from which the left operand bands are taken.
image2ImageThe image from which the right operand bands are taken.

ee.Image.gte

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.
UsageReturns
Image.gte(image2)Image
ArgumentTypeDetails
this: image1ImageThe image from which the left operand bands are taken.
image2ImageThe image from which the right operand bands are taken.

ee.Image.hersDescriptor

Creates a dictionary of Histogram Error Ring Statistic (HERS) descriptor arrays from square array properties of an element. The HERS radius is taken to be the array's (side_length - 1) / 2.
UsageReturns
Image.hersDescriptor(selectors, buckets, peakWidthScale)Dictionary
ArgumentTypeDetails
this: elementElementThe element with array properties.
selectorsList, default: nullThe array properties for which descriptors will be created. Selected array properties must be square, floating point arrays. Defaults to all array properties.
bucketsInteger, default: 100The number of HERS buckets. Defaults to 100.
peakWidthScaleFloat, default: 1The HERS peak width scale. Defaults to 1.0.

ee.Image.hersFeature

Computes the Histogram Error Ring Statistic (HERS) for each pixel in each band matching the keys in the descriptor. Only the bands for which HERS could be computed are returned.
UsageReturns
Image.hersFeature(reference, peakWidthScale)Image
ArgumentTypeDetails
this: imageImageThe input image.
referenceDictionaryThe reference descriptor computed with ee.Feature.hersDescriptor(...).
peakWidthScaleFloat, default: 1The HERS peak width scale.

ee.Image.hersImage

Computes the Histogram Error Ring Statistic (HERS) for each pair of pixels in each band present in both images. Only the bands for which HERS could be computed are returned.
UsageReturns
Image.hersImage(image2, radius, buckets, peakWidthScale)Image
ArgumentTypeDetails
this: imageImageThe input image.
image2ImageThe image to compare.
radiusIntegerThe radius of the window.
bucketsInteger, default: 100The number of HERS buckets.
peakWidthScaleFloat, default: 1The HERS peak width scale.

ee.Image.hsvToRgb

Transforms the image from the HSV color space to the RGB color space. Expects a 3 band image in the range [0, 1], and produces three bands: red, green and blue with values in the range [0, 1].
UsageReturns
Image.hsvToRgb()Image
ArgumentTypeDetails
this: imageImageThe image to transform.

ee.Image.hypot

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.
UsageReturns
Image.hypot(image2)Image
ArgumentTypeDetails
this: image1ImageThe image from which the left operand bands are taken.
image2ImageThe image from which the right operand bands are taken.

ee.Image.id

Returns the ID of a given element within a collection. Objects outside collections are not guaranteed to have IDs.
UsageReturns
Image.id()String
ArgumentTypeDetails
this: elementElementThe element from which the ID is taken.

ee.Image.int

Casts the input value to a signed 32-bit integer.
UsageReturns
Image.int()Image
ArgumentTypeDetails
this: valueImageThe image to which the operation is applied.

ee.Image.int16

Casts the input value to a signed 16-bit integer.
UsageReturns
Image.int16()Image
ArgumentTypeDetails
this: valueImageThe image to which the operation is applied.

ee.Image.int32

Casts the input value to a signed 32-bit integer.
UsageReturns
Image.int32()Image
ArgumentTypeDetails
this: valueImageThe image to which the operation is applied.

ee.Image.int64

Casts the input value to a signed 64-bit integer.
UsageReturns
Image.int64()Image
ArgumentTypeDetails
this: valueImageThe image to which the operation is applied.

ee.Image.int8

Casts the input value to a signed 8-bit integer.
UsageReturns
Image.int8()</