nesp-sop-seagrass-mapping

Standard Operating Procedure for Seagrass Mapping using Optical Remote Sensing

Version 0.9, April 2025

A larger set of authors will be compiled for v1.0, but for the meantime please contact:
Mitchell Lyons (mitchell.lyons@unsw.edu.au)

Table of Contents

  1. Introduction
  2. SOP Development
  3. System Architecture
  4. Data Acquisition and Preparation
  5. Training Data Collection and Curation
  6. Image Processing and Analysis
  7. Classification and Modelling
  8. Output Production and Validation
  9. Post-processing and Refinement
  10. Quality Control and Documentation
  11. Conclusion and Future Directions
  12. SOP Maintenance
  13. Acknowledgements
  14. References
  15. Appendices

1. Introduction

1.1 Purpose and Scope

This Standard Operating Procedure (SOP) provides comprehensive guidelines for mapping seagrass habitats using optical remote sensing techniques. It outlines standardized methodologies for data acquisition, processing, classification, validation, and quality control to ensure consistency, repeatability, and comparability across different mapping initiatives. While the primary focus is on using Sentinel-2 multitemporal imagery within the Google Earth Engine (GEE) platform, the SOP provides flexibility to accommodate alternative satellite sensors, computing environments, and specific project requirements.

Real-world Application

This SOP also provides an example of real-world application, and will aim to expand this over time. At present applicaiton includes:

1.2 Background

Seagrasses constitute one of the most important benthic habitats in coastal waters globally, providing numerous ecosystem services including nursery habitat, carbon sequestration, sediment stabilization, and water quality improvement. Accurate and up-to-date information on seagrass distribution, extent, and condition is essential for effective marine spatial planning, conservation management, and environmental monitoring.

Despite their ecological significance, many seagrass meadows remain unmapped or poorly documented, particularly in remote areas and subtidal environments. Spatial mapping data for seagrass is often lacking in many temperate coastal areas, especially for subtidal habitats in southern regions. Traditional field-based mapping approaches, while accurate, are resource-intensive and impractical for large-scale and repeated assessments.

Remote sensing technologies offer an effective solution for mapping seagrass at various spatial and temporal scales. Optical remote sensing, in particular, leverages the distinctive spectral signatures of seagrass to detect and delineate meadows from surrounding substrate types. Recent advancements in satellite sensor capabilities, cloud computing infrastructure, and machine learning algorithms have significantly enhanced our ability to map seagrass habitats efficiently and accurately.

1.3 Overview of Remote Sensing Approaches

Several optical remote sensing approaches can be employed for seagrass mapping, each with distinct advantages and limitations:

Satellite-based multispectral imagery: Platforms such as Sentinel-2, Landsat, and commercial satellites (e.g., Planet, WorldView) provide wide spatial coverage and regular revisit intervals, enabling large-scale and temporal monitoring. This SOP primarily focuses on Sentinel-2 imagery due to its optimal combination of spatial resolution (10m), spectral capabilities, global coverage, and free accessibility.

Airborne multispectral/hyperspectral imagery: These platforms offer higher spatial resolution but typically cover smaller areas and are acquired less frequently. They may be appropriate for detailed mapping of specific sites or as validation data.

Drone-based imagery: Unmanned aerial vehicles (UAVs) equipped with multispectral sensors can capture very high-resolution imagery of seagrass beds, but their application is limited to small spatial extents and is often influenced by environmental conditions.

The selection of an appropriate remote sensing approach depends on various factors, including the spatial scale of interest, required mapping accuracy, available resources, and specific project objectives.

2. SOP Development

2.1 Evolution of Seagrass Mapping Techniques

Remote sensing techniques for seagrass mapping have evolved considerably over the past decades, with significant methodological improvements driven by advances in sensor technology, computational capabilities, and analytical methods.

Early approaches relied primarily on visual interpretation of aerial photographs or simple classification of single-date satellite imagery. These methods, while valuable for establishing baseline distributions, were limited in their ability to distinguish seagrass from other aquatic vegetation and to account for temporal variability in seagrass coverage.

The development of more sophisticated multispectral sensors with improved spectral, spatial, and radiometric resolutions has enabled more accurate discrimination between seagrass and other benthos. Concurrently, the transition from pixel-based to object-based image analysis and the integration of contextual information has enhanced classification accuracy.

The emergence of machine learning algorithms, particularly random forests and boosted regression trees, has further improved mapping capabilities by better capturing complex relationships between environmental predictors and seagrass distribution. Most recently, the adoption of cloud-based computing platforms like Google Earth Engine has facilitated the processing of large volumes of satellite data, enabling multi-temporal analysis and near-real-time monitoring over vast geographic areas.

2.2 Current Best Practices

Based on extensive research and practical experience, several best practices have been identified for effective seagrass mapping using optical remote sensing:

This SOP incorporates these best practices while maintaining flexibility to accommodate specific project requirements and technological advancements.

2.3 Conceptual framework

Figure 1. shows the conceptual framework for technical and methodological components covered in this SOP.

Figure 1

2.4 Relationship to Other Protocols and real-world applications

This SOP builds upon and complements existing protocols for marine habitat mapping and seagrass monitoring. It aligns with internationally recognized standards and classification schemes, such as the Seamap Australia Benthic Classification Scheme, to ensure interoperability and consistency across different mapping initiatives.

While primarily focused on remote sensing methodologies, this SOP acknowledges the importance of field-based approaches and encourages their integration as complementary data sources. Reference is made to relevant field protocols where appropriate, particularly for the collection of training and validation data.

This SOP is accompanied by a real-world application - NESP 3.6 project - seagrass mapping in Tayaritya, Tasmania in the Appendices, and over time, other examples will be added.

3. System Architecture

3.1 Remote Sensing Platforms and Sensors

3.1.1 Satellite Platforms

Various satellite platforms can be utilized for seagrass mapping, with selection dependent on project requirements and resource availability:

Sentinel-2 (Recommended Primary Platform)

Landsat 8/9

Commercial High-Resolution Satellites (Planet, WorldView, SPOT, etc.)

3.1.2 Sensor Considerations

For optimal seagrass mapping, sensors should ideally provide:

Sentinel-2 Multi-Spectral Instrument (MSI) satisfies these requirements with its 13 spectral bands, 10m resolution for key bands, and 5-day revisit time, making it highly suitable for operational seagrass mapping.

3.2 Computing Resources and Software Environments

3.2.1 Cloud Computing Platforms

Google Earth Engine (GEE) (Primary Recommended Platform)

Digital Earth Australia (DEA)

Other Options: Microsoft Planetary Computer, Amazon Web Services (AWS) Earth on AWS, commercial remote sensing platforms

3.2.2 Local Computing Environments

For projects with specific requirements or constraints, local computing environments may be preferred:

3.2.3 Hardware Requirements

Hardware specifications depend on the selected software environment and data volume:

3.3 Data Storage and Management

3.3.1 Storage Considerations

Effective data management requires appropriate storage solutions:

3.3.2 Data Organization

Standardized file naming conventions and directory structures are essential for efficient data management:

3.3.3 Version Control

Implementation of version control for both data and code:

4. Data Acquisition and Preparation

4.1 Satellite Imagery Selection and Acquisition

4.1.1 Imagery Selection Criteria

When selecting satellite imagery for seagrass mapping, consider the following factors:

Spatial coverage: Ensure complete coverage of the study area, accounting for potential tiling schemes and overlap requirements.

Temporal window: Select imagery from periods that maximize seagrass detectability (typically during low tide for intertidal areas and periods of high water clarity for subtidal regions). For multi-temporal analysis, define an appropriate time range to capture seasonal variations while maintaining ecological relevance.

Cloud cover: Prioritize cloud-free or low-cloud-cover images, especially over the areas of interest. For multi-temporal approaches, implement effective cloud masking procedures.

Sea state conditions: Select imagery acquired during calm conditions to minimize sun glint and water surface roughness.

Water clarity: Consider seasonal and spatial variations in water quality, prioritizing periods of higher clarity where possible.

4.1.2 Sentinel-2 Imagery Acquisition

For Sentinel-2 imagery (recommended platform):

Data access platforms:

Product levels:

Collection version:

4.1.3 Alternative Imagery Sources

Landsat imagery:

Commercial high-resolution imagery:

4.2 Ancillary Data Sources

4.2.1 Bathymetry and Topography

Bathymetric data is essential for seagrass mapping as it provides information on water depth, which influences light availability and seagrass distribution. Sources include:

4.2.2 Environmental Variables

Additional environmental datasets that may improve classification accuracy:

Wave exposure data:

Substrate information:

Water quality parameters:

4.2.3 Existing Habitat Maps

Previously produced habitat maps can provide valuable context and training data:

4.3 Pre-processing and Data Cleaning

4.3.1 Sentinel-2 Pre-processing

When using Google Earth Engine (GEE) for processing Sentinel-2 imagery:

Filtering and selection:

// Example GEE code for filtering Sentinel-2 collection
var s2_collection = ee.ImageCollection("COPERNICUS/S2_SR")
  .filterBounds(studyArea)
  .filterDate(startDate, endDate)
  .filter(ee.Filter.lt("CLOUDY_PIXEL_PERCENTAGE", cloudThreshold));

Cloud and shadow masking:

There are other cloud masking options that will be detailed in 6. Image Processing and Analysis as well as in the fully worked example in the appendix.

// Cloud masking function for Sentinel-2
function maskS2clouds(image) {
  var scl = image.select('SCL');
  var cloudMask = scl.neq(9).and(scl.neq(8)).and(scl.neq(7)).and(scl.neq(3));
  return image.updateMask(cloudMask);
}

// Apply cloud masking to collection
var s2_masked = s2_collection.map(maskS2clouds);

Band selection:

// Select relevant bands for seagrass mapping
var bands = ['B2', 'B3', 'B4', 'B8'];
var s2_selected = s2_masked.select(bands);

4.3.2 Geometric and Radiometric Corrections

These corrections are typically already applied in Sentinel-2 Level-2A products but may require additional processing for other imagery sources:

Geometric corrections:

Radiometric corrections:

4.3.3 Study Area Delineation

Define the appropriate study area boundaries to focus processing and reduce computational requirements:

Land-water masking:

// Create land-water mask using global datasets
var landMask = ee.Image("MODIS/MOD44W/MOD44W_005_2000_02_24").select('water_mask');

Depth limitation:

// Mask areas beyond mappable depth using bathymetry data
var bathymetry = ee.Image("GEBCO/2020/bathymetry").select('elevation');
var depthMask = bathymetry.gte(-15); // Limit to 15m depth

Administrative or ecological boundaries:

5. Training Data Collection and Curation

5.1 Field Data Collection Protocols

5.1.1 Sampling Design

A well-designed field sampling strategy is crucial for collecting representative training and validation data:

Spatially balanced sampling:

Sample size determination:

5.1.2 Field Methods

Drop camera systems (recommended for subtidal habitats):

Snorkel or SCUBA surveys:

UAV surveys (for intertidal areas):

Boat-based observations:

5.2 Training Data Requirements

5.2.1 Attribute Information

Essential attributes to record for each sampling point:

Primary classification:

Secondary attributes:

Environmental parameters:

5.2.2 Spatial Accuracy Requirements

To ensure proper alignment with satellite imagery:

Positioning systems:

Spatial uncertainty documentation:

5.2.3 Temporal Considerations

Align field data collection with satellite imagery acquisition where possible:

5.3 Data Validation and Quality Control

5.3.1 Field Data Quality Assurance

Implement quality control measures during and after field data collection:

Field verification:

Data cleaning procedures:

5.3.2 Integration with Existing Knowledge

Enhance field data with contextual information:

Expert knowledge incorporation:

Historical context:

5.3.3 Training Dataset Preparation

Format and organize field data for integration with remote sensing analysis:

Data formatting:

Stratification for model training:

6. Image Processing and Analysis

6.1 Multi-temporal Stack Creation

6.1.1 Temporal Window Selection

Define an appropriate time period for creating multi-temporal image stacks:

Annual composites:

Seasonal composites:

Custom time periods:

6.1.2 Pixel-Level Filtering

Implement filtering strategies to improve the quality of multi-temporal stacks:

Cloud and shadow removal:

// GEE example for masking clouds in Sentinel-2 time series
function maskS2clouds(image) {
  var scl = image.select('SCL');
  var cloudMask = scl.lt(7).and(scl.gt(3));  // Values 4, 5, 6 are valid pixels
  return image.updateMask(cloudMask);
}

Water depth filtering:

// GEE example for filtering pixels based on depth
function maskDepth(image) {
  return image.updateMask(bathymetry.gt(-20));  // Mask areas deeper than 20m
}

Turbidity filtering:

6.1.3 Statistical Compositing

Calculate statistical summaries across the temporal dimension:

Percentile composites:

// GEE example for creating percentile composites
var p20 = filteredCollection.reduce(ee.Reducer.percentile([20]));
var p50 = filteredCollection.reduce(ee.Reducer.percentile([50]));  // Median
var p80 = filteredCollection.reduce(ee.Reducer.percentile([80]));

Temporal variance measures:

// Calculate standard deviation across time series
var stdDev = filteredCollection.reduce(ee.Reducer.stdDev());

Interval means:

// Calculate interval mean (e.g., 20th-50th percentile mean)
var intervalMean = filteredCollection.reduce(ee.Reducer.intervalMean(20, 50));

6.2 Cloud Masking and Atmospheric Correction

6.2.1 Cloud and Shadow Detection

Apply robust methods for identifying and masking clouds and their shadows:

Sentinel-2 Scene Classification Layer (SCL):

// Utilize SCL band to mask clouds and shadows
function maskClouds(image) {
  var scl = image.select('SCL');
  var validPixels = scl.neq(3).and(scl.neq(7)).and(scl.neq(8)).and(scl.neq(9)).and(scl.neq(10));
  return image.updateMask(validPixels);
}

Cloud probability layer:

// Use cloud probability dataset (available for Sentinel-2)
var s2CloudProbability = ee.ImageCollection('COPERNICUS/S2_CLOUD_PROBABILITY');
function maskCloudProbability(image) {
  var cloudProbabilityMap = s2CloudProbability.filter(ee.Filter.eq('system:index', image.get('system:index')))
                            .first();
  var cloudMask = cloudProbabilityMap.lt(30);  // 30% threshold
  return image.updateMask(cloudMask);
}

Custom spectral indices:

6.2.2 Atmospheric Correction

Ensure consistent atmospheric correction across the image time series:

Pre-processed collections:

Custom atmospheric correction:

6.2.3 Aquatic Corrections

Apply additional corrections specific to aquatic environments:

Sun glint correction:

Water column correction:

6.3 Environmental Variable Derivation

6.3.1 Spectral Indices Calculation

Compute spectral indices that enhance seagrass detection:

Normalized difference indices:

// GEE example for calculating NDVI
var ndvi = image.normalizedDifference(['B8', 'B4']).rename('NDVI');

// Modified indices for aquatic vegetation
var ndwi = image.normalizedDifference(['B3', 'B8']).rename('NDWI');

Band ratios:

// Calculate band ratios relevant for seagrass detection
var blueGreenRatio = image.select('B2').divide(image.select('B3')).rename('BG_ratio');
var greenRedRatio = image.select('B3').divide(image.select('B4')).rename('GR_ratio');

Principal Component Analysis:

// Perform PCA on spectral bands
var bands = ['B2', 'B3', 'B4', 'B5', 'B6', 'B7', 'B8'];
var pcaImage = ee.Image(PCA(image.select(bands), studyRegion, scale, bands.length));

6.3.2 Bathymetric Derivatives

Generate bathymetry-derived variables that influence seagrass distribution:

Slope:

// Calculate bathymetric slope
var slope = ee.Terrain.slope(bathymetry);

Rugosity:

// Calculate terrain rugosity (standard deviation of slope)
var neighborhood = ee.Kernel.circle(10, 'meters');
var rugosity = slope.reduceNeighborhood({
  reducer: ee.Reducer.stdDev(),
  kernel: neighborhood
});

Benthic Position Index (BPI):

// Calculate BPI at different scales
var innerRadius = 10;
var outerRadius = 30;
var bpi = calculateBPI(bathymetry, innerRadius, outerRadius);

6.3.3 Hydrodynamic Variables

Incorporate variables related to wave exposure and water movement:

Wave exposure indices:

Current velocity proxies:

Tidal influence:

7. Classification and Modelling

7.1 Machine Learning Algorithm Selection

Random Forest is recommended as the primary classification algorithm for seagrass mapping due to its robustness, interpretability, and proven performance:

Key advantages:

Implementation in GEE:

// Random Forest classifier in GEE
var classifier = ee.Classifier.smileRandomForest({
  numberOfTrees: 500,
  minLeafPopulation: 2,
  variablesPerSplit: null,  // defaults to square root of number of variables
  bagFraction: 0.5,
  seed: 42
}).train({
  features: trainingData,
  classProperty: 'class',
  inputProperties: bands
});

Important parameters:

7.1.2 Alternative Algorithms

Boosted Regression Trees:

Support Vector Machine:

Deep Learning approaches:

7.1.3 Ensemble Approaches

Consider ensemble methods combining multiple algorithms for improved performance:

Majority voting:

Weighted ensemble:

Stacked generalization:

7.2 Model Training and Parameterization

7.2.1 Training Data Preparation

Prepare field data for model training:

Data formatting:

// GEE example for importing and formatting training data
var trainingPoints = ee.FeatureCollection('projects/myproject/assets/seagrass_training_points');

// Add spectral information to points
var sampledPoints = covariateStack.sampleRegions({
  collection: trainingPoints,
  properties: ['class'],
  scale: 10,
  geometries: true
});

Class balancing:

Train-test splitting:

// Split data into training and validation sets (70/30)
var withRandom = sampledPoints.randomColumn();
var trainingSet = withRandom.filter(ee.Filter.lt('random', 0.7));
var validationSet = withRandom.filter(ee.Filter.gte('random', 0.7));

7.2.2 Feature Selection

Identify the most informative variables for model training:

Correlation analysis:

Feature importance assessment:

// Train a preliminary Random Forest to assess variable importance
var classifier = ee.Classifier.smileRandomForest(100).train({
  features: trainingSet,
  classProperty: 'class',
  inputProperties: allVariables
});

// Get variable importance
var importance = classifier.explain().get('importance');
print('Variable importance:', importance);

Recursive feature elimination:

7.2.3 Parameter Optimization

Fine-tune model parameters to maximize performance:

Grid search:

Iterative refinement:

Cross-validation:

7.3 Classification Approaches

7.3.1 Binary Classification

Simplest approach focusing on seagrass presence/absence:

Implementation:

// Binary classification in GEE
var binaryClassifier = ee.Classifier.smileRandomForest(500).train({
  features: trainingData,
  classProperty: 'seagrass_presence',  // 0 = absent, 1 = present
  inputProperties: selectedVariables
});

// Apply classifier to generate probability map
var probabilityMap = covariateStack.classify(binaryClassifier, 'probability');

Threshold selection:

Output format:

7.3.2 Multi-class Classification

More detailed classification incorporating cover classes or species:

Implementation:

// Multi-class classification in GEE
var multiClassifier = ee.Classifier.smileRandomForest(500).train({
  features: trainingData,
  classProperty: 'seagrass_class',  // e.g., 0=none, 1=sparse, 2=medium, 3=dense
  inputProperties: selectedVariables
});

// Apply classifier
var classMap = covariateStack.classify(multiClassifier);

Hierarchical approach:

Class definition considerations:

7.3.3 Regression Approach

Estimate continuous cover values rather than discrete classes:

Implementation:

// Regression in GEE
var regressionModel = ee.Classifier.smileRandomForest(500)
  .setOutputMode('REGRESSION')
  .train({
    features: trainingData,
    classProperty: 'percent_cover',  // Continuous values (0-100%)
    inputProperties: selectedVariables
  });

// Apply model
var coverMap = covariateStack.classify(regressionModel);

Advantages:

Challenges:

8. Output Production and Validation

8.1 Map Generation Process

8.1.1 Classification Implementation

Apply the trained model to generate seagrass maps:

Basic classification:

// Apply classifier to image stack
var classifiedMap = covariateStack.classify(trainedClassifier);

Probability output:

// Generate probability map
var probabilityMap = covariateStack.classify(trainedClassifier, 'probability');

Multiple output types:

8.1.2 Threshold Application

Convert probability outputs to categorical maps:

Default threshold:

// Apply 50% threshold for binary classification
var binaryMap = probabilityMap.gt(0.5);

Optimized threshold:

// Apply threshold optimized from validation (e.g., 0.7)
var binaryMap = probabilityMap.gt(0.7);

Multiple thresholds:

// Generate maps at different confidence levels
var highConfidence = probabilityMap.gt(0.8);
var mediumConfidence = probabilityMap.gt(0.6).and(probabilityMap.lt(0.8));
var lowConfidence = probabilityMap.gt(0.4).and(probabilityMap.lt(0.6));

8.1.3 Output Formats and Resolution

Prepare maps in appropriate formats for distribution and use:

GeoTIFF export:

// Export classification as GeoTIFF
Export.image.toDrive({
  image: classifiedMap,
  description: 'Seagrass_Classification',
  folder: 'Seagrass_Mapping',
  region: studyArea,
  scale: 10,
  crs: 'EPSG:4326',
  maxPixels: 1e13
});

Vector format:

// Convert raster to vector for certain applications
var seagrassVector = binaryMap.reduceToVectors({
  scale: 10,
  geometryType: 'polygon',
  eightConnected: true,
  maxPixels: 1e13,
  reducer: ee.Reducer.mean()
});

Resolution considerations:

8.2 Accuracy Assessment

8.2.1 Validation Data Preparation

Utilize independent validation data to assess map accuracy:

Independent test set:

Validation data integration:

// Sample classification results at validation points
var validationResults = classifiedMap.sampleRegions({
  collection: validationPoints,
  properties: ['reference_class'],
  scale: 10
});

Confusion matrix generation:

// Generate confusion matrix
var confusionMatrix = validationResults.errorMatrix({
  actual: 'reference_class',
  predicted: 'classification'
});

8.2.2 Accuracy Metrics

Calculate and report standard accuracy metrics:

Overall accuracy:

// Calculate overall accuracy
var overallAccuracy = confusionMatrix.accuracy();
print('Overall Accuracy:', overallAccuracy);

Class-specific metrics:

// Calculate producer's and user's accuracy
var producersAccuracy = confusionMatrix.producersAccuracy();
var usersAccuracy = confusionMatrix.consumersAccuracy();
print('Producer\'s Accuracy:', producersAccuracy);
print('User\'s Accuracy:', usersAccuracy);

Kappa coefficient:

// Calculate Cohen's Kappa
var kappa = confusionMatrix.kappa();
print('Kappa Coefficient:', kappa);

F1-score and other metrics:

8.2.3 Area Estimation and Uncertainty

Quantify the extent of seagrass and associated uncertainty:

Area calculation:

// Calculate total seagrass area
var pixelArea = ee.Image.pixelArea();
var seagrassArea = binaryMap.multiply(pixelArea).reduceRegion({
  reducer: ee.Reducer.sum(),
  geometry: studyArea,
  scale: 10,
  maxPixels: 1e13
});

Confidence intervals:

Error-adjusted area estimates:

8.3 Validation Approaches

8.3.1 Traditional Accuracy Assessment

Standard approach using point-based reference data:

Confusion matrix analysis:

Cross-validation:

Independent validation:

8.3.2 Spatial Accuracy Assessment

Evaluate spatial patterns and context:

Patch-based assessment:

Boundary accuracy:

Spatial autocorrelation of errors:

8.3.3 Expert Validation

Supplement quantitative validation with expert assessment:

Visual inspection:

Stakeholder feedback:

Consistency checking:

9. Post-processing and Refinement

9.1 Basic Pixel Filtering

9.1.1 Noise Reduction

Apply filtering techniques to reduce classification noise:

Majority filter:

// Apply majority filter to smooth classification
var kernel = ee.Kernel.square(1);
var smoothed = classifiedMap.reduceNeighborhood({
  reducer: ee.Reducer.mode(),
  kernel: kernel
});

Minimum mapping unit:

// Remove small isolated patches
var patchSize = 5;  // Minimum number of connected pixels
var connectedPixels = classifiedMap.connectedPixels(patchSize);
var filteredMap = classifiedMap.updateMask(connectedPixels.gte(patchSize));

Morphological operations:

9.1.2 Edge Enhancement

Refine classification boundaries:

Boundary extraction:

// Extract seagrass boundaries
var boundaries = binaryMap.not().and(binaryMap.focal_max(1));

Edge-aware filtering:

Boundary adjustment:

9.1.3 Gap Filling

Address data gaps and classification artifacts:

Interpolation techniques:

Conditional filling:

// Fill small gaps in seagrass areas
var gapFilled = binaryMap.focal_mode({
  radius: 1,
  kernelType: 'square',
  iterations: 1
});

Mask-based approaches:

9.2 Environmental Corrections

9.2.1 Depth-Based Refinement

Apply corrections based on depth relationships:

Depth range filtering:

// Mask seagrass predictions beyond ecological depth limits
var depthMask = bathymetry.gte(-20).and(bathymetry.lte(0));  // Limit to 0-20m depth
var refinedMap = classifiedMap.updateMask(depthMask);

Depth-specific probability adjustments:

Bathymetric context:

9.2.2 Substrate-Based Corrections

Refine classification based on substrate suitability:

Substrate masking:

// Mask seagrass predictions in unsuitable substrate areas
var suitableSubstrate = substrateMap.eq(1).or(substrateMap.eq(2));  // e.g., sand or mud
var refinedMap = classifiedMap.updateMask(suitableSubstrate);

Probability adjustment:

Integration with geomorphic classification:

9.2.3 Exposure-Based Modifications

Adjust classification based on hydrodynamic exposure:

Wave exposure masking:

// Mask seagrass predictions in high-energy environments
var lowExposure = waveExposure.lt(threshold);
var refinedMap = classifiedMap.updateMask(lowExposure);

Species-specific adjustments:

Seasonal considerations:

9.3 Geographic location-based refinements

9.3.1 Regional Context Integration

Apply refinements based on regional knowledge:

Bioregional adjustments:

Management zone integration:

Local knowledge incorporation:

9.3.2 Manual Editing

Apply targeted manual corrections where necessary:

Expert review and editing:

Reference data integration:

Feedback incorporation:

9.3.3 Final Quality Control

Conduct comprehensive quality assessment before finalization:

Logical consistency checks:

Edge effect assessment:

Time-series consistency:

10. Quality Control and Documentation

10.1 Quality Assurance Procedures

10.1.1 Process Documentation

Maintain comprehensive documentation of the mapping process:

Workflow documentation:

Input data tracking:

Decision logging:

10.1.2 Quality Control Checkpoints

Implement systematic quality checks throughout the mapping process:

Pre-processing checks:

Classification checks:

Post-processing checks:

10.1.3 Independent Review

Facilitate external assessment of mapping products:

Peer review process:

Stakeholder review:

Cross-validation with alternative approaches:

10.2 Metadata Standards and Documentation

10.2.1 Metadata Requirements

Adhere to established metadata standards for geospatial datasets:

Essential metadata elements:

Standardized formats:

Tool-specific implementation:

// GEE example for adding metadata
var classified = classified.set({
  'title': 'Seagrass distribution map for [region]',
  'created_by': 'Author Name',
  'creation_date': Date.now(),
  'source_imagery': 'Sentinel-2 MSI',
  'time_period': startDate + ' to ' + endDate,
  'classification_method': 'Random Forest',
  'overall_accuracy': overallAccuracy,
  'kappa': kappa
});

10.2.2 Technical Documentation

Develop detailed technical documentation for mapping products:

Methodology report:

Data dictionary:

Limitations statement:

10.2.3 User Documentation

Create accessible documentation for end users:

User guide:

Quick reference materials:

Tutorial materials:

10.3 Data Archiving Protocols

10.3.1 Archival Requirements

Establish protocols for long-term data preservation:

Data selection:

Format specifications:

Documentation inclusion:

10.3.2 Repository Selection

Choose appropriate repositories for data storage:

Institutional repositories:

Domain-specific repositories:

General-purpose repositories:

10.3.3 Version Control and Updates

Implement systems for tracking changes and updates:

Version numbering:

Change documentation:

Update notification:

11. Conclusion and Future Directions

11.1 Limitations and Considerations

11.1.1 Methodological Limitations

Acknowledge inherent constraints of the mapping approach:

Remote sensing limitations:

Classification challenges:

Validation constraints:

11.1.2 Environmental Factors

Consider environmental influences on mapping accuracy:

Water quality effects:

Phenological considerations:

Disturbance effects:

11.1.3 Application Constraints

Provide guidance on appropriate use of mapping products:

Scale considerations:

Temporal relevance:

Uncertainty implications:

11.2 Future Developments

11.2.1 Technological Advancements

Highlight potential improvements through technological innovation:

Sensor developments:

Computational advancements:

Analytical innovations:

11.2.2 Methodological Improvements

Identify opportunities for methodological enhancement:

Multi-sensor integration:

Time-series analysis:

Three-dimensional mapping:

11.2.3 Application Expansion

Explore emerging applications for seagrass mapping:

Ecosystem service assessment:

Climate change monitoring:

Conservation planning:

11.3 Research Needs

11.3.1 Knowledge Gaps

Identify critical areas requiring further research:

Species-level mapping:

Condition assessment:

Temporal dynamics:

11.3.2 Validation Improvements

Highlight needs for enhanced validation approaches:

Standardized field protocols:

Uncertainty quantification:

Independent verification:

11.3.3 Integration Opportunities

Identify opportunities for enhanced integration:

Cross-disciplinary collaboration:

Multi-scale approaches:

Knowledge co-production:

12. SOP Maintenance

12.1 Review Schedule

12.1.1 Regular Review Cycle

Establish schedule for routine SOP evaluation:

Annual review:

Major review (3-5 years):

Event-triggered review:

12.1.2 Review Process

Stakeholder input:

12.2 Update Procedures

12.2.1 Revisions

Define approach for substantial SOP restructuring:

Revision planning:

Development process:

Implementation strategy:

12.3 Version Control

12.3.1 Versioning System

Implement clear version management approach:

12.3.2 Document Control

Establish protocols for managing SOP documentation:

12.3.3 Backwards Compatibility

Address compatibility considerations across versions:

13. Acknowledgements

This SOP was developed through collaborative efforts involving multiple organizations and individuals. Key contributors include:

Funding for SOP development was provided by the National Environmental Science Program (NESP) Marine and Coastal Hub.

We also acknowledge the contributions of numerous researchers, technicians, and field staff who participated in data collection, analysis, and review activities that supported the development of this SOP.

14. References

Australian and New Zealand Environment and Conservation Council (ANZECC) and Agriculture and Resource Management Council of Australia and New Zealand (ARMCANZ). (2000). Australian and New Zealand Guidelines for Fresh and Marine Water Quality. Canberra, Australia.

Bekkby, T., Moy, F. E., Olsen, H., Rinde, E., Bodvin, T., Bøe, R., … & Alve, E. (2013). The Norwegian program for mapping of marine habitats – providing knowledge and maps for ICZMP. In Global challenges in integrated coastal zone management (pp. 21-30). John Wiley & Sons, Ltd.

Butler, C., Lucieer, V., Walsh, P., Flukes, E., & Johnson, C. (2017). Seamap Australia [Version 1.0] the development of a national benthic marine classification scheme for the Australian continental shelf. Final Report to the Australian National Data Service (ANDS) High Values Collection #19. Institute for Marine and Antarctic Studies, University of Tasmania.

Congalton, R. G. (1991). A review of assessing the accuracy of classifications of remotely sensed data. Remote Sensing of Environment, 37, 35-46.

Duffy, J. P., Pratt, L., Anderson, K., Land, P. E., & Shutler, J. D. (2018). Spatial assessment of intertidal seagrass meadows using optical imaging systems and a lightweight drone. Estuarine, Coastal and Shelf Science, 200, 169-180.

Eugenio, F., Marcello, J., Martin, J., & Rodríguez-Esparragón, D. (2017). Benthic habitat mapping using multispectral high-resolution imagery: Evaluation of shallow water atmospheric correction techniques. Sensors, 17(11), 2639.

Foster, S. D. (2021). MBHdesign: An R-package for efficient spatial survey designs. Methods in Ecology and Evolution, 12(3), 415-420.

Gorelick, N., Hancher, M., Dixon, M., Ilyushchenko, S., Thau, D., & Moore, R. (2017). Google Earth Engine: Planetary-scale geospatial analysis for everyone. Remote Sensing of Environment, 202, 18-27.

Green, E. P., Mumby, P. J., Edwards, A. J., & Clark, C. D. (2000). Remote sensing handbook for tropical coastal management. UNESCO Publishing.

Hayes, K. R., Foster, S. D., Lawrence, E., Przeslawski, R., Caley, M. J., Williams, A., … & Hosack, G. R. (2017). Spatially balanced designs that incorporate legacy sites. Methods in Ecology and Evolution.

Hewitt, J., Althaus, F., Hill, N., Ferrari, R., Edwards, L., Przeslawski, R., … & Gowlett-Holmes, K. (2015). A standardised vocabulary for identifying benthic biota and substrata from underwater imagery: The CATAMI classification scheme. PLoS One, 10(10).

Kovacs, E., Roelfsema, C., Lyons, M., Zhao, S., & Phinn, S. (2018). Seagrass habitat mapping: how do Landsat 8 OLI, Sentinel-2, ZY-3A, and Worldview-3 perform? Remote Sensing Letters, 9(7), 686-695.

Landis, J. R., & Koch, G. G. (1977). The measurement of observer agreement for categorical data. Biometrics, 33, 159-174.

Lauer, M., & Aswani, S. (2008). Integrating indigenous ecological knowledge and multi-spectral image classification for marine habitat mapping in Oceania. Ocean & Coastal Management, 51(6), 495-504.

Lyons, M., Phinn, S., & Roelfsema, C. (2011). Integrating Quickbird multi-spectral satellite and field data: mapping bathymetry, seagrass cover, seagrass species and change in Moreton Bay, Australia in 2004 and 2007. Remote Sensing, 3(1), 42-64.

Lyons, M., Roelfsema, C., Kovacs, E., Samper-Villarreal, J., Saunders, M., Maxwell, P., & Phinn, S. (2015). Rapid monitoring of seagrass biomass using a simple linear modelling approach, in the field and from space. Marine Ecology Progress Series, 530, 1-14.

Lyons, M. B., Keith, D. A., Phinn, S. R., Mason, T. J., & Elith, J. (2018). A comparison of resampling methods for remote sensing classification and accuracy assessment. Remote Sensing of Environment, 208, 145-153.

Mastrantonis, S., Radford, B., Langlois, T., Spencer, C., de Lestang, S., & Hickey, S. (2024). A novel method for robust marine habitat mapping using a kernelised aquatic vegetation index. ISPRS Journal of Photogrammetry and Remote Sensing, 209, 472-480.

McKenzie, L. J., Finkbeiner, M. A., & Kirkman, H. (2001). Methods for mapping seagrass distribution. In Global seagrass research methods (pp. 101-121). Elsevier Science.

Murray, N. J., Worthington, T. A., Bunting, P., Duce, S., Hagger, V., Lovelock, C. E., … & Lyons, M. B. (2022). High-resolution mapping of losses and gains of Earth’s tidal wetlands. Science, 376(6594), 744-749.

Phinn, S. R., Roelfsema, C. M., & Mumby, P. J. (2012). Multi-scale, object-based image analysis for mapping geomorphic and ecological zones on coral reefs. International Journal of Remote Sensing, 33(12), 3768-3797.

Roelfsema, C. M., Lyons, M., Kovacs, E. M., Maxwell, P., Saunders, M. I., Samper-Villarreal, J., & Phinn, S. R. (2014). Multi-temporal mapping of seagrass cover, species and biomass: A semi-automated object based image analysis approach. Remote Sensing of Environment, 150, 172-187.

Stehman, S. V. (2009). Sampling designs for accuracy assessment of land cover. International Journal of Remote Sensing, 30(20), 5243-5272.

Traganos, D., Aggarwal, B., Poursanidis, D., Topouzelis, K., Chrysoulakis, N., & Reinartz, P. (2018). Towards global-scale seagrass mapping and monitoring using Sentinel-2 on Google Earth Engine: The case study of the Aegean and Ionian Seas. Remote Sensing, 10(8), 1227.

Traganos, D., & Reinartz, P. (2018). Mapping Mediterranean seagrasses with Sentinel-2 imagery. Marine Pollution Bulletin, 134, 197-209.

Vanhellemont, Q. (2019). Adaptation of the dark spectrum fitting atmospheric correction for aquatic applications of the Landsat and Sentinel-2 archives. Remote Sensing of Environment, 225, 175-192.

Waycott, M., Duarte, C. M., Carruthers, T. J., Orth, R. J., Dennison, W. C., Olyarnik, S., … & Williams, S. L. (2009). Accelerating loss of seagrasses across the globe threatens coastal ecosystems. Proceedings of the National Academy of Sciences, 106(30), 12377-12381.

Wicaksono, P., & Lazuardi, W. (2019). Random forest classification scenarios for benthic habitat mapping using Planetscope image. IGARSS 2019 - 2019 IEEE International Geoscience and Remote Sensing Symposium, 8245-8248.

Zoffoli, M. L., Gernez, P., Rosa, P., Le Bris, A., Brando, V. E., Barillé, A. L., … & Barillé, L. (2020). Sentinel-2 remote sensing of Zostera noltei-dominated intertidal seagrass meadows. Remote Sensing of Environment, 251.

15. Appendices

Appendix A: Code Examples

A.1 Generic Google Earth Engine Code Examples for Seagrass Mapping

// Google Earth Engine JavaScript code for seagrass mapping
// This provides a full workflow example that can be adapted to specific projects

// Define study area (replace with specific region of interest)
var studyArea = ee.Geometry.Rectangle([longitude1, latitude1, longitude2, latitude2]);

// Define time period for analysis
var startDate = '2020-01-01';
var endDate = '2023-12-31';
var cloudThreshold = 20; // Maximum cloud cover percentage

// Load Sentinel-2 Level 2A collection and filter
var s2Collection = ee.ImageCollection('COPERNICUS/S2_SR')
  .filterBounds(studyArea)
  .filterDate(startDate, endDate)
  .filter(ee.Filter.lt('CLOUDY_PIXEL_PERCENTAGE', cloudThreshold));

// Cloud masking function
function maskS2clouds(image) {
  var scl = image.select('SCL');
  var cloudMask = scl.lt(7).and(scl.gt(3));  // Values 4, 5, 6 are valid pixels
  return image.updateMask(cloudMask);
}

// Apply cloud masking
var s2Masked = s2Collection.map(maskS2clouds);

// Select relevant bands for seagrass mapping
var bands = ['B2', 'B3', 'B4', 'B8'];
var s2Selected = s2Masked.select(bands);

// Calculate percentile composites
var p20 = s2Selected.reduce(ee.Reducer.percentile([20])).rename(['B2_p20', 'B3_p20', 'B4_p20', 'B8_p20']);
var p40 = s2Selected.reduce(ee.Reducer.percentile([40])).rename(['B2_p40', 'B3_p40', 'B4_p40', 'B8_p40']);
var p60 = s2Selected.reduce(ee.Reducer.percentile([60])).rename(['B2_p60', 'B3_p60', 'B4_p60', 'B8_p60']);
var p80 = s2Selected.reduce(ee.Reducer.percentile([80])).rename(['B2_p80', 'B3_p80', 'B4_p80', 'B8_p80']);

// Load bathymetry data
var bathymetry = ee.Image('projects/my-project/assets/bathymetry');

// Generate bathymetric derivatives
var slope = ee.Terrain.slope(bathymetry);
var neighborhood = ee.Kernel.circle(10, 'meters');
var rugosity = slope.reduceNeighborhood({
  reducer: ee.Reducer.stdDev(),
  kernel: neighborhood
});

// Load wave climate data
var waveClimate = ee.Image('projects/my-project/assets/wave_power');

// Combine all covariates into a stack
var covariateStack = ee.Image.cat([
  p20, p40, p60, p80,
  bathymetry, slope, rugosity,
  waveClimate
]);

// Load training data
var trainingPoints = ee.FeatureCollection('projects/my-project/assets/seagrass_training_points');

// Sample covariates at training points
var trainingData = covariateStack.sampleRegions({
  collection: trainingPoints,
  properties: ['class'],
  scale: 10,
  geometries: true
});

// Split into training and validation sets
var withRandom = trainingData.randomColumn();
var trainingSet = withRandom.filter(ee.Filter.lt('random', 0.7));
var validationSet = withRandom.filter(ee.Filter.gte('random', 0.7));

// Train Random Forest classifier
var classifier = ee.Classifier.smileRandomForest({
  numberOfTrees: 500,
  minLeafPopulation: 2,
  variablesPerSplit: null,
  bagFraction: 0.5,
  seed: 42
}).train({
  features: trainingSet,
  classProperty: 'class',
  inputProperties: covariateStack.bandNames()
});

// Get variable importance
var importance = classifier.explain().get('importance');
print('Variable importance:', importance);

// Apply classifier to generate probability map
var probabilityMap = covariateStack.classify(classifier, 'probability');

// Apply threshold to create binary map
var binaryMap = probabilityMap.gt(0.5);

// Apply majority filter to reduce noise
var kernel = ee.Kernel.square(1);
var smoothed = binaryMap.reduceNeighborhood({
  reducer: ee.Reducer.mode(),
  kernel: kernel
});

// Mask by depth threshold
var depthMask = bathymetry.gt(-20);  // Limit to 20m depth
var refinedMap = smoothed.updateMask(depthMask);

// Validate using test set
var validationResults = refinedMap.sampleRegions({
  collection: validationSet,
  properties: ['class'],
  scale: 10
});

// Generate confusion matrix
var confusionMatrix = validationResults.errorMatrix({
  actual: 'class',
  predicted: 'classification'
});

// Calculate accuracy metrics
var overallAccuracy = confusionMatrix.accuracy();
var kappa = confusionMatrix.kappa();
print('Overall Accuracy:', overallAccuracy);
print('Kappa Coefficient:', kappa);

// Calculate seagrass area
var pixelArea = ee.Image.pixelArea();
var seagrassArea = refinedMap.multiply(pixelArea).reduceRegion({
  reducer: ee.Reducer.sum(),
  geometry: studyArea,
  scale: 10,
  maxPixels: 1e13
});

// Display results
Map.centerObject(studyArea, 10);
Map.addLayer(probabilityMap, {min: 0, max: 1, palette: ['white', 'green']}, 'Seagrass Probability');
Map.addLayer(refinedMap, {palette: ['green']}, 'Seagrass Binary Map');

A.2 Generic Python Code for Seagrass Mapping with ODC/DEA

# Python code example for seagrass mapping using Open Data Cube / Digital Earth Australia
# This provides a framework that can be adapted to specific projects

import datacube
import xarray as xr
import numpy as np
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, confusion_matrix, cohen_kappa_score
import geopandas as gpd
from shapely.geometry import Point

# Initialize the Data Cube
dc = datacube.Datacube(app='seagrass_mapping')

# Define the study area and time period
latitude = (-33.0, -32.5)
longitude = (151.0, 151.5)
time = ('2020-01', '2023-12')

# Load Sentinel-2 data
s2_data = dc.load(
    product='s2_ard_granule',
    x=longitude,
    y=latitude,
    time=time,
    measurements=['blue', 'green', 'red', 'nir'],
    output_crs='EPSG:3577',
    resolution=(-10, 10),
    dask_chunks={'time': 1, 'x': 1000, 'y': 1000}
)

# Load cloud mask
cloud_mask = dc.load(
    product='s2_ard_cloud',
    x=longitude,
    y=latitude,
    time=time,
    output_crs='EPSG:3577',
    resolution=(-10, 10),
    dask_chunks={'time': 1, 'x': 1000, 'y': 1000}
)

# Apply cloud mask
s2_masked = s2_data.where(cloud_mask.clear_and_valid, np.nan)

# Calculate percentile composites
s2_p20 = s2_masked.quantile(0.2, dim='time')
s2_p40 = s2_masked.quantile(0.4, dim='time')
s2_p60 = s2_masked.quantile(0.6, dim='time')
s2_p80 = s2_masked.quantile(0.8, dim='time')

# Load bathymetry data
bathymetry = dc.load(
    product='bathymetry',
    x=longitude,
    y=latitude,
    output_crs='EPSG:3577',
    resolution=(-10, 10)
)

# Calculate bathymetric derivatives
from scipy.ndimage import sobel
slope_x = sobel(bathymetry.bathymetry.values, axis=1)
slope_y = sobel(bathymetry.bathymetry.values, axis=0)
slope = np.sqrt(slope_x**2 + slope_y**2)

# Convert slope to xarray
slope_xr = xr.DataArray(
    slope,
    dims=bathymetry.bathymetry.dims,
    coords=bathymetry.bathymetry.coords,
    name='slope'
)

# Calculate rugosity (standard deviation of slope in neighborhood)
from scipy.ndimage import generic_filter
rugosity = generic_filter(slope, np.std, size=3)

# Convert rugosity to xarray
rugosity_xr = xr.DataArray(
    rugosity,
    dims=bathymetry.bathymetry.dims,
    coords=bathymetry.bathymetry.coords,
    name='rugosity'
)

# Load wave climate data
wave_climate = xr.open_dataset('wave_climate.nc')

# Combine all covariates
covariates = xr.merge([
    s2_p20, s2_p40, s2_p60, s2_p80,
    bathymetry, 
    slope_xr, rugosity_xr,
    wave_climate
])

# Load training data
training_points = gpd.read_file('seagrass_training_points.shp')

# Extract covariate values at training points
X_train = []
y_train = []

for idx, point in training_points.iterrows():
    x, y = point.geometry.x, point.geometry.y
    pixel_values = covariates.sel(x=x, y=y, method='nearest').to_array().values
    if not np.isnan(pixel_values).any():
        X_train.append(pixel_values)
        y_train.append(point['class'])

X_train = np.array(X_train)
y_train = np.array(y_train)

# Split into training and validation sets
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X_train, y_train, test_size=0.3, random_state=42)

# Train Random Forest classifier
rf = RandomForestClassifier(
    n_estimators=500,
    min_samples_leaf=2,
    max_features='sqrt',
    random_state=42,
    n_jobs=-1
)

rf.fit(X_train, y_train)

# Get feature importance
feature_importance = pd.DataFrame({
    'feature': covariates.data_vars.keys(),
    'importance': rf.feature_importances_
}).sort_values('importance', ascending=False)

print(feature_importance)

# Apply classifier to generate probability map
def predict_proba(sample):
    # Reshape for sklearn
    sample_reshaped = sample.reshape(1, -1)
    # Get probability for seagrass class (assuming class 1 is seagrass)
    return rf.predict_proba(sample_reshaped)[0, 1]

probability_map = xr.apply_ufunc(
    predict_proba,
    covariates.to_array(),
    input_core_dims=[['variable']],
    vectorize=True,
    dask='parallelized'
)

# Apply threshold to create binary map
binary_map = probability_map > 0.5

# Apply majority filter to reduce noise
from scipy.ndimage import median_filter
smoothed = median_filter(binary_map.values, size=3)

# Mask by depth threshold
depth_mask = bathymetry.bathymetry > -20  # Limit to 20m depth
refined_map = binary_map.where(depth_mask)

# Validate using test set
y_pred = rf.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
conf_matrix = confusion_matrix(y_test, y_pred)
kappa = cohen_kappa_score(y_test, y_pred)

print(f"Overall Accuracy: {accuracy:.4f}")
print(f"Confusion Matrix:\n{conf_matrix}")
print(f"Kappa Coefficient: {kappa:.4f}")

# Calculate seagrass area
pixel_area = 10 * 10  # 10m resolution, area in m²
seagrass_area = np.sum(binary_map.values) * pixel_area
seagrass_area_km2 = seagrass_area / 1000000  # Convert to km²

print(f"Estimated Seagrass Area: {seagrass_area_km2:.2f} km²")

# Save outputs
probability_map.to_netcdf('seagrass_probability.nc')
binary_map.to_netcdf('seagrass_binary.nc')

Appendix B: Parameter Settings

Parameter Recommended Value Notes
Cloud threshold <20% Initial filtering of scenes
Cloud probability mask <10% Per-pixel cloud masking
Time period 3-4 years Balance between temporal relevance and data availability
Percentile values 20, 40, 60, 80 Capture distribution across time series
Composite method Percentile-based More robust than mean/median for coastal environments
Spatial resolution 10m Native resolution for key S2 bands
Minimum mapping unit 5 pixels ~500m² for Sentinel-2

B.2 Random Forest Classification Parameters

Parameter Recommended Value Range to Test Notes
Number of trees 500 300-1000 More trees increase stability but require more computation
Minimum leaf population 2 1-5 Lower values capture more detail but risk overfitting
Variables per split sqrt(n) sqrt(n) to n/3 Default (sqrt) typically performs well
Bag fraction 0.5 0.5-0.7 Controls randomness in tree building
Maximum depth No limit 10-No limit Unlimited often works well for remote sensing data
Class weights Balanced Balanced/Custom Consider custom weights for imbalanced classes

B.3 Post-processing Parameters

Operation Parameter Recommended Value Notes
Majority filter Window size 3x3 Balance between noise reduction and detail preservation
Minimum patch size Number of pixels 5 Remove isolated pixels and small patches
Gap filling Maximum gap size 3 pixels Fill small gaps within larger patches
Depth masking Maximum depth -20m Adjust based on local water clarity
Edge smoothing Iterations 1 Minimal smoothing to preserve ecological detail

Appendix C: Additional Resources

C.1 Reference Datasets

Dataset Source URL Description
Global Distribution of Seagrasses UNEP-WCMC https://data.unep-wcmc.org/datasets/7 Global compilation of seagrass distribution
Australian National Seagrass Dataset Seamap Australia https://seamapaustralia.org/ Compilation of Australian seagrass mapping
Sentinel-2 L2A Copernicus Open Access Hub https://scihub.copernicus.eu/ Atmospherically corrected Sentinel-2 imagery
Australian Bathymetry AusSeabed https://portal.ga.gov.au/persona/marine High-resolution bathymetry for Australian waters
Global Wave Climate CAWCR https://data.csiro.au/collection/csiro:39819 Wave hindcast model outputs

C.2 Software Tools

Tool Type URL Application
Google Earth Engine Cloud platform https://earthengine.google.com/ Image processing and analysis
Open Data Cube Python framework https://www.opendatacube.org/ Data management and analysis
QGIS Desktop GIS https://qgis.org/ Visualization and editing
SNAP Desktop software https://step.esa.int/main/toolboxes/snap/ Sentinel-2 preprocessing
Acolite Desktop software https://github.com/acolite/acolite Atmospheric correction for aquatic applications

C.3 Training Resources

Resource Type URL Focus
Introduction to Google Earth Engine Online course https://developers.google.com/earth-engine/tutorials GEE basics and applications
Digital Earth Australia Training Tutorials https://training.dea.ga.gov.au/ ODC/DEA applications
Seagrass Mapping with Remote Sensing Research paper https://doi.org/10.3390/rs10081227 Methodological guidance
Marine Benthic Habitat Mapping Book https://doi.org/10.1007/978-3-319-25121-9 Comprehensive overview
Marine Habitat Mapping Field Protocols Manual https://marine.gov.scot/data/seabed-habitat-mapping-guidance Field methods

C.4 Relevant Communities of Practice

Appendix D: Case studies applying and demonstrating the SOP