gee-acolite 1.0.0__py3-none-any.whl

gee_acolite/__init__.py

@@ -0,0 +1,49 @@
+"""
+GEE ACOLITE - Atmospheric correction for Google Earth Engine
+
+This package provides ACOLITE atmospheric correction optimized for 
+Google Earth Engine workflows with Sentinel-2 imagery.
+
+Main Features:
+- Dark spectrum fitting atmospheric correction
+- AOT estimation (fixed geometry)
+- Water quality parameter computation
+- Cloud masking integration
+
+Note: Requires ACOLITE package to be installed separately.
+Install from: https://github.com/acolite/acolite
+"""
+
+__version__ = "0.1.0"
+__author__ = "Sergio"
+__license__ = "GPL-3.0"
+
+# Main atmospheric correction class
+from gee_acolite.correction import ACOLITE
+
+# Bathymetry utilities
+from gee_acolite.bathymetry import multi_image
+
+# Water quality parameters
+from gee_acolite.water_quality import (
+    compute_water_bands,
+    compute_water_mask,
+    PRODUCTS
+)
+
+# Utility modules
+from gee_acolite import utils, sensors
+
+__all__ = [
+    # Main class
+    "ACOLITE",
+    # Bathymetry
+    "multi_image",
+    # Water quality
+    "compute_water_bands",
+    "compute_water_mask",
+    "PRODUCTS",
+    # Modules
+    "utils",
+    "sensors",
+]

gee_acolite/bathymetry.py

@@ -0,0 +1,4 @@
+import ee
+
+def multi_image(images: ee.ImageCollection, band: str = 'pSDB_green') -> ee.Image:
+    return images.qualityMosaic(band)

gee_acolite/correction.py

@@ -0,0 +1,567 @@
+import numpy as np
+import scipy.stats
+import ee
+import os
+
+
+from typing import List, Tuple
+from types import ModuleType
+from functools import partial
+
+from gee_acolite.utils.l1_convert import l1_to_rrs
+from gee_acolite.utils.masks import mask_negative_reflectance
+from gee_acolite.water_quality import compute_water_bands
+
+
+class ACOLITE(object):
+    def __init__(self, acolite: ModuleType, settings: str | dict) -> None:
+        self.acolite = acolite
+        self.settings = self.__load_settings(settings)
+
+    def __load_settings(self, settings: str | dict):
+        # return self.acolite.acolite.settings.load(settings)
+        return self.acolite.acolite.settings.parse('S2A_MSI', settings = settings)
+    
+    def correct(self, images : ee.ImageCollection) -> Tuple[ee.ImageCollection, dict]:
+        images = l1_to_rrs(images, self.settings.get('s2_target_res', 10))
+        images, settings = self.l1_to_l2(images.toList(images.size()), images.size().getInfo(), self.settings)
+
+        return images, settings
+    
+
+    def l1_to_l2(self, images : ee.List, size : int, settings : dict) -> Tuple[ee.ImageCollection, dict]:
+        corrected_images = []
+
+        if settings['aerosol_correction'] == 'dark_spectrum':
+            for index in range(size):
+                rhos, bands, glint_params = self.dask_spectrum_fitting(ee.Image(images.get(index)), settings)
+        
+                if settings['dsf_residual_glint_correction'] and settings['dsf_residual_glint_correction_method'] == 'alternative':
+                    rhos = self.deglint_alternative(rhos, 
+                                                    bands, 
+                                                    glint_params,
+                                                    glint_max=float(settings.get('glint_mask_rhos_threshold', 0.05)))
+
+                rhos = rhos.copyProperties(ee.Image(images.get(index)))
+                rhos = rhos.set('system:time_start', ee.Image(images.get(index)).get('system:time_start'))
+
+                corrected_images.append(rhos)
+            
+        corrected_images = ee.ImageCollection.fromImages(corrected_images)
+
+        if settings['l2w_parameters']:
+            corrected_images = corrected_images.map(partial(compute_water_bands, settings=settings))
+            
+        return corrected_images, settings
+    
+    def dask_spectrum_fitting(self, image : ee.Image, settings : dict) -> Tuple[ee.Image, List[str], dict]:
+        if settings.get('ancillary_data', False):
+            settings = self.get_ancillary_data(image, settings)
+        else:
+            for data, default in [(key, f'{key}_default') for key in ['uoz', 'uwv', 'wind', 'pressure']]:
+                settings[data] = settings.get(default)
+
+        # Check if fixed AOT and LUT are provided
+        if settings.get('dsf_fixed_aot') is not None and settings.get('dsf_fixed_lut') is not None:
+            # Use fixed AOT and LUT (bypass dark spectrum fitting)
+            am, glint_ave, bands = self.compute_correction_with_fixed_aot(
+                image, 
+                float(settings['dsf_fixed_aot']), 
+                settings['dsf_fixed_lut'], 
+                settings
+            )
+        else:
+            # Normal dark spectrum fitting workflow
+            am, glint_ave, bands = self.select_lut(image, settings)
+        
+        rhos = self.compute_rhos(image, am)
+
+        return rhos, bands, glint_ave
+    
+    def estimate_aot_per_lut(self, pdark: dict, lutd: dict, rsrd: dict, ttg: dict, 
+                             geometry: dict, settings: dict, 
+                             aot_skip_bands: List[str] = ['9', '10', '11', '12']) -> dict:
+        """
+        Estimate AOT for each LUT model using dark spectrum fitting.
+        
+        Parameters:
+        - pdark: Dark spectrum values per band
+        - lutd: LUT dictionary with atmospheric models
+        - rsrd: Relative spectral response dictionary
+        - ttg: Gas transmittance dictionary
+        - geometry: Dict with 'raa', 'vza', 'sza', 'pressure'
+        - settings: Processing settings
+        - aot_skip_bands: Bands to skip in AOT estimation
+        
+        Returns:
+        - results: Dict with AOT estimation results per LUT
+        """
+        results = {}
+        nbands = settings['dsf_nbands']
+        
+        raa = geometry['raa']
+        vza = geometry['vza']
+        sza = geometry['sza']
+        pressure = geometry['pressure']
+        
+        for lut in lutd:
+            taua_arr = None
+            rhot_arr = None
+            taua_bands = []
+            
+            # Run through bands to estimate AOT
+            for b in rsrd['rsr_bands']:
+                if b in aot_skip_bands: 
+                    continue
+
+                # Get path reflectance from LUT for this band
+                ret = lutd[lut]['rgi'][b]((pressure, lutd[lut]['ipd']['romix'], 
+                                          raa, vza, sza, lutd[lut]['meta']['tau']))
+
+                # Dark spectrum value for this band
+                rhot = np.asarray([pdark['B{}'.format(b)]])
+                
+                # Gas correction
+                rhot /= ttg['tt_gas'][b]
+                
+                # Interpolate AOT from observed rhot
+                taua = np.interp(rhot, ret, lutd[lut]['meta']['tau'])
+                
+                if taua_arr is None:
+                    rhot_arr = 1.0 * rhot
+                    taua_arr = 1.0 * taua
+                else:
+                    rhot_arr = np.vstack((rhot_arr, rhot))
+                    taua_arr = np.vstack((taua_arr, taua))
+
+                taua_bands.append(b)
+
+            # Aggregate AOT from darkest bands
+            bidx = np.argsort(taua_arr[:, 0])
+            taua = np.nanmean(taua_arr[bidx[0: nbands], 0])
+            taua_std = np.nanstd(taua_arr[bidx[0: nbands], 0])
+            taua_cv = taua_std / taua
+
+            # Store results for this LUT
+            results[lut] = {
+                'taua_bands': taua_bands, 
+                'taua_arr': taua_arr, 
+                'rhot_arr': rhot_arr,
+                'taua': taua, 
+                'taua_std': taua_std, 
+                'taua_cv': taua_cv,
+                'bidx': bidx
+            }
+        
+        return results
+    
+    def select_best_model(self, results: dict, lutd: dict, geometry: dict, 
+                         settings: dict) -> Tuple[str, float, str, float]:
+        """
+        Select best atmospheric model based on selection criterion.
+        
+        Parameters:
+        - results: AOT estimation results per LUT from estimate_aot_per_lut
+        - lutd: LUT dictionary with atmospheric models
+        - geometry: Dict with 'raa', 'vza', 'sza', 'pressure'
+        - settings: Processing settings with selection method
+        
+        Returns:
+        - sel_lut: Selected LUT name
+        - sel_aot: Selected AOT value
+        - sel_par: Selection parameter name
+        - sel_val: Selection parameter value
+        """
+        dsf_model_selection = settings.get('dsf_model_selection', 'min_drmsd')
+        dsf_nbands_fit = settings.get('dsf_nbands_fit', 2)
+        
+        pressure = geometry['pressure']
+        raa = geometry['raa']
+        vza = geometry['vza']
+        sza = geometry['sza']
+        
+        if dsf_model_selection == 'min_drmsd':
+            # RMSD validation: compare predictions vs observations
+            for lut in results:
+                fit_band_indices = results[lut]['bidx'][0:dsf_nbands_fit]
+                
+                rmsd_values = []
+                for fit_idx in fit_band_indices:
+                    band = results[lut]['taua_bands'][fit_idx]
+                    
+                    # Observed rhot (gas corrected)
+                    rhot_obs = results[lut]['rhot_arr'][fit_idx, 0]
+                    
+                    # Modeled rhot using estimated AOT
+                    rhot_model = lutd[lut]['rgi'][band]((pressure, lutd[lut]['ipd']['romix'], 
+                                                         raa, vza, sza, results[lut]['taua']))
+                    
+                    # Squared difference
+                    rmsd_values.append((rhot_obs - rhot_model) ** 2)
+                
+                # Compute RMSD
+                results[lut]['rmsd'] = np.sqrt(np.mean(rmsd_values))
+            
+            sel_par = 'rmsd'
+            
+        elif dsf_model_selection == 'min_dtau':
+            # Minimum delta tau between two darkest bands
+            for lut in results:
+                if len(results[lut]['taua_arr']) >= 2:
+                    dtau = np.abs(results[lut]['taua_arr'][results[lut]['bidx'][0], 0] - 
+                                  results[lut]['taua_arr'][results[lut]['bidx'][1], 0])
+                    results[lut]['dtau'] = dtau
+                else:
+                    results[lut]['dtau'] = np.inf
+            
+            sel_par = 'dtau'
+            
+        else:
+            # Fallback: coefficient of variation
+            sel_par = 'taua_cv'
+        
+        # Select LUT with minimum selection parameter
+        sel_lut = None
+        sel_aot = None
+        sel_val = np.inf
+
+        for lut in results:
+            if results[lut][sel_par] < sel_val:
+                sel_val = results[lut][sel_par] * 1.0
+                sel_aot = results[lut]['taua'] * 1.0
+                sel_lut = '{}'.format(lut)
+        
+        return sel_lut, sel_aot, sel_par, sel_val
+    
+    def select_lut(self, image : ee.Image, settings : dict, aot_skip_bands : List[str] = ['9', '10', '11', '12']) -> Tuple[dict, dict, List[str]]:
+        """
+        Main function for LUT selection and atmospheric correction parameter computation.
+        
+        This function orchestrates:
+        1. Dark spectrum extraction
+        2. AOT estimation per LUT model
+        3. Model selection based on validation criterion
+        4. Computation of atmospheric correction parameters
+        
+        Parameters:
+        - image: Input ee.Image
+        - settings: Processing settings
+        - aot_skip_bands: Bands to skip in AOT estimation
+        
+        Returns:
+        - am: Atmospheric correction parameters (romix, dutott, astot, tg)
+        - glint_ave: Glint correction parameters per band
+        - bands: List of band names
+        """
+        # Extract dark spectrum
+        pdark = self.compute_pdark(image, settings)
+
+        # Get geometry and atmospheric parameters
+        raa = image.get('raa').getInfo()
+        vza = image.get('vza').getInfo()
+        sza = image.get('sza').getInfo()
+
+        geometry = {
+            'raa': raa,
+            'vza': vza,
+            'sza': sza,
+            'pressure': settings['pressure']
+        }
+
+        # Get sensor and load LUTs
+        sensor = 'S2A_MSI' if 'S2A' in image.get('PRODUCT_ID').getInfo() else 'S2B_MSI'
+        
+        lutd = self.acolite.aerlut.import_luts(sensor=sensor)
+        rsrd = self.acolite.shared.rsr_dict(sensor=sensor)[sensor]
+        ttg = self.acolite.ac.gas_transmittance(sza, vza, 
+                                                pressure=settings['pressure'], 
+                                                uoz=settings['uoz'], 
+                                                uwv=settings['uwv'], 
+                                                rsr=rsrd['rsr'])
+        luti = self.acolite.aerlut.import_rsky_luts(models=[1,2], 
+                                                     lutbase='ACOLITE-RSKY-202102-82W', 
+                                                     sensor=sensor)
+
+        # Step 1: Estimate AOT for each LUT model
+        results = self.estimate_aot_per_lut(pdark, lutd, rsrd, ttg, geometry, 
+                                           settings, aot_skip_bands)
+        
+        # Step 2: Select best model
+        sel_lut, sel_aot, sel_par, sel_val = self.select_best_model(results, lutd, 
+                                                                     geometry, settings)
+        
+        print(f'Selected model {sel_lut}: AOT={sel_aot:.3f}, {sel_par}={sel_val:.4e}')
+        print(f'  Geometry: SZA={geometry["sza"]:.2f}°, VZA={geometry["vza"]:.2f}°, RAA={geometry["raa"]:.2f}°')
+        print(f'  Pressure: {geometry["pressure"]:.2f} hPa')
+
+        # Step 3: Compute atmospheric correction parameters for selected model
+        am = {}
+        for par in lutd[sel_lut]['ipd']:
+            am[par] = {b: lutd[sel_lut]['rgi'][b]((geometry['pressure'], 
+                                                   lutd[sel_lut]['ipd'][par], 
+                                                   raa, vza, sza, sel_aot))
+                        for b in rsrd['rsr_bands']}
+        am.update({'tg': ttg['tt_gas']})
+
+        # Step 4: Compute glint correction parameters
+        model = int(sel_lut[-1])
+        glint_wind = 20
+        glint_bands = ['11', '12']
+
+        glint_dict = {b: luti[model]['rgi'][b]((raa, vza, sza, glint_wind, sel_aot)) 
+                     for b in rsrd['rsr_bands']}
+        glint_ave = {b: glint_dict[b] / ((glint_dict[glint_bands[0]] + 
+                                         glint_dict[glint_bands[1]]) / 2) 
+                    for b in glint_dict}
+
+        return am, glint_ave, rsrd['rsr_bands']
+    
+    def compute_correction_with_fixed_aot(self, image: ee.Image, aot: float, lut_name: str, 
+                                         settings: dict) -> Tuple[dict, dict, List[str]]:
+        """
+        Compute atmospheric correction parameters using fixed AOT and LUT.
+        
+        This function bypasses dark spectrum fitting and directly computes
+        correction parameters for a specified AOT and atmospheric model.
+        
+        Parameters:
+        - image: Input ee.Image (TOA reflectance)
+        - aot: Fixed aerosol optical thickness at 550nm
+        - lut_name: LUT name (e.g., 'ACOLITE-LUT-202110-MOD2')
+        - settings: Processing settings
+        
+        Returns:
+        - am: Atmospheric correction parameters (romix, dutott, astot, tg)
+        - glint_ave: Glint correction parameters per band
+        - bands: List of band names
+        """
+        # Extract geometry from image
+        raa = image.get('raa').getInfo()
+        vza = image.get('vza').getInfo()
+        sza = image.get('sza').getInfo()
+        
+        geometry = {
+            'raa': raa,
+            'vza': vza,
+            'sza': sza,
+            'pressure': settings['pressure']
+        }
+        
+        # Get sensor
+        sensor = 'S2A_MSI' if 'S2A' in image.get('PRODUCT_ID').getInfo() else 'S2B_MSI'
+        
+        # Load specified LUT
+        lutd = self.acolite.aerlut.import_luts(sensor=sensor)
+        
+        # Verify LUT exists
+        if lut_name not in lutd:
+            available_luts = list(lutd.keys())
+            raise ValueError(f"LUT '{lut_name}' not found. Available LUTs: {available_luts}")
+        
+        # Get RSR data
+        rsrd = self.acolite.shared.rsr_dict(sensor=sensor)[sensor]
+        pressure = settings['pressure']
+        uoz = settings['uoz']
+        uwv = settings['uwv']
+
+        # Compute gas transmittance
+        ttg = self.acolite.ac.gas_transmittance(sza, vza, 
+                                                pressure=pressure, 
+                                                uoz=uoz, 
+                                                uwv=uwv, 
+                                                rsr=rsrd['rsr'])
+        
+        # Load sky glint LUTs
+        luti = self.acolite.aerlut.import_rsky_luts(models=[1,2], 
+                                                     lutbase='ACOLITE-RSKY-202102-82W', 
+                                                     sensor=sensor)
+        
+        print(f'Using fixed AOT={aot:.3f} with LUT={lut_name}')
+        print(f'  Geometry: SZA={geometry["sza"]:.2f}°, VZA={geometry["vza"]:.2f}°, RAA={geometry["raa"]:.2f}°')
+        print(f'  Pressure: {geometry["pressure"]:.2f} hPa')
+        
+        # Compute atmospheric correction parameters for specified LUT and AOT
+        am = {}
+        for par in lutd[lut_name]['ipd']:
+            am[par] = {b: lutd[lut_name]['rgi'][b]((geometry['pressure'], 
+                                                     lutd[lut_name]['ipd'][par], 
+                                                     raa, vza, sza, aot))
+                        for b in rsrd['rsr_bands']}
+        am.update({'tg': ttg['tt_gas']})
+        
+        # Compute glint correction parameters
+        model = int(lut_name[-1])  # Extract model number from LUT name
+        glint_wind = 20
+        glint_bands = ['11', '12']
+        
+        glint_dict = {b: luti[model]['rgi'][b]((raa, vza, sza, glint_wind, aot)) 
+                     for b in rsrd['rsr_bands']}
+        glint_ave = {b: glint_dict[b] / ((glint_dict[glint_bands[0]] + 
+                                         glint_dict[glint_bands[1]]) / 2) 
+                    for b in glint_dict}
+        
+        return am, glint_ave, rsrd['rsr_bands']
+    
+    def compute_pdark(self, image : ee.Image, settings : dict):
+        obands_rhot = ['B1', 'B2', 'B3', 'B4', 'B5', 'B6', 'B7', 'B8', 'B8A', 'B9', 'B10', 'B11', 'B12']
+
+        image_to_reduce = image.updateMask(image.gt(0))
+
+        pdark_by_band = {}
+        indexes = np.arange(settings['dsf_intercept_pixels'])
+
+        for band in obands_rhot:
+            if settings.get('dsf_spectrum_option', 'darkest') == 'darkest':
+                band_data = image_to_reduce.select(band).reduceRegion(reducer = ee.Reducer.percentile([0]), 
+                                                        bestEffort = True, scale = 10, maxPixels = 1e8)
+                
+                if band_data:
+                    pdark_by_band[band] = band_data.getInfo()[band]
+                else:
+                    pdark_by_band[band] = 0.0
+
+            elif settings.get('dsf_spectrum_option', 'darkest') == 'percentile':
+                band_data = image_to_reduce.select(band).reduceRegion(reducer = ee.Reducer.percentile([settings['dsf_percentile']]), 
+                                                        bestEffort = True, scale = 10, maxPixels = 1e8)
+                
+                if band_data:
+                    pdark_by_band[band] = band_data.getInfo()[band]
+                else:
+                    pdark_by_band[band] = 0.0
+            elif settings.get('dsf_spectrum_option', 'darkest') == 'intercept':
+                data = image_to_reduce.select(band).reduceRegion(reducer = ee.Reducer.toList(), scale = 30, bestEffort = True, maxPixels = 1e8)
+                band_data = data.get(band)
+
+                if band_data:
+                    values = ee.List(band_data).sort().slice(0, settings['dsf_intercept_pixels']).getInfo()
+                    slope, intercept, r, p, se = scipy.stats.linregress(indexes, values)
+                    pdark_by_band[band] = intercept
+                else:
+                    pdark_by_band[band] = 0.0
+
+        return pdark_by_band
+    
+    def compute_rhos(self, image : ee.Image, am : dict) -> ee.Image:
+        l2r_rrs = ee.Image().select([])
+
+        romix = am['romix']
+        dutott = am['dutott']
+        astot = am['astot']
+        tgas = am['tg']
+
+        for band in romix:
+            band_name = 'B' + band
+            rhot_noatm = ee.Image().expression('(data / tg) - ppath', {'data' : image.select(band_name), 'tg' : tgas[band], 'ppath' : float(romix[band])}).rename(band_name)
+            rhos = ee.Image().expression('(data) / (tdu + sa * data)', {'data' : rhot_noatm.select(band_name), 'tdu' : float(dutott[band]), 'sa' : float(astot[band])}).rename(band_name)
+            rhos = mask_negative_reflectance(rhos, band_name)
+            l2r_rrs = l2r_rrs.addBands(image.select(band_name).rename(f'rhot_{band_name}').toFloat())
+            l2r_rrs = l2r_rrs.addBands(rhos.rename(f'rhos_{band_name}').toFloat())
+
+        return l2r_rrs
+
+
+    def get_ancillary_data(self, image: ee.Image, settings : dict) -> dict:
+        settings = self.prepare_earthdata_credentials(settings)
+        iso_date, lon, lat = self.prepare_query(image)
+
+        anc = self.acolite.ac.ancillary.get(iso_date, lon, lat)
+
+        for data, default in [('uoz', 'uoz_default'), ('uwv', 'uwv_default'), 
+                            ('wind', 'wind_default'), ('pressure', 'pressure_default')]:
+            settings[data] = anc.get(data, settings.get(default)) 
+        
+        return settings
+
+    def prepare_query(self, image: ee.Image):
+        coords = image.geometry().centroid().coordinates().getInfo()
+        iso_date = ee.Date(image.get('system:time_start')).format('YYYY-MM-dd HH:mm:ss').getInfo()
+
+        lon, lat = coords
+        return iso_date,lon,lat
+
+    def prepare_earthdata_credentials(self, settings: dict) -> dict:
+        for k in ['EARTHDATA_u', 'EARTHDATA_p']:
+            kv = settings[k] if k in settings else self.acolite.ac.config[k]
+            if len(kv) == 0: continue
+            os.environ[k] = kv
+        
+        return settings
+
+
+    def deglint_alternative(self, image : ee.Image, bands : List[str], 
+                            glint_ave : dict, glint_min : float = 0, glint_max : float = 0.08) -> ee.Image:
+        """
+        Alternative glint correction method based on ACOLITE's acolite_l2r.py implementation.
+        
+        This method:
+        1. Uses reference SWIR bands (B11, B12) to estimate observed glint
+        2. Computes average modeled surface reflectance (glint_ave) for reference bands
+        3. For each band, scales the observed glint by the ratio of:
+           - Modeled surface reflectance for current band
+           - Average modeled surface reflectance of reference bands
+        4. Subtracts the scaled glint from each band's rhos
+        
+        Parameters:
+        - image: Image with rhos bands
+        - bands: List of band numbers (as strings)
+        - glint_ave: Dict with modeled surface reflectance ratio per band
+        - glint_min: Minimum threshold for glint mask (default: 0)
+        - glint_max: Maximum threshold for glint mask (glint_mask_rhos_threshold)
+        """
+        
+        # Start with a copy of the original image to preserve all bands
+        deglinted = image
+        
+        # Reference bands for glint estimation (SWIR bands: B11=1610nm, B12=2190nm)
+        # These bands are sensitive to sun glint but have minimal water-leaving radiance
+        glint_ref_bands = ['rhos_B11', 'rhos_B12']
+        
+        # Step 1: Compute observed glint reference (gc_ref_mean in ACOLITE)
+        # Average of reference bands gives the observed glint signal
+        rhos_b11 = image.select('rhos_B11')
+        rhos_b12 = image.select('rhos_B12')
+        gc_ref_mean = (rhos_b11.add(rhos_b12)).divide(2).rename('gc_ref_mean')
+        
+        # Step 2: Compute average modeled surface reflectance for reference bands (gc_sur_mean in ACOLITE)
+        # This is the average of glint_ave values for B11 and B12
+        gc_sur_mean = (glint_ave['11'] + glint_ave['12']) / 2.0
+        
+        # Step 3: Create glint mask (gc_sub in ACOLITE)
+        # Only apply correction where observed glint is below threshold and positive
+        glint_mask = gc_ref_mean.gt(glint_min).And(gc_ref_mean.lt(glint_max))
+        
+        # Step 4: Apply band-specific glint correction
+        for band in bands:
+            band_name = 'rhos_B' + band
+            
+            # Skip if modeled surface reflectance is invalid
+            if np.isinf(glint_ave[band]) or np.isnan(glint_ave[band]):
+                continue
+            
+            # Compute current band glint (cur_rhog in ACOLITE):
+            # cur_rhog = gc_ref_mean * (surf_current_band / gc_sur_mean)
+            # 
+            # This scales the observed glint by the ratio of:
+            # - Modeled surface reflectance for current band (glint_ave[band])
+            # - Average modeled surface reflectance of reference bands (gc_sur_mean)
+            #
+            # The ratio accounts for spectral variation in surface reflectance
+            glint_ratio = glint_ave[band] / gc_sur_mean
+            cur_rhog = gc_ref_mean.multiply(glint_ratio).rename('cur_rhog')
+            
+            # Mask the glint correction to valid pixels
+            cur_rhog = cur_rhog.updateMask(glint_mask)
+            
+            # Apply glint correction: rhos_corrected = rhos_original - glint
+            rhos_corrected = image.select(band_name).subtract(cur_rhog)
+            
+            # Mask negative values (can occur in dark pixels or over-correction)
+            rhos_corrected = mask_negative_reflectance(rhos_corrected, band_name)
+            
+            # Replace the band in the output image (overwrite=True)
+            deglinted = deglinted.addBands(rhos_corrected, overwrite=True)
+        
+        # Optional: Write glint mean for visualization/validation
+        deglinted = deglinted.addBands(gc_ref_mean.rename('glint_mean'))
+        
+        return deglinted

gee_acolite/sensors/__init__.py

@@ -0,0 +1,10 @@
+"""
+Sensor-specific configurations and constants
+"""
+
+from gee_acolite.sensors.sentinel2 import SENTINEL2_BANDS, BAND_BY_SCALE
+
+__all__ = [
+    "SENTINEL2_BANDS",
+    "BAND_BY_SCALE",
+]

gee_acolite/sensors/sentinel2.py

@@ -0,0 +1,6 @@
+SENTINEL2_BANDS = ['B1', 'B2', 'B3', 'B4', 'B5', 'B6', 'B7', 'B8', 'B8A', 'B9', 'B10', 'B11', 'B12']
+BAND_BY_SCALE = {
+    10 : 'B2',
+    20 : 'B5',
+    60 : 'B1',
+}

gee_acolite/utils/__init__.py

@@ -0,0 +1,44 @@
+"""
+Utility functions for GEE ACOLITE processing
+"""
+
+from gee_acolite.utils.l1_convert import l1_to_rrs, DN_to_rrs, resample
+from gee_acolite.utils.masks import (
+    mask_negative_reflectance,
+    toa_mask,
+    cirrus_mask,
+    non_water,
+    add_cloud_bands,
+    add_shadow_bands,
+    add_cld_shdw_mask,
+    cld_shdw_mask,
+)
+from gee_acolite.utils.search import (
+    search,
+    search_list,
+    search_with_cloud_proba,
+    search_list_with_cloud_proba,
+    join_s2_with_cloud_prob,
+)
+
+__all__ = [
+    # L1 conversion
+    "l1_to_rrs",
+    "DN_to_rrs",
+    "resample",
+    # Masks
+    "mask_negative_reflectance",
+    "toa_mask",
+    "cirrus_mask",
+    "non_water",
+    "add_cloud_bands",
+    "add_shadow_bands",
+    "add_cld_shdw_mask",
+    "cld_shdw_mask",
+    # Search
+    "search",
+    "search_list",
+    "search_with_cloud_proba",
+    "search_list_with_cloud_proba",
+    "join_s2_with_cloud_prob",
+]

gee_acolite/utils/l1_convert.py

@@ -0,0 +1,47 @@
+import ee
+from functools import partial
+
+from gee_acolite.sensors.sentinel2 import SENTINEL2_BANDS, BAND_BY_SCALE
+
+
+def l1_to_rrs(images : ee.ImageCollection, scale: int) -> ee.ImageCollection:
+    resample_scale = partial(resample, band = BAND_BY_SCALE.get(scale, 'B2'))
+    return images.select(SENTINEL2_BANDS).map(DN_to_rrs).map(resample_scale)
+
+def DN_to_rrs(image : ee.Image) -> ee.Image:
+    rrs = image.divide(10_000)
+
+    rrs = rrs.set('sza', image.get('MEAN_SOLAR_ZENITH_ANGLE'))
+    rrs = rrs.set('saa', image.get('MEAN_SOLAR_AZIMUTH_ANGLE'))
+    rrs = rrs.set('vza', get_mean_band_angle(image, 'ZENITH'))
+    rrs = rrs.set('vaa', get_mean_band_angle(image, 'AZIMUTH'))
+
+    raa = ee.Number(rrs.get('saa')).subtract(rrs.get('vaa')).abs()
+
+    raa = ee.Algorithms.If(raa.gt(180), raa.subtract(360).abs(), raa)
+    rrs = rrs.set('raa', raa)
+    rrs = rrs.set('PRODUCT_ID', ee.String(ee.String(image.get('PRODUCT_ID')).split('L1C').get(0)))
+
+    rrs = rrs.set('system:time_start', image.get('system:time_start'))
+
+    rrs = rrs.copyProperties(image)
+    rrs = rrs.set('system:time_start', image.get('system:time_start'))
+
+    return rrs
+
+def get_mean_band_angle(image : ee.Image, angle_name : str) -> ee.Number:
+    bands = image.bandNames()
+    
+    for index in range(13):
+       bands = bands.set(index, ee.String('MEAN_INCIDENCE_' + angle_name + '_ANGLE_').cat(bands.get(index)))
+    
+    angle = ee.Number(0)
+    for index in range(13):
+       angle = angle.add(ee.Number(image.get(bands.get(index))))
+    else:
+        angle = angle.divide(image.bandNames().length())
+    
+    return angle
+
+def resample(image : ee.Image, band: str) -> ee.Image:
+    return image.resample('bilinear').reproject(image.select(band).projection())

gee_acolite/utils/masks.py

@@ -0,0 +1,113 @@
+import ee
+
+
+def mask_negative_reflectance(image : ee.Image, band : str) -> ee.Image:
+    return image.updateMask(image.select(band).gte(0)).rename(band)
+
+def toa_mask(image : ee.Image, band : str = 'rhot_B11', threshold : float = 0.03):
+    return image.select(band).lt(threshold)
+
+def cirrus_mask(image : ee.Image, band : str = 'rhot_B10', threshold : float = 0.005):
+    return image.select(band).lt(threshold)
+
+def non_water(image : ee.Image, band : str = 'rhot_B11', threshold : float = 0.05) -> ee.Image:
+    return image.select(band).lt(threshold)
+
+
+def add_cloud_bands(img : ee.Image, cloud_prob_threshold : float = 50) -> ee.Image:
+    """
+    Añade banda de máscara de nubes a la imagen
+    
+    Args:
+        img: Imagen con banda 'probability' de Cloud Probability
+        cloud_prob_threshold: Umbral de probabilidad de nube (0-100)
+        
+    Returns:
+        Imagen con banda 'clouds' añadida
+    """
+    # Obtener probabilidad de nubes (ya está como banda)
+    cld_prb = ee.Image(img.get('cloud_prob')).select('probability')
+    
+    # Máscara de nubes basada en umbral de probabilidad
+    is_cloud = cld_prb.gt(cloud_prob_threshold).rename('clouds')
+    
+    return img.addBands(is_cloud)
+
+
+def add_shadow_bands(img : ee.Image, nir_dark_threshold : float = 0.15, 
+                     cloud_proj_distance : float = 1) -> ee.Image:
+    """
+    Añade bandas de máscara de sombras a la imagen L1C
+    
+    Args:
+        img: Imagen con banda 'clouds' ya añadida
+        nir_dark_threshold: Umbral para píxeles oscuros en NIR (0-1)
+        cloud_proj_distance: Distancia de proyección de sombras en km
+        
+    Returns:
+        Imagen con bandas 'dark_pixels', 'cloud_transform' y 'shadows' añadidas
+    """
+    # Píxeles oscuros en NIR (posibles sombras) - para L1C usar B8 directamente
+    dark_pixels = img.select('rhot_B8').lt(nir_dark_threshold * 10000).rename('dark_pixels')
+    
+    # Dirección de proyección de sombras
+    shadow_azimuth = ee.Number(90).subtract(ee.Number(img.get('MEAN_SOLAR_AZIMUTH_ANGLE')))
+    
+    # Proyectar sombras desde nubes
+    cld_proj = img.select('clouds').directionalDistanceTransform(shadow_azimuth, cloud_proj_distance * 10) \
+        .reproject(**{'crs': img.select(0).projection(), 'scale': 100}) \
+        .select('distance') \
+        .mask() \
+        .rename('cloud_transform')
+    
+    # Identificar sombras como intersección de píxeles oscuros y proyección de nubes
+    shadows = cld_proj.multiply(dark_pixels).rename('shadows')
+    
+    return img.addBands(ee.Image([dark_pixels, cld_proj, shadows]))
+
+
+def add_cld_shdw_mask(img : ee.Image, cloud_prob_threshold : float = 50, 
+                      nir_dark_threshold : float = 0.15, cloud_proj_distance : float = 1, 
+                      buffer : int = 50) -> ee.Image:
+    """
+    Añade máscara combinada de nubes y sombras con buffer
+    
+    Args:
+        img: Imagen con banda 'probability' de Cloud Probability
+        cloud_prob_threshold: Umbral de probabilidad de nube (0-100)
+        nir_dark_threshold: Umbral para píxeles oscuros en NIR (0-1)
+        cloud_proj_distance: Distancia de proyección de sombras en km
+        buffer: Buffer alrededor de nubes en metros
+        
+    Returns:
+        Imagen con banda 'cloudmask' añadida
+    """
+    # Añadir bandas de nubes
+    img_cloud = add_cloud_bands(img, cloud_prob_threshold)
+    
+    # Añadir bandas de sombras
+    img_cloud_shadow = add_shadow_bands(img_cloud, nir_dark_threshold, cloud_proj_distance)
+    
+    # Combinar máscaras
+    is_cld_shdw = img_cloud_shadow.select('clouds').add(img_cloud_shadow.select('shadows')).gt(0)
+    
+    # Aplicar buffer
+    is_cld_shdw = is_cld_shdw.focal_min(2).focal_max(buffer * 2 / 20) \
+        .reproject(**{'crs': img.select([0]).projection(), 'scale': 20}) \
+        .rename('cloudmask')
+    
+    return img_cloud_shadow.addBands(is_cld_shdw)
+
+
+def cld_shdw_mask(img : ee.Image) -> ee.Image:
+    """
+    Aplica la máscara de nubes y sombras a la imagen
+    
+    Args:
+        img: Imagen con banda 'cloudmask' ya añadida
+        
+    Returns:
+        Imagen enmascarada con solo las bandas B* (bandas Sentinel-2)
+    """
+    # Obtener máscara
+    return img.select('cloudmask').Not()

gee_acolite/utils/search.py

@@ -0,0 +1,79 @@
+import ee
+
+from typing import Optional
+
+
+def search(roi : ee.Geometry, start : str, end : str, 
+           collection : str = 'S2_HARMONIZED', tile : Optional[str] = None) -> ee.ImageCollection:
+    if tile is None:
+        sentinel2_l1 = ee.ImageCollection(f'COPERNICUS/{collection}').filterBounds(roi).filterDate(start, end)
+    else:
+        sentinel2_l1 = ee.ImageCollection(f'COPERNICUS/{collection}').filterBounds(roi).filterDate(start, end).filter(ee.Filter.stringContains('PRODUCT_ID', tile))
+
+    return sentinel2_l1
+
+def search_list(roi : ee.Geometry, starts : list[str], ends : list[str], 
+                collection : str = 'S2_HARMONIZED', tile : Optional[str] = None) -> ee.ImageCollection:
+    
+    return ee.ImageCollection.fromImages([search(roi, start, end, collection, tile).first() for start, end in zip(starts, ends)])
+
+
+def search_with_cloud_proba(roi : ee.Geometry, start : str, end : str, 
+                            collection : str = 'S2_HARMONIZED', tile : Optional[str] = None) -> ee.ImageCollection:
+    """
+    Busca imágenes Sentinel-2 y une con Cloud Probability
+    
+    Args:
+        roi: Región de interés
+        start: Fecha de inicio (formato 'YYYY-MM-DD')
+        end: Fecha de fin (formato 'YYYY-MM-DD')
+        collection: Nombre de la colección de Sentinel-2 (default: 'S2_HARMONIZED')
+        tile: Identificador del tile (opcional)
+        
+    Returns:
+        Colección de imágenes con Cloud Probability unida
+    """
+    s2_collection = search(roi, start, end, collection, tile)
+    return join_s2_with_cloud_prob(s2_collection)
+
+
+def search_list_with_cloud_proba(roi : ee.Geometry, starts : list[str], ends : list[str], 
+                                 collection : str = 'S2_HARMONIZED', tile : Optional[str] = None) -> ee.ImageCollection:
+    """
+    Busca una lista de imágenes Sentinel-2 y une con Cloud Probability
+    
+    Args:
+        roi: Región de interés
+        starts: Lista de fechas de inicio (formato 'YYYY-MM-DD')
+        ends: Lista de fechas de fin (formato 'YYYY-MM-DD')
+        collection: Nombre de la colección de Sentinel-2 (default: 'S2_HARMONIZED')
+        tile: Identificador del tile (opcional)
+        
+    Returns:
+        Colección de imágenes con Cloud Probability unida
+    """
+    s2_collection = search_list(roi, starts, ends, collection, tile)
+    return join_s2_with_cloud_prob(s2_collection)
+
+
+def join_s2_with_cloud_prob(s2_collection : ee.ImageCollection) -> ee.ImageCollection:
+    """
+    Une la colección Sentinel-2 con Cloud Probability
+    
+    Args:
+        s2_collection: Colección de imágenes Sentinel-2 L1C
+        roi: Región de interés
+        
+    Returns:
+        Colección de imágenes con Cloud Probability unida como propiedad 'cloud_prob'
+    """
+    
+    def add_cloud_prob(img):
+        img_index = img.get('system:index')
+        cloud = ee.ImageCollection('COPERNICUS/S2_CLOUD_PROBABILITY') \
+            .filter(ee.Filter.equals('system:index', img_index)) \
+            .first()
+        
+        return img.set('cloud_prob', cloud)
+    
+    return s2_collection.map(add_cloud_prob)

gee_acolite/water_quality.py

@@ -0,0 +1,140 @@
+import numpy as np
+import ee
+
+import gee_acolite.utils.masks as masks
+from gee_acolite.sensors.sentinel2 import SENTINEL2_BANDS
+
+
+def compute_water_mask(image: ee.Image, settings: dict) -> ee.Image:
+    mask = masks.non_water(image, 
+                           threshold = settings.get('l2w_mask_threshold', 0.05))
+    mask = mask.updateMask(masks.cirrus_mask(image, 
+                                             threshold = settings.get('l2w_mask_cirrus_threshold', 0.005)))
+    
+    for band in SENTINEL2_BANDS:
+        mask = mask.updateMask( masks.toa_mask(image, 
+                                                f'rhot_{band}', 
+                                                settings.get('l2w_mask_high_toa_threshold', 0.3)) )
+        
+    if settings.get('s2_cloud_proba', False):
+        CLOUD_PROB_THRESHOLD = int(settings.get('s2_cloud_proba__cloud_threshold', 50))
+        NIR_DARK_THRESHOLD = float(settings.get('s2_cloud_proba__nir_dark_threshold', 0.15))
+        CLOUD_PROJ_DISTANCE = int(settings.get('s2_cloud_proba__cloud_proj_distance', 10))
+        BUFFER = int(settings.get('s2_cloud_proba__buffer', 50))
+        mask = mask.updateMask(masks.cld_shdw_mask(masks.add_cld_shdw_mask(image, 
+                                                                           CLOUD_PROB_THRESHOLD, 
+                                                                           NIR_DARK_THRESHOLD, 
+                                                                           CLOUD_PROJ_DISTANCE, 
+                                                                           BUFFER)))
+
+    return mask
+
+def compute_water_bands(image: ee.Image, settings: dict) -> ee.Image:
+    mask = compute_water_mask(image, settings)
+
+    for product in settings['l2w_parameters']:
+        new_band = PRODUCTS[product](image)
+        
+        if isinstance(new_band, list):
+            new_band = [band.updateMask(mask) for band in new_band]
+        else:
+            new_band = new_band.updateMask(mask)
+        
+        image = image.addBands(new_band)
+    
+    return image
+
+
+def spm_nechad2016_665(image : ee.Image) -> ee.Image:
+    return image.expression('(A * red) / (1 - (red / C))', {'A' : 342.10,
+                                                            'C' : 0.19563, 
+                                                            'red' : image.select('rhos_B4') }).rename('SPM_Nechad2016_665').toFloat()
+
+def spm_nechad2016_704(image : ee.Image) -> ee.Image:
+    return image.expression('(A * red) / (1 - (red / C))', {'A' : 444.36,
+                                                            'C' : 0.18753, 
+                                                            'red' : image.select('rhos_B5') }).rename('SPM_Nechad2016_704').toFloat()
+
+def spm_nechad2016_740(image : ee.Image) -> ee.Image:
+    return image.expression('(A * red) / (1 - (red / C))', {'A' : 1517.00,
+                                                            'C' : 0.19736, 
+                                                            'red' : image.select('rhos_B6') }).rename('SPM_Nechad2016_739').toFloat()
+
+def tur_nechad2016_665(image : ee.Image) -> ee.Image:
+    return image.expression('(A * red) / (1 - (red / C))', {'A' : 366.14,
+                                                            'C' : 0.19563, 
+                                                            'red' : image.select('rhos_B4') }).rename('TUR_Nechad2016_665').toFloat()
+
+def tur_nechad2016_704(image : ee.Image) -> ee.Image:
+    return image.expression('(A * red) / (1 - (red / C))', {'A' : 439.09,
+                                                            'C' : 0.18753, 
+                                                            'red' : image.select('rhos_B5') }).rename('TUR_Nechad2016_704').toFloat()
+
+def tur_nechad2016_740(image : ee.Image) -> ee.Image:
+    return image.expression('(A * red) / (1 - (red / C))', {'A' : 1590.66,
+                                                            'C' : 0.19736, 
+                                                            'red' : image.select('rhos_B6') }).rename('TUR_Nechad2016_739').toFloat()
+
+def chl_oc2(image : ee.Image) -> ee.Image:
+    A, B, C, D, E = 0.1977,-1.8117,1.9743,-2.5635,-0.7218 # TODO : interpolar B1 a las dimensiones de B2
+    x = image.expression('log( x / y )', {'x' : image.select('rhos_B2'), 
+                                          'y' : image.select('rhos_B3') }).rename('x')
+    return image.expression('10 ** (A + B * x + C * (x**2) + D * (x**3) + E * (x**4) )', {'A' : A, 
+                                                                                          'B' : B, 
+                                                                                          'C' : C, 
+                                                                                          'D' : D,
+                                                                                          'E' : E,
+                                                                                          'x' : x }).rename('chl_oc2').toFloat()
+
+def chl_oc3(image : ee.Image) -> ee.Image:
+    A, B, C, D, E = 0.2412,-2.0546,1.1776,-0.5538,-0.4570 # TODO : interpolar B1 a las dimensiones de B2
+    x = image.expression('log( x / y )', {'x' : image.select('rhos_B2').max(image.select('rhos_B1')).rename('x'), 
+                                          'y' : image.select('rhos_B3') }).rename('x')
+    return image.expression('10 ** (A + B * x + C * (x**2) + D * (x**3) + E * (x**4) )', {'A' : A, 
+                                                                                          'B' : B, 
+                                                                                          'C' : C, 
+                                                                                          'D' : D,
+                                                                                          'E' : E,
+                                                                                          'x' : x }).rename('chl_oc3').toFloat()
+
+def chl_re_mishra(image : ee.Image) -> ee.Image:
+    a, b, c = 14.039, 86.11, 194.325
+    ndci = image.normalizedDifference(['rhos_B5', 'rhos_B4']).rename('ndci')
+    return image.expression('a + b * ndci + c * ndci * ndci', {'a' : a, 
+                                                               'b' : b, 
+                                                               'c' : c, 
+                                                               'ndci' : ndci }).rename('chl_re_mishra').toFloat()
+
+def ndwi(image : ee.Image) -> ee.Image:
+    return image.normalizedDifference(['Rrs_B3', 'Rrs_B8']).rename('ndwi').toFloat()
+
+def pSDB_red(image : ee.Image) -> ee.Image:
+    return image.expression('log(n * pi * blue) / log(n * pi * red)', {'n' : 1_000,
+                                                                       'pi' : float(np.pi),
+                                                                       'blue' : image.select('Rrs_B2'),
+                                                                       'red' : image.select('Rrs_B4') }).rename('pSDB_red').toFloat()
+
+def pSDB_green(image : ee.Image) -> ee.Image:
+    return image.expression('log(n * pi * blue) / log(n * pi * green)', {'n' : 1_000,
+                                                                         'pi' : float(np.pi),
+                                                                         'blue' : image.select('Rrs_B2'),
+                                                                         'green' : image.select('Rrs_B3') }).rename('pSDB_green').toFloat()
+
+def rrs(image : ee.Image) -> ee.image:
+    bands = ['B1', 'B2', 'B3', 'B4', 'B5', 'B6', 'B7', 'B8', 'B8A', 'B9', 'B10', 'B11', 'B12']
+    return [ image.select(f'rhos_{band}').divide(np.pi).rename(f'Rrs_{band}').toFloat() for band in bands ]
+
+PRODUCTS = {
+    'spm_nechad2016' : spm_nechad2016_665,
+    'spm_nechad2016_704' : spm_nechad2016_704,
+    'spm_nechad2016_740' : spm_nechad2016_740,
+    'tur_nechad2016' : tur_nechad2016_665,
+    'tur_nechad2016_704' : tur_nechad2016_704,
+    'tur_nechad2016_740' : tur_nechad2016_740,
+    'chl_oc2' : chl_oc2,
+    'chl_oc3' : chl_oc3,
+    'chl_re_mishra' : chl_re_mishra,
+    'pSDB_red' : pSDB_red,
+    'pSDB_green' : pSDB_green,
+    'Rrs_*' : rrs
+}

gee_acolite-1.0.0.dist-info/METADATA

@@ -0,0 +1,161 @@
+Metadata-Version: 2.4
+Name: gee_acolite
+Version: 1.0.0
+Summary: ACOLITE atmospheric correction for Google Earth Engine
+Home-page: https://github.com/Aouei/gee_acolite
+Author: Sergio
+Author-email: Aouei <sergiohercar1@gmail.com>
+License: GPL-3.0
+Project-URL: Homepage, https://github.com/Aouei/gee_acolite
+Project-URL: Documentation, https://github.com/Aouei/gee_acolite
+Project-URL: Repository, https://github.com/Aouei/gee_acolite
+Project-URL: Bug Tracker, https://github.com/Aouei/gee_acolite/issues
+Keywords: earth-engine,atmospheric-correction,acolite,sentinel-2,remote-sensing,water-quality
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: GIS
+Classifier: Topic :: Scientific/Engineering :: Atmospheric Science
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: earthengine-api>=0.1.350
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: scipy>=1.7.0
+Requires-Dist: netcdf4>=1.7.0
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# GEE ACOLITE
+
+ACOLITE atmospheric correction implementation for Google Earth Engine (GEE).
+
+## Description
+
+This package provides atmospheric correction for Sentinel-2 imagery using the ACOLITE dark spectrum fitting method, optimized for Google Earth Engine workflows. It includes:
+
+- **Dark Spectrum Fitting**: Multiple methods (darkest, percentile, intercept)
+- **AOT Estimation**: Fixed geometry mode
+- **Atmospheric Correction**: Full LUT-based correction
+- **Water Quality Parameters**: SPM, turbidity, chlorophyll, bathymetry indices
+- **Cloud Masking**: Integration with Sentinel-2 Cloud Probability
+
+## Installation
+
+### From PyPI (when published)
+
+```bash
+pip install gee_acolite
+```
+
+### From source
+
+```bash
+git clone https://github.com/Aouei/gee_acolite.git
+cd gee_acolite
+pip install -e .
+```
+
+## Features
+
+### Atmospheric Correction Methods
+
+- **Fixed Geometry**: Single AOT estimation for entire image
+- **Dark Spectrum Options**:
+  - `darkest`: Use minimum values
+  - `percentile`: Use Nth percentile
+  - `intercept`: Linear regression intercept
+
+### Model Selection Criteria
+
+- `min_drmsd`: Minimum RMSD between observed and modeled reflectance
+- `min_dtau`: Minimum delta AOT between darkest bands
+- `taua_cv`: Minimum coefficient of variation
+
+### Water Quality Products
+
+- **SPM**: Suspended particulate matter (Nechad 2016)
+- **Turbidity**: Water turbidity (Nechad 2016)
+- **Chlorophyll**: Chl-a concentration (OC2, OC3, Mishra)
+- **Bathymetry**: Pseudo satellite-derived bathymetry (pSDB)
+- **Indices**: NDWI, custom band ratios
+
+## Requirements
+
+- Python ≥ 3.8
+- earthengine-api ≥ 0.1.350
+- numpy ≥ 1.20.0
+- scipy ≥ 1.7.0
+- **ACOLITE** (standalone installation required)
+
+### Installing ACOLITE
+
+This package requires the ACOLITE atmospheric correction software to be installed separately:
+
+```bash
+# Clone ACOLITE repository
+git clone https://github.com/acolite/acolite.git
+
+# Install ACOLITE
+cd acolite
+pip install -e .
+```
+
+**Important:** ACOLITE is not available on PyPI and must be installed from source.
+
+## Contributing
+
+Contributions are welcome! Please:
+
+1. Fork the repository
+2. Create a feature branch
+3. Add tests for new features
+4. Submit a pull request
+
+## License
+
+This project is licensed under the GNU General Public License v3.0 - see the [LICENSE](LICENSE) file for details.
+
+## Citation
+
+If you use this package in your research, please cite:
+
+```bibtex
+@software{gee_acolite,
+  author = {Sergio},
+  title = {GEE ACOLITE: Atmospheric Correction for Google Earth Engine},
+  year = {2025},
+  url = {https://github.com/Aouei/gee_acolite}
+}
+```
+
+And the original ACOLITE paper:
+
+```bibtex
+@article{vanhellemont2019,
+  title={Adaptation of the dark spectrum fitting atmospheric correction for aquatic applications of the Landsat and Sentinel-2 archives},
+  author={Vanhellemont, Quinten and Ruddick, Kevin},
+  journal={Remote Sensing of Environment},
+  volume={225},
+  pages={175--192},
+  year={2019},
+  publisher={Elsevier}
+}
+```
+
+## Acknowledgments
+
+This package is based on the ACOLITE software developed by RBINS (Royal Belgian Institute of Natural Sciences).
+
+## Contact
+
+- GitHub: [@Aouei](https://github.com/Aouei)
+- Email: sergiohercar1@gmail.com

gee_acolite-1.0.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+gee_acolite/__init__.py,sha256=GF2_P0j4Frb51YDbpENtKTsPAAEyhYi9ZtZkIqvCpPg,1138
+gee_acolite/bathymetry.py,sha256=1NgFc50BVJRtRfu5-5Ue-3J1T9_00_v3re_RfdFSKTE,134
+gee_acolite/correction.py,sha256=OwkXaEvnJsOZPjeO26u_ZkcZU-0bvypXkjl1OlhELUI,25368
+gee_acolite/water_quality.py,sha256=AIfm0-3SLVXKPC4HcCvQ1xjlOFI4YLLTGteXRTP3ixA,8404
+gee_acolite/sensors/__init__.py,sha256=MVEkrBW8bpheVUEVY59pKZWGj9aLAc8XMB0D1dCIYvo,196
+gee_acolite/sensors/sentinel2.py,sha256=YsVwS_Iz8jjN2-_JzCFovUuxnD-FGrV2Wh_eaXyv53U,170
+gee_acolite/utils/__init__.py,sha256=QjU8DYaaHQCVSCEF8VhduH9_06qnXJ7JvJ854bVuO0U,953
+gee_acolite/utils/l1_convert.py,sha256=mmGtI84c8NklsV6qDSxddVePah8cwW-Y3YZfuHVztck,1786
+gee_acolite/utils/masks.py,sha256=r3miWzc_zASPg-L_WpGyZPrd_tWuJNAuGdhtl52YoTI,4352
+gee_acolite/utils/search.py,sha256=Qek9UdVlJna-ENr58GyU6bnA_UTDNND-Eop9xrwVSLI,3190
+gee_acolite-1.0.0.dist-info/licenses/LICENSE,sha256=9xIEV9y9JDhPyeJTfbFWv247NO3RCoDhczSd0kUjsSA,787
+gee_acolite-1.0.0.dist-info/METADATA,sha256=Q6gNfaDotwpWUCvQJgSFODnNWSajMBoQdg5QQsz-Tk8,4842
+gee_acolite-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+gee_acolite-1.0.0.dist-info/top_level.txt,sha256=KQskKluvsN5NxC3MP24oMVA6iLs88Fk_NkobsHX8BSY,12
+gee_acolite-1.0.0.dist-info/RECORD,,

gee_acolite-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

gee_acolite-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+GNU GENERAL PUBLIC LICENSE
+Version 3, 29 June 2007
+
+Copyright (C) 2025 Sergio
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+---
+
+Full GPL 3.0 License Text: https://www.gnu.org/licenses/gpl-3.0.txt

gee_acolite-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+gee_acolite