eotdl 2025.2.10__py3-none-any.whl → 2025.4.2__py3-none-any.whl

eotdl/__init__.py

@@ -1 +1 @@
-__version__ = "2025.02.10"
+__version__ = "2025.04.02"

eotdl/access/__init__.py

@@ -2,6 +2,16 @@
 Data access module for eotdl package.
 """
 
-from .download import download_sentinel_imagery, search_and_download_sentinel_imagery
-from .search import search_sentinel_imagery
-from .sentinelhub.parameters import SUPPORTED_SENSORS
+from .download import (
+    download_sentinel_imagery,
+    search_and_download_sentinel_imagery,
+    advanced_imagery_download,
+)
+from .search import search_sentinel_imagery, advanced_imagery_search
+from .sentinelhub.parameters import (
+    SUPPORTED_COLLECTION_IDS,
+    DATA_COLLECTION_ID,
+    get_default_parameters,
+    OUTPUT_FORMAT,
+)
+from .sentinelhub.evalscripts import EvalScripts

eotdl/access/download.py

@@ -2,49 +2,82 @@
 Download imagery
 """
 
-from datetime import datetime
+from datetime import datetime, timedelta
 from typing import Union, List, Optional
 
 from .sentinelhub import (
     SHClient,
-    SH_PARAMETERS_DICT,
     evaluate_sentinel_parameters,
     imagery_from_tmp_to_dir,
+    get_default_parameters,
+    SHParameters,
+    filter_times,
 )
-from .search import search_sentinel_imagery
+from .search import advanced_imagery_search
 
 
 def download_sentinel_imagery(
     output: str,
     time_interval: Union[str, datetime, List[Union[str, datetime]]],
     bounding_box: List[Union[int, float]],
-    sensor: str,
+    collection_id: str,
     name: Optional[str] = None,
 ) -> None:
     """
     Download Sentinel imagery
     """
-    evaluate_sentinel_parameters(sensor, time_interval, bounding_box, output)
+    evaluate_sentinel_parameters(time_interval, bounding_box, collection_id, output)
+    parameters = get_default_parameters(collection_id)
+    return advanced_imagery_download(
+        output, time_interval, bounding_box, parameters, name
+    )
+
 
-    client = SHClient()
-    parameters = SH_PARAMETERS_DICT[sensor]()
+def advanced_imagery_download(
+    output: str,
+    time_interval: Union[str, datetime, List[Union[str, datetime]]],
+    bounding_box: List[Union[int, float]],
+    parameters: SHParameters,
+    name: Optional[str] = None,
+) -> None:
+    """
+    Advanced imagery download
+    """
+    evaluate_sentinel_parameters(
+        time_interval, bounding_box, output=output, parameters=parameters
+    )
+    client = SHClient(parameters.BASE_URL)
 
-    results = search_sentinel_imagery(time_interval, bounding_box, sensor)
-    timestamps = [date.strftime("%Y-%m-%d") for date in results.get_timestamps()]
+    results = advanced_imagery_search(time_interval, bounding_box, parameters)
+    timestamps = results.get_timestamps()
+    time_difference = timedelta(hours=1)
+    filtered_timestamps = filter_times(timestamps, time_difference)
 
     requests_list = []
-    for date in timestamps:
-        requests_list.append(client.request_data(date, bounding_box, parameters))
+    for date in filtered_timestamps:
+        timestamp_interval = (date - time_difference, date + time_difference)
+        requests_list.append(
+            client.request_data(timestamp_interval, bounding_box, parameters)
+        )
     if len(requests_list) == 0:
-        print(f"No images found for {sensor} in the specified time: {time_interval}")
+        print(
+            f"No images found for {parameters.DATA_COLLECTION.api_id} in the specified time: {time_interval}"
+        )
         return
     elif len(requests_list) <= 2:
         bulk = False
     else:
         bulk = True
 
-    data = client.download_data(requests_list)
-    imagery_from_tmp_to_dir(output, client.tmp_dir, name=name, bulk=bulk)
+    client.download_data(requests_list)
+    imagery_from_tmp_to_dir(
+        output,
+        bounding_box,
+        client.tmp_dir,
+        name=name,
+        bulk=bulk,
+        output_format=parameters.OUTPUT_FORMAT.value,
+    )
 
 
 def search_and_download_sentinel_imagery(

eotdl/access/search.py

@@ -5,20 +5,48 @@ Search imagery
 from typing import Union, List
 from datetime import datetime
 
-from .sentinelhub import SHClient, SH_PARAMETERS_DICT, evaluate_sentinel_parameters
+from .sentinelhub import (
+    SHClient,
+    get_default_parameters,
+    evaluate_sentinel_parameters,
+    SHParameters,
+    supports_cloud_coverage,
+)
 
 
 def search_sentinel_imagery(
     time_interval: Union[str, datetime, List[Union[str, datetime]]],
     bounding_box: List[Union[int, float]],
-    sensor: str,
+    collection_id: str,
 ) -> None:
     """
     Search Sentinel imagery
     """
     evaluate_sentinel_parameters(
-        sensor, time_interval, bounding_box, output_needed=False
+        time_interval, bounding_box, collection_id, output_needed=False
     )
-    client = SHClient()
-    parameters = SH_PARAMETERS_DICT[sensor]()
+    parameters = get_default_parameters(collection_id)
+    client = SHClient(parameters.BASE_URL)
+    return client.search_data(bounding_box, time_interval, parameters)
+
+
+def advanced_imagery_search(
+    time_interval: Union[str, datetime, List[Union[str, datetime]]],
+    bounding_box: List[Union[int, float]],
+    parameters: SHParameters,
+) -> None:
+    """
+    Advanced imagery search
+    """
+    evaluate_sentinel_parameters(
+        time_interval, bounding_box, output_needed=False, parameters=parameters
+    )
+
+    if (
+        supports_cloud_coverage(parameters.DATA_COLLECTION.api_id)
+        and parameters.MAX_CLOUD_COVERAGE
+    ):
+        parameters.FILTER = "eo:cloud_cover < " + str(parameters.MAX_CLOUD_COVERAGE)
+
+    client = SHClient(parameters.BASE_URL)
     return client.search_data(bounding_box, time_interval, parameters)

eotdl/access/sentinelhub/__init__.py

@@ -3,6 +3,10 @@ Sentinel-Hub data access module.
 """
 
 from .client import SHClient
-from .parameters import SHParameters, SH_PARAMETERS_DICT
+from .parameters import (
+    SHParameters,
+    supports_cloud_coverage,
+    get_default_parameters,
+)
 from .evalscripts import EvalScripts
-from .utils import evaluate_sentinel_parameters, imagery_from_tmp_to_dir
+from .utils import evaluate_sentinel_parameters, imagery_from_tmp_to_dir, filter_times

eotdl/access/sentinelhub/client.py

@@ -3,6 +3,7 @@ Module for managing the Sentinel Hub configuration and data access
 """
 
 import json
+from datetime import datetime
 from os import getenv
 from os.path import exists
 from sentinelhub import (
@@ -13,13 +14,11 @@ from sentinelhub import (
     CRS,
     SentinelHubRequest,
     SentinelHubDownloadClient,
-    MimeType,
 )
 import uuid
 
 from ...repos.AuthRepo import AuthRepo
 from .parameters import SHParameters
-from ...tools.time_utils import prepare_time_interval
 from ...tools.geo_utils import compute_image_size
 
 
@@ -28,7 +27,7 @@ class SHClient:
     Client class to manage the Sentinel Hub Python interface.
     """
 
-    def __init__(self) -> None:
+    def __init__(self, base_url) -> None:
         """ """
         self.config = SHConfig()
         if getenv("SH_CLIENT_ID") and getenv("SH_CLIENT_SECRET"):
@@ -57,6 +56,7 @@ class SHClient:
                 else:
                     self.config.sh_client_id = creds["SH_CLIENT_ID"]
                     self.config.sh_client_secret = creds["SH_CLIENT_SECRET"]
+        self.config.sh_base_url = base_url
         self.catalog = SentinelHubCatalog(config=self.config)
         self.tmp_dir = "/tmp/sentinelhub/" + str(uuid.uuid4())
 
@@ -77,12 +77,11 @@ class SHClient:
         return search_iterator
 
     def request_data(
-        self, time_interval, bounding_box: list, parameters: SHParameters
+        self, time_interval: datetime, bounding_box: list, parameters: SHParameters
     ) -> list:
         """
         Request data from Sentinel Hub
         """
-        time_interval = prepare_time_interval(time_interval)
         bounding_box, _ = compute_image_size(bounding_box, parameters)
 
         return SentinelHubRequest(
@@ -95,7 +94,9 @@ class SHClient:
                     mosaicking_order=parameters.MOSAICKING_ORDER,
                 )
             ],
-            responses=[SentinelHubRequest.output_response("default", MimeType.TIFF)],
+            responses=[
+                SentinelHubRequest.output_response("default", parameters.OUTPUT_FORMAT)
+            ],
             bbox=bounding_box,
             size=bbox_to_dimensions(bounding_box, parameters.RESOLUTION),
             config=self.config,

eotdl/access/sentinelhub/evalscripts.py

@@ -27,6 +27,28 @@ class EvalScripts:
                 }
                 """
 
+    SENTINEL_1_ENHANCED_VISUALIZATION = """
+                //VERSION=3
+                function setup() {
+                return {
+                    input: ["VV", "VH", "dataMask"],
+                    output: { bands: 4 }
+                }
+                }
+
+                function evaluatePixel(sample) {
+                var water_threshold = 25; //lower means more water
+                
+                if (sample.VV / sample.VH > water_threshold) {
+                    // watervis
+                    return [sample.VV, 8 * sample.VV, 0.5 + 3 * sample.VV + 2000 * sample.VH, sample.dataMask];
+                } else {
+                    // landvis
+                    return [3 * sample.VV, 1.1 * sample.VV + 8.75 * sample.VH, 1.75 * sample.VH, sample.dataMask];
+                }
+                }
+                """
+
     SENTINEL_2_L1C = """
                 //VERSION=3
                 function setup() {
@@ -113,6 +135,26 @@ class EvalScripts:
                 }
                 """
 
+    SENTINEL_2_L2A_TRUE_COLOR = """
+        //VERSION=3
+        let minVal = 0.0;
+        let maxVal = 0.4;
+
+        let viz = new HighlightCompressVisualizer(minVal, maxVal);
+
+        function setup() {
+        return {
+            input: ["B04", "B03", "B02","dataMask"],
+            output: { bands: 4 }
+        };
+        }
+
+        function evaluatePixel(samples) {
+            let val = [samples.B04, samples.B03, samples.B02,samples.dataMask];
+            return viz.processList(val);
+        }
+        """
+
     DEM = """
         //VERSION=3
 
@@ -130,3 +172,227 @@ class EvalScripts:
             return [sample.DEM]
         }
         """
+
+    DEM_TOPOGRAPHIC = """
+        //VERSION=3
+        // To set custom max and min values, set
+        // defaultVis to false and choose your max and
+        // min values. The color map will then be scaled
+        // to those max and min values
+        const defaultVis = true
+        const max = 9000
+        const min = -9000
+
+        function setup() {
+            return {
+                input: ["DEM", "dataMask"],
+                output: [
+                    { id: "default", bands: 4, sampleTYPE: 'AUTO' },
+                    { id: "index", bands: 1, sampleType: 'FLOAT32' },
+                    { id: "dataMask", bands: 1 }
+                ]
+            };
+        }
+
+        function updateMap(max, min) {
+            const numIntervals = map.length
+            const intervalLength = (max - min) / (numIntervals - 1);
+            for (let i = 0; i < numIntervals; i++) {
+                map[i][0] = max - intervalLength * i
+            }
+        }
+
+        const map = [
+            [8000, 0xffffff],
+            [7000, 0xf2f2f2],
+            [6000, 0xe5e5e5],
+            [5500, 0x493811],
+            [5000, 0x5e4c26],
+            [4500, 0x726038],
+            [4000, 0x87724c],
+            [3500, 0x998760],
+            [3000, 0xad9b75],
+            [2500, 0xc1af89],
+            [2000, 0xd6c49e],
+            [1500, 0xead8af],
+            [1000, 0xfcedbf],
+            [900, 0xaadda0],
+            [800, 0xa5d69b],
+            [700, 0x96ce8e],
+            [600, 0x84c17a],
+            [500, 0x7aba70],
+            [400, 0x72b266],
+            [300, 0x5ea354],
+            [200, 0x4c933f],
+            [100, 0x3d873d],
+            [75, 0x357c3a],
+            [50, 0x2d722d],
+            [25, 0x266821],
+            [10, 0x1e5e14],
+            [0.01, 0x165407]
+        ];
+
+        if (!defaultVis) updateMap(max, min);
+        // add ocean color
+        map.push([-10000, 0x0f0f8c])
+        const visualizer = new ColorMapVisualizer(map);
+
+        function evaluatePixel(sample) {
+            let val = sample.DEM;
+            let imgVals = visualizer.process(val)
+
+            // Return the 4 inputs and define content for each one
+            return {
+                default: [...imgVals, sample.dataMask],
+                index: [val],
+                dataMask: [sample.dataMask]
+            };
+        }
+        """
+
+    HLS_FALSE_COLOR = """
+        //VERSION=3
+
+        function setup() {
+        return {
+            input: ["NIR_Narrow", "Red", "Green", "dataMask"],
+            output: { bands: 3 }
+        };
+        }
+
+        function evaluatePixel(sample) {
+        return [2.5 * sample.NIR_Narrow, 2.5 * sample.Red, 2.5 * sample.Green, sample.dataMask];
+        }
+        """
+
+    HLS_TRUE_COLOR = """
+        //VERSION=3
+
+        function setup() {
+            return {
+                input: ["Blue","Green","Red", "dataMask"],
+                output: { bands: 4 }
+            };
+        }
+
+        function evaluatePixel(sample) {
+            return [2.5 * sample.Red, 2.5 * sample.Green, 2.5 * sample.Blue, sample.dataMask];
+        }
+        """
+
+    HLS_NDVI = """
+        //VERSION=3
+
+        function setup() { 
+            return {
+                input: ["NIR_Narrow", "Red", "dataMask"],
+                output: { bands: 4 }
+            };
+        }
+
+        function evaluatePixel(sample) {
+            var ndvi = (sample.NIR_Narrow - sample.Red) / (sample.NIR_Narrow + sample.Red)
+
+            if (ndvi<-1.1) return [0,0,0, sample.dataMask];
+            else if (ndvi<-0.2) return [0.75,0.75,0.75, sample.dataMask];
+            else if (ndvi<-0.1) return [0.86,0.86,0.86, sample.dataMask];
+            else if (ndvi<0) return [1,1,0.88, sample.dataMask];
+            else if (ndvi<0.025) return [1,0.98,0.8, sample.dataMask];
+            else if (ndvi<0.05) return [0.93,0.91,0.71, sample.dataMask];
+            else if (ndvi<0.075) return [0.87,0.85,0.61, sample.dataMask];
+            else if (ndvi<0.1) return [0.8,0.78,0.51, sample.dataMask];
+            else if (ndvi<0.125) return [0.74,0.72,0.42, sample.dataMask];
+            else if (ndvi<0.15) return [0.69,0.76,0.38, sample.dataMask];
+            else if (ndvi<0.175) return [0.64,0.8,0.35, sample.dataMask];
+            else if (ndvi<0.2) return [0.57,0.75,0.32, sample.dataMask];
+            else if (ndvi<0.25) return [0.5,0.7,0.28, sample.dataMask];
+            else if (ndvi<0.3) return [0.44,0.64,0.25, sample.dataMask];
+            else if (ndvi<0.35) return [0.38,0.59,0.21, sample.dataMask];
+            else if (ndvi<0.4) return [0.31,0.54,0.18, sample.dataMask];
+            else if (ndvi<0.45) return [0.25,0.49,0.14, sample.dataMask];
+            else if (ndvi<0.5) return [0.19,0.43,0.11, sample.dataMask];
+            else if (ndvi<0.55) return [0.13,0.38,0.07, sample.dataMask];
+            else if (ndvi<0.6) return [0.06,0.33,0.04, sample.dataMask];
+            else return [0,0.27,0, sample.dataMask];
+        }
+        """
+
+    LANDSAT_OT_L2_TRUE_COLOR = """
+        //VERSION=3
+
+        let minVal = 0.0;
+        let maxVal = 0.4;
+
+        let viz = new DefaultVisualizer(minVal, maxVal);
+
+        function evaluatePixel(samples) {
+            let val = [samples.B04, samples.B03, samples.B02, samples.dataMask];
+            return viz.processList(val);
+        }
+
+        function setup() {
+            return {
+                input: [{
+                bands: [ "B02", "B03", "B04", "dataMask" ]
+                }],
+                output: { bands: 4 }  }
+            }
+        """
+    LANDSAT_OT_L2_NDVI = """
+        //VERSION=3
+        
+        function setup() {
+        return {
+            input: ["B03", "B04", "B05", "dataMask"],
+            output: [
+            { id: "default", bands: 4 },
+            { id: "index", bands: 1, sampleType: "FLOAT32" },
+            { id: "eobrowserStats", bands: 2 },
+            { id: "dataMask", bands: 1 },
+            ],
+        };
+        }
+
+        function evaluatePixel(samples) {
+        let val = index(samples.B05, samples.B04);
+        let imgVals = null;
+        // The library for tiffs works well only if there is only one channel returned.
+        // So we encode the "no data" as NaN here and ignore NaNs on frontend.
+        const indexVal = samples.dataMask === 1 && val >= -1 && val <= 1 ? val : NaN;
+
+        if (val < -1.1) imgVals = [0, 0, 0, samples.dataMask];
+        else if (val < -0.2) imgVals = [0.75, 0.75, 0.75, samples.dataMask];
+        else if (val < -0.1) imgVals = [0.86, 0.86, 0.86, samples.dataMask];
+        else if (val < 0) imgVals = [1, 1, 0.88, samples.dataMask];
+        else if (val < 0.025) imgVals = [1, 0.98, 0.8, samples.dataMask];
+        else if (val < 0.05) imgVals = [0.93, 0.91, 0.71, samples.dataMask];
+        else if (val < 0.075) imgVals = [0.87, 0.85, 0.61, samples.dataMask];
+        else if (val < 0.1) imgVals = [0.8, 0.78, 0.51, samples.dataMask];
+        else if (val < 0.125) imgVals = [0.74, 0.72, 0.42, samples.dataMask];
+        else if (val < 0.15) imgVals = [0.69, 0.76, 0.38, samples.dataMask];
+        else if (val < 0.175) imgVals = [0.64, 0.8, 0.35, samples.dataMask];
+        else if (val < 0.2) imgVals = [0.57, 0.75, 0.32, samples.dataMask];
+        else if (val < 0.25) imgVals = [0.5, 0.7, 0.28, samples.dataMask];
+        else if (val < 0.3) imgVals = [0.44, 0.64, 0.25, samples.dataMask];
+        else if (val < 0.35) imgVals = [0.38, 0.59, 0.21, samples.dataMask];
+        else if (val < 0.4) imgVals = [0.31, 0.54, 0.18, samples.dataMask];
+        else if (val < 0.45) imgVals = [0.25, 0.49, 0.14, samples.dataMask];
+        else if (val < 0.5) imgVals = [0.19, 0.43, 0.11, samples.dataMask];
+        else if (val < 0.55) imgVals = [0.13, 0.38, 0.07, samples.dataMask];
+        else if (val < 0.6) imgVals = [0.06, 0.33, 0.04, samples.dataMask];
+        else imgVals = [0, 0.27, 0, samples.dataMask];
+
+        return {
+            default: imgVals,
+            index: [indexVal],
+            eobrowserStats: [val, isCloud(samples) ? 1 : 0],
+            dataMask: [samples.dataMask],
+        };
+        }
+
+        function isCloud(samples) {
+        const NGDR = index(samples.B03, samples.B04);
+        const bRatio = (samples.B03 - 0.175) / (0.39 - 0.175);
+        return bRatio > 1 || (bRatio > 0 && NGDR > 0);
+        }
+        """