Bathymetry¶

import ee
from gee_acolite.bathymetry import multi_image
from gee_acolite import ACOLITE

# Process multiple images with ACOLITE
corrected_images, settings = ac_gee.correct(images)

# Compute bathymetry for each image
def add_bathymetry(image):
from gee_acolite.water_quality import compute_water_bands

def add_bathymetry(image):
    return compute_water_bands(image, settings, products=['pSDB_green', 'pSDB_red'])

images_with_sdb = corrected_images.map(add_bathymetry)

# Create quality mosaic using green band
best_bathymetry = multi_image(images_with_sdb, band='pSDB_green')

# Visualize
Map.addLayer(best_bathymetry.select('pSDB_green'),
             {'min': -5, 'max': 0, 'palette': ['white', 'cyan', 'blue', 'navy']},
             'Bathymetry Green')

import ee
import pandas as pd
from gee_acolite.bathymetry import multi_image

# Process images by year
years = [2020, 2021, 2022, 2023]
yearly_mosaics = {}

for year in years:
    # Search images for the year
    start = f'{year}-01-01'
    end = f'{year}-12-31'
    images_year = search(roi, start, end, tile='30SYJ')

    # Correct and compute bathymetry
    corrected, settings = ac_gee.correct(images_year)
    with_sdb = corrected.map(lambda img: compute_water_bands(
        img, settings, products=['pSDB_green', 'pSDB_red'])
    )

    # Create annual mosaic
    yearly_mosaics[year] = multi_image(with_sdb, band='pSDB_green')

# Analyze temporal changes
def extract_depth_profile(mosaic, line_geometry):
    """Extract depth profile along a line"""
    profile = mosaic.select('pSDB_green').reduceRegion(
        reducer=ee.Reducer.toList(),
        geometry=line_geometry,
        scale=10
    )
    return profile.getInfo()

# Extract profiles for each year
transect = ee.Geometry.LineString([[-0.35, 39.48], [-0.33, 39.48]])
profiles = {year: extract_depth_profile(mosaic, transect) 
            for year, mosaic in yearly_mosaics.items()}

import numpy as np
from sklearn.metrics import mean_squared_error, r2_score

def validate_sdb(predicted_depths, measured_depths):
    """
    Validate satellite-derived bathymetry against in-situ measurements.

    Parameters
    ----------
    predicted_depths : array-like
        Depths predicted by pSDB
    measured_depths : array-like
        Measured depths (e.g., echosounder)

    Returns
    -------
    dict
        Validation metrics (RMSE, R², bias)
    """
    rmse = np.sqrt(mean_squared_error(measured_depths, predicted_depths))
    r2 = r2_score(measured_depths, predicted_depths)
    bias = np.mean(predicted_depths - measured_depths)

    return {
        'RMSE': rmse,
        'R2': r2,
        'Bias': bias,
        'n_samples': len(predicted_depths)
    }

# Validation example
validation_points = ee.FeatureCollection('users/yourname/validation_points')

def extract_sdb_at_point(feature):
    point = feature.geometry()
    sdb_value = best_bathymetry.select('pSDB_green').reduceRegion(
        reducer=ee.Reducer.first(),
        geometry=point,
        scale=10
    ).get('pSDB_green')
    return feature.set('sdb_predicted', sdb_value)

validated = validation_points.map(extract_sdb_at_point)