Skip to content

GitLab

Last edited by Ramicés dos Santos Silva
Page history

Google Earth Engine Code Documentation

Summary

Steps

The code performs the following steps:

  1. Defines an array of baseline coordinates and another set of coordinates for a different region.
  2. Creates a baseline geometry using the baseline coordinates and adds it as a layer to the map.
  3. Generates orthogonal transects based on the baseline coordinates and adds them as a layer to the map.
  4. Filters an image collection based on a geometry and a date range.
  5. Retrieves the number of images in the image collection and converts it to a list.
  6. Iterates over each image in the list and performs several operations:
    1. Adds the image as a layer to the map.
    2. Retrieves the green and near-infrared bands of the image.
    3. Identifies water features in the image using a threshold value.
    4. If water features are found, it performs the following steps:
      1. Calculates the shoreline by intersecting the water features with a buffered geometry.
      2. Removes noise from the shoreline.
      3. Applies a Gaussian filter to smoothen the shoreline.
      4. Creates a feature for the shoreline and adds it as a layer to the map.
      5. Appends the shoreline feature to an evaluated array.
  7. Calculates the statistics of the evaluated shorelines along the transects.
  8. Generates visualizations of the transects and shoreline statistics.
  9. Calculates the intersections between the first transect and each shoreline feature.
  10. Prints the results of the intersections.
  11. Centers the map on the baseline geometry.

Overall, the code processes a collection of satellite images to identify and analyze shorelines using transects and calculates statistics related to the shorelines.

Code

applyScaleFactors

Applies scale factors to the input image.

function applyScaleFactors(image) {
  var opticalBands = image.select('SR_B.').multiply(0.0000275).add(-0.2);
  var thermalBands = image.select('ST_B.*').multiply(0.00341802).add(149.0);
  return image.addBands(opticalBands, null, true).addBands(thermalBands, null, true);
}
Inputs:

- image: The input image to apply scale factors. Must be an Earth Engine image.

Output:

- The output image with scale factors applied.

Use

- Call the function as follows:

applyScaleFactors(image);

centerMapOnGeometry

Centers the map on a specified geometry.

function centerMapOnGeometry(){
  //center in the first point defined in geometry
  var list = geometry.coordinates();
  var point = list.getInfo();
  Map.setCenter(point[0][0][0],point[0][0][1],13);
}
Inputs:

- No input parameters for this function.

Output:

- No output for this function.

Use

- Call the function as follows:

centerMapOnGeometry();

gaussianKernel

Calculates a Gaussian kernel with a specified size, mean, and sigma.

var gaussianKernel = function (size, mean, sigma) {
  var gaussianCurve = function (x, mean, sigma)  {
    var divider = ee
      .Number(sigma)
      .multiply(ee.Number(2).multiply(Math.PI).sqrt());
    var exponent = ee.Number(-1).multiply(
      ee
        .Number(x)
        .subtract(mean)
        .pow(2)
        .divide(ee.Number(2).multiply(ee.Number(sigma).pow(2)))
    );
     return ee.Number(1).divide(divider).multiply(exponent.exp());
  };
   var half = ee.Number(size).divide(2).floor();
   var begin = ee.Number(0).subtract(half),
    end = ee.Number(0).add(half);
   // Get the normal distribution Y value for each X
  // in the interval
  var kernel = ee.List.sequence(begin, end).map(function (i) { return gaussianCurve(i, mean, sigma)});
   var sum = kernel.reduce(ee.Reducer.sum());
   // Normalize each value, so that the sum of the list
  // will be equal to one
  var normalizedKernel = kernel.map(function (val) { return ee.Number(val).divide(sum)});
   return normalizedKernel;
};
Inputs:

- size: The size of the kernel. Must be a positive integer. - mean: The mean of the Gaussian distribution. - sigma: The standard deviation of the Gaussian distribution.

Output:

- normalizedKernel: A list of values representing the normalized Gaussian kernel.

Use

- Call the function as follows:

var kernel = gaussianKernel(5, 0, 1);

linearGaussianFilter

Calculates a linear Gaussian filter using a given set of coordinates.

var linearGaussianFilter = function (
  coordinates
 ) {
  var samples = 3;
  var mean = 0;
  var sd = 1;
  var coordinateList = ee.List(coordinates);
   // Setup gauss distribution kernel parameters
  var kernelSize = ee.Number(samples);
  var kernelMean = ee.Number(mean);
  var kernelSd = ee.Number(sd);
  var kernel = gaussianKernel(kernelSize, kernelMean, kernelSd);
   var first = coordinateList.reduce(ee.Reducer.first()),
    last = coordinateList.reduce(ee.Reducer.last());
   var sequence = ee.List.sequence(
    ee.Number(0),
    coordinateList.length().subtract(kernelSize)
  );
   var path = sequence.map(function (index) {
    // Take interval of the kernel size to apply the smoothing
    // and zip it to the kernel, so each element in the new list
    // will be a pair of a 2d point and its weight
    var interval = coordinateList
      .slice(ee.Number(index), ee.Number(index).add(kernelSize))
      .zip(kernel);
     // Map the elements, multiplying their axis values by their weight
    var gaussian = interval.map(function (element) {
      // Each element contains a 2d point (0) and a kernel weight (1)
      var asList = ee.List(element);
       var point = ee.List(asList.get(0));
      var weight = ee.Number(asList.get(1));
       // Now we map the two values (each point dimention), multiplying to the weight
      return point.map( function (value) { return ee.Number(value).multiply(weight)});
    });
     // Sum longitude and latitude separately
    var smoothenLong = gaussian
      .map(function (point){ return  ee.List(point).get(0)})
      .reduce(ee.Reducer.sum());
    var smoothenLat = gaussian
      .map(function (point) { return ee.List(point).get(1)})
      .reduce(ee.Reducer.sum());
     // Return final smoothen point
    return ee.List([smoothenLong, smoothenLat]);
  });
   var smoothen = ee.List([]).add(first).cat(path).add(last);
   // return original coordinates if the kernelSize is less than or equal to the length
  // of the given coordinates, otherwise return smoothen coordinates.
  return ee.Algorithms.If(
    coordinateList.size().lte(kernelSize),
    coordinateList,
    smoothen
  );
};
Inputs:

- coordinates: A list of coordinates to be filtered.

Output:

- If the length of the given coordinates is less than or equal to the kernel size, the function returns the original coordinates. Otherwise, it returns the smoothened coordinates.

Use

- Call the function as follows:

var filteredCoordinates = linearGaussianFilter(coordinates);

removeShorelineNoise

This function removes noise from shorelines by calculating the intersection between the shorelines and transects, and returning the geometry with the highest weight.

var removeShorelineNoise = function (shorelines, transects) {
  var coordinates = ee.Geometry(shorelines).coordinates();

  var guard = ee.List(
    ee.Algorithms.If(
      ee.Geometry(shorelines).type().compareTo("MultiLineString").eq(0),
      coordinates,
      [coordinates]
    )
  );
Inputs:

- shorelines: a geometry representing the shorelines to remove noise from. - transects: a geometry representing the transects to calculate the intersection with the shorelines.

var shorelines = ee.Geometry.LineString([[0, 0], [1, 1], [1, 2]]);
var transects = ee.Geometry.LineString([[0, 1], [1, 1]]);
var noiselessShoreline = removeShorelineNoise(shorelines, transects);
Output:

- a geometry representing the noiseless shoreline.

var noiselessShoreline = removeShorelineNoise(shorelines, transects);
print(noiselessShoreline);
Use

To use this function, follow these steps: - Define the shorelines and transects geometries. - Call the removeShorelineNoise function with the shorelines and transects geometries as inputs. - The function will return a geometry representing the noiseless shoreline.

var shorelines = ee.Geometry.LineString([[0, 0], [1, 1], [1, 2]]);
var transects = ee.Geometry.LineString([[0, 1], [1, 1]]);
var noiselessShoreline = removeShorelineNoise(shorelines, transects);
Map.addLayer(shorelines, {}, "Shorelines");
Map.addLayer(transects, {}, "Transects");
Map.addLayer(noiselessShoreline, {}, "Noiseless shoreline");

toDegrees

This function converts longitude and latitude values from radians to degrees.

var toDegrees = function (lng, lat)  {
  lat = lat.multiply(180 / Math.PI);
  lng = lng.multiply(180 / Math.PI);
  return [lng.add(540).mod(360).subtract(180), lat];
};
Inputs:

- lng: a number representing the longitude value in radians. - lat: a number representing the latitude value in radians.

var lng = ee.Number(0.7853981634); // 45 degrees in radians
var lat = ee.Number(0.5235987756); // 30 degrees in radians
var degrees = toDegrees(lng, lat);
Output:

- an array containing the converted longitude and latitude values in degrees.

var degrees = toDegrees(lng, lat);
print(degrees);
Use

To use this function, follow these steps: - Define the longitude and latitude values in radians. - Call the toDegrees function with the longitude and latitude values as inputs. - The function will return an array containing the converted longitude and latitude values in degrees.

var lng = ee.Number(0.7853981634); // 45 degrees in radians
var lat = ee.Number(0.5235987756); // 30 degrees in radians
var degrees = toDegrees(lng, lat);
print(degrees);

computeDisplacement

This function computes the new longitude and latitude coordinates based on the input longitude, latitude, angle (theta), and distance.

var computeDisplacement = function (lng, lat, theta, distance)  {
  ...
};
Inputs:

- lng: a number representing the longitude value in degrees. - lat: a number representing the latitude value in degrees. - theta: a number representing the angle in degrees. - distance: a number representing the distance in meters.

var lng = ee.Number(-122.4194); // San Francisco longitude
var lat = ee.Number(37.7749); // San Francisco latitude
var theta = ee.Number(45); // 45 degrees angle
var distance = ee.Number(1000); // 1000 meters distance
var newCoordinates = computeDisplacement(lng, lat, theta, distance);
Output:

- an array containing the new longitude and latitude coordinates.

var newCoordinates = computeDisplacement(lng, lat, theta, distance);
print(newCoordinates);
Use

To use this function, follow these steps: - Define the longitude, latitude, angle (theta), and distance values. - Call the computeDisplacement function with the longitude, latitude, angle, and distance values as inputs. - The function will return an array containing the new longitude and latitude coordinates.

var lng = ee.Number(-122.4194); // San Francisco longitude
var lat = ee.Number(37.7749); // San Francisco latitude
var theta = ee.Number(45); // 45 degrees angle
var distance = ee.Number(1000); // 1000 meters distance
var newCoordinates = computeDisplacement(lng, lat, theta, distance);
print(newCoordinates);

offsetMapper

This function creates a mapping function that takes an offset value and returns a feature representing a line segment.

var offsetMapper = function (extent, origin, theta) {
  ...
};
Inputs:

- extent: a number representing the extent value. - origin: an array containing the origin coordinates. - theta: a number representing the angle in degrees.

var extent = ee.Number(1000); // extent value
var origin = [ee.Number(-122.4194), ee.Number(37.7749)]; // origin coordinates
var theta = ee.Number(45); // 45 degrees angle
var mappingFunction = offsetMapper(extent, origin, theta);
Output:

- a feature representing a line segment.

var mappingFunction = offsetMapper(extent, origin, theta);
print(mappingFunction);
Use

To use this function, follow these steps: - Define the extent, origin coordinates, and angle (theta) values. - Call the offsetMapper function with the extent, origin, and theta values as inputs. - The function will return a mapping function that takes an offset value and returns a feature representing a line segment.

var extent = ee.Number(1000); // extent value
var origin = [ee.Number(-122.4194), ee.Number(37.7749)]; // origin coordinates
var theta = ee.Number(45); // 45 degrees angle
var mappingFunction = offsetMapper(extent, origin, theta);
print(mappingFunction);

toRadians

This function converts a value from degrees to radians.

var toRadians = function (value)  {
  ...
};
Inputs:

- value: a number representing the value in degrees.

var value = 45; // 45 degrees
var radians = toRadians(value);
Output:

- a number representing the value in radians.

var value = 45; // 45 degrees
var radians = toRadians(value);
print(radians);
Use

To use this function, follow these steps: - Define the value in degrees that you want to convert to radians. - Call the toRadians function with the value as an input. - The function will return the value converted to radians.

var value = 45; // 45 degrees
var radians = toRadians(value);
print(radians);

computeBearing

This function calculates the bearing between two points on the Earth's surface using their longitude and latitude coordinates.

var computeBearing = function (lng1, lat1, lng2, lat2)  {
  ...
};
Inputs:

- lng1: a number representing the longitude of the first point. - lat1: a number representing the latitude of the first point. - lng2: a number representing the longitude of the second point. - lat2: a number representing the latitude of the second point.

var lng1 = -122.4194; // longitude of the first point
var lat1 = 37.7749; // latitude of the first point
var lng2 = -122.4313; // longitude of the second point
var lat2 = 37.7675; // latitude of the second point
var bearing = computeBearing(lng1, lat1, lng2, lat2);
Output:

- a number representing the bearing between the two points.

var lng1 = -122.4194; // longitude of the first point
var lat1 = 37.7749; // latitude of the first point
var lng2 = -122.4313; // longitude of the second point
var lat2 = 37.7675; // latitude of the second point
var bearing = computeBearing(lng1, lat1, lng2, lat2);
print(bearing);
Use

To use this function, follow these steps: - Define the longitude and latitude coordinates of the two points. - Call the computeBearing function with the longitude and latitude values as inputs. - The function will return the bearing between the two points.

var lng1 = -122.4194; // longitude of the first point
var lat1 = 37.7749; // latitude of the first point
var lng2 = -122.4313; // longitude of the second point
var lat2 = 37.7675; // latitude of the second point
var bearing = computeBearing(lng1, lat1, lng2, lat2);
print(bearing);

transectAccumulator

This function is a higher-order function that returns another function. The returned function is used to accumulate and process data for generating transects along a line segment.

var transectAccumulator = function (step, extent) {
  ...
};
Inputs:

- step: a number representing the distance between each transect. - extent: a number representing the total distance of the line segment.

var step = 10; // distance between each transect
var extent = 100; // total distance of the line segment
var accumulator = transectAccumulator(step, extent);
Output:

- a function that accumulates and processes data for generating transects along a line segment.

var step = 10; // distance between each transect
var extent = 100; // total distance of the line segment
var accumulator = transectAccumulator(step, extent);
var result = accumulator(data);
Use

To use this function, follow these steps: - Define the distance between each transect and the total distance of the line segment. - Call the transectAccumulator function with the step and extent values as inputs. - The function will return another function that can be used to accumulate and process data for generating transects along a line segment.

var step = 10; // distance between each transect
var extent = 100; // total distance of the line segment
var accumulator = transectAccumulator(step, extent);
var result = accumulator(data);

generateOrthogonalTransects

This function generates orthogonal transects along a line segment.

var generateOrthogonalTransects = function (coordinates, step, extent) {
  ...
};
Inputs:

- coordinates: a list of coordinates representing the line segment. - step: a number representing the distance between each transect. - extent: a number representing the total distance of the line segment.

var coordinates = [[0,0], [0,10], [10,10], [10,0]]; // list of coordinates representing the line segment
var step = 10; // distance between each transect
var extent = 100; // total distance of the line segment
var transects = generateOrthogonalTransects(coordinates, step, extent);
Output:

- a list of orthogonal transects along the line segment.

var coordinates = [[0,0], [0,10], [10,10], [10,0]]; // list of coordinates representing the line segment
var step = 10; // distance between each transect
var extent = 100; // total distance of the line segment
var transects = generateOrthogonalTransects(coordinates, step, extent);
print(transects);
Use

To use this function, follow these steps: - Define a list of coordinates representing the line segment. - Define the distance between each transect and the total distance of the line segment. - Call the generateOrthogonalTransects function with the coordinates, step, and extent values as inputs. - The function will return a list of orthogonal transects along the line segment.

var coordinates = [[0,0], [0,10], [10,10], [10,0]]; // list of coordinates representing the line segment
var step = 10; // distance between each transect
var extent = 100; // total distance of the line segment
var transects = generateOrthogonalTransects(coordinates, step, extent);
print(transects);

thresholdingAlgorithm

This`` ``function`` ``calculates`` ``the`` ``threshold`` ``value`` ``for`` ``image`` ``segmentation`` ``using`` ``the`` ``thresholding`` ``algorithm.

var thresholdingAlgorithm =  function (histogram, count) {
  ...
};
Inputs:

- histogram: a dictionary representing the histogram of pixel values in an image. - count: the total count of pixels in the image.

var histogram = { "bucketMeans": [0, 1, 2, 3], "histogram": [10, 20, 30, 40] }; // example histogram
var count = 1000; // example count
var threshold = thresholdingAlgorithm(histogram, count);
Output:

- the threshold value for image segmentation.

var histogram = { "bucketMeans": [0, 1, 2, 3], "histogram": [10, 20, 30, 40] }; // example histogram
var count = 1000; // example count
var threshold = thresholdingAlgorithm(histogram, count);
print(threshold);
Use

To use this function, follow these steps: - Define a histogram dictionary representing the histogram of pixel values in an image. - Define the total count of pixels in the image. - Call the thresholdingAlgorithm function with the histogram and count values as inputs. - The function will return the threshold value for image segmentation.

var histogram = { "bucketMeans": [0, 1, 2, 3], "histogram": [10, 20, 30, 40] }; // example histogram
var count = 1000; // example count
var threshold = thresholdingAlgorithm(histogram, count);
print(threshold);

selectThreshold

This function selects a threshold value based on the given parameter.

var selectThreshold = function (threshold) {
  ...
};
Inputs:

- threshold: a numeric value representing the threshold to be selected.

var threshold = 0.0; // example threshold
var thresholdFunction = selectThreshold(threshold);
Output:

- a function that takes image, band, _, and scale as inputs and returns a threshold value.

var threshold = 0.0; // example threshold
var thresholdFunction = selectThreshold(threshold);
var image = ee.Image("example_image"); // example image
var band = "example_band"; // example band
var scale = 30; // example scale
var selectedThreshold = thresholdFunction(image, band, _, scale);
print(selectedThreshold);
Use

To use this function, follow these steps: - Define a threshold value. - Call the selectThreshold function with the threshold value as input. - The function will return a threshold function. - Call the threshold function with image, band, _, and scale values as inputs. - The threshold function will return a selected threshold value.

var threshold = 0.0; // example threshold
var thresholdFunction = selectThreshold(threshold);
var image = ee.Image("example_image"); // example image
var band = "example_band"; // example band
var scale = 30; // example scale
var selectedThreshold = thresholdFunction(image, band, _, scale);
print(selectedThreshold);

identifyWaterFeature

This function identifies water features in an image based on a given threshold and returns the geometry of the water feature.

var identifyWaterFeature = function (
  image,
  geometry,
  scale,
  band,
  thresholdFn
){
  ...
};
Inputs:

- image: an image representing the area of interest. - geometry: a geometry object representing the region of interest. - scale: a numeric value representing the scale at which to perform the analysis. - band: a string representing the band to use for the analysis. - thresholdFn: a function that calculates the threshold value for identifying water features.

var image = ee.Image("example_image"); // example image
var geometry = ee.Geometry.Point(0, 0); // example geometry
var scale = 30; // example scale
var band = "example_band"; // example band
var thresholdFn = function (ndwi, band, geometry, scale) {
  // example threshold function
  var threshold = ee.Number(0.01);
  return threshold;
};
var waterGeometry = identifyWaterFeature(image, geometry, scale, band, thresholdFn);
print(waterGeometry);
Output:

- a geometry object representing the water feature.

var image = ee.Image("example_image"); // example image
var geometry = ee.Geometry.Point(0, 0); // example geometry
var scale = 30; // example scale
var band = "example_band"; // example band
var thresholdFn = function (ndwi, band, geometry, scale) {
  // example threshold function
  var threshold = ee.Number(0.01);
  return threshold;
};
var waterGeometry = identifyWaterFeature(image, geometry, scale, band, thresholdFn);
print(waterGeometry);
Use

To use this function, follow these steps: - Define an image, geometry, scale, band, and threshold function. - Call the identifyWaterFeature function with the defined inputs. - The function will return the geometry of the identified water feature. - Print or use the waterGeometry variable to access the geometry.

var image = ee.Image("example_image"); // example image
var geometry = ee.Geometry.Point(0, 0); // example geometry
var scale = 30; // example scale
var band = "example_band"; // example band
var thresholdFn = function (ndwi, band, geometry, scale) {
  // example threshold function
  var threshold = ee.Number(0.01);
  return threshold;
};
var waterGeometry = identifyWaterFeature(image, geometry, scale, band, thresholdFn);
print(waterGeometry);

generateTransectsStatistics

This function generates statistics for transects based on a given baseline and shorelines, and returns the modified transects with additional properties.

var generateTransectsStatistics = function (
  transects,
  baseline,
  shorelines,
  keepProps
) {
  ...
};
Inputs:

- transects: a feature collection representing the transects. - baseline: a feature representing the baseline for distance calculations. - shorelines: a feature collection representing the shorelines for distance calculations. - keepProps: an array of property names to keep from the original transects.

var transects = ee.FeatureCollection("example_transects"); // example transects
var baseline = ee.Feature("example_baseline"); // example baseline
var shorelines = ee.FeatureCollection("example_shorelines"); // example shorelines
var keepProps = ["prop1", "prop2"]; // example property names
var transectsStats = generateTransectsStatistics(transects, baseline, shorelines, keepProps);
print(transectsStats);
Output:

- a feature collection representing the modified transects with additional properties.

var transects = ee.FeatureCollection("example_transects"); // example transects
var baseline = ee.Feature("example_baseline"); // example baseline
var shorelines = ee.FeatureCollection("example_shorelines"); // example shorelines
var keepProps = ["prop1", "prop2"]; // example property names
var transectsStats = generateTransectsStatistics(transects, baseline, shorelines, keepProps);
print(transectsStats);
Use

To use this function, follow these steps: - Define the transects, baseline, shorelines, and keepProps. - Call the generateTransectsStatistics function with the defined inputs. - The function will return the modified transects with additional properties. - Print or use the transectsStats variable to access the modified transects.

var transects = ee.FeatureCollection("example_transects"); // example transects
var baseline = ee.Feature("example_baseline"); // example baseline
var shorelines = ee.FeatureCollection("example_shorelines"); // example shorelines
var keepProps = ["prop1", "prop2"]; // example property names
var transectsStats = generateTransectsStatistics(transects, baseline, shorelines, keepProps);
print(transectsStats);

calculateDistances

This function calculates the distances between a transect and a baseline, as well as the distances between the transect and multiple shorelines. It returns a dictionary with the calculated distances and additional metadata.

var calculateDistances =  function (transect, baseline, shorelines) {
  ...
};
Inputs:

- transect: a feature representing the transect. - baseline: a feature representing the baseline. - shorelines: a feature collection representing the shorelines.

var transect = ee.Feature("example_transect"); // example transect
var baseline = ee.Feature("example_baseline"); // example baseline
var shorelines = ee.FeatureCollection("example_shorelines"); // example shorelines
var distances = calculateDistances(transect, baseline, shorelines);
print(distances);
Output:

- a dictionary containing the calculated distances and additional metadata.

var transect = ee.Feature("example_transect"); // example transect
var baseline = ee.Feature("example_baseline"); // example baseline
var shorelines = ee.FeatureCollection("example_shorelines"); // example shorelines
var distances = calculateDistances(transect, baseline, shorelines);
print(distances);
Use

To use this function, follow these steps: - Define the transect, baseline, and shorelines. - Call the calculateDistances function with the defined inputs. - The function will return a dictionary with the calculated distances and additional metadata. - Print or use the distances variable to access the calculated distances.

var transect = ee.Feature("example_transect"); // example transect
var baseline = ee.Feature("example_baseline"); // example baseline
var shorelines = ee.FeatureCollection("example_shorelines"); // example shorelines
var distances = calculateDistances(transect, baseline, shorelines);
print(distances);

withPrefix

This function takes a string as input and adds the prefix "cassie:" to it. It returns the modified string.

var withPrefix = function (str) { return "cassie:" + str};
Inputs:

- str: a string that needs to be modified.

var str = "example string"; // example input string
var modifiedStr = withPrefix(str);
print(modifiedStr);
Output:

- a string with the prefix "cassie:" added to it.

var str = "example string"; // example input string
var modifiedStr = withPrefix(str);
print(modifiedStr);
Use

To use this function, follow these steps: - Define a string that needs to be modified. - Call the withPrefix function with the defined string as the input. - The function will return the modified string. - Print or use the modifiedStr variable to access the modified string.

var str = "example string"; // example input string
var modifiedStr = withPrefix(str);
print(modifiedStr);

calculateStatistics

This`` ``JavaScript`` ``function`` ``calculates`` ``various`` ``statistics`` ``from`` ``a`` ``given`` ``measurement.`` ``The`` ``measurement`` ``is`` ``expected`` ``to`` ``be`` ``a`` ``dictionary`` ``with`` ``distance`` ``and`` ``date`` ``values.`` ``The`` ``function`` ``calculates`` ``the`` ``earliest,`` ``latest,`` ``closest,`` ``and`` ``farthest`` ``measurements,`` ``as`` ``well`` ``as`` ``SCE`` ``(Shoreline`` ``Change`` ``Envelope),`` ``NSM`` ``(Net`` ``Shoreline`` ``Movement),`` ``EPR`` ``(End`` ``Point`` ``Rate),`` ``LRR`` ``(Linear`` ``Regression`` ``Rate),`` ``correlation,`` ``and`` ``R-squared`` ``values.`` ``Additionally,`` ``it`` ``labels`` ``the`` ``data`` ``using`` ``the`` ``Esteves`` ``method`` ``and`` ``formats`` ``the`` ``first`` ``and`` ``last`` ``dates`` ``to`` ``ISO`` ``standard`` ``format`` ``in`` ``UTC.

var calculateStatistics = function (measurement) {
  ...
};
Inputs:

- measurement: a dictionary containing distance and date values for each measurement.

var measurement = {distance: 100, date: new Date()}; // example input
var stats = calculateStatistics(measurement);
console.log(stats);
Output:

- A dictionary containing the calculated statistics: SCE, NSM, EPR, LRR, correlation, R-squared values, Esteves label, first and last dates, and internal data such as count, trend, and regression.

var measurement = {distance: 100, date: new Date()}; // example input
var stats = calculateStatistics(measurement);
console.log(stats);
Use

To use this function, follow these steps: - Define a measurement dictionary with distance and date values. - Call the calculateStatistics function with the defined measurement as the input. - The function will return a dictionary with the calculated statistics. - Use console.log or similar to view the returned statistics.

var measurement = {distance: 100, date: new Date()}; // example input
var stats = calculateStatistics(measurement);
console.log(stats);

estevesLabelling

This function is used to classify land cover based on a given Land Ruggedness Index (LRR) value.

var estevesLabelling = function (lrr) {
  var classification = ee.Algorithms.If(
    lrr.lt(-1.0),
    ESTEVES_LABELS["Critically Eroded"].class,
    ee.Algorithms.If(
      lrr.lt(-0.5),
      ESTEVES_LABELS["Eroded"].class,
      ee.Algorithms.If(
        lrr.lt(0.5),
        ESTEVES_LABELS["Stable"].class,
        ESTEVES_LABELS["Accreted"].class
      )
    )
  );
  return ee.String(classification);
};
Inputs:

- lrr: The Land Ruggedness Index (LRR) value used for classification.

Output:

- Classification: The land cover classification based on the given LRR value.

Use

1. Define the Land Ruggedness Index (LRR) value. 2. Call the function "estevesLabelling" with the LRR value as the input. 3. The function will classify the land cover based on the LRR value and return the classification.

 <Given a code example for the call function>;

complementaryProperties

This function takes a transect, a measurement, and a list of properties to keep as input. It generates complementary properties based on the input and returns a summary with the combined properties.

var complementaryProperties = function (transect, measurement, keepProps) {
  var props = ee.Dictionary(
    ee.Algorithms.If(keepProps, transect.toDictionary(keepProps), {})
  );
   /* Distances properties  */
  var distanceInfo = measurement.values();
   var dates = serializeList(
    distanceInfo.map( function (item) {
      // Format Data as ISO standart formating and and UTC
      return ee.Date(ee.Dictionary(item).get("date")).format(null, 'UTC')
    })
  );
  var distances = serializeList(
    distanceInfo.map(function (item) { return ee.Dictionary(item).getNumber("distance")})
  );
   /* Coordinates properties  */
  var coordinates = transect.geometry().coordinates();
   var start = ee.List(coordinates.get(0)),
    end = ee.List(coordinates.get(1));
   var longStart = start.getNumber(0),
    longEnd = end.getNumber(0);
   var latStart = start.getNumber(1),
    latEnd = end.getNumber(1);
   /* Summary */
  var summary = ee.Dictionary({
    longStart: longStart,
    longEnd: longEnd,
    latStart: latStart,
    latEnd: latEnd,
    dates: dates,
    distances: distances,
  });
   return summary.combine(props);
};
Inputs:

- transect: The transect object. - measurement: The measurement object. - keepProps: A list of properties to keep.

Output:

- summary: A summary object containing the combined properties.

Use

To use this function, follow these steps: - Define a transect object. - Define a measurement object. - Define a list of properties to keep (optional). - Call the complementaryProperties function with the defined transect, measurement, and keepProps as inputs. - The function will generate complementary properties based on the input and return a summary object with the combined properties.

var transect = ...; // define transect object
var measurement = ...; // define measurement object
var keepProps = ...; // define list of properties to keep (optional)
var summary = complementaryProperties(transect, measurement, keepProps);
print(summary);

serializeList

This function takes a subject as input and serializes it into a string format. It converts a list into a string representation enclosed in square brackets.

var serializeList = function (subject) {
  return ee.String('"[').cat(ee.List(subject).join(",")).cat(']"');
};
Inputs:

- subject: The list to be serialized.

var myList = [1, 2, 3]; // example input list
var serializedString = serializeList(myList);
print(serializedString);
Output:

- serializedString: A string representation of the input list, enclosed in square brackets.

var myList = [1, 2, 3]; // example input list
var serializedString = serializeList(myList);
print(serializedString);
Use

To use this function, follow these steps: - Define a list that needs to be serialized. - Call the serializeList function with the defined list as the input. - The function will return a string representation of the input list, enclosed in square brackets. - Print or use the serializedString variable to access the serialized list.

var myList = [1, 2, 3]; // example input list
var serializedString = serializeList(myList);
print(serializedString);

combineReducers

This function takes two reducers as input and combines them into a single reducer. It returns the combined reducer.

var combineReducers = function (reducer01, reducer02) {
  return reducer01.combine(reducer02, "", true);
};
Inputs:

- reducer01: The first reducer to be combined. - reducer02: The second reducer to be combined.

var reducer1 = ...; // example input reducer 1
var reducer2 = ...; // example input reducer 2
var combinedReducer = combineReducers(reducer1, reducer2);
print(combinedReducer);
Output:

- combinedReducer: The combined reducer.

var reducer1 = ...; // example input reducer 1
var reducer2 = ...; // example input reducer 2
var combinedReducer = combineReducers(reducer1, reducer2);
print(combinedReducer);
Use

To use this function, follow these steps: - Define two reducers that need to be combined. - Call the combineReducers function with the defined reducers as inputs. - The function will return the combined reducer. - Print or use the combinedReducer variable to access the combined reducer.

var reducer1 = ...; // example input reducer 1
var reducer2 = ...; // example input reducer 2
var combinedReducer = combineReducers(reducer1, reducer2);
print(combinedReducer);

expandHorizontally

This function takes a list of transects and an amount as input. It expands each transect horizontally by the specified amount and returns the expanded transects.

var expandHorizontally = function (transects, amount) {
  amount = ee.Number(amount).divide(2);
   var mapper = function (transect)  {
    transect = ee.Feature(transect);
     var coords = transect.geometry().coordinates();
    var a = ee.List(coords.get(0));
    var b = ee.List(coords.get(1));
     var theta = computeBearing(a.get(0), a.get(1), b.get(0), b.get(1)).add(
      Math.PI
    );
    var alpha = theta.add(Math.PI * 0.5);
    var beta = theta.subtract(Math.PI * 0.5);
     var a1 = computeDisplacement(a.get(0), a.get(1), alpha, amount);
    var a2 = computeDisplacement(a.get(0), a.get(1), beta, amount);
     var b1 = computeDisplacement(b.get(0), b.get(1), alpha, amount);
    var b2 = computeDisplacement(b.get(0), b.get(1), beta, amount);
     var rectangle = ee.Feature(ee.Geometry.Polygon([[a1, a2, b2, b1]]));
    return rectangle.copyProperties(transect);
  };
   return transects.map(mapper);
};
Inputs:

- transects: A list of transects to be expanded. - amount: The amount by which the transects should be expanded horizontally.

var transects = ...; // example input transects
var amount = 100; // example input amount
var expandedTransects = expandHorizontally(transects, amount);
print(expandedTransects);
Output:

- expandedTransects: The expanded transects.

var transects = ...; // example input transects
var amount = 100; // example input amount
var expandedTransects = expandHorizontally(transects, amount);
print(expandedTransects);
Use

To use this function, follow these steps: - Define a list of transects that need to be expanded. - Specify the amount by which the transects should be expanded horizontally. - Call the expandHorizontally function with the defined transects and amount as inputs. - The function will return the expanded transects. - Print or use the expandedTransects variable to access the expanded transects.

var transects = ...; // example input transects
var amount = 100; // example input amount
var expandedTransects = expandHorizontally(transects, amount);
print(expandedTransects);

summaryShorelineStatistics

This function calculates summary statistics for shoreline distances.

var summaryShorelineStatistics = function (transects, shorelines) {
  // Code explanation goes here
};
Inputs:

- transects: A list of transects. - shorelines: A feature collection of shorelines.

Output:

- A feature collection with summary statistics for each shoreline.

Use

To use the summaryShorelineStatistics function, follow these steps:
1. Call the function and provide the transects and shorelines as inputs.

2. Retrieve the output feature collection.

 var result = summaryShorelineStatistics(transects, shorelines);

sequence

This function generates a sequence of numbers starting from 0 up to a given number n-1.

var sequence = function (n) {
  var start = 0;
  return Array.from(Array(n).keys()).map(function (val) {return val + start});
};
Inputs:

- n: a number indicating the length of the sequence.

var n = 5; // example input number
var result = sequence(n);
console.log(result);
Output:

- An array of numbers representing the sequence from 0 to n-1.

var n = 5; // example input number
var result = sequence(n);
console.log(result);
Use

To use this function, follow these steps: - Define a number n indicating the length of the desired sequence. - Call the sequence function with n as the input. - The function will return an array of numbers representing the sequence. - Print or use the result variable to access the generated sequence.

var n = 5; // example input number
var result = sequence(n);
console.log(result);

generateColors

This function generates a specified number of colors based on the amount and lightness parameters. It uses the ColorConverter library to convert the colors from HSL to hexadecimal format.

var generateColors = function (amount, lightness) {
  var slice = amount=== 1 ? 0 : 240.0 / (amount - 1);
   return sequence(amount).map(function (i)  {
    return "#" + ColorConverter.hsl.hex(slice * i, 100, lightness);
  });
}
Inputs:

- amount: a number indicating the desired number of colors to generate. - lightness: a number indicating the lightness value for the generated colors.

var amount = 5; // example input number
var lightness = 50; // example input number
var colors = generateColors(amount, lightness);
console.log(colors);
Output:

- An array of colors represented in hexadecimal format.

var amount = 5; // example input number
var lightness = 50; // example input number
var colors = generateColors(amount, lightness);
console.log(colors);
Use

To use this function, follow these steps: - Define the amount of colors to generate and the desired lightness value. - Call the generateColors function with the defined parameters. - The function will return an array of colors represented in hexadecimal format. - Print or use the colors variable to access the generated colors.

var amount = 5; // example input number
var lightness = 50; // example input number
var colors = generateColors(amount, lightness);
console.log(colors);