Algotithms

Acquisition

The given code is a JavaScript module that contains several functions related to acquiring and processing satellite imagery data.

1. The  `sliceByRevisit`  function takes a collection of satellite images, a starting date, and a number of days as input. It filters the collection by the specified date and duration, and returns the filtered collection.
2. The  `acquireFromDate`  function takes a specific date, a satellite image collection, and a geometry (region of interest) as input. It uses the  `sliceByRevisit`  function to filter the collection based on the specified date and a fixed number of days (16 days in this case). It then applies a mosaic operation to the filtered collection and clips the resulting mosaic to the specified geometry. The function sets additional properties to the mosaic image using the  `mergeProperties`  function. It retrieves the selected satellite type from the session storage and determines the appropriate QA band name. Finally, it calls the  `scoreClouds`  function with the mosaic image, geometry, and QA band name to calculate a cloud score for the image.
3. The  `processCollection`  function takes a satellite type and a geometry as input. It retrieves the satellite image collection for the specified type using the  `getSatelliteCollection`  function. It then retrieves the earliest and latest dates from the collection using the  `retrieveExtremes`  function. The function adds grid positions to each image in the collection and sorts them in ascending order. It retrieves the northeasternmost grid position within the specified geometry. It filters the images in the collection based on the northeastern position. It again retrieves the earliest and latest dates from the filtered collection. The function calculates the difference in days between the earliest image in the northeastern position and the globally earliest image. It computes the remainder of the difference divided by the fixed number of days (16 days). It then calculates the step (number of days to go back) by subtracting the remainder from the fixed number of days. The function computes the date of the earliest possible image in the northeastern position by going back in time using the calculated step. It calculates the number of complete orbital cycles between the earliest and latest possible dates of the images in the northeastern position. It generates slices of 16 days for each complete cycle. For each slice, it creates an empty image and sets metadata related to the corresponding orbital cycle. It keeps only the images whose combined geometries contain the region of interest. Finally, it returns a list of dates from the valid images.
4. The  `generateCloudMap`  function takes a list of dates, a satellite image collection, and a geometry as input. It maps over the list of dates and calls the  `acquireFromDate`  function to acquire the cloud score image for each date. It retrieves the cloud score from each image and returns a list of cloud scores.

sliceByRevisit

The `sliceByRevisit` function filters a collection of satellite images based on a starting date and a number of days.

const sliceByRevisit = (collection, startingDate, days) => {
  const start = ee.Date(startingDate).update(null, null, null, 0, 0, 0);
  const end = start.advance(days, "day");
   return collection.filterDate(start, end);
};

Inputs:

- collection: A collection of satellite images. - startingDate: The starting date for filtering the collection. - days: The number of days for filtering the collection.

Output:

- Returns a filtered collection of satellite images.

Use

To use the `sliceByRevisit` function, follow these steps: - Call the function `sliceByRevisit` and provide the collection of satellite images, starting date, and number of days as inputs. - The function will filter the collection based on the specified starting date and number of days. - The filtered collection will be returned as the output.

const filteredCollection = sliceByRevisit(satelliteImages, "2021-01-01", 16);

acquireFromDate

The `acquireFromDate` function retrieves satellite images from a given date onwards, filters them based on a geometry, and calculates cloud scores for the filtered images.

export const acquireFromDate = (date, collection, geometry) => {
  const slice = sliceByRevisit(
    ee.ImageCollection(collection).filterBounds(geometry),
    date,
    REVISIT_DAYS
  );
  const mosaicked = slice.mosaic().clip(geometry);
   const image = mosaicked.set(mergeProperties(slice));
   let satellite = window.sessionStorage.getItem("selectedSatellite");
  let qaBand = satellite= "Landsat" ? "QA_PIXEL" : "QA60";
   console.log("QA BAND AQUI", qaBand)
   return scoreClouds(image, geometry, qaBand);
};

Inputs:

- date: The starting date to retrieve satellite images from. - collection: The collection of satellite images to retrieve from. - geometry: The geometry to filter the satellite images by.

Output:

- Returns a cloud score for the filtered satellite image.

Use

To use the `acquireFromDate` function, follow these steps: - Call the function `acquireFromDate` and provide the starting date, collection of satellite images, and geometry as inputs. - The function will filter the satellite images based on the provided geometry and starting date. - It will calculate the cloud score for the filtered image. - The cloud score will be returned as the output.

const cloudScore = acquireFromDate("2021-01-01", satelliteImages, geometry);

acquireFromDate

The `acquireFromDate` function retrieves satellite images from a given date onwards, filters them based on a geometry, and calculates cloud scores for the filtered images.

export const acquireFromDate = (date, collection, geometry) => {
  const slice = sliceByRevisit(
    ee.ImageCollection(collection).filterBounds(geometry),
    date,
    REVISIT_DAYS
  );
  const mosaicked = slice.mosaic().clip(geometry);
  const image = mosaicked.set(mergeProperties(slice));
  let satellite = window.sessionStorage.getItem("selectedSatellite");
  let qaBand = satellite= "Landsat" ? "QA_PIXEL" : "QA60";
  console.log("QA BAND AQUI", qaBand)
  return scoreClouds(image, geometry, qaBand);
};

Inputs:

- date: The starting date to retrieve satellite images from. - collection: The collection of satellite images to retrieve from. - geometry: The geometry to filter the satellite images by.

Output:

- Returns a cloud score for the filtered satellite image.

Use

To use the `acquireFromDate` function, follow these steps: - Call the function `acquireFromDate` and provide the starting date, collection of satellite images, and geometry as inputs. - The function will filter the satellite images based on the provided geometry and starting date. - It will calculate the cloud score for the filtered image. - The cloud score will be returned as the output.

const cloudScore = acquireFromDate("2021-01-01", satelliteImages, geometry);

processCollection

The `processCollection` function performs a series of operations on a satellite image collection based on the selected satellite and a specified geometry.

export const processCollection = (satellite, geometry) => {
  const query = getSatelliteCollection(satellite).filterBounds(geometry);
  const global = retrieveExtremes(query);
  const enhanced = query
    .map(addGridPosition(satellite))
    .sort(Metadata.GRID_POSITION);
  const northeasternPosition = ee
    .Image(enhanced.toList(1).get(0))
    .get(Metadata.GRID_POSITION);
  const filtered = enhanced.filter(
    ee.Filter.eq(Metadata.GRID_POSITION, northeasternPosition)
  );
  const northeastern = retrieveExtremes(filtered);
  const difference = northeastern.earliest
    .difference(global.earliest, "day")
    .abs();
  const remainder = ee.Number(difference).mod(REVISIT_DAYS);
  const step = ee.Number(REVISIT_DAYS).subtract(remainder);
  const earliestDate = global.earliest.advance(step.multiply(-1), "day");
  const completeCycles = ee
    .Number(earliestDate.difference(global.latest, "day").abs())
    .divide(REVISIT_DAYS)
    .ceil();
  const additions = ee.List.sequence(0, null, REVISIT_DAYS, completeCycles);
  const carriers = additions.map((increment) => {
    const startingDate = earliestDate.advance(increment, "day");
    const collection = sliceByRevisit(query, startingDate, REVISIT_DAYS);
    const empty = ee.Algorithms.IsEqual(collection.size(), 0);
    const properties = ee.Algorithms.If(empty, {}, mergeProperties(collection));
    return ee.Image(0).set(properties);
  });
  const valid = ee.ImageCollection.fromImages(carriers).filter(
    ee.Filter.contains(Metadata.FOOTPRINT, geometry)
  );
  return ee.List(valid.toList(valid.size()).map(getDate));
};

Inputs:

- satellite: The selected satellite for processing the image collection. - geometry: The geometry to filter the image collection by.

Output:

- Returns a list of dates corresponding to the processed images in the collection.

Use

To use the `processCollection` function, follow these steps: - Call the function `processCollection` and provide the satellite and geometry as inputs. - The function will filter the image collection based on the provided satellite and geometry. - It will perform various operations on the filtered collection, including retrieving extremes, sorting by grid position, and filtering by northeastern position. - The function will generate slices of images based on complete orbital cycles and add metadata to the slices. - It will filter the slices based on the geometry and return a list of dates corresponding to the valid images.

const dates = processCollection("Landsat", geometry);

generateCloudMap

The `generateCloudMap` function takes a list of dates, an image collection, and a geometry as inputs. It generates a list of cloud values corresponding to the provided dates and collection.

export const generateCloudMap = (dates, collection, geometry) => {
  const cloudList = ee.List(dates).map((date) => {
    const image = ee.Image(acquireFromDate(date, collection, geometry));
    return image.get("CLOUDS");
  });
   return cloudList;
};

Inputs:

- dates: A list of dates for which to generate the cloud values. - collection: The image collection from which to acquire images. - geometry: The geometry to filter the image collection by.

Output:

- Returns a list of cloud values corresponding to the provided dates and collection.

Use

To use the `generateCloudMap` function, follow these steps: - Call the function `generateCloudMap` and provide the dates, collection, and geometry as inputs. - The function will iterate over the provided dates and acquire the corresponding image from the collection based on the date and geometry. - It will extract the cloud value from each image and create a list of these values. - The function will return the generated list of cloud values.

const cloudValues = generateCloudMap(dates, imageCollection, geometry);

CSqueeze

The given code is used for geospatial analysis. It primarily analyses land cover and shorelines using Google Earth Engine (imported as 'ee') and Turf.js (imported as 'turf'), two powerful libraries for geospatial analysis. The code contains the functions bellow:

1. landParsing : This function takes in four parameters: landcover, sidesCoords, centerCoord, and shoreline. It checks if the given landcover is water, calculates the intersection of the sides of the landcover with its geometry, and then calculates the length and coordinates of these intersections. It also calculates the distance of the intersections from the center and shoreline. It then determines which side of the landcover is larger and if the landcover is water, it notes the side and intersection point. Finally, it returns an object containing details about the landcover, including its name, class, length of sides, biggest side, intersection points, distances from the baseline and shoreline, and information related to water.
2. landParsingTurf : This function is similar to landParsing but uses the Turf.js library for geospatial operations instead of Google Earth Engine. It takes the same parameters and performs similar operations but uses Turf.js methods like turf.point , turf.lineString , turf.buffer , turf.feature , turf.intersect , turf.length , turf.getCoords , turf.distance , and turf.nearestPointOnLine . 3. extractShoreLine : This function takes in two parameters: baseLineCoords and waterGeometry. It creates a geometry for the baseline and water body, then calculates the intersection of the baseline with the water body. This intersection represents the shoreline. The code also imports and uses a list of landcovers and a 'satellite' object from other modules. The landcovers list is used to assign names and classes to the landcover based on its id.
3. extractShoreLineTurf(baseLine, waterGeometry) : This function takes a base line and a water geometry as inputs. It converts the water geometry into a turf feature, intersects it with the base line, and then converts the intersection into a line, which represents the shoreline.
4. landCoversIntersections(transect, landcoversdata, shoreLine, year) : This function takes a transect, land cover data, a shoreline, and a year as inputs. It then calculates the intersections of the transect with the land cover data. The function also determines which side of the transect intersects with the water body.
5. landCoversIntersectionsTurf(transect, landcoversdata, shoreLine, year) : This function is similar to the previous one, but it uses Turf.js functions for the calculations.
6. filterElevation(image, elevation, type, satellite) : This function takes an image, an elevation value, a type, and a satellite as inputs. It filters the image based on the elevation value, using different methods depending on the type and satellite provided. It returns the filtered image. 5. applyScaleFactors(image) : This function takes an image as input and applies scale factors to the optical and thermal bands of the image. It returns the image with the adjusted bands. 6. getMapBiomasClassificationsList() : This function retrieves a list of band IDs from a specific image in the MapBiomas project on Google Earth Engine. It returns this list. Overall, these functions are used for processing and analyzing geographical data, likely as part of a larger application for environmental or geographical studies.
7. getMapBiomasClassificationYear(AOI, year, elevation = 10) : This function retrieves a classification image from the MapBiomas database for a specific year and area of interest (AOI). The image is then clipped to the AOI and filtered by elevation.
8. getLandCoverLabelMapBiomas(value) : This function returns a label for a given land cover value. It maps the input value to one of four categories: mangrove, vegetation, water, or human.
9. maskCloudLandsat(image, qa_band) and maskCloudSentinel(image) : These two functions are used to mask cloud cover from Landsat and Sentinel satellite images, respectively. They both use bitwise operations to filter out pixels that are flagged as clouds or cloud shadows.
10. getImageCSqueezeInfos(missionName) : This function retrieves metadata for a given satellite mission name.
11. applySaviBand(image, bands) , applyEviBand(image, bands) , applyNdviBand(image, bands) , applyMndwiBand(image, bands) , applyUiBand(image, bands) : These functions calculate various vegetation indices (SAVI, EVI, NDVI, MNDWI, UI) from an image using specific band combinations.
12. trainAndClassify(image, classificationAreas, bands, AOICoords) : This function trains a random forest classifier using the provided image, classification areas, and bands. The trained classifier is then used to classify the image.
13. getMangroves() : This function retrieves a global mangrove map from the ESA WorldCover database, masks out all non-mangrove areas, calculates the slope of the mangrove areas, and returns an overlay of the slope map.

landParsing

This function takes several inputs and performs calculations to determine various properties related to land cover and water bodies.

function landParsing(landcover, sidesCoords, centerCoord, shoreline) {

  var isWater = landcover.id === 2;

  var center = ee.Geometry.Point(centerCoord);

  var intersectionSideOne = ee.Geometry.LineString(sidesCoords[0]).intersection(landcover.geometry, 1);

  var intersectionSideTwo = ee.Geometry.LineString(sidesCoords[1]).intersection(landcover.geometry, 1);

  var intersectionData = ee.Dictionary({
    intersectionSideOneLength: intersectionSideOne.length(),
    intersectionSideTwoLength: intersectionSideTwo.length(),
    intersectionSideOneCoordinatesFlatten: intersectionSideOne.coordinates().flatten(),
    intersectionSideTwoCoordinatesFlatten: intersectionSideTwo.coordinates().flatten()
  }).getInfo()

  var lengthSide = [0, 0]
  var distancesFromBaseLine = [0, 0];
  var distancesFromShoreLine = [0, 0];
  var landCoverIntersectPoint = [null, null];
  var landCoverBiggestSide = -1;
  var waterSide = -1;
  var waterIntersectPoint = [0, 0];

  var oneCoordsFlatten = intersectionData.intersectionSideOneCoordinatesFlatten.reverse()
  var twoCoordsFlatten = intersectionData.intersectionSideTwoCoordinatesFlatten.reverse()

  if (oneCoordsFlatten.length > 0 && twoCoordsFlatten.length > 0) {

    lengthSide[0] = intersectionData.intersectionSideOneLength;
    lengthSide[1] = intersectionData.intersectionSideTwoLength;

    landCoverIntersectPoint[0] = [oneCoordsFlatten[1], oneCoordsFlatten[0]];
    landCoverIntersectPoint[1] = [twoCoordsFlatten[1], twoCoordsFlatten[0]];

    distancesFromBaseLine[0] = landCoverIntersectPoint[0] !== null ? ee.Geometry.Point(landCoverIntersectPoint[0]).distance(center, 1).getInfo() : null;

    distancesFromBaseLine[1] = landCoverIntersectPoint[1] !== null ? ee.Geometry.Point(landCoverIntersectPoint[1]).distance(center, 1).getInfo() : null;

    distancesFromShoreLine[0] = landCoverIntersectPoint[0] !== null ? ee.Geometry.Point(landCoverIntersectPoint[0]).distance(shoreline, 1).getInfo() : null;

    distancesFromShoreLine[1] = landCoverIntersectPoint[1] !== null ? ee.Geometry.Point(landCoverIntersectPoint[1]).distance(shoreline, 1).getInfo() : null;

    if (lengthSide[0] > lengthSide[1]) landCoverBiggestSide = 0;
    else landCoverBiggestSide = 1;
  }
  else if (twoCoordsFlatten.length > 0) {

    lengthSide[1] = intersectionData.intersectionSideTwoLength;
    landCoverIntersectPoint[1] = [twoCoordsFlatten[1], twoCoordsFlatten[0]];

    distancesFromBaseLine[1] = landCoverIntersectPoint[1] !== null ? ee.Geometry.Point(landCoverIntersectPoint[1]).distance(center, 1).getInfo() : null;

    distancesFromShoreLine[1] = landCoverIntersectPoint[1] !== null ? ee.Geometry.Point(landCoverIntersectPoint[1]).distance(shoreline, 1).getInfo() : null;

    landCoverBiggestSide = 1;
  }
  else if (oneCoordsFlatten.length > 0) {

    lengthSide[0] = intersectionData.intersectionSideOneLength;
    landCoverIntersectPoint[0] = [oneCoordsFlatten[1], oneCoordsFlatten[0]];
    distancesFromBaseLine[0] = landCoverIntersectPoint[0] !== null ? ee.Geometry.Point(landCoverIntersectPoint[0]).distance(center, 1).getInfo() : null;

    distancesFromShoreLine[0] = landCoverIntersectPoint[0] !== null ? ee.Geometry.Point(landCoverIntersectPoint[0]).distance(shoreline, 1).getInfo() : null;

    landCoverBiggestSide = 0;
  }

  if (isWater) {
    waterSide = landCoverBiggestSide;
    waterIntersectPoint = landCoverIntersectPoint[landCoverBiggestSide];
  }

  var name = landcovers[landcover.id];
  var classe = landcovers[landcover.id];

  return {
    label: landcover.id,
    name: name,
    classe: classe,
    lengthSide: lengthSide,
    biggestSide: landCoverBiggestSide,
    intersectPoint: landCoverIntersectPoint,
    baseLineDistance: distancesFromBaseLine,
    shoreLineDistance: distancesFromShoreLine,
    waterSide: waterSide,
    waterIntersectPoint: waterIntersectPoint
  };
}

'Inputs:'

- landcover: The land cover object. - sidesCoords: An array containing the coordinates of the two sides. - centerCoord: The coordinate of the center point. - shoreline: The shoreline geometry.

'Output:'

- label: The ID of the land cover. - name: The name of the land cover. - classe: The class of the land cover. - lengthSide: An array containing the lengths of the two sides. - biggestSide: The index of the biggest side. - intersectPoint: An array containing the intersection points of the land cover with the sides. - baseLineDistance: An array containing the distances from the base line. - shoreLineDistance: An array containing the distances from the shoreline. - waterSide: The index of the water side. - waterIntersectPoint: The intersection point of the water side.

'Use'

- Create an instance of the land cover object. - Define the coordinates of the two sides. - Specify the center coordinate. - Provide the shoreline geometry. - Call the function landParsing with the inputs mentioned above. - Retrieve the desired properties from the output.

var landcover = ...; // create the land cover object
var sidesCoords = [...]; // define the coordinates of the sides
var centerCoord = ...; // specify the center coordinate
var shoreline = ...; // provide the shoreline geometry

var result = landParsing(landcover, sidesCoords, centerCoord, shoreline);

landParsingTurf

This function parses a given landcover to determine its attributes and the relationships to other geographical features. It takes in four parameters: landcover, sidesCoords, centerCoord, and shoreline. The function uses the Turf.js library to perform various geographical operations, including creating points and lines, buffering lines, intersecting shapes, and calculating distances. It checks if the landcover is water, calculates the intersection of the landcover with two sides, and determines the length and coordinates of the intersections. It then calculates the distances from the baseline and shoreline for each side, determines the biggest side, and if the landcover is water, it assigns the water side and intersection point. Finally, it returns an object with all the calculated attributes and measurements.

function landParsingTurf(landcover, sidesCoords, centerCoord, shoreline) {

  var isWater = landcover.id === 2;

  var center = turf.point(centerCoord);

  var sideOneTurf = turf.lineString(sidesCoords[0])
  var sideOne = turf.buffer(sideOneTurf, 1, options);
  var sideTwoTurf = turf.lineString(sidesCoords[1])
  var sideTwo = turf.buffer(sideTwoTurf, 1, options);

  var landcoverTurf = turf.feature(landcover.geometry)

  // if (landcover.geometry.type === "MultiPolygon") {
  //   landcoverTurf = turf.multiPolygon(landcover.geometry.coordinates)
  // } else {
  //   landcoverTurf = turf.polygon(landcover.geometry.coordinates)
  // }

  var intersectionSideOne = turf.intersect(sideOne, landcoverTurf);
  var intersectionSideTwo = turf.intersect(sideTwo, landcoverTurf);

  var intersectionData = {
    intersectionSideOneLength: intersectionSideOne ? turf.length(intersectionSideOne, options) : 0,
    intersectionSideTwoLength: intersectionSideTwo ? turf.length(intersectionSideTwo, options) : 0,
    intersectionSideOneCoordinatesFlatten: intersectionSideOne ? turf.getCoords(intersectionSideOne).flat(Infinity) : [],
    intersectionSideTwoCoordinatesFlatten: intersectionSideTwo ? turf.getCoords(intersectionSideTwo).flat(Infinity) : []
  };

  var lengthSide = [0, 0]
  var distancesFromBaseLine = [0, 0];
  var distancesFromShoreLine = [0, 0];
  var landCoverIntersectPoint = [null, null];
  var landCoverBiggestSide = -1;
  var waterSide = -1;
  var waterIntersectPoint = [0, 0];

  var oneCoordsFlatten = intersectionData.intersectionSideOneCoordinatesFlatten.reverse()
  var twoCoordsFlatten = intersectionData.intersectionSideTwoCoordinatesFlatten.reverse()

  if (oneCoordsFlatten.length > 0 && twoCoordsFlatten.length > 0) {

    lengthSide[0] = intersectionData.intersectionSideOneLength;
    lengthSide[1] = intersectionData.intersectionSideTwoLength;

    landCoverIntersectPoint[0] = [oneCoordsFlatten[1], oneCoordsFlatten[0]];
    landCoverIntersectPoint[1] = [twoCoordsFlatten[1], twoCoordsFlatten[0]];

    distancesFromBaseLine[0] = landCoverIntersectPoint[0] !== null ? turf.distance(turf.point(landCoverIntersectPoint[0]), center, options) : null;

    distancesFromBaseLine[1] = landCoverIntersectPoint[1] !== null ? turf.distance(turf.point(landCoverIntersectPoint[1]), center, options) : null;

    var pontoShoreLineProximo0 = turf.nearestPointOnLine(shoreline, turf.point(landCoverIntersectPoint[0]), options);

    distancesFromShoreLine[0] = landCoverIntersectPoint[0] !== null ? turf.distance(turf.point(landCoverIntersectPoint[0]), pontoShoreLineProximo0, options) : null;

    var pontoShoreLineProximo1 = turf.nearestPointOnLine(shoreline, turf.point(landCoverIntersectPoint[1]), options);

    distancesFromShoreLine[1] = landCoverIntersectPoint[1] !== null ? turf.distance(turf.point(landCoverIntersectPoint[1]), pontoShoreLineProximo1, options) : null;

    if (lengthSide[0] > lengthSide[1]) landCoverBiggestSide = 0;
    else landCoverBiggestSide = 1;
  }
  else if (twoCoordsFlatten.length > 0) {

    lengthSide[1] = intersectionData.intersectionSideTwoLength;
    landCoverIntersectPoint[1] = [twoCoordsFlatten[1], twoCoordsFlatten[0]];

    distancesFromBaseLine[1] = landCoverIntersectPoint[1] !== null ? turf.distance(turf.point(landCoverIntersectPoint[1]), center, options) : null;

    var pontoShoreLineProximo1 = turf.nearestPointOnLine(shoreline, turf.point(landCoverIntersectPoint[1]), options);

    distancesFromShoreLine[1] = landCoverIntersectPoint[1] !== null ? turf.distance(turf.point(landCoverIntersectPoint[1]), pontoShoreLineProximo1, options) : null;

    landCoverBiggestSide = 1;
  }
  else if (oneCoordsFlatten.length > 0) {

    lengthSide[0] = intersectionData.intersectionSideOneLength;
    landCoverIntersectPoint[0] = [oneCoordsFlatten[1], oneCoordsFlatten[0]];

    distancesFromBaseLine[0] = landCoverIntersectPoint[0] !== null ? turf.distance(turf.point(landCoverIntersectPoint[0]), center, options) : null;

    var pontoShoreLineProximo0 = turf.nearestPointOnLine(shoreline, turf.point(landCoverIntersectPoint[0]), options);

    distancesFromShoreLine[0] = landCoverIntersectPoint[0] !== null ? turf.distance(turf.point(landCoverIntersectPoint[0]), pontoShoreLineProximo0, options) : null;

    landCoverBiggestSide = 0;
  }

  if (isWater) {
    waterSide = landCoverBiggestSide;
    waterIntersectPoint = landCoverIntersectPoint[landCoverBiggestSide];
  }

  var name = landcovers[landcover.id];
  var classe = landcovers[landcover.id];

  return {
    label: landcover.id,
    name: name,
    classe: classe,
    lengthSide: lengthSide,
    biggestSide: landCoverBiggestSide,
    intersectPoint: landCoverIntersectPoint,
    baseLineDistance: distancesFromBaseLine,
    shoreLineDistance: distancesFromShoreLine,
    waterSide: waterSide,
    waterIntersectPoint: waterIntersectPoint
  };
}
function landParsingTurf(landcover, sidesCoords, centerCoord, shoreline) {...}

Inputs:

- landcover: The landcover object to be parsed. - sidesCoords: An array containing the coordinates of the two sides. - centerCoord: The coordinates of the center point. - shoreline: The shoreline object.

Output:

An object containing the following properties: - label: The ID of the landcover. - name: The name of the landcover. - classe: The class of the landcover. - lengthSide: The lengths of the two sides. - biggestSide: The biggest side. - intersectPoint: The intersection points of the landcover with the two sides. - baseLineDistance: The distances from the baseline for each side. - shoreLineDistance: The distances from the shoreline for each side. - waterSide: The water side, if the landcover is water. - waterIntersectPoint: The water intersection point, if the landcover is water.

Use

- Call the function landParsingTurf with the required parameters: landcover, sidesCoords, centerCoord, and shoreline. - The function will perform various geographical operations and calculations using the Turf.js library. - It will return an object with the calculated attributes and measurements.

landParsingTurf(landcover, sidesCoords, centerCoord, shoreline);

extractShoreLine

This function takes in the baseLineCoords and waterGeometry as input parameters and returns the intersection of the base line geometry and the water geometry lines.

export const extractShoreLine = (baseLineCoords, waterGeometry) => {
  var baseLineGeometry = ee.Geometry(baseLineCoords.geometry);
  var waterGeometryLines = ee.FeatureCollection(waterGeometry.coordinates.map(function (l) {
    return ee.Feature(ee.Geometry.MultiLineString(l))
  })).geometry();
   return baseLineGeometry.intersection(waterGeometryLines, ee.ErrorMargin(1));
}

Inputs:

- baseLineCoords: The coordinates of the base line geometry. This should be in a format that can be converted to an ee.Geometry object. - waterGeometry: The geometry of the water. This should be in a format that can be converted to an ee.FeatureCollection object.

Output:

- Intersection: The intersection of the base line geometry and the water geometry lines.

Use

- Create a base line geometry using the desired coordinates. - Create a water geometry using the desired coordinates. - Call the extractShoreLine function, passing in the base line geometry and water geometry as input parameters. - The function will return the intersection of the base line geometry and the water geometry lines.

extractShoreLine(baseLineCoords, waterGeometry);

extractShoreLineTurf

This function takes in the baseLine and waterGeometry as input parameters and returns the shoreline as a line geometry.

export const extractShoreLineTurf = (baseLine, waterGeometry) => {
  var waterTurf = turf.feature(waterGeometry);
  var intersection = turf.intersect(baseLine, waterTurf);
  var shoreLine = turf.polygonToLine(intersection);
  return shoreLine;
}

Inputs:

- baseLine: The base line geometry. This should be in a format that can be converted to a turf feature object. - waterGeometry: The geometry of the water. This should be in a format that can be converted to a turf feature object.

Output:

- shoreLine: The shoreline as a line geometry.

Use

- Create a base line geometry using the desired coordinates. - Create a water geometry using the desired coordinates. - Call the extractShoreLineTurf function, passing in the base line geometry and water geometry as input parameters. - The function will return the shoreline as a line geometry.

extractShoreLineTurf(baseLine, waterGeometry);

landCoversIntersections

This function takes in the transect, landcoversdata, shoreLine, and year as input parameters and returns an object containing various outputs related to land cover intersections.

export const landCoversIntersections = (transect, landcoversdata, shoreLine, year) => {

  var sideOneCoords = transect.sides[0].coords.map(arr => Object.values(arr));
  var sideTwoCoords = transect.sides[1].coords.map(arr => Object.values(arr));


  var sideOne = sideOneCoords;
  var sideTwo = sideTwoCoords;

  var completeLine = [sideOne, sideTwo];
  var lineCenter = transect.center;

  // // var landcoversCodes = ee.Algorithms.If(filter, filter, landcovers.distinct('label').aggregate_array('label'))

  var waterSide = -1;
  var waterIntersectPoint = [0, 0];
  var landcoversOutput = [];

  var waters = landcoversdata.filter(function (l) { return l.id === 2 })
  var outputwater = waters.map(function (water) {
    return landParsing(water, [sideOne, sideTwo], lineCenter, shoreLine)
  })[0]

  waterSide = outputwater.waterSide;
  waterIntersectPoint = outputwater.waterIntersectPoint;

  if (waterSide > -1) {
    if (waterSide === 0) {

      sideOne = sideTwoCoords
      sideTwo = [lineCenter, waterIntersectPoint]
      completeLine = [sideOne, sideTwo]
    }

    if (waterSide === 1) {

      sideOne = sideOneCoords

      sideTwo = [lineCenter, waterIntersectPoint]

      completeLine = [sideOne, sideTwo]
    }
  }

  landcoversOutput = landcoversdata.map(landcover => {
    return landParsing(landcover, [sideOne, sideTwo], lineCenter, shoreLine)
  });

  var saida = {
    id: transect.transect,
    year,
    center: lineCenter,
    completeLine,
    sides: transect.sides,
    waterSide: waterSide,
    waterIntersectPoint: waterIntersectPoint,
    landCoversIntersections: landcoversOutput
  };

  return saida;

}

Inputs:

- transect: The transect object containing information about the transect line. - landcoversdata: The land cover data used for intersection analysis. This should be an array of land cover objects. - shoreLine: The shoreline as a line geometry. This should be in a format that can be used for intersection analysis. - year: The year associated with the analysis.

Output:

- saida: An object containing various outputs related to land cover intersections. The properties of saida include:

 - id: The transect ID.
 - year: The year associated with the analysis.
 - center: The center point of the transect line.
 - completeLine: The complete line geometry of the transect.
 - sides: An array containing the two sides of the transect line.
 - waterSide: The side of the transect line where water is intersected (-1 if no water intersection).
 - waterIntersectPoint: The coordinates of the point where the transect line intersects with water.
 - landCoversIntersections: An array containing the intersection results for each land cover object in the landcoversdata array.

Use

- Create a transect object containing information about the transect line. - Prepare the land cover data for intersection analysis. - Create the shoreline as a line geometry. - Specify the year associated with the analysis. - Call the landCoversIntersections function, passing in the transect, landcoversdata, shoreLine, and year as input parameters. - The function will return an object containing various outputs related to land cover intersections.

landCoversIntersections(transect, landcoversdata, shoreLine, year);

landCoversIntersectionsTurf

This function takes in the transect, landcoversdata, shoreLine, and year as input parameters and returns an object containing various outputs related to land cover intersections using the Turf library.

export const landCoversIntersectionsTurf = (transect, landcoversdata, shoreLine, year) => {

  var sideOneCoords = transect.sides[0].coords.map(arr => Object.values(arr));
  var sideTwoCoords = transect.sides[1].coords.map(arr => Object.values(arr));


  var sideOne = sideOneCoords;
  var sideTwo = sideTwoCoords;

  var completeLine = [sideOne, sideTwo];
  var lineCenter = transect.center;

  // // var landcoversCodes = ee.Algorithms.If(filter, filter, landcovers.distinct('label').aggregate_array('label'))

  var waterSide = -1;
  var waterIntersectPoint = [0, 0];
  var landcoversOutput = [];

  var waters = landcoversdata.filter(function (l) { return l.id === 2 })
  var outputwater = waters.map(function (water) {
    return landParsingTurf(water, [sideOne, sideTwo], lineCenter, shoreLine)
  })[0]

  waterSide = outputwater.waterSide;
  waterIntersectPoint = outputwater.waterIntersectPoint;

  if (waterSide > -1) {
    if (waterSide === 0) {

      sideOne = sideTwoCoords
      sideTwo = [lineCenter, waterIntersectPoint]
      completeLine = [sideOne, sideTwo]
    }

    if (waterSide === 1) {

      sideOne = sideOneCoords

      sideTwo = [lineCenter, waterIntersectPoint]

      completeLine = [sideOne, sideTwo]
    }
  }

  landcoversOutput = landcoversdata.map(landcover => {
    return landParsingTurf(landcover, [sideOne, sideTwo], lineCenter, shoreLine)
  });

  var saida = {
    id: transect.transect,
    year,
    center: lineCenter,
    completeLine,
    sides: transect.sides,
    waterSide: waterSide,
    waterIntersectPoint: waterIntersectPoint,
    landCoversIntersections: landcoversOutput
  };

  return saida;

}

Inputs:

- transect: The transect object containing information about the transect line. - landcoversdata: The land cover data used for intersection analysis. This should be an array of land cover objects. - shoreLine: The shoreline as a line geometry. This should be in a format that can be used for intersection analysis. - year: The year associated with the analysis.

Output:

- saida: An object containing various outputs related to land cover intersections. The properties of saida include:

 - id: The transect ID.
 - year: The year associated with the analysis.
 - center: The center point of the transect line.
 - completeLine: The complete line geometry of the transect.
 - sides: An array containing the two sides of the transect line.
 - waterSide: The side of the transect line where water is intersected (-1 if no water intersection).
 - waterIntersectPoint: The coordinates of the point where the transect line intersects with water.
 - landCoversIntersections: An array containing the intersection results for each land cover object in the landcoversdata array.

Use

- Create a transect object containing information about the transect line. - Prepare the land cover data for intersection analysis. - Create the shoreline as a line geometry. - Specify the year associated with the analysis. - Call the landCoversIntersectionsTurf function, passing in the transect, landcoversdata, shoreLine, and year as input parameters. - The function will return an object containing various outputs related to land cover intersections using the Turf library.

landCoversIntersectionsTurf(transect, landcoversdata, shoreLine, year);

filterElevation

This function takes in the image, elevation, type, and satellite as input parameters and returns an image with an elevation mask applied.

export const filterElevation = (image, elevation, type = null, satellite = "LANDSAT") => {

  var elevationMask;

  // Digital Elevation Model (DEM)
  // var dem = ee.Image("USGS/SRTMGL1_003").lte(elevation);

  // ALOS DSM: Global 30m v3.2
  // var dem = ee.ImageCollection('JAXA/ALOS/AW3D30/V3_2').select('DSM').mosaic().lte(elevation);
  var dataset = ee.ImageCollection('JAXA/ALOS/AW3D30/V3_2').select(0).mosaic().lte(elevation);

  // var dem = ee.Image("users/nlang/ETH_GlobalCanopyHeightSD_2020_10m_v1").lte(elevation)

  // NADA ELEVATION
  // var nasa = ee.Image('NASA/NASADEM_HGT/001').select(0).lte(elevation);

  if (type === "mapbiomas") {
    // Reprojeta e redimensiona a imagem DSM para a mesma projeção e resolução espacial da imagem classification
    var dataset_reproj = dataset.reproject({
      crs: image.projection(),
      scale: image.projection().nominalScale(),
    });

    // Subtrai a imagem DSM da imagem classification
    var classification_minus_dataset = image.subtract(dataset_reproj);

    // Define a máscara para excluir a área do DSM
    var mask = dataset_reproj.eq(0).not();

    // Aplica a máscara à imagem classification_minus_dsm
    elevationMask = classification_minus_dataset.updateMask(mask);
    return image.updateMask(elevationMask)
  } else {
    if (satellite === "S2") {
      dataset = ee.Image('USGS/SRTMGL1_003');
      elevationMask = dataset.lte(elevation);
    } else {
      elevationMask = dataset.subtract(image.select(0));
    }
  }

  return image.updateMask(elevationMask);

}

Inputs:

- image: The image to be filtered based on elevation. - elevation: The elevation threshold used for filtering. - type: The type of filter to apply ("mapbiomas" or null). - satellite: The satellite used for the filter ("LANDSAT" or "S2").

Output:

- image: The filtered image with an elevation mask applied.

Use

- Prepare the image to be filtered based on elevation. - Specify the elevation threshold for filtering. - Optional: Specify the type of filter to apply ("mapbiomas" or null). - Optional: Specify the satellite used for the filter ("LANDSAT" or "S2"). - Call the filterElevation function, passing in the image, elevation, type, and satellite as input parameters. - The function will return the filtered image with an elevation mask applied.

filterElevation(image, elevation, type, satellite);

applyScaleFactors

This function takes in an image as input and applies scale factors to the optical and thermal bands. It then adds the scaled bands to the input image and returns the modified image.

export const applyScaleFactors = (image) => {
  var opticalBands = image.select('SR_B.').multiply(0.0000275).add(-0.2);
  var thermalBand = image.select('ST_B.*').multiply(0.00341802).add(149.0);
  return image.addBands(opticalBands, null, true)
    .addBands(thermalBand, null, true);
}

Inputs:

- image: The input image to which scale factors will be applied.

Output:

- image: The modified image with scaled bands added.

Use

- Prepare the image to which scale factors will be applied. - Call the applyScaleFactors function, passing in the image as an input parameter. - The function will apply scale factors to the optical and thermal bands of the image and add the scaled bands to the input image. - The modified image with scaled bands added will be returned.

applyScaleFactors(image);

getMapBiomasClassificationsList

This function retrieves the list of classifications from the MapBiomas dataset. It fetches the MapBiomas image and extracts the band IDs to create a list of classifications.

export const getMapBiomasClassificationsList = () => {
  var mapbiomas = ee.Image("projects/mapbiomas-workspace/public/collection7/mapbiomas_collection70_integration_v2").getInfo();
  var list = mapbiomas.bands.map((m) => m.id);

  return list;
}

Inputs:

No input parameters for this function.

Output:

- list: The list of classifications from the MapBiomas dataset.

Use

- Call the getMapBiomasClassificationsList function. - The function will retrieve the list of classifications from the MapBiomas dataset. - The list of classifications will be returned.

getMapBiomasClassificationsList();

getMapBiomasClassificationYear

This function retrieves the MapBiomas classification image for a specific year within a given Area of Interest (AOI). It selects the classification band corresponding to the specified year and clips the image to the AOI. The function also applies an optional elevation filter before returning the classified image.

export const getMapBiomasClassificationYear = (AOI, year, elevation = 10) => {
  let classified = ee
    .Image(
      "projects/mapbiomas-workspace/public/collection7/mapbiomas_collection70_integration_v2"
    )
    .select("classification_" + year)
    .clip(ee.Geometry.Polygon(AOI));

  classified = filterElevation(classified, elevation, "mapbiomas")

  return classified;
}

Inputs:

- AOI: The Area of Interest (AOI) for which the MapBiomas classification image will be retrieved. - year: The specific year for which the MapBiomas classification image will be retrieved. - elevation (optional): The elevation threshold for filtering the classification image. Default value is 10.

Output:

- classified: The MapBiomas classification image for the specified year and AOI.

Use

- Define the Area of Interest (AOI) and the specific year for which the MapBiomas classification image is needed. - Call the getMapBiomasClassificationYear function, passing in the AOI and year as input parameters. - The function will retrieve the MapBiomas classification image for the specified year and AOI. - If an elevation threshold is provided, the function will apply the elevation filter to the classification image. - The classified image will be returned.

getMapBiomasClassificationYear(AOI, year, elevation);

getLandCoverLabelMapBiomas

This function returns the label for a given land cover value based on the MapBiomas land cover types. It takes a land cover value as input and checks if it belongs to any of the predefined land cover types. If a match is found, the corresponding label is returned. If no match is found, a default label of 3 is returned.

export function getLandCoverLabelMapBiomas(value) {

  let landcoverstypes = {
    mangrove: {
      label: 0,
      types: [5]
    },
    vegetation: {
      label: 1,
      types: [1, 3, 4, 5, 49, 10, 11, 12, 32, 29, 50, 13]
    },
    water: {
      label: 2,
      types: [26, 33]
    },
    human: {
      label: 3,
      types: [14, 15, 18, 19, 39, 20, 40, 62, 41, 36, 46, 47, 48, 9, 21, 22, 23, 24, 30, 25, 31, 27]
    },
  }

  for (const type of Object.entries(landcoverstypes)) {
    if (type[1].types.includes(value)) {
      return type[1].label;
    }
  }
  return 3;
}

Inputs:

- value: The land cover value for which the label will be determined.

Output:

- label: The label corresponding to the given land cover value. If no match is found, a default label of 3 is returned.

Use

- Define the land cover value for which the label is needed. - Call the getLandCoverLabelMapBiomas function, passing in the land cover value as an input parameter. - The function will determine the label based on the land cover value. - The label will be returned.

getLandCoverLabelMapBiomas(value);

maskCloudLandsat

This function masks cloud and cloud shadow pixels in a Landsat image using the quality assessment (QA) band. It takes an input image and the QA band name as parameters. The function applies bitwise operations to create a mask that identifies cloud and cloud shadow pixels based on specific bit masks. The image is then updated with the mask, effectively masking out the cloud and cloud shadow pixels.

export function maskCloudLandsat(image, qa_band) {
  var cloudShadowBitMask = (1 << 3);
  var cloudsBitMask = (1 << 5);
  var qa = image.select(qa_band);
  var mask = qa.bitwiseAnd(cloudShadowBitMask).eq(0).and(qa.bitwiseAnd(cloudsBitMask).eq(0));
  return image.updateMask(mask);
}

Inputs:

- image: The Landsat image to be masked. - qa_band: The name of the quality assessment (QA) band in the Landsat image.

Output:

- image: The input Landsat image with cloud and cloud shadow pixels masked out.

Use

- Provide an input Landsat image and the name of the quality assessment (QA) band. - Call the maskCloudLandsat function, passing in the image and qa_band as input parameters. - The function will create a mask based on the QA band to identify cloud and cloud shadow pixels. - The input image will be updated with the mask, masking out the cloud and cloud shadow pixels. - The updated image will be returned.

maskCloudLandsat(image, qa_band);

maskCloudSentinel

This function masks cloud and cirrus pixels in a Sentinel-2 image using the quality assessment (QA) band. It takes an input image as a parameter. The function applies bitwise operations to create a mask that identifies cloud and cirrus pixels based on specific bit masks. The image is then updated with the mask, effectively masking out the cloud and cirrus pixels and dividing the image by 10000.

export function maskCloudSentinel(image) {
  var qa = image.select('QA60');

  // Bits 10 and 11 are clouds and cirrus, respectively.
  var cloudBitMask = 1 << 10;
  var cirrusBitMask = 1 << 11;

  // Both flags should be set to zero, indicating clear conditions.
  var mask = qa.bitwiseAnd(cloudBitMask).eq(0)
    .and(qa.bitwiseAnd(cirrusBitMask).eq(0));

  return image.updateMask(mask).divide(10000);
}

Inputs:

- image: The Sentinel-2 image to be masked.

Output:

- image: The input Sentinel-2 image with cloud and cirrus pixels masked out and divided by 10000.

Use

- Provide an input Sentinel-2 image. - Call the maskCloudSentinel function, passing in the image as an input parameter. - The function will create a mask based on the QA band to identify cloud and cirrus pixels. - The input image will be updated with the mask, masking out the cloud and cirrus pixels and dividing the image by 10000. - The updated image will be returned.

maskCloudSentinel(image);

getImageCSqueezeInfos

This function retrieves metadata information for a given mission name. It takes a missionName parameter as input. The function checks if the missionName includes the string "LANDSAT". If true, it retrieves the metadata from the second satellite object in the satellite array. Otherwise, it retrieves the metadata from the first satellite object. The function returns an object containing the metadata.

export const getImageCSqueezeInfos = (missionName) => {
  let metadata;

  if (missionName.includes("LANDSAT")) {
    metadata = satellite[1].get(missionName);
  } else {
    metadata = satellite[0].get(missionName);
  }

  return { metadata }
}

Inputs:

- missionName: The name of the mission for which metadata information is to be retrieved.

Output:

- metadata: The metadata information for the given mission name.

Use

- Provide a mission name as input. - Call the getImageCSqueezeInfos function, passing in the missionName as an input parameter. - The function will check if the missionName includes the string "LANDSAT". - If true, it will retrieve the metadata from the second satellite object in the satellite array. - If false, it will retrieve the metadata from the first satellite object. - The function will return an object containing the metadata information.

getImageCSqueezeInfos(missionName);

applySaviBand

This function applies the Soil-Adjusted Vegetation Index (SAVI) to an input image using the specified bands. It takes two parameters: image and bands. The function calculates the SAVI using the formula: 1.5 * (NIR - RED) / (NIR + RED + 5000), where NIR represents the Near-Infrared band and RED represents the Red band. The result is then renamed as "SAVI".

export const applySaviBand = (image, bands) => image
  .expression("1.5 * (NIR - RED) / (NIR + RED + 5000)", {
    NIR: image.select(bands.nir),
    RED: image.select(bands.red),
  })
  .rename("SAVI");

Inputs:

- image: The input image to which SAVI will be applied. - bands: An object containing the names of the NIR and RED bands used in the SAVI calculation.

Output:

- image: The input image with the SAVI band applied and renamed as "SAVI".

Use

- Provide an input image and a bands object with the names of the NIR and RED bands. - Call the applySaviBand function, passing in the image and bands as input parameters. - The function will calculate the SAVI using the NIR and RED bands from the input image. - The result will be a new image with the SAVI band applied and renamed as "SAVI".

applySaviBand(image, bands);

applyEviBand

This function applies the Enhanced Vegetation Index (EVI) to an input image using the specified bands. It takes two parameters: image and bands. The function calculates the EVI using the formula: (2.5 * ((NIR - RED)) / (NIR + 6 * RED - 7.5 * BLUE + 1)), where NIR represents the Near-Infrared band, RED represents the Red band, and BLUE represents the Blue band. The result is then renamed as "EVI".

export const applyEviBand = (image, bands) => image
  .expression(
    "(2.5 * ((NIR - RED)) / (NIR + 6 * RED - 7.5 * BLUE + 1))",
    {
      NIR: image.select(bands.nir),
      RED: image.select(bands.red),
      BLUE: image.select(bands.blue),
    }
  )
  .rename("EVI");

Inputs:

- image: The input image to which EVI will be applied. - bands: An object containing the names of the NIR, RED, and BLUE bands used in the EVI calculation.

Output:

- image: The input image with the EVI band applied and renamed as "EVI".

Use

- Provide an input image and a bands object with the names of the NIR, RED, and BLUE bands. - Call the applyEviBand function, passing in the image and bands as input parameters. - The function will calculate the EVI using the NIR, RED, and BLUE bands from the input image. - The result will be a new image with the EVI band applied and renamed as "EVI".

applyEviBand(image, bands);

applyNdviBand

This function applies the Normalized Difference Vegetation Index (NDVI) to an input image using the specified bands. It takes two parameters: image and bands. The function calculates the NDVI using the formula: (NIR - RED) / (NIR + RED), where NIR represents the Near-Infrared band and RED represents the Red band. The result is then renamed as "NDVI".

export const applyNdviBand = (image, bands) =>
   image.expression('(NIR - RED) / (NIR + RED)', {
     'NIR': image.select(bands.nir),
     'RED': image.select(bands.red),
   }).rename('NDVI')
 

Inputs:

- image: The input image to which NDVI will be applied. - bands: An object containing the names of the NIR and RED bands used in the NDVI calculation.

Output:

- image: The input image with the NDVI band applied and renamed as "NDVI".

Use

- Provide an input image and a bands object with the names of the NIR and RED bands. - Call the applyNdviBand function, passing in the image and bands as input parameters. - The function will calculate the NDVI using the NIR and RED bands from the input image. - The result will be a new image with the NDVI band applied and renamed as "NDVI".

applyNdviBand(image, bands);

applyMndwiBand

This function applies the Modified Normalized Difference Water Index (MNDWI) to an input image using the specified bands. It takes two parameters: image and bands. The function calculates the MNDWI using the formula: (GREEN - SWIR) / (GREEN + SWIR), where GREEN represents the Green band and SWIR represents the Shortwave Infrared band. The result is then renamed as "MNDWI".

export const applyMndwiBand = (image, bands) =>
   image.expression('(GREEN - SWIR) / (GREEN + SWIR)', {
     'GREEN': image.select(bands.green),
     'SWIR': image.select(bands.swir),
   }).rename('MNDWI')
 

Inputs:

- image: The input image to which MNDWI will be applied. - bands: An object containing the names of the Green and Shortwave Infrared (SWIR) bands used in the MNDWI calculation.

Output:

- image: The input image with the MNDWI band applied and renamed as "MNDWI".

Use

- Provide an input image and a bands object with the names of the Green and SWIR bands. - Call the applyMndwiBand function, passing in the image and bands as input parameters. - The function will calculate the MNDWI using the Green and SWIR bands from the input image. - The result will be a new image with the MNDWI band applied and renamed as "MNDWI".

applyMndwiBand(image, bands);

trainAndClassify

This function trains a classifier using the provided image and classification areas, and then classifies the image based on the trained classifier. It takes four parameters: image, classificationAreas, bands, and AOICoords. The function performs the following steps:

1. Selects the specified bands from the input image.

2. Samples regions within the classification areas using the selected bands and the "LandCover" property. 3. Trains a random forest classifier using the sampled training data, with the "LandCover" property as the class property and the selected bands as the input properties. 4. Classifies the input image using the trained classifier. 5. Returns the classified image.

export const trainAndClassify = (image, classificationAreas, bands, AOICoords) => {
  let trainingData = image
    .select(bands)
    .sampleRegions({
      collection: classificationAreas,
      properties: ["LandCover"],
      scale: 30,
    });
   let classifier = ee.Classifier.smileRandomForest(30).train({
    features: trainingData,
    classProperty: "LandCover",
    inputProperties: bands,
  });
   let classified = image
    .select(bands)
    .classify(classifier);
   return classified;
}
 

Inputs:

- image: The input image to be classified. - classificationAreas: The collection of areas used for training the classifier. - bands: The names of the bands to be used for training and classification. - AOICoords: The coordinates of the area of interest (AOI).

Output:

- classified: The classified image.

Use

- Provide an input image, a collection of classification areas, the names of the bands, and the coordinates of the AOI. - Call the trainAndClassify function, passing in the required parameters. - The function will train a classifier using the image and classification areas. - It will then classify the image based on the trained classifier. - The result will be the classified image.

trainAndClassify(image, classificationAreas, bands, AOICoords);

getMangroves

This function retrieves the mangrove areas from the "ESA/WorldCover/v200" dataset. It performs the following steps: 1. Retrieves the first image from the "ESA/WorldCover/v200" dataset. 2. Creates a mask to keep only the mangrove areas (value 95 represents mangroves). 3. Applies the mask to the original image, resulting in an image with only the mangrove areas. 4. Sets the visualization parameters for the mangrove areas, including the minimum and maximum values and the color palette. 5. Calculates the slope of the mangrove areas using the ee.Terrain.slope function. 6. Retrieves the map ID and creates an Earth Engine TileSource using the visualization parameters. 7. Creates an ImageOverlay using the TileSource. 8. Returns the ImageOverlay.

export const getMangroves = function () {
  var dataset = ee.ImageCollection("ESA/WorldCover/v200").first();
   var mangroveMask = dataset.select('Map').eq(95);
   var mangroves = dataset.updateMask(mangroveMask);
   var visualization = {
    min: 95,
    max: 95,
    palette: ['000000', 'red']
  };
   var slope = ee.Terrain.slope(mangroves);
  var mapId = slope.getMap(visualization);
  var tileSource = new ee.layers.EarthEngineTileSource(mapId);
  var overlay = new ee.layers.ImageOverlay(tileSource);
   return overlay;
}
 

Inputs:

No input parameters for this function.

Output:

- overlay: An ImageOverlay containing the mangrove areas.

Use

- Call the getMangroves function. - The function will retrieve the mangrove areas from the "ESA/WorldCover/v200" dataset and create an ImageOverlay. - The ImageOverlay can be used to display the mangrove areas on a map.

getMangroves();

Geodesy

This code is a module that provides functions for computing displacement and bearing between two geographic coordinates using Earth Engine.

1. The code begins by importing the "ee" module from the "../../services/earth-engine" directory. Next, the constant variable "EARTHS_RADIUS" is defined with a value of 6371000, which represents the radius of the Earth in meters.
2. The code then defines two helper functions: "toDegrees" and "toRadians". The "toDegrees" function takes longitude and latitude values as input and converts them from radians to degrees. It multiplies the latitude and longitude values by 180 divided by Math.PI to convert them to degrees. It then returns an array containing the converted longitude and latitude values.
3. The "toRadians" function takes a value in degrees as input and converts it to radians. It multiplies the input value by Math.PI divided by 180 and returns the result as an ee.Number object. Next, the code exports two functions: "computeDisplacement" and "computeBearing".
4. The "computeDisplacement" function takes longitude, latitude, theta (bearing angle), and distance as input. It first converts the latitude and longitude values to radians using the "toRadians" function. The theta and distance values are converted to ee.Number objects.
5. The function then calculates the delta value by dividing the distance by the Earth's radius.
6. It then calculates the latitude components of the new coordinates using trigonometric functions. The latitude left component is obtained by multiplying the sine of latitude by the cosine of delta. The latitude right component is obtained by multiplying the cosine of latitude by the sine of delta and the cosine of theta. The latitude components are added together and passed through the arcsine function to obtain the new latitude value.
7. Next, the function calculates the longitude components of the new coordinates. The longitude Y component is obtained by multiplying the sine of theta by the sine of delta and the cosine of latitude. The longitude X component is obtained by subtracting the sine of latitude multiplied by the sine of the new latitude from the cosine of delta. The longitude components are then used to calculate the new longitude value using the atan2 function.
8. Finally, the function calls the "toDegrees" function to convert the new longitude and latitude values from radians to degrees and returns the result.
9. The "computeBearing" function takes four arguments: the longitude and latitude values of two points. It first converts the latitude and longitude values to radians using the "toRadians" function.
10. The function then calculates the delta longitude by subtracting the first longitude from the second longitude.
11. Next, the function calculates the y component of the bearing vector by multiplying the sine of the delta longitude by the cosine of the second latitude.
12. The function then calculates the x component of the bearing vector using trigonometric functions. It subtracts the product of the sine of the first latitude and the cosine of the second latitude multiplied by the cosine of the delta longitude from the product of the cosine of the first latitude and the sine of the second latitude.
13. Finally, the function uses the atan2 function to calculate the bearing angle from the x and y components and returns the result.

    ---

computeDisplacement

This function calculates the displacement between two geographic coordinates using Earth Engine.

 
 const computeDisplacement = (lng, lat, theta, distance) => {
  lat = toRadians(lat);
  lng = toRadians(lng);
  theta = ee.Number(theta);
  distance = ee.Number(distance);
   const delta = distance.divide(EARTHS_RADIUS);
  const latLeft = lat.sin().multiply(delta.cos());
  const latRight = lat.cos().multiply(delta.sin()).multiply(theta.cos());
  const newLat = latLeft.add(latRight).asin();
   const lngY = theta.sin().multiply(delta.sin()).multiply(lat.cos());
  const lngX = delta.cos().subtract(lat.sin().multiply(newLat.sin()));
  const newLng = lng.add(lngX.atan2(lngY));
   return toDegrees(newLng, newLat);
};

Inputs:

- lng: The longitude of the starting point. - lat: The latitude of the starting point. - theta: The bearing angle in degrees. - distance: The distance to travel in meters.

Output:

- An array containing the longitude and latitude of the new location.

Use

- Call the function with the starting longitude, latitude, bearing angle, and distance as inputs. - The function will return an array with the longitude and latitude of the new location.

 computeDisplacement(10, 20, 45, 1000);

computeBearing

This function calculates the bearing angle between two geographic coordinates using Earth Engine.

 
 const computeBearing = (lng1, lat1, lng2, lat2) => {
  lat1 = toRadians(lat1);
  lat2 = toRadians(lat2);
  lng1 = toRadians(lng1);
  lng2 = toRadians(lng2);
   const deltaLng = lng2.subtract(lng1);
  const y = deltaLng.sin().multiply(lat2.cos());
   const rightTerm = lat1.sin().multiply(lat2.cos()).multiply(deltaLng.cos());
  const x = lat1.cos().multiply(lat2.sin()).subtract(rightTerm);
   return x.atan2(y);
};

Inputs:

- lng1: The longitude of the first point. - lat1: The latitude of the first point. - lng2: The longitude of the second point. - lat2: The latitude of the second point.

Output:

- The bearing angle in radians.

Use

- Call the function with the longitude and latitude values of the two points as inputs. - The function will return the bearing angle between the two points.

 computeBearing(10, 20, 30, 40);

Imagery

The code is written in JavaScript and appears to be part of a larger application related to geospatial analysis, specifically for analyzing satellite imagery. It uses Google Earth Engine (GEE) for processing and analyzing geospatial data. Here is a step-by-step explanation of the code:

1. The  `scoreCloudRatio`  function calculates the ratio of cloud coverage in a given region. It takes a masked image with pixel values indicating cloud presence (1 for cloud, 0 for no cloud), a band name, and a geometry representing the region of interest. It also takes optional parameters for scale and maximum pixels. It first multiplies the masked image by the pixel area to get the cloudy area, then it reduces the region by adding pixel values and divides it by the pixel count to get the cloud ratio.
2. The  `scoreClouds`  function calculates the ratio of cloud coverage in an image. It takes an image, a geometry, and a quality assurance (qa) band. It creates expressions for cloud and shadow based on bit shifting operations, applies these expressions to the image, and calculates the ratio of cloudy area to total area. The function then sets this ratio as a property "CLOUDS" on the image and returns the image.
3. The  `generateLayer`  function creates a new layer from a given image, mission, name, and optional parameters. If parameters are undefined, it generates visualization parameters based on the mission.
4. The  `createThumbnail`  and  `createThumbnailCSqueeze`  functions generate a thumbnail for the given image. The functions take an image, a geometry, parameters, and a callback function as arguments. They apply different scaling factors and visualization parameters based on the satellite type (Landsat or Sentinel-2) stored in the session storage. The functions then return the thumbnail URL.
5. The  `cumulativeWindow`  function calculates the cumulative window of a histogram by removing up to a certain percentile of pixels in each side of the histogram's buckets. It takes a full histogram and a percentile as arguments and returns the bounds (min/max) of the cumulative window.

Overall, the code is designed to process and analyze satellite imagery, specifically for cloud coverage and creating thumbnails of the images.

scoreCloudRatio

This function calculates the ratio of the sum of cloud pixels to the total area of a given geometry.

 
 export const scoreCloudRatio = (
  masked,
  bandName,
  geometry,
  scale = 30,
  maxPixels = 1e12
) => {
  const cloudyArea = masked.multiply(ee.Image.pixelArea());
   const cloudClassSum = cloudyArea.reduceRegion({
    reducer: ee.Reducer.sum(),
    scale: scale,
    maxPixels: maxPixels,
    geometry: geometry,
  });
   return ee.Number(cloudClassSum.get(bandName)).divide(geometry.area());
};
 

Inputs:

- masked: The input image with cloud masking applied. - bandName: The name of the band to calculate the cloud sum for. - geometry: The geometry to calculate the cloud sum within. - scale (optional): The scale at which to reduce the image. Default is 30. - maxPixels (optional): The maximum number of pixels to reduce. Default is 1e12.

Output:

- A number representing the ratio of the sum of cloud pixels to the total area of the geometry.

Use

To use the scoreCloudRatio function, follow these steps: - Provide the required input parameters: masked, bandName, and geometry. - Optionally, specify the scale and maxPixels parameters if needed. - Call the function by passing the input parameters. - The function will return the calculated cloud ratio.

 scoreCloudRatio(masked, bandName, geometry);

scoreClouds

This function calculates the ratio of cloudy pixels to the total area of a given geometry in an input image. It takes three parameters: image, geometry, and qa. The function uses the specified quality assessment (QA) band to filter out cloudy and shadow pixels using the C2 algorithm. It then calculates the area of the remaining cloudy pixels and divides it by the area of the input geometry to obtain the cloudy pixel ratio. The function returns the input image with the cloudy pixel ratio added as a property named "CLOUDS".

export const scoreClouds = (image, geometry, qa) => {
  const cloud = "((b(0) >> 3) & 1)"; //C2
  const shadow = "((b(0) >> 4) & 1)"; //C2 
  const expr =  `(${cloud} || ${shadow})` ;
  const filtered = image.select(qa).expression(expr);
  const imageArea = filtered.multiply(ee.Image.pixelArea());
  const res = imageArea.reduceRegion({
    reducer: ee.Reducer.sum(),
    scale: 1000,
    maxPixels: 1e9,
    geometry: geometry,
  });
  const cloudyArea = res.get(qa);
  const ratio = ee.Number(cloudyArea).divide(geometry.area(1));
  return image.set("CLOUDS", ratio);
};
 

Inputs:

- image: The input image to calculate the cloudy pixel ratio for. - geometry: The geometry to calculate the cloudy pixel ratio within. - qa: The name of the quality assessment (QA) band to use for filtering cloudy and shadow pixels.

Output:

- An image with the cloudy pixel ratio added as a property named "CLOUDS".

Use

To use the scoreClouds function, follow these steps: - Provide the required input parameters: image, geometry, and qa. - Call the function by passing the input parameters. - The function will calculate the cloudy pixel ratio using the C2 algorithm and the specified QA band. - The result will be an image with the cloudy pixel ratio added as a property named "CLOUDS".

scoreClouds(image, geometry, qa);

generateLayer

This function generates a layer using an input image, mission, name, and parameters. If the params parameter is undefined, the function calls the generateVisualizationParams function to generate default visualization parameters based on the mission. The function then creates a new Layer object using the input image, name, and params, and returns it.

export const generateLayer = (image, mission, name, params) => {
  if (params=== undefined) {
    console.log("params is undefined", params);
    params = generateVisualizationParams(mission);
  }
  return new Layer(image, name, params);
};

Inputs:

- image: The input image to generate the layer from. - mission: The mission associated with the layer. - name: The name of the layer. - params: Optional visualization parameters for the layer. If not provided, default parameters will be generated based on the mission.

Output:

- layer: A new Layer object generated using the input image, name, and params.

Use

To use the generateLayer function, follow these steps: - Provide the required input parameters: image, mission, and name. - Optionally provide the params parameter for custom visualization parameters. - Call the function by passing the input parameters. - If the params parameter is not provided, the function will generate default visualization parameters based on the mission. - The function will create a new Layer object using the input image, name, and params (or default parameters). - The result will be the generated layer.

generateLayer(image, mission, name, params);

createThumbnail

This function is used to create a thumbnail image based on the input image, geometry, parameters, and callback function. The function first checks the selected satellite from the session storage. If the satellite is "Landsat", it applies scaling factors to the image using the applyScaleFactors function. It then defines a visualization object with the specified bands, minimum value, and maximum value. The function visualizes the image using the visualization parameters and returns the thumbnail URL. If the selected satellite is not "Landsat", the function generates a thumbnail using generic code for LANDSAT COL1 and SENTINEL satellites. The generation parameters are defined based on the input geometry, format, dimensions, and additional parameters. The function checks the date of the image and applies specific generation parameters if the image belongs to the Sentinel-2 satellite and the date is after February 1, 2022. The function then returns the thumbnail URL.

export const createThumbnail = (image, geometry, params, callback) => {
  //code for LANDSAT COLLECTION 2
  let satellite = window.sessionStorage.getItem("selectedSatellite");
  if (satellite === "Landsat") {
    //if(image.getInfo().bands[0].id.indexOf("SR") != -1){
    // Applies scaling factors.
    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);
    }
    // image = applyScaleFactors(image);
    console.log("bands thumbnail", params.bands, "image", image, image.getInfo());
    var visualization = {
      bands: params.bands,//['SR_B4', 'SR_B3', 'SR_B2']
      min: 0.0,
      max: 0.4, //0.3
    };
    console.log("IMG::", "param", params, "bands", params.bands, image.getInfo(), "Id()", image.id(), "Id().getInfo()", image.id, image.id().getInfo(), "properties", image.propertyNames().getInfo());
    //LANDSAT- 5 (3,2,1)
    var outImg = image.visualize(visualization);
    //console.log("createThumbnail", "visualization", outImg.getThumbURL({region: geometry,dimensions: 512, format: 'png'}))
    return outImg.getThumbURL({ region: geometry, dimensions: 512, format: 'png' }, callback);
  } else {
    //generic code (LANDSAT COL1, SENTINEL)
    const generationParams = {
      region: geometry,
      format: "jpg",
      dimensions: 512,
      ...params,
    };
    if (satellite === "Sentinel-2") {

      let dt = new Date(image.getInfo().properties["system:time_start"].value);
      let dtThreshold = new Date(2022, 1, 1);// 01.02.2022
      if (dt > dtThreshold) {
        generationParams.max = 4000;
        generationParams.min = 1000;
        return image.getThumbURL(generationParams, callback);
      }
    }
    return image.getThumbURL(generationParams, callback);
  }
};
};

Inputs:

- image: The input image to create a thumbnail from. - geometry: The geometry to define the region of interest for the thumbnail. - params: Additional parameters for thumbnail generation. - callback: The callback function to handle the thumbnail URL.

Output:

- thumbnailURL: The URL of the generated thumbnail image.

Use

To use the createThumbnail function, follow these steps: - Provide the required input parameters: image, geometry, params, and callback. - Optionally provide additional parameters for customizing the thumbnail generation. - Call the function by passing the input parameters. - The function will generate a thumbnail image based on the input image, geometry, and parameters. - The result will be the URL of the generated thumbnail image.

createThumbnail(image, geometry, params, callback);

createThumbnailCSqueeze

This function is used to create a thumbnail image based on the given parameters.

 
 export const createThumbnailCSqueeze = (image, geometry, params, callback) => {
  console.log("CREATING CSQUEEZE THUMBNAIL", params, geometry)
  //code for LANDSAT COLLECTION 2
  let satellite = window.sessionStorage.getItem("selectedSatellite");
  if (satellite === "Landsat") {
    //if(image.getInfo().bands[0].id.indexOf("SR") != -1){
    // Applies scaling factors.
    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);
    }
    image = applyScaleFactors(image);
    console.log("bands thumbnail", params.bands, "image", image, image.getInfo());
    var visualization = {
      bands: params.bands,//['SR_B4', 'SR_B3', 'SR_B2']
      min: 0.0,
      max: 0.3, //0.3
    };
    // console.log("IMG::", "param", params, "bands", params.bands, image.getInfo(), "Id()", image.id(), "Id().getInfo()", image.id, image.id().getInfo(), "properties", image.propertyNames().getInfo());
    //LANDSAT- 5 (3,2,1)
    var outImg = image.visualize(visualization);
    //console.log("createThumbnail", "visualization", outImg.getThumbURL({region: geometry,dimensions: 512, format: 'png'}))
    return outImg.getThumbURL({ region: geometry, dimensions: 512, format: 'png' }, callback);
  } else {
    //generic code (LANDSAT COL1, SENTINEL)
    const generationParams = {
      region: geometry,
      format: "jpg",
      dimensions: 512,
      ...params,
    };
    // if (satellite === "Sentinel-2") {

    //   let dt = new Date(image.getInfo().properties["system:time_start"].value);
    //   let dtThreshold = new Date(2022, 1, 1);// 01.02.2022
    //   if (dt > dtThreshold) {
    //     generationParams.max = 4000;
    //     generationParams.min = 1000;
    //     return image.getThumbURL(generationParams, callback);
    //   }
    // }
    return image.getThumbURL(generationParams, callback);
  }
};

Inputs:

- image: The image to create a thumbnail from. - geometry: The geometry of the thumbnail. - params: Additional parameters for creating the thumbnail. - callback: The callback function to be executed after the thumbnail is created.

Output:

- The URL of the created thumbnail image.

Use

- Call the function with the required inputs to create a thumbnail image.

 createThumbnailCSqueeze(image, geometry, params, callback);

cumulativeWindow

Calculates the cumulative window of the *fullHistogram* by removing up to *percentile* pixels in each side of the histogram's buckets.

export const cumulativeWindow = (fullHistogram, percentile) => {
  /* Cast to dictionary and retrieve histogram and buckets */
  const cast = ee.Dictionary(fullHistogram);
  const histogram = ee.List(cast.get("histogram"));
  const buckets = ee.List(cast.get("bucketMeans"));

  const pixelCount = ee.Number(histogram.reduce(ee.Reducer.sum()));
  const cumulativeCut = pixelCount.multiply(percentile);

  /*
   * lowerBound returns the min level where cumulative sum
   * would have exceeded the percentile threshold
   */
  const lowerBound = (histogram, buckets) => {
    const cumulativeMin = ee.List.sequence(
      0,
      buckets.size().subtract(1)
    ).iterate(
      (idx, acc) => {
        const ctx = ee.Dictionary(acc);

        const sum = ctx.getNumber("sum").add(histogram.getNumber(idx));
        const min = ee.Algorithms.If(
          sum.gt(cumulativeCut),
          ctx.getNumber("min"),
          buckets.getNumber(idx)
        );

        return ee.Dictionary({ min, sum });
      },
      { min: buckets.getNumber(0), sum: 0 }
    );

    return ee.Dictionary(cumulativeMin).getNumber("min");
  };

  /* Calculate the bound of each side */
  const lower = lowerBound(histogram, buckets);
  const upper = lowerBound(histogram.reverse(), buckets.reverse());

  return ee.List([lower, upper]);
};