Code Add

cassie_code/src/algorithms/acquisition/index.md

+```markdown
+# Earth Engine Satellite Imagery Processing
+
+This code file is designed to process satellite imagery using Google Earth Engine. It includes functions to acquire images from a specific date, process collections of images, and generate cloud maps. The code relies on several utility functions and external libraries.
+
+## Dependencies
+- Google Earth Engine (`ee`)
+- Utility functions from `../utils`
+- Metadata handling from `../../common/metadata`
+- Cloud scoring from `../imagery`
+
+## Constants
+- `REVISIT_DAYS`: The number of days between satellite revisits (16 days).
+
+## Functions
+
+### `sliceByRevisit(collection, startingDate, days)`
+Slices an image collection based on a starting date and a number of days.
+
+- **Parameters:**
+  - `collection` (ee.ImageCollection): The image collection to slice.
+  - `startingDate` (String): The starting date for the slice.
+  - `days` (Number): The number of days to include in the slice.
+- **Returns:** 
+  - `ee.ImageCollection`: The sliced image collection.
+
+### `acquireFromDate(date, collection, geometry)`
+Acquires a mosaicked and clipped image from a specific date within a given geometry.
+
+- **Parameters:**
+  - `date` (String): The date to acquire the image from.
+  - `collection` (String): The satellite image collection.
+  - `geometry` (ee.Geometry): The geometry to clip the image to.
+- **Returns:** 
+  - `ee.Image`: The processed image with cloud scoring applied.
+
+### `processCollection(satellite, geometry)`
+Processes a satellite image collection to compute valid dates for image acquisition.
+
+- **Parameters:**
+  - `satellite` (String): The satellite name.
+  - `geometry` (ee.Geometry): The geometry to filter the collection by.
+- **Returns:** 
+  - `ee.List`: A list of valid dates for image acquisition.
+
+### `generateCloudMap(dates, collection, geometry)`
+Generates a cloud map for a list of dates within a given geometry.
+
+- **Parameters:**
+  - `dates` (ee.List): A list of dates to generate the cloud map for.
+  - `collection` (String): The satellite image collection.
+  - `geometry` (ee.Geometry): The geometry to filter the collection by.
+- **Returns:** 
+  - `ee.List`: A list of cloud scores for each date.
+
+## Usage Example
+
+```javascript
+import { acquireFromDate, processCollection, generateCloudMap } from './path/to/this/file';
+
+// Define parameters
+const satellite = 'Landsat';
+const geometry = ee.Geometry.Point([longitude, latitude]);
+const date = '2023-01-01';
+
+// Acquire image from a specific date
+const image = acquireFromDate(date, satellite, geometry);
+
+// Process collection to get valid dates
+const validDates = processCollection(satellite, geometry);
+
+// Generate cloud map
+const cloudMap = generateCloudMap(validDates, satellite, geometry);
+```
+
+## Edge Cases and Assumptions
+- Assumes that the input date is in a valid format.
+- Assumes that the satellite collection contains images for the specified geometry.
+- Handles cases where no images are found within a slice by setting empty properties.
+
+## References
+- Google Earth Engine Documentation: [https://developers.google.com/earth-engine](https://developers.google.com/earth-engine)
+```
+
+

cassie_code/src/algorithms/csqueeze/index.md

+```markdown
+# Code Overview
+
+This code provides various functions for processing and analyzing geographical and satellite data using the Earth Engine and Turf.js libraries. It includes functions for land cover parsing, shoreline extraction, cloud masking, and vegetation index calculations.
+
+## Dependencies
+
+- `earth-engine` (imported as `ee`)
+- `@turf/turf` (imported as `turf`)
+- `../../common/satellites` (imported as `satellite`)
+
+## Functions
+
+### `landParsing`
+
+Parses land cover data to determine intersections and distances.
+
+**Parameters:**
+- `landcover` (Object): The land cover data.
+- `sidesCoords` (Array): Coordinates of the sides.
+- `centerCoord` (Array): Center coordinates.
+- `shoreline` (Object): Shoreline geometry.
+
+**Returns:**
+- Object containing parsed land cover data.
+
+### `landParsingTurf`
+
+Similar to `landParsing` but uses Turf.js for geometric operations.
+
+**Parameters:**
+- `landcover` (Object): The land cover data.
+- `sidesCoords` (Array): Coordinates of the sides.
+- `centerCoord` (Array): Center coordinates.
+- `shoreline` (Object): Shoreline geometry.
+
+**Returns:**
+- Object containing parsed land cover data.
+
+### `extractShoreLine`
+
+Extracts the shoreline from baseline coordinates and water geometry.
+
+**Parameters:**
+- `baseLineCoords` (Array): Baseline coordinates.
+- `waterGeometry` (Object): Water geometry.
+
+**Returns:**
+- Shoreline geometry.
+
+### `extractShoreLineTurf`
+
+Similar to `extractShoreLine` but uses Turf.js for geometric operations.
+
+**Parameters:**
+- `baseLine` (Object): Baseline geometry.
+- `waterGeometry` (Object): Water geometry.
+
+**Returns:**
+- Shoreline geometry.
+
+### `landCoversIntersections`
+
+Calculates intersections of land covers along a transect.
+
+**Parameters:**
+- `transect` (Object): Transect data.
+- `landcoversdata` (Array): Land cover data.
+- `shoreLine` (Object): Shoreline geometry.
+- `year` (Number): Year of the data.
+
+**Returns:**
+- Object containing land cover intersections.
+
+### `landCoversIntersectionsTurf`
+
+Similar to `landCoversIntersections` but uses Turf.js for geometric operations.
+
+**Parameters:**
+- `transect` (Object): Transect data.
+- `landcoversdata` (Array): Land cover data.
+- `shoreLine` (Object): Shoreline geometry.
+- `year` (Number): Year of the data.
+
+**Returns:**
+- Object containing land cover intersections.
+
+### `filterElevation`
+
+Filters an image based on elevation.
+
+**Parameters:**
+- `image` (Object): The image to filter.
+- `elevation` (Number): Elevation threshold.
+- `type` (String, optional): Type of filtering.
+- `satellite` (String, optional): Satellite name.
+
+**Returns:**
+- Filtered image.
+
+### `applyScaleFactors`
+
+Applies scale factors to an image.
+
+**Parameters:**
+- `image` (Object): The image to scale.
+
+**Returns:**
+- Scaled image.
+
+### `getMapBiomasClassificationsList`
+
+Retrieves a list of MapBiomas classifications.
+
+**Returns:**
+- Array of classification IDs.
+
+### `getMapBiomasClassificationYear`
+
+Retrieves MapBiomas classification for a specific year.
+
+**Parameters:**
+- `AOI` (Array): Area of interest.
+- `year` (Number): Year of the classification.
+- `elevation` (Number, optional): Elevation threshold.
+
+**Returns:**
+- Classified image.
+
+### `getLandCoverLabelMapBiomas`
+
+Maps a value to a land cover label based on MapBiomas classifications.
+
+**Parameters:**
+- `value` (Number): The value to map.
+
+**Returns:**
+- Land cover label.
+
+### `maskCloudLandsat`
+
+Masks clouds in a Landsat image.
+
+**Parameters:**
+- `image` (Object): The image to mask.
+- `qa_band` (String): Quality assurance band.
+
+**Returns:**
+- Cloud-masked image.
+
+### `maskCloudSentinel`
+
+Masks clouds in a Sentinel image.
+
+**Parameters:**
+- `image` (Object): The image to mask.
+
+**Returns:**
+- Cloud-masked image.
+
+### `getImageCSqueezeInfos`
+
+Retrieves metadata for a given mission name.
+
+**Parameters:**
+- `missionName` (String): The mission name.
+
+**Returns:**
+- Object containing metadata.
+
+### `applySaviBand`
+
+Applies the SAVI band to an image.
+
+**Parameters:**
+- `image` (Object): The image to process.
+- `bands` (Object): Band names.
+
+**Returns:**
+- Image with SAVI band.
+
+### `applyEviBand`
+
+Applies the EVI band to an image.
+
+**Parameters:**
+- `image` (Object): The image to process.
+- `bands` (Object): Band names.
+
+**Returns:**
+- Image with EVI band.
+
+### `applyNdviBand`
+
+Applies the NDVI band to an image.
+
+**Parameters:**
+- `image` (Object): The image to process.
+- `bands` (Object): Band names.
+
+**Returns:**
+- Image with NDVI band.
+
+### `applyMndwiBand`
+
+Applies the MNDWI band to an image.
+
+**Parameters:**
+- `image` (Object): The image to process.
+- `bands` (Object): Band names.
+
+**Returns:**
+- Image with MNDWI band.
+
+### `applyUiBand`
+
+Applies the UI band to an image.
+
+**Parameters:**
+- `image` (Object): The image to process.
+- `bands` (Object): Band names.
+
+**Returns:**
+- Image with UI band.
+
+### `trainAndClassify`
+
+Trains a classifier and classifies an image.
+
+**Parameters:**
+- `image` (Object): The image to classify.
+- `classificationAreas` (Object): Training data.
+- `bands` (Array): Band names.
+- `AOICoords` (Array): Area of interest coordinates.
+
+**Returns:**
+- Classified image.
+
+### `getMangroves`
+
+Retrieves mangrove data from the ESA WorldCover dataset.
+
+**Returns:**
+- Mangrove overlay.
+```
+
+

cassie_code/src/algorithms/geodesy/index.md

+```markdown
+# Earth Engine Utilities
+
+This code file provides utility functions for geographic calculations using the Google Earth Engine (GEE) service. It includes functions to compute displacement and bearing between geographic coordinates.
+
+## Dependencies
+- Google Earth Engine (GEE) service
+
+## Constants
+- `EARTHS_RADIUS`: The radius of the Earth in meters (6371000 meters).
+
+## Functions
+
+### `toDegrees(lng, lat)`
+Converts longitude and latitude from radians to degrees.
+
+#### Parameters
+- `lng` (ee.Number): Longitude in radians.
+- `lat` (ee.Number): Latitude in radians.
+
+#### Returns
+- `Array`: An array containing the converted longitude and latitude in degrees.
+
+### `toRadians(value)`
+Converts a value from degrees to radians.
+
+#### Parameters
+- `value` (Number): The value in degrees.
+
+#### Returns
+- `ee.Number`: The value converted to radians.
+
+### `computeDisplacement(lng, lat, theta, distance)`
+Computes the new geographic coordinates after moving a certain distance in a specified direction from a starting point.
+
+#### Parameters
+- `lng` (Number): Longitude of the starting point in degrees.
+- `lat` (Number): Latitude of the starting point in degrees.
+- `theta` (Number): Bearing angle in degrees.
+- `distance` (Number): Distance to move in meters.
+
+#### Returns
+- `Array`: An array containing the new longitude and latitude in degrees.
+
+#### Example Usage
+```javascript
+const newCoords = computeDisplacement(-73.935242, 40.730610, 45, 1000);
+console.log(newCoords); // [newLng, newLat]
+```
+
+### `computeBearing(lng1, lat1, lng2, lat2)`
+Computes the bearing angle between two geographic coordinates.
+
+#### Parameters
+- `lng1` (Number): Longitude of the first point in degrees.
+- `lat1` (Number): Latitude of the first point in degrees.
+- `lng2` (Number): Longitude of the second point in degrees.
+- `lat2` (Number): Latitude of the second point in degrees.
+
+#### Returns
+- `ee.Number`: The bearing angle in radians.
+
+#### Example Usage
+```javascript
+const bearing = computeBearing(-73.935242, 40.730610, -74.0060, 40.7128);
+console.log(bearing); // Bearing angle in radians
+```
+
+## Edge Cases and Assumptions
+- Assumes input coordinates are in degrees.
+- Assumes the Earth is a perfect sphere with a radius of 6371000 meters.
+- The functions rely on the Google Earth Engine (GEE) service for numerical operations.
+
+## References
+- [Google Earth Engine API](https://developers.google.com/earth-engine)
+```
+
+

cassie_code/src/algorithms/imagery/index.md

+# Code Overview
+
+This code file provides several utility functions for working with satellite imagery using the Google Earth Engine (GEE) API. The primary functionalities include scoring cloud ratios, generating layers, creating thumbnails, and calculating cumulative windows for histograms.
+
+## Dependencies
+- Google Earth Engine (GEE) API
+- Custom classes and utilities from local modules
+
+## Functions
+
+### `scoreCloudRatio`
+
+Calculates the cloud ratio in a given region based on a masked image.
+
+#### Parameters
+- `masked` (ee.Image): The masked image with cloud presence indicated by pixel values.
+- `bandName` (string): The name of the band to be analyzed.
+- `geometry` (ee.Geometry): The region of interest.
+- `scale` (number, default=30): The scale for the reduction.
+- `maxPixels` (number, default=1e12): The maximum number of pixels to include in the reduction.
+
+#### Returns
+- `ee.Number`: The cloud ratio in the specified region.
+
+#### Example
+```javascript
+const cloudRatio = scoreCloudRatio(maskedImage, 'cloudBand', regionGeometry);
+```
+
+### `scoreClouds`
+
+Scores clouds in an image based on a quality assessment (QA) band.
+
+#### Parameters
+- `image` (ee.Image): The input image.
+- `geometry` (ee.Geometry): The region of interest.
+- `qa` (string): The QA band to be used for cloud scoring.
+
+#### Returns
+- `ee.Image`: The input image with an added property "CLOUDS" indicating the cloud ratio.
+
+#### Example
+```javascript
+const cloudScoredImage = scoreClouds(inputImage, regionGeometry, 'QA60');
+```
+
+### `generateLayer`
+
+Generates a visualization layer from an image.
+
+#### Parameters
+- `image` (ee.Image): The input image.
+- `mission` (string): The mission name (e.g., 'Landsat', 'Sentinel').
+- `name` (string): The name of the layer.
+- `params` (object): Visualization parameters.
+
+#### Returns
+- `Layer`: A new Layer object.
+
+#### Example
+```javascript
+const layer = generateLayer(inputImage, 'Landsat', 'LayerName', visualizationParams);
+```
+
+### `createThumbnail`
+
+Creates a thumbnail URL for an image.
+
+#### Parameters
+- `image` (ee.Image): The input image.
+- `geometry` (ee.Geometry): The region of interest.
+- `params` (object): Thumbnail parameters.
+- `callback` (function): Callback function to handle the thumbnail URL.
+
+#### Returns
+- `string`: The thumbnail URL.
+
+#### Example
+```javascript
+const thumbnailUrl = createThumbnail(inputImage, regionGeometry, thumbnailParams, callback);
+```
+
+### `createThumbnailCSqueeze`
+
+Creates a thumbnail URL for an image with specific scaling factors applied.
+
+#### Parameters
+- `image` (ee.Image): The input image.
+- `geometry` (ee.Geometry): The region of interest.
+- `params` (object): Thumbnail parameters.
+- `callback` (function): Callback function to handle the thumbnail URL.
+
+#### Returns
+- `string`: The thumbnail URL.
+
+#### Example
+```javascript
+const thumbnailUrl = createThumbnailCSqueeze(inputImage, regionGeometry, thumbnailParams, callback);
+```
+
+### `cumulativeWindow`
+
+Calculates the cumulative window of a histogram by removing a specified percentile of pixels from each side.
+
+#### Parameters
+- `fullHistogram` (ee.Dictionary): The full histogram dictionary.
+- `percentile` (number | ee.Number): The percentile to be removed from each side.
+
+#### Returns
+- `ee.List`: The cumulative window bounds (min/max).
+
+#### Example
+```javascript
+const windowBounds = cumulativeWindow(histogramDict, 0.05);
+```
+
+## Edge Cases and Assumptions
+- Assumes that input data is in the correct format and within expected ranges.
+- Handles large datasets by setting appropriate `maxPixels` values.
+- Specific scaling factors are applied for Landsat Collection 2 images.
+
+## References
+- Google Earth Engine API: [https://developers.google.com/earth-engine](https://developers.google.com/earth-engine)
+

cassie_code/src/algorithms/index.md

+# Overview
+This code file serves as an entry point for exporting various modules and functionalities related to satellite data processing. It consolidates and re-exports components from different files, making them accessible from a single location.
+
+# Dependencies
+- The code relies on ES6 module syntax for importing and exporting functionalities.
+
+# Modules
+
+## Satellite
+This module is imported as the default export from the `satellite` file. It likely contains core functionalities related to satellite data.
+
+## Shoreline
+This module is imported from the `shoreline` file and re-exported as a namespace. It likely contains functionalities related to shoreline data processing.
+
+## Acquisition
+This module is imported from the `acquisition` file and re-exported as a namespace. It likely contains functionalities related to data acquisition processes.
+
+## Utils
+This module is imported from the `utils` file and re-exported as a namespace. It likely contains utility functions that support various operations within the system.
+
+# Usage Example
+To use any of the exported modules, you can import them in your code as follows:
+
+```javascript
+import { Satellite } from 'path-to-this-file';
+import { Shoreline } from 'path-to-this-file';
+import { Acquisition } from 'path-to-this-file';
+import { Utils } from 'path-to-this-file';
+
+// Example usage
+const satelliteData = new Satellite();
+const shorelineData = Shoreline.getShorelineData();
+const acquisitionData = Acquisition.startAcquisition();
+const formattedData = Utils.formatData(satelliteData);
+```
+
+# Assumptions and Edge Cases
+- It is assumed that the files `satellite`, `shoreline`, `acquisition`, and `utils` exist in the same directory as this file.
+- The code assumes that the imported modules are correctly implemented and do not contain any syntax errors.
+
+# References
+- For more information on ES6 module syntax, refer to the [MDN Web Docs on import](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import) and [export](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/export).
+

cassie_code/src/algorithms/satellite/index.md

+# Overview
+This code file serves as an entry point for importing and exporting satellite data processing modules. It consolidates different satellite data classes into a single exportable object for easier access and usage.
+
+## Dependencies
+- `Landsat`: Handles data processing for Landsat satellite imagery.
+- `LandsatTOA`: Manages Top of Atmosphere (TOA) corrections for Landsat data.
+- `Sentinel`: Processes data from Sentinel satellite imagery.
+
+# Module Documentation
+
+## Landsat
+Handles data processing for Landsat satellite imagery. This module is responsible for various operations such as data extraction, transformation, and analysis specific to Landsat satellites.
+
+## LandsatTOA
+Manages Top of Atmosphere (TOA) corrections for Landsat data. This module applies necessary corrections to Landsat imagery to account for atmospheric interference, ensuring more accurate data analysis.
+
+## Sentinel
+Processes data from Sentinel satellite imagery. This module provides functionalities for handling Sentinel data, including extraction, transformation, and analysis.
+
+# Usage Example
+To use any of the satellite data processing modules, you can import them from the consolidated export object:
+
+```javascript
+import SatelliteModules from './path_to_this_file';
+
+const { Landsat, LandsatTOA, Sentinel } = SatelliteModules;
+
+// Example usage
+const landsatData = new Landsat();
+const landsatToaData = new LandsatTOA();
+const sentinelData = new Sentinel();
+```
+
+This approach allows for a clean and organized way to access different satellite data processing functionalities from a single import statement.
+

cassie_code/src/algorithms/satellite/landsat.md

+# Code Overview
+
+This code is designed to interact with Google Earth Engine (GEE) to process satellite imagery data. It includes functions to filter and process image collections based on specific criteria, such as date and geographic bounds, and to generate cloud cover maps.
+
+## Dependencies
+
+- Google Earth Engine (GEE) library
+- Utility functions from `../utils`
+- Metadata constants from `../../common/metadata`
+- Cloud scoring function from `../imagery`
+
+## Functions
+
+### `addGridPosition(element)`
+
+Adds a grid position to an image based on its WRS path and row.
+
+- **Parameters:**
+  - `element`: An image element from GEE.
+- **Returns:** 
+  - An image with an added grid position property.
+
+### `sliceByRevisit(collection, startingDate, days)`
+
+Slices an image collection based on a starting date and a number of days.
+
+- **Parameters:**
+  - `collection`: GEE ImageCollection to be sliced.
+  - `startingDate`: The starting date for the slice.
+  - `days`: Number of days to include in the slice.
+- **Returns:** 
+  - A filtered image collection.
+
+### `acquireFromDate(date, mission, geometry)`
+
+Acquires a mosaic image from a specific date, mission, and geometry, and scores it for cloud cover.
+
+- **Parameters:**
+  - `date`: The date for which to acquire the image.
+  - `mission`: The satellite mission (e.g., Landsat).
+  - `geometry`: The geographic bounds for the image.
+- **Returns:** 
+  - A cloud-scored image.
+
+### `processCollection(mission, geometry)`
+
+Processes an image collection to compute valid dates for image acquisition.
+
+- **Parameters:**
+  - `mission`: The satellite mission.
+  - `geometry`: The geographic bounds for the image collection.
+- **Returns:** 
+  - A list of valid dates.
+
+### `generateCloudMap(dates, mission, geometry)`
+
+Generates a cloud cover map for a list of dates.
+
+- **Parameters:**
+  - `dates`: A list of dates.
+  - `mission`: The satellite mission.
+  - `geometry`: The geographic bounds for the images.
+- **Returns:** 
+  - A list of cloud cover percentages.
+
+### `queryAvailable(mission)`
+
+Queries available images for a given mission and geometry.
+
+- **Parameters:**
+  - `mission`: The satellite mission.
+- **Returns:** 
+  - A function that takes `geometry` as a parameter and returns a dictionary of dates and cloud cover percentages.
+
+### `getAvailable(mission)`
+
+Placeholder function for getting available images.
+
+- **Parameters:**
+  - `mission`: The satellite mission.
+- **Returns:** 
+  - A function that takes `geometry` as a parameter.
+
+### `acquire(mission)`
+
+Acquires an image for a given mission, date, and geometry.
+
+- **Parameters:**
+  - `mission`: The satellite mission.
+  - `date`: The date for which to acquire the image.
+  - `geometry`: The geographic bounds for the image.
+- **Returns:** 
+  - The acquired image.
+
+### `format(properties)`
+
+Formats image properties into a string.
+
+- **Parameters:**
+  - `properties`: The properties of the image.
+- **Returns:** 
+  - A formatted string.
+
+## Usage Examples
+
+### Acquiring an Image
+
+```javascript
+const mission = { name: 'LANDSAT/LC08/C01/T1_SR', cycle: 16, bands: { qa: 'BQA' } };
+const date = '2021-01-01';
+const geometry = ee.Geometry.Point([102.0, 17.0]);
+
+const image = acquireFromDate(date, mission, geometry);
+```
+
+### Generating a Cloud Map
+
+```javascript
+const dates = ['2021-01-01', '2021-01-17'];
+const cloudMap = generateCloudMap(dates, mission, geometry);
+```
+
+### Querying Available Images
+
+```javascript
+const availableImages = queryAvailable(mission)(geometry);
+```
+
+## Edge Cases and Assumptions
+
+- Assumes that input dates are in a valid format.
+- Assumes that the geometry provided is valid and within the bounds of the satellite mission.
+- Handles cases where no images are available by returning empty lists or dictionaries.
+
+## References
+
+- [Google Earth Engine Documentation](https://developers.google.com/earth-engine)
+- Utility functions and metadata constants are imported from local modules.
+

cassie_code/src/algorithms/satellite/landsatToa.md

+```markdown
+# Earth Engine Utilities
+
+This code file provides a set of utilities for working with Google Earth Engine (GEE) to process satellite imagery. It includes functions for cloud masking, date slicing, and metadata management.
+
+## Dependencies
+- `ee` from `../../services/earth-engine`
+- Utility functions from `../utils`
+- Cloud scoring from `../imagery`
+- Metadata constants from `../../common/metadata`
+
+## Functions
+
+### addGridPosition
+Adds a grid position to an image based on its WRS path and row.
+
+**Parameters:**
+- `element` (Object): The image element to which the grid position will be added.
+
+**Returns:**
+- `ee.Image`: The image with the added grid position.
+
+### sliceByRevisit
+Slices an image collection by a given revisit period starting from a specific date.
+
+**Parameters:**
+- `collection` (ee.ImageCollection): The image collection to slice.
+- `startingDate` (String): The starting date for the slice.
+- `days` (Number): The number of days for the revisit period.
+
+**Returns:**
+- `ee.ImageCollection`: The sliced image collection.
+
+### maskTOAClouds
+Masks clouds in an image based on the Top of Atmosphere (TOA) reflectance.
+
+**Parameters:**
+- `image` (ee.Image): The image to mask.
+- `bandName` (String): The name of the band to use for cloud masking.
+
+**Returns:**
+- `ee.Image`: The cloud-masked image.
+
+### acquireFromDate
+Acquires an image from a specific date, mission, and geometry, and calculates the cloud ratio.
+
+**Parameters:**
+- `date` (String): The date to acquire the image.
+- `mission` (Object): The mission details including name, cycle, and bands.
+- `geometry` (ee.Geometry): The geometry to clip the image to.
+
+**Returns:**
+- `ee.Image`: The processed image with cloud ratio metadata.
+
+### processCollection
+Processes an image collection to compute valid dates for image acquisition.
+
+**Parameters:**
+- `mission` (Object): The mission details including name and cycle.
+- `geometry` (ee.Geometry): The geometry to filter the image collection.
+
+**Returns:**
+- `ee.List`: A list of valid dates for image acquisition.
+
+### generateCloudMap
+Generates a cloud map for a list of dates, mission, and geometry.
+
+**Parameters:**
+- `dates` (ee.List): The list of dates to generate the cloud map for.
+- `mission` (Object): The mission details including name and bands.
+- `geometry` (ee.Geometry): The geometry to clip the images to.
+
+**Returns:**
+- `ee.List`: A list of cloud ratios for each date.
+
+### queryAvailable
+Queries available images for a given mission and geometry.
+
+**Parameters:**
+- `mission` (Object): The mission details including name and cycle.
+- `geometry` (ee.Geometry): The geometry to filter the image collection.
+
+**Returns:**
+- `ee.Dictionary`: A dictionary mapping dates to cloud ratios.
+
+### getAvailable
+Placeholder function for getting available images.
+
+**Parameters:**
+- `mission` (Object): The mission details.
+- `geometry` (ee.Geometry): The geometry to filter the image collection.
+
+### acquire
+Acquires an image for a given date, mission, and geometry.
+
+**Parameters:**
+- `mission` (Object): The mission details.
+- `date` (String): The date to acquire the image.
+- `geometry` (ee.Geometry): The geometry to clip the image to.
+
+**Returns:**
+- `ee.Image`: The acquired image.
+
+### format
+Formats properties into a string.
+
+**Parameters:**
+- `properties` (Object): The properties to format.
+
+**Returns:**
+- `String`: The formatted string.
+
+## Usage Example
+
+```javascript
+import EarthEngineUtils from './path/to/earth-engine-utils';
+
+const mission = {
+  name: 'LANDSAT/LC08/C01/T1_TOA',
+  cycle: 16,
+  bands: {
+    qa: 'BQA'
+  }
+};
+
+const geometry = ee.Geometry.Point([102.0, 17.0]);
+
+// Query available images
+const availableImages = EarthEngineUtils.queryAvailable(mission)(geometry);
+
+// Acquire an image for a specific date
+const date = '2021-01-01';
+const image = EarthEngineUtils.acquire(mission)(date, geometry);
+
+// Format properties
+const properties = { 'system:time_start': '2021-01-01', 'cloud': 0.1 };
+const formatted = EarthEngineUtils.format(properties);
+console.log(formatted);
+```
+
+## Edge Cases and Assumptions
+- Assumes that input data will be in the correct format.
+- Handles cases where no valid images are found by returning `null`.
+- Based on Google Earth Engine's API and its specific methods and data structures.
+```
+

cassie_code/src/algorithms/satellite/sentinel.md

+# Code Documentation
+
+## Overview
+This code file is designed to interact with the Google Earth Engine (GEE) to process satellite imagery data. It includes functions to filter and manipulate image collections, mask clouds, and generate cloud coverage maps. The code is particularly focused on handling data from different satellite missions, such as LANDSAT and Sentinel.
+
+## Dependencies
+- Google Earth Engine (GEE)
+- External utility functions from `../utils`
+- Metadata handling from `../../common/metadata`
+- Cloud scoring from `../imagery`
+- LANDSAT-specific algorithms from `../../algorithms/satellite/landsat`
+
+## Functions
+
+### `addGridPosition(element)`
+Adds grid position metadata to an image.
+
+**Parameters:**
+- `element`: The image element to which the grid position will be added.
+
+**Returns:**
+- An image with the grid position metadata.
+
+### `sliceByRevisit(collection, startingDate, days)`
+Slices an image collection by a specified revisit period.
+
+**Parameters:**
+- `collection`: The image collection to be sliced.
+- `startingDate`: The starting date for the slice.
+- `days`: The number of days for the revisit period.
+
+**Returns:**
+- A filtered image collection.
+
+### `getImageDate(image)`
+Extracts the date from an image ID.
+
+**Parameters:**
+- `image`: The image from which the date will be extracted.
+
+**Returns:**
+- A JavaScript `Date` object representing the image date.
+
+### `maskS2Clouds(img, geometry, bandName, scale, imgDateParam)`
+Masks clouds in Sentinel-2 images based on cloud and cirrus bitmasks.
+
+**Parameters:**
+- `img`: The image to be processed.
+- `geometry`: The geometry for the region of interest.
+- `bandName`: The name of the QA band.
+- `scale`: The scale for the cloud masking.
+- `imgDateParam`: Optional parameter for the image date.
+
+**Returns:**
+- The cloud coverage ratio.
+
+### `acquireFromDate(date, mission, geometry)`
+Acquires an image from a specified date and mission, and processes it for cloud coverage.
+
+**Parameters:**
+- `date`: The date for which the image is to be acquired.
+- `mission`: The satellite mission (e.g., LANDSAT, Sentinel).
+- `geometry`: The geometry for the region of interest.
+
+**Returns:**
+- An image with cloud coverage metadata.
+
+### `processCollection(mission, geometry)`
+Processes an image collection to compute valid dates for image acquisition.
+
+**Parameters:**
+- `mission`: The satellite mission.
+- `geometry`: The geometry for the region of interest.
+
+**Returns:**
+- A list of valid dates.
+
+### `generateCloudMap(dates, mission, geometry)`
+Generates a cloud coverage map for a list of dates.
+
+**Parameters:**
+- `dates`: A list of dates.
+- `mission`: The satellite mission.
+- `geometry`: The geometry for the region of interest.
+
+**Returns:**
+- A list of cloud coverage values.
+
+### `queryAvailable(mission)`
+Returns a function that queries available images for a given mission and geometry.
+
+**Parameters:**
+- `mission`: The satellite mission.
+
+**Returns:**
+- A function that takes `geometry` as a parameter and returns a dictionary of dates and cloud coverage values.
+
+### `getAvailable(mission)`
+Returns a function that gets available images for a given mission and geometry.
+
+**Parameters:**
+- `mission`: The satellite mission.
+
+**Returns:**
+- A function that takes `geometry` as a parameter and returns a dictionary of dates and cloud coverage values.
+
+### `acquire(mission)`
+Returns a function that acquires an image for a given mission, date, and geometry.
+
+**Parameters:**
+- `mission`: The satellite mission.
+
+**Returns:**
+- A function that takes `date` and `geometry` as parameters and returns the acquired image.
+
+### `format(properties)`
+Formats image properties for display.
+
+**Parameters:**
+- `properties`: The properties of the image.
+
+**Returns:**
+- A formatted string of the image properties.
+
+## Usage Examples
+
+### Acquiring an Image
+```javascript
+const mission = { name: "LANDSAT" };
+const date = "2022-01-01";
+const geometry = ee.Geometry.Point([0, 0]);
+
+const image = acquireFromDate(date, mission, geometry);
+console.log(image.getInfo());
+```
+
+### Generating a Cloud Map
+```javascript
+const dates = ["2022-01-01", "2022-01-02"];
+const mission = { name: "Sentinel-2" };
+const geometry = ee.Geometry.Point([0, 0]);
+
+const cloudMap = generateCloudMap(dates, mission, geometry);
+console.log(cloudMap.getInfo());
+```
+
+## Edge Cases and Assumptions
+- Assumes that the input data will always be in the correct format.
+- Handles cases where the image ID is not available by logging an error.
+- Assumes that the `CLOUDY_PIXEL_PERCENTAGE` property is present in the image metadata for cloud masking.
+
+## References
+- Google Earth Engine Documentation: [https://developers.google.com/earth-engine](https://developers.google.com/earth-engine)
+- LANDSAT Algorithms: [../../algorithms/satellite/landsat](../../algorithms/satellite/landsat)
+

cassie_code/src/algorithms/shoreline/extraction.md

+# Shoreline Extraction Algorithms
+
+This code file contains a set of functions designed to process satellite imagery and extract shoreline features. The primary purpose is to identify water bodies, remove noise from shorelines, and apply various filters to produce clean and accurate shoreline data.
+
+## Dependencies
+- `earth-engine` (ee)
+- `geodesy` for geospatial calculations
+- `metadata` for handling metadata
+- `utils` for utility functions
+- `tools/effects` for callback and evaluation functions
+- `@material-ui/icons` for UI icons
+
+## Functions
+
+### identifyWaterFeature
+Partitions the raster image using the water index and the threshold function, then reduces the output raster to vector, corresponding to the water body in the given image.
+
+**Parameters:**
+- `image` (ee.Image): The input image.
+- `geometry` (ee.Geometry): The area of interest.
+- `scale` (Number): The scale of the analysis.
+- `bands` (Object): The bands to be used for the water index.
+- `thresholdFn` (Function): The function to determine the threshold.
+
+**Returns:**
+- `ee.Geometry`: The identified water body.
+
+### removeShorelineNoise
+Removes noises from the shoreline by keeping only the polygons that have the most intersections with the transects.
+
+**Parameters:**
+- `shorelines` (ee.Geometry.MultiLineString): The input shorelines.
+- `transects` (ee.Geometry.MultiLineString | ee.FeatureCollection): The transects for noise removal.
+
+**Returns:**
+- `ee.Feature<ee.Geometry.LineString>`: The shoreline without noise.
+
+### gaussianKernel
+Creates a Gaussian kernel controlled by size, mean, and sigma. The output kernel size is always odd.
+
+**Parameters:**
+- `size` (Number): The size of the kernel.
+- `mean` (Number): The mean of the Gaussian distribution.
+- `sigma` (Number): The standard deviation of the Gaussian distribution.
+
+**Returns:**
+- `ee.List<Number>`: The Gaussian kernel.
+
+### linearGaussianFilter
+Convolves over the list of coordinates producing local averages weighted by the produced kernel of samples, mean, and sd. The result is a smoothed list with removed noises.
+
+**Parameters:**
+- `coordinates` (ee.List): List containing the path.
+- `samples` (ee.Number): Size of the kernel (default: 3).
+- `mean` (ee.Number): Center of the normal distribution (default: 0).
+- `sd` (ee.Number): Standard Deviation (default: 1).
+
+**Returns:**
+- `ee.List<Number>`: The filtered coordinates.
+
+### thresholdingAlgorithm
+Given a histogram, finds the appropriate thresholds for a specified number of classes.
+
+**Parameters:**
+- `histogram` (ee.Dictionary): The input histogram.
+- `count` (Number): The number of classes.
+
+**Returns:**
+- `ee.Number`: The optimal threshold.
+
+### selectThreshold
+Selects the threshold function according to the input threshold.
+
+**Parameters:**
+- `threshold` (Number): The input threshold.
+
+**Returns:**
+- `Function`: The thresholding function.
+
+### extractShoreline
+Extracts the raw shoreline of the given image by identifying the water feature and converting it into linestrings.
+
+**Parameters:**
+- `image` (ee.Image): The input image.
+- `geometry` (ee.Geometry): The area of interest.
+- `scale` (Number): The scale of the analysis.
+- `bands` (Object): The bands to be used.
+- `thresholdFn` (Function): The function to determine the threshold.
+
+**Returns:**
+- `ee.Geometry.MultiLineString`: The extracted shoreline.
+
+### deriveShoreline
+Fully derives the shoreline using the satellite image. The satellite-derived shoreline is a single smoothed linestring without noisy features.
+
+**Parameters:**
+- `image` (ee.Image): The input image.
+- `geometry` (ee.Geometry): The area of interest.
+- `scale` (Number): The scale of the analysis.
+- `bands` (Object): The bands to be used.
+- `threshold` (Function): The threshold function.
+- `transects` (ee.FeatureCollection | ee.List): The transects for noise removal.
+- `props` (Array<String>): Additional properties.
+- `opticalResolution` (Number): The optical resolution of the satellite.
+
+**Returns:**
+- `ee.Feature`: The derived shoreline.
+
+### deriveShorelines
+Acquires and extracts shorelines given an array of dates.
+
+**Parameters:**
+- `dates` (Array): A list containing the dates of the images to be analyzed.
+- `satellite` (Object): Information about the satellite.
+- `geometry` (ee.Geometry): The area of interest.
+- `scale` (Number): The scale of the analysis.
+- `threshold` (ee.Number): Suggested threshold for the extraction.
+- `transects` (ee.FeatureCollection | ee.List): The transects for noise removal.
+
+**Returns:**
+- `ee.FeatureCollection`: A FeatureCollection of polygons.
+
+### expandCoastline
+Expands the given coordinates by a specified distance.
+
+**Parameters:**
+- `coordinates` (ee.List): The input coordinates.
+- `distance` (Number): The distance to expand.
+
+**Returns:**
+- `ee.Feature`: The expanded coastline.
+
+### rectifyJunctions
+Normalizes the junctions of segments.
+
+**Parameters:**
+- `segments` (ee.List): The input segments.
+- `originalCoordinates` (ee.List): The original coordinates.
+
+**Returns:**
+- `ee.List`: The rectified junctions.
+

cassie_code/src/algorithms/shoreline/index.md

+# Overview
+This code file serves as an entry point to re-export modules from three different files: `extraction`, `statistics`, and `transects`. This allows for a consolidated import interface for these modules, making it easier to manage and use them in other parts of the application.
+
+# Dependencies
+- The code assumes that the files `extraction.js`, `statistics.js`, and `transects.js` exist in the same directory and export the necessary functionalities.
+
+# Usage
+To use the functionalities provided by the `extraction`, `statistics`, and `transects` modules, you can import them from this file as shown in the example below:
+
+```javascript
+import { someFunctionFromExtraction, someFunctionFromStatistics, someFunctionFromTransects } from './thisFileName';
+```
+
+# Edge Cases and Assumptions
+- It is assumed that the modules `extraction`, `statistics`, and `transects` are correctly implemented and exported.
+- If any of these modules do not exist or fail to export the expected functionalities, this file will throw an error during the import process.
+
+# Code
+```javascript
+export * from "./extraction";
+export * from "./statistics";
+export * from "./transects";
+```
+
+This code re-exports all the exports from the `extraction`, `statistics`, and `transects` modules, making them available for import from this file.
+

cassie_code/src/algorithms/shoreline/statistics.md

+# Code Documentation
+
+## Overview
+This code provides a set of functions to calculate and append various statistics and properties related to transects and shorelines using Google Earth Engine (GEE). The primary functionalities include calculating distances, classifying transect change rates, generating statistics, and appending useful properties to transects and shorelines.
+
+## Dependencies
+- Google Earth Engine (GEE)
+- Utility functions from `../utils`
+- Metadata constants from `../../common/metadata`
+- Utility constants from `../../common/utils`
+
+## Functions
+
+### `calculateDistances`
+Calculates the distance of each shoreline to the point of interest given by the intersection of the transect with the baseline.
+
+#### Parameters
+- `transect` (`ee.Feature`): The transect feature.
+- `baseline` (`ee.Geometry.LineString`): The reference baseline.
+- `shorelines` (`ee.FeatureCollection`): The collection of shoreline features.
+
+#### Returns
+- `ee.Dictionary`: A dictionary containing the distances.
+
+#### Example
+```javascript
+const distances = calculateDistances(transect, baseline, shorelines);
+```
+
+### `estevesLabelling`
+Classifies the transect change rate using the intervals proposed by Esteves and Finkl (1998).
+
+#### Parameters
+- `lrr` (`ee.Number`): The linear regression rate.
+
+#### Returns
+- `ee.String`: The classified linear regression rate.
+
+#### Example
+```javascript
+const label = estevesLabelling(lrr);
+```
+
+### `calculateStatistics`
+Calculates the general DSAS Statistics (SCE, NSM, EPR, LRR) and Esteves classification for a given dictionary of a transect's distance set.
+
+#### Parameters
+- `measurement` (`ee.Dictionary`): The dictionary of distances of the transect.
+
+#### Returns
+- `ee.Dictionary`: A dictionary containing the statistics.
+
+#### Example
+```javascript
+const stats = calculateStatistics(measurement);
+```
+
+### `complementaryProperties`
+Appends useful transect data to its properties, such as latitude, longitude, serialized dates, and distance vectors.
+
+#### Parameters
+- `transect` (`ee.Feature`): The transect feature.
+- `measurement` (`ee.Dictionary`): The dictionary of distances of the transect.
+- `keepProps` (`Array<String>`): The array of transect properties to keep.
+
+#### Returns
+- `ee.Dictionary`: A dictionary containing the useful and kept properties.
+
+#### Example
+```javascript
+const props = complementaryProperties(transect, measurement, keepProps);
+```
+
+### `generateTransectsStatistics`
+Adds information about DSAS statistics and Esteves classification while adding useful properties to the transects.
+
+#### Parameters
+- `transects` (`ee.List`): The orthogonal transects.
+- `baseline` (`ee.Geometry`): The baseline.
+- `shorelines` (`ee.FeatureCollection`): The shorelines.
+- `keepProps` (`Array<String>`): The array of transect properties to keep.
+
+#### Returns
+- `ee.List<ee.Feature>`: The transects with added statistics.
+
+#### Example
+```javascript
+const transectsWithStats = generateTransectsStatistics(transects, baseline, shorelines, keepProps);
+```
+
+### `summaryShorelineStatistics`
+Adds statistics about the distances observed in transects, such as standard deviation and mean, to the shorelines.
+
+#### Parameters
+- `transects` (`ee.List<Feature>`): The list of transect features.
+- `shorelines` (`ee.FeatureCollection`): The collection of shoreline features.
+
+#### Returns
+- `ee.FeatureCollection`: The shorelines with added statistics.
+
+#### Example
+```javascript
+const shorelinesWithStats = summaryShorelineStatistics(transects, shorelines);
+```
+
+## Edge Cases and Assumptions
+- Assumes that input data will always be in the expected format.
+- Handles cases where no distances are calculated by returning an empty dictionary.
+- If the code is based on a research paper, external libraries, or online resources, provide links or references to those resources.
+
+## References
+- Esteves and Finkl (1998) for transect change rate classification intervals.
+

cassie_code/src/algorithms/shoreline/transects.md

+# Code Overview
+
+This code is designed to generate transects orthogonal to a specified polygon and expand them horizontally. It utilizes the Google Earth Engine (GEE) library and some geodesic computations to achieve this.
+
+## Dependencies
+
+- Google Earth Engine (`ee`)
+- Geodesy utilities (`computeBearing`, `computeDisplacement`)
+- Metadata constants (`INTERNALS`)
+
+## Functions
+
+### `offsetMapper(extent, origin, theta)`
+
+Creates a function that maps offsets to transects.
+
+#### Parameters
+
+- `extent` (Number): The extent of the transect.
+- `origin` (List): The origin point for the transect.
+- `theta` (Number): The angle for the transect.
+
+#### Returns
+
+- Function: A function that takes an offset and returns a transect as an `ee.Feature`.
+
+### `transectAccumulator(step, extent)`
+
+Creates a function that accumulates transects along a path.
+
+#### Parameters
+
+- `step` (Number): The step size for the transects.
+- `extent` (Number): The extent of the transect.
+
+#### Returns
+
+- Function: A function that takes the current and last points and returns an accumulated list of transects.
+
+### `generateOrthogonalTransects(coordinates, step, extent)`
+
+Generates transects orthogonal to the specified polygon.
+
+#### Parameters
+
+- `coordinates` (ee.List): A list of coordinates defining the polygon.
+- `step` (Number): The step size for the transects.
+- `extent` (Number): The extent of the transect.
+
+#### Returns
+
+- `ee.List`: A list of transects as `ee.FeatureCollection`.
+
+#### Example Usage
+
+```javascript
+const coordinates = ee.List([
+  [0, 0],
+  [1, 1],
+  [2, 2],
+]);
+const step = 10;
+const extent = 5;
+const transects = generateOrthogonalTransects(coordinates, step, extent);
+```
+
+### `expandHorizontally(transects, amount)`
+
+Expands the transects horizontally by a specified amount.
+
+#### Parameters
+
+- `transects` (ee.List): A list of transects as `ee.FeatureCollection`.
+- `amount` (Number): The amount to expand the transects.
+
+#### Returns
+
+- `ee.List`: A list of expanded transects as `ee.FeatureCollection`.
+
+#### Example Usage
+
+```javascript
+const expandedTransects = expandHorizontally(transects, 10);
+```
+
+## Edge Cases and Assumptions
+
+- Assumes that the input coordinates are in a valid format and order.
+- Assumes that the step and extent values are positive numbers.
+- Handles cases where the space between transects is greater than the length of the segment.
+
+## References
+
+- Google Earth Engine: [https://developers.google.com/earth-engine/](https://developers.google.com/earth-engine/)
+- Geodesy computations: Internal utility functions `computeBearing` and `computeDisplacement`.
+

cassie_code/src/algorithms/utils/index.md

+# Code Overview
+
+This code provides a set of utility functions for working with satellite imagery using Google Earth Engine (GEE). It includes functions for manipulating image metadata, merging image collections, and applying various transformations and calculations to the images.
+
+## Dependencies
+
+- `lodash/pick`: Used for picking specific properties from objects.
+- `../../services/earth-engine`: Custom service for interacting with Google Earth Engine.
+- `../../common/metadata`: Common metadata constants.
+- `../../common/indices`: Common indices for image processing.
+
+## Functions
+
+### `addGridPosition(satellite)`
+
+Adds a grid position to an image based on the satellite's computed grid position.
+
+- **Parameters:**
+  - `satellite`: The satellite object used to compute the grid position.
+- **Returns:** A function that takes an image element and returns the image with the grid position set.
+
+### `getDate(image)`
+
+Retrieves the date from an image's metadata.
+
+- **Parameters:**
+  - `image`: The image from which to retrieve the date.
+- **Returns:** The date of the image.
+
+### `mergeFootprints(collection)`
+
+Merges the footprints of a collection of images into a single geometry.
+
+- **Parameters:**
+  - `collection`: The collection of images.
+- **Returns:** The merged geometry of the collection.
+
+### `retrieveExtremes(collection)`
+
+Retrieves the earliest and latest images in a collection based on their start time.
+
+- **Parameters:**
+  - `collection`: The collection of images.
+- **Returns:** An object containing the earliest and latest dates.
+
+### `mergeProperties(collection)`
+
+Merges properties of a collection of images, including the earliest date and footprint.
+
+- **Parameters:**
+  - `collection`: The collection of images.
+- **Returns:** An object containing merged properties such as name, footprint, start time, and sensor ID.
+
+### `combineReducers(...reducers)`
+
+Combines multiple reducers into a single reducer.
+
+- **Parameters:**
+  - `...reducers`: The reducers to combine.
+- **Returns:** The combined reducer.
+
+### `serializeList(subject)`
+
+Serializes a list into a string format.
+
+- **Parameters:**
+  - `subject`: The list to serialize.
+- **Returns:** The serialized string.
+
+### `generateVisualizationParams(mission)`
+
+Generates visualization parameters for a mission.
+
+- **Parameters:**
+  - `mission`: The mission object containing band information and visualization parameters.
+- **Returns:** An object containing the visualization parameters.
+
+### `evaluate(query)`
+
+Binds the evaluate method to a query.
+
+- **Parameters:**
+  - `query`: The query to evaluate.
+- **Returns:** The bound evaluate method.
+
+### `applyExpression(image, expressionOrLabel, bands)`
+
+Applies an expression to an image using specified bands.
+
+- **Parameters:**
+  - `image`: The image to which the expression is applied.
+  - `expressionOrLabel`: The expression or label to apply.
+  - `bands`: The bands to use in the expression.
+- **Returns:** The image with the applied expression.
+
+### `imageToKey(image)`
+
+Converts an image to a key by serializing its ID and version.
+
+- **Parameters:**
+  - `image`: The image to convert.
+- **Returns:** The serialized key.
+
+### `getSatelliteCollection(satellite)`
+
+Retrieves the image collection for a satellite.
+
+- **Parameters:**
+  - `satellite`: The satellite object containing the collection set.
+- **Returns:** The image collection.
+
+### `simplify(amount)`
+
+Simplifies a feature by a specified amount.
+
+- **Parameters:**
+  - `amount`: The amount by which to simplify the feature.
+- **Returns:** A function that takes a feature and returns the simplified feature.
+
+## Usage Examples
+
+### Adding Grid Position
+
+```javascript
+const satellite = { /* satellite object */ };
+const image = ee.Image('some-image-id');
+const addPosition = addGridPosition(satellite);
+const imageWithPosition = addPosition(image);
+```
+
+### Merging Footprints
+
+```javascript
+const collection = ee.ImageCollection('some-collection-id');
+const mergedFootprint = mergeFootprints(collection);
+```
+
+### Applying Expression
+
+```javascript
+const image = ee.Image('some-image-id');
+const bands = { red: 'B4', green: 'B3', blue: 'B2', nir: 'B5', swir: 'B6' };
+const resultImage = applyExpression(image, 'NDVI', bands);
+```
+
+## Assumptions and Edge Cases
+
+- Assumes that input data is in the correct format expected by Google Earth Engine.
+- Handles edge cases such as empty collections by returning appropriate default values.
+- If the code is based on external resources, references are provided within the comments.
+

cassie_code/src/app/components/core/index.md

+# Code Overview
+
+This code file serves as an entry point for exporting various components from their respective files. These components are likely part of a larger UI library or application.
+
+## Dependencies
+
+- The code assumes that the components `ActivityIndicator`, `DropdownButton`, `Footer`, `NavigationBar`, `Scroller`, and `User` are defined in their respective files within the same directory.
+
+## Exported Components
+
+### ActivityIndicator
+- **Purpose**: Provides a visual indicator for loading activities.
+- **Usage**: 
+  ```javascript
+  import { ActivityIndicator } from 'path-to-this-file';
+  ```
+
+### DropdownButton
+- **Purpose**: Represents a button that, when clicked, shows a dropdown menu.
+- **Usage**: 
+  ```javascript
+  import { DropdownButton } from 'path-to-this-file';
+  ```
+
+### Footer
+- **Purpose**: Represents the footer section of a webpage or application.
+- **Usage**: 
+  ```javascript
+  import { Footer } from 'path-to-this-file';
+  ```
+
+### NavigationBar
+- **Purpose**: Represents the navigation bar, typically used for site or app navigation.
+- **Usage**: 
+  ```javascript
+  import { NavigationBar } from 'path-to-this-file';
+  ```
+
+### Scroller
+- **Purpose**: Provides scrolling functionality, likely for a container or list.
+- **Usage**: 
+  ```javascript
+  import { Scroller } from 'path-to-this-file';
+  ```
+
+### User
+- **Purpose**: Represents user-related functionalities or data.
+- **Usage**: 
+  ```javascript
+  import { User } from 'path-to-this-file';
+  ```
+
+## Assumptions and Edge Cases
+
+- It is assumed that the components are correctly implemented and exported as default exports in their respective files.
+- The code does not handle cases where the components might not be found or incorrectly implemented in their respective files.
+

cassie_code/src/app/components/index.md

+# Code Overview
+
+This code file serves as an entry point for exporting modules from various parts of the project. It consolidates exports from multiple files, making them accessible from a single location.
+
+## Dependencies
+
+- This file relies on the presence of the following modules within the same directory:
+  - `snacks`
+  - `visualization`
+  - `map`
+  - `core`
+
+# Module Documentation
+
+## Snacks Module
+
+Exports all functionalities related to snacks. This could include classes, functions, and constants that deal with snack-related operations.
+
+## Visualization Module
+
+Exports all functionalities related to data visualization. This could include classes, functions, and constants that help in rendering visual representations of data.
+
+## Map Module
+
+Exports all functionalities related to mapping. This could include classes, functions, and constants that deal with geographical data and map rendering.
+
+## Core Module
+
+Exports all core functionalities of the application. This could include essential classes, functions, and constants that form the backbone of the system.
+
+# Usage Example
+
+To use any of the functionalities provided by these modules, you can import them as follows:
+
+```javascript
+import { someFunction } from './snacks';
+import { anotherFunction } from './visualization';
+import { mapFunction } from './map';
+import { coreFunction } from './core';
+
+// Example usage
+someFunction();
+anotherFunction();
+mapFunction();
+coreFunction();
+```
+
+# Assumptions and Edge Cases
+
+- It is assumed that all the modules (`snacks`, `visualization`, `map`, `core`) exist in the same directory as this file.
+- If any of these modules are missing, the import/export statements will fail, leading to runtime errors.
+
+# References
+
+- For more details on how to structure module exports in JavaScript, refer to the [MDN Web Docs on export](https://developer.mozilla.org/en-US/docs/web/javascript/reference/statements/export).
+

cassie_code/src/app/components/map/ShapeList/index.md

+```markdown
+# ShapeList Module
+
+This module exports the `ShapeList` component, which is the default export from the `./ShapeList` file.
+
+## Dependencies
+- This module relies on the `ShapeList` component defined in the `./ShapeList` file.
+
+## Usage
+To use the `ShapeList` component in your project, you can import it as follows:
+
+```javascript
+import { ShapeList } from 'path-to-this-module';
+```
+
+## Example
+Here is a simple example of how to use the `ShapeList` component:
+
+```javascript
+import React from 'react';
+import { ShapeList } from 'path-to-this-module';
+
+const App = () => (
+  <div>
+    <h1>Shapes</h1>
+    <ShapeList />
+  </div>
+);
+
+export default App;
+```
+```
+

cassie_code/src/app/components/map/index.md

+```markdown
+# Module Overview
+
+This module serves as an entry point for exporting various components used in the application. It consolidates and re-exports components from different files, making them easily accessible for import in other parts of the application.
+
+## Dependencies
+
+- This module relies on several internal components, each defined in their respective files.
+
+## Exported Components
+
+### ShapeList
+- **Description**: Exports all functionalities from the `ShapeList` module.
+
+### ActionList
+- **Description**: Default export from the `ActionList` module.
+- **Usage**:
+  ```javascript
+  import ActionList from './ActionList';
+  ```
+
+### FeatureInfo
+- **Description**: Default export from the `FeatureInfo` module.
+- **Usage**:
+  ```javascript
+  import FeatureInfo from './FeatureInfo';
+  ```
+
+### GoogleMap
+- **Description**: Default export from the `GoogleMap` module.
+- **Usage**:
+  ```javascript
+  import GoogleMap from './GoogleMap';
+  ```
+
+### ImageChooserCard
+- **Description**: Default export from the `ImageChooserCard` module.
+- **Usage**:
+  ```javascript
+  import ImageChooserCard from './ImageChooserCard';
+  ```
+
+### ImageChooserForm
+- **Description**: Default export from the `ImageChooserForm` module.
+- **Usage**:
+  ```javascript
+  import ImageChooserForm from './ImageChooserForm';
+  ```
+
+### ImageViewer
+- **Description**: Default export from the `ImageViewer` module.
+- **Usage**:
+  ```javascript
+  import ImageViewer from './ImageViewer';
+  ```
+
+### LayerActions
+- **Description**: Default export from the `LayerActions` module.
+- **Usage**:
+  ```javascript
+  import LayerActions from './LayerActions';
+  ```
+
+### LayerViewer
+- **Description**: Default export from the `LayerViewer` module.
+- **Usage**:
+  ```javascript
+  import LayerViewer from './LayerViewer';
+  ```
+
+### LoadedImagesAccordion
+- **Description**: Default export from the `LoadedImagesAccordion` module.
+- **Usage**:
+  ```javascript
+  import LoadedImagesAccordion from './LoadedImagesAccordion';
+  ```
+
+### OpacityControl
+- **Description**: Default export from the `OpacityControl` module.
+- **Usage**:
+  ```javascript
+  import OpacityControl from './OpacityControl';
+  ```
+```
+

cassie_code/src/app/components/snacks/index.md

+# Overview
+This code file is responsible for exporting two modules, `Notifier` and `Task`, from their respective files. These modules are likely part of a larger system and are being made available for import in other parts of the application.
+
+# Dependencies
+- The code assumes that there are two files named `Notifier.js` and `Task.js` in the same directory.
+
+# Modules
+
+## Notifier
+This module is exported as the default export from the `Notifier.js` file. It is likely responsible for handling notifications within the system.
+
+## Task
+This module is exported as the default export from the `Task.js` file. It is likely responsible for managing tasks within the system.
+
+# Usage Example
+To use these modules in another part of the application, you can import them as follows:
+
+```javascript
+import { Notifier, Task } from './path-to-this-file';
+
+// Example usage
+const notifier = new Notifier();
+const task = new Task();
+```
+
+# Assumptions
+- The `Notifier.js` and `Task.js` files exist in the same directory as this file.
+- The modules `Notifier` and `Task` are the default exports of their respective files.
+

cassie_code/src/app/components/visualization/index.md

+```markdown
+# Code Overview
+
+This code file exports several components that are likely part of a larger system related to data visualization and image processing. The components are:
+
+- `EvolutionChart`
+- `ImageTable`
+- `SatelliteImageThumbnail`
+- `TransectDataTable`
+- `TransectEvolution`
+
+These components are imported from their respective files and then re-exported for use in other parts of the application.
+
+## Dependencies
+
+- The code assumes that the components `EvolutionChart`, `ImageTable`, `SatelliteImageThumbnail`, `TransectDataTable`, and `TransectEvolution` are defined in their respective files within the same directory.
+
+## Components
+
+### EvolutionChart
+
+Represents a chart that likely visualizes some form of evolutionary data.
+
+### ImageTable
+
+Represents a table that displays images, possibly with associated metadata.
+
+### SatelliteImageThumbnail
+
+Represents a thumbnail view of a satellite image.
+
+### TransectDataTable
+
+Represents a table that displays data related to transects, which are typically used in environmental and geographical studies.
+
+### TransectEvolution
+
+Represents a component that visualizes the evolution of transect data over time.
+
+## Usage Example
+
+```javascript
+import { EvolutionChart, ImageTable, SatelliteImageThumbnail, TransectDataTable, TransectEvolution } from './path-to-this-file';
+
+// Example usage in a React component
+function App() {
+  return (
+    <div>
+      <EvolutionChart />
+      <ImageTable />
+      <SatelliteImageThumbnail />
+      <TransectDataTable />
+      <TransectEvolution />
+    </div>
+  );
+}
+```
+
+## Assumptions and Edge Cases
+
+- It is assumed that the components being imported are correctly defined and exported in their respective files.
+- The code does not handle cases where the components might not be found or fail to import.
+
+## References
+
+- If these components are based on specific libraries or research papers, it would be helpful to include those references here.
+```
+