water-column-sonar-processing 0.0.1__py3-none-any.whl → 25.11.1__py3-none-any.whl

water_column_sonar_processing/cruise/create_empty_zarr_store.py

@@ -0,0 +1,191 @@
+import os
+import tempfile
+
+import numpy as np
+
+from water_column_sonar_processing.aws import DynamoDBManager, S3Manager
+from water_column_sonar_processing.model import ZarrManager
+from water_column_sonar_processing.utility import Cleaner
+
+
+# TODO: change name to "CreateLocalEmptyZarrStore"
+class CreateEmptyZarrStore:
+    #######################################################
+    def __init__(
+        self,
+    ):
+        self.__overwrite = True
+        # self.input_bucket_name = os.environ.get("INPUT_BUCKET_NAME")
+        # self.output_bucket_name = os.environ.get("OUTPUT_BUCKET_NAME")
+
+    #######################################################
+    # TODO: moved this to the s3_manager
+    # def upload_zarr_store_to_s3(
+    #     self,
+    #     output_bucket_name: str,
+    #     local_directory: str,
+    #     object_prefix: str,
+    #     cruise_name: str,
+    # ) -> None:
+    #     print("uploading model store to s3")
+    #     s3_manager = S3Manager()
+    #     #
+    #     print("Starting upload with thread pool executor.")
+    #     # # 'all_files' is passed a list of lists: [[local_path, s3_key], [...], ...]
+    #     all_files = []
+    #     for subdir, dirs, files in os.walk(f"{local_directory}/{cruise_name}.zarr"):
+    #         for file in files:
+    #             local_path = os.path.join(subdir, file)
+    #             # TODO: find a better method for splitting strings here:
+    #             # 'level_2/Henry_B._Bigelow/HB0806/EK60/HB0806.zarr/.zattrs'
+    #             s3_key = f"{object_prefix}/{cruise_name}.zarr{local_path.split(f'{cruise_name}.zarr')[-1]}"
+    #             all_files.append([local_path, s3_key])
+    #     #
+    #     # print(all_files)
+    #     s3_manager.upload_files_with_thread_pool_executor(
+    #         output_bucket_name=output_bucket_name,
+    #         all_files=all_files,
+    #     )
+    #     print("Done uploading with thread pool executor.")
+    #     # TODO: move to common place
+
+    #######################################################
+    def create_cruise_level_zarr_store(
+        self,
+        output_bucket_name: str,
+        ship_name: str,
+        cruise_name: str,
+        sensor_name: str,
+        table_name: str,
+        # override_cruise_min_epsilon=None,
+    ) -> None:
+        """
+        Initialize zarr store. The water_level needs to be integrated.
+        """
+        tempdir = tempfile.TemporaryDirectory()
+        try:
+            # HB0806 - 123, HB0903 - 220
+            dynamo_db_manager = DynamoDBManager()
+            s3_manager = S3Manager()
+
+            df = dynamo_db_manager.get_table_as_df(
+                table_name=table_name,
+                cruise_name=cruise_name,
+            )
+
+            # TODO: filter the dataframe just for enums >= LEVEL_1_PROCESSING
+            # df[df['PIPELINE_STATUS'] < PipelineStatus.LEVEL_1_PROCESSING] = np.nan
+
+            # TODO: VERIFY GEOJSON EXISTS as prerequisite!!!
+
+            print(f"DataFrame shape: {df.shape}")
+            cruise_channels = list(
+                set([i for sublist in df["CHANNELS"].dropna() for i in sublist])
+            )
+            cruise_channels.sort()
+
+            consolidated_zarr_width = np.sum(
+                df["NUM_PING_TIME_DROPNA"].dropna().astype(int)
+            )
+
+            # [3] calculate the max/min measurement resolutions for the whole cruise
+            # cruise_min_echo_range = np.min(
+            #     (df["MIN_ECHO_RANGE"] + df["WATER_LEVEL"]).dropna().astype(float)
+            # )
+
+            # [4] calculate the np.max(max_echo_range + water_level)
+            cruise_max_echo_range = np.max(
+                (df["MAX_ECHO_RANGE"] + df["WATER_LEVEL"]).dropna().astype(float)
+            )
+
+            # TODO: set this to either 1 or 0.5 meters
+            cruise_min_epsilon = np.min(df["MIN_ECHO_RANGE"].dropna().astype(float))
+
+            print(f"cruise_max_echo_range: {cruise_max_echo_range}")
+
+            # [5] get number of channels
+            cruise_frequencies = [
+                float(i) for i in df["FREQUENCIES"].dropna().values.flatten()[0]
+            ]
+            print(cruise_frequencies)
+
+            new_width = int(consolidated_zarr_width)
+            print(f"new_width: {new_width}")
+            #################################################################
+            store_name = f"{cruise_name}.zarr"
+            print(store_name)
+            ################################################################
+            # Delete existing model store if it exists
+            zarr_prefix = os.path.join("level_2", ship_name, cruise_name, sensor_name)
+            child_objects = s3_manager.get_child_objects(
+                bucket_name=output_bucket_name,
+                sub_prefix=zarr_prefix,
+            )
+            #
+            if len(child_objects) > 0:
+                s3_manager.delete_nodd_objects(
+                    bucket_name=output_bucket_name,
+                    objects=child_objects,
+                )
+            ################################################################
+            # Create new model store
+            zarr_manager = ZarrManager()
+            new_height = len(  # [0.19m down to 1001.744m] = 5272 samples, 10.3 tiles @ 512
+                zarr_manager.get_depth_values(  # these depths should be from min_epsilon to max_range+water_level
+                    # min_echo_range=cruise_min_echo_range,
+                    max_echo_range=cruise_max_echo_range,
+                    cruise_min_epsilon=cruise_min_epsilon,
+                )
+            )
+            print(f"new_height: {new_height}")
+
+            zarr_manager.create_zarr_store(
+                path=tempdir.name,  # TODO: need to use .name or problem
+                ship_name=ship_name,
+                cruise_name=cruise_name,
+                sensor_name=sensor_name,
+                frequencies=cruise_frequencies,
+                width=new_width,
+                # min_echo_range=cruise_min_echo_range,
+                max_echo_range=cruise_max_echo_range,
+                cruise_min_epsilon=cruise_min_epsilon,
+                calibration_status=True,
+            )
+            #################################################################
+            s3_manager.upload_zarr_store_to_s3(
+                output_bucket_name=output_bucket_name,
+                local_directory=tempdir.name,  # TODO: need to use .name or problem
+                object_prefix=zarr_prefix,
+                cruise_name=cruise_name,
+            )
+            # https://noaa-wcsd-zarr-pds.s3.amazonaws.com/index.html
+            #################################################################
+            # Verify count of the files uploaded
+            # count = self.__get_file_count(store_name=store_name)
+            # #
+            # raw_zarr_files = self.__get_s3_files(  # TODO: just need count
+            #     bucket_name=self.__output_bucket,
+            #     sub_prefix=os.path.join(zarr_prefix, store_name),
+            # )
+            # if len(raw_zarr_files) != count:
+            #     print(f'Problem writing {store_name} with proper count {count}.')
+            #     raise Exception("File count doesnt equal number of s3 Zarr store files.")
+            # else:
+            #     print("File counts match.")
+            #################################################################
+            # Success
+            # TODO: update enum in dynamodb
+            print("Done creating cruise level zarr store.")
+            #################################################################
+        except Exception as err:
+            raise RuntimeError(
+                f"Problem trying to create new cruise model store, {err}"
+            )
+        finally:
+            cleaner = Cleaner()
+            cleaner.delete_local_files()
+            # TODO: should delete zarr store in temp directory too?
+        print("Done creating cruise level model store")
+
+
+###########################################################

water_column_sonar_processing/cruise/datatree_manager.py

@@ -0,0 +1,21 @@
+# ### https://xarray-datatree.readthedocs.io/en/latest/data-structures.html
+# import xarray as xr
+# from datatree import DataTree
+#
+#
+# class DatatreeManager:
+#     #######################################################
+#     def __init__(
+#         self,
+#     ):
+#         self.dtype = "float32"
+#
+#     #################################################################
+#     def create_datatree(
+#         self,
+#         input_ds,
+#     ) -> None:
+#         ds1 = xr.Dataset({"foo": "orange"})
+#         dt = DataTree(name="root", dataset=ds1)  # create root node
+#         # ds2 = xr.Dataset({"bar": 0}, coords={"y": ("y", [0, 1, 2])})
+#         return dt

water_column_sonar_processing/cruise/resample_regrid.py

@@ -0,0 +1,339 @@
+import gc
+import warnings
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import xarray as xr
+
+from water_column_sonar_processing.aws import DynamoDBManager
+from water_column_sonar_processing.geometry import GeometryManager
+from water_column_sonar_processing.model import ZarrManager
+
+warnings.simplefilter("ignore", category=RuntimeWarning)
+
+
+class ResampleRegrid:
+    #######################################################
+    def __init__(
+        self,
+    ):
+        self.__overwrite = True
+        # self.input_bucket_name = os.environ.get("INPUT_BUCKET_NAME")
+        # self.output_bucket_name = os.environ.get("OUTPUT_BUCKET_NAME")
+        self.dtype = "float32"
+
+    #################################################################
+    def interpolate_data(
+        self,
+        input_xr,
+        ping_times,
+        all_cruise_depth_values,  # includes water_level offset
+        water_level,  # this is the offset that will be added to each respective file
+    ) -> np.ndarray:
+        """
+        What gets passed into interpolate data
+        """
+        print("Interpolating dataset.")
+        try:
+            data = np.empty(
+                (
+                    len(all_cruise_depth_values),
+                    len(ping_times),
+                    len(input_xr.frequency_nominal),
+                ),
+                dtype=self.dtype,
+            )
+
+            data[:] = np.nan
+
+            regrid_resample = xr.DataArray(  # where data will be written to
+                data=data,
+                dims=("depth", "time", "frequency"),
+                coords={
+                    "depth": all_cruise_depth_values,
+                    "time": ping_times,
+                    "frequency": input_xr.frequency_nominal.values,
+                },
+            )
+
+            # shift the input data by water_level
+            input_xr.echo_range.values = (
+                input_xr.echo_range.values + water_level
+            )  # water_level # TODO: change
+
+            channels = input_xr.channel.values
+            for channel in range(
+                len(channels)
+            ):  # ?TODO: leaving off here, need to subset for just indices in time axis
+                gc.collect()
+                max_depths = np.nanmax(
+                    a=input_xr.echo_range.sel(channel=input_xr.channel[channel]).values,
+                    # + water_level,
+                    axis=1,
+                )
+                superset_of_max_depths = set(
+                    max_depths
+                )  # HB1501, D20150503-T102035.raw, TypeError: unhashable type: 'numpy.ndarray'
+                set_of_max_depths = list(
+                    {x for x in superset_of_max_depths if x == x}
+                )  # removes nan's
+                # iterate through partitions of dataset with similar depths and resample
+                for select_max_depth in set_of_max_depths:
+                    # TODO: for nan just skip and leave all nan's
+                    select_indices = [
+                        i
+                        for i in range(0, len(max_depths))
+                        if max_depths[i] == select_max_depth
+                    ]
+
+                    # now create new DataArray with proper dimension and indices
+                    # data_select = input_xr.Sv.sel(
+                    #     channel=input_xr.channel[channel]
+                    # ).values[select_indices, :].T  # TODO: dont like this transpose
+                    data_select = input_xr.Sv.sel(channel=input_xr.channel[channel])[
+                        select_indices, :
+                    ].T.values
+                    # change from ".values[select_indices, :].T" to "[select_indices, :].values.T"
+
+                    times_select = input_xr.ping_time.values[select_indices]
+                    depths_select = input_xr.echo_range.sel(
+                        channel=input_xr.channel[channel]
+                    ).values[
+                        select_indices[0], :
+                    ]  # '0' because all others in group should be same
+
+                    da_select = xr.DataArray(
+                        data=data_select,
+                        dims=("depth", "time"),
+                        coords={
+                            "depth": depths_select,
+                            "time": times_select,
+                        },
+                    ).dropna(dim="depth")
+                    resampled = da_select.interp(
+                        depth=all_cruise_depth_values, method="nearest"
+                    )
+                    # write to the resample array
+                    regrid_resample.loc[
+                        dict(
+                            time=times_select,
+                            frequency=input_xr.frequency_nominal.values[channel],
+                        )
+                    ] = resampled
+                    print(f"updated {len(times_select)} ping times")
+                    gc.collect()
+        except Exception as err:
+            raise RuntimeError(f"Problem finding the dynamodb table, {err}")
+        print("Done interpolating dataset.")
+        return regrid_resample.values.copy()
+
+    #################################################################
+    def resample_regrid(
+        self,
+        ship_name,
+        cruise_name,
+        sensor_name,
+        table_name,
+        bucket_name,
+        override_select_files=None,
+        # override_cruise_min_epsilon=None,
+        endpoint_url=None,
+    ) -> None:
+        """
+        The goal here is to interpolate the dataset against the depth values already populated
+        in the existing file level model stores. We open the cruise-level store with model for
+        read/write operations. We open the file-level store with Xarray to leverage tools for
+        resampling and subsetting the dataset.
+        """
+        print("Resample Regrid, Interpolating dataset.")
+        try:
+            zarr_manager = ZarrManager()
+            geo_manager = GeometryManager()
+
+            output_zarr_store = zarr_manager.open_s3_zarr_store_with_zarr(
+                ship_name=ship_name,
+                cruise_name=cruise_name,
+                sensor_name=sensor_name,
+                output_bucket_name=bucket_name,
+                endpoint_url=endpoint_url,
+            )
+
+            # get dynamo stuff
+            dynamo_db_manager = DynamoDBManager()
+            cruise_df = dynamo_db_manager.get_table_as_df(
+                # ship_name=ship_name,
+                cruise_name=cruise_name,
+                # sensor_name=sensor_name,
+                table_name=table_name,
+            )
+
+            #########################################################
+            #########################################################
+            all_file_names = cruise_df["FILE_NAME"]
+
+            if override_select_files is not None:
+                all_file_names = override_select_files
+
+            # Iterate files
+            for file_name in all_file_names:
+                gc.collect()
+                file_name_stem = Path(file_name).stem
+                print(f"Processing file: {file_name_stem}.")
+
+                if f"{file_name_stem}.raw" not in list(cruise_df["FILE_NAME"]):
+                    raise Exception("Raw file file_stem not found in dynamodb.")
+
+                # status = PipelineStatus['LEVEL_1_PROCESSING']
+                # TODO: filter rows by enum success, filter the dataframe just for enums >= LEVEL_1_PROCESSING
+                #  df[df['PIPELINE_STATUS'] < PipelineStatus.LEVEL_1_PROCESSING] = np.nan
+
+                # Get index from all cruise files. Note: should be based on which are included in cruise.
+                index = int(
+                    cruise_df.index[cruise_df["FILE_NAME"] == f"{file_name_stem}.raw"][
+                        0
+                    ]
+                )
+
+                # Get input store — this is unadjusted for water_level
+                input_xr_zarr_store = zarr_manager.open_s3_zarr_store_with_xarray(
+                    ship_name=ship_name,
+                    cruise_name=cruise_name,
+                    sensor_name=sensor_name,
+                    file_name_stem=file_name_stem,
+                    input_bucket_name=bucket_name,
+                    endpoint_url=endpoint_url,
+                )
+
+                # This is the vertical offset of the sensor related to the ocean surface
+                # See https://echopype.readthedocs.io/en/stable/data-proc-additional.html
+                if "water_level" in input_xr_zarr_store.keys():
+                    water_level = input_xr_zarr_store.water_level.values
+                else:
+                    water_level = 0.0
+                #########################################################################
+                # [3] Get needed time indices — along the x-axis
+                # Offset from start index to insert new dataset. Note that missing values are excluded.
+                ping_time_cumsum = np.insert(
+                    np.cumsum(
+                        cruise_df["NUM_PING_TIME_DROPNA"].dropna().to_numpy(dtype=int)
+                    ),
+                    obj=0,
+                    values=0,
+                )
+                start_ping_time_index = ping_time_cumsum[index]
+                end_ping_time_index = ping_time_cumsum[index + 1]
+
+                max_echo_range = np.max(
+                    (cruise_df["MAX_ECHO_RANGE"] + cruise_df["WATER_LEVEL"])
+                    .dropna()
+                    .astype(float)
+                )
+                cruise_min_epsilon = np.min(
+                    cruise_df["MIN_ECHO_RANGE"].dropna().astype(float)
+                )
+
+                # Note: cruise dims (depth, time, frequency)
+                all_cruise_depth_values = zarr_manager.get_depth_values(  # needs to integrate water_level
+                    # min_echo_range=min_echo_range,
+                    max_echo_range=max_echo_range,  # does it here
+                    cruise_min_epsilon=cruise_min_epsilon,  # remove this & integrate into min_echo_range
+                )  # with offset of 7.5 meters, 0 meter measurement should now start at 7.5 meters
+
+                print(" ".join(list(input_xr_zarr_store.Sv.dims)))
+                if set(input_xr_zarr_store.Sv.dims) != {
+                    "channel",
+                    "ping_time",
+                    "range_sample",
+                }:
+                    raise Exception("Xarray dimensions are not as expected.")
+
+                indices, geospatial = geo_manager.read_s3_geo_json(
+                    ship_name=ship_name,
+                    cruise_name=cruise_name,
+                    sensor_name=sensor_name,
+                    file_name_stem=file_name_stem,
+                    input_xr_zarr_store=input_xr_zarr_store,
+                    endpoint_url=endpoint_url,
+                    output_bucket_name=bucket_name,
+                )
+
+                input_xr = input_xr_zarr_store.isel(
+                    ping_time=indices
+                )  # Problem with HB200802-D20080310-T174959.zarr/
+
+                ping_times = input_xr.ping_time.values
+                # Date format: numpy.datetime64('2007-07-20T02:10:25.845073920') converts to "1184897425.845074"
+                epoch_seconds = [
+                    (pd.Timestamp(i) - pd.Timestamp("1970-01-01")) / pd.Timedelta("1s")
+                    for i in ping_times
+                ]
+                output_zarr_store["time"][start_ping_time_index:end_ping_time_index] = (
+                    epoch_seconds
+                )
+
+                # --- UPDATING --- #
+                regrid_resample = self.interpolate_data(
+                    input_xr=input_xr,
+                    ping_times=ping_times,
+                    all_cruise_depth_values=all_cruise_depth_values,  # should accommodate the water_level already
+                    water_level=water_level,  # not applied to anything yet
+                )
+
+                print(
+                    f"start_ping_time_index: {start_ping_time_index}, end_ping_time_index: {end_ping_time_index}"
+                )
+                #########################################################################
+                # write Sv values to cruise-level-model-store
+
+                for fff in range(regrid_resample.shape[-1]):
+                    output_zarr_store["Sv"][
+                        :, start_ping_time_index:end_ping_time_index, fff
+                    ] = regrid_resample[:, :, fff]
+                #########################################################################
+                # TODO: add the "detected_seafloor_depth/" to the
+                #  L2 cruise dataarrays
+                # TODO: make bottom optional
+                # TODO: Only checking the first channel for now. Need to average across all channels
+                #  in the future. See https://github.com/CI-CMG/water-column-sonar-processing/issues/11
+                if "detected_seafloor_depth" in input_xr.variables:
+                    print(
+                        "Found detected_seafloor_depth, adding dataset to output store."
+                    )
+                    detected_seafloor_depth = input_xr.detected_seafloor_depth.values
+                    detected_seafloor_depth[detected_seafloor_depth == 0.0] = np.nan
+                    # TODO: problem here: Processing file: D20070711-T210709.
+
+                    # Use the lowest frequencies to determine bottom
+                    detected_seafloor_depths = detected_seafloor_depth[0, :]
+
+                    detected_seafloor_depths[detected_seafloor_depths == 0.0] = np.nan
+                    print(f"min depth measured: {np.nanmin(detected_seafloor_depths)}")
+                    print(f"max depth measured: {np.nanmax(detected_seafloor_depths)}")
+                    # available_indices = np.argwhere(np.isnan(geospatial['latitude'].values))
+                    output_zarr_store["bottom"][
+                        start_ping_time_index:end_ping_time_index
+                    ] = detected_seafloor_depths
+                #
+                #########################################################################
+                # [5] write subset of latitude/longitude
+                output_zarr_store["latitude"][
+                    start_ping_time_index:end_ping_time_index
+                ] = geospatial.dropna()[
+                    "latitude"
+                ].values  # TODO: get from ds_sv directly, dont need geojson anymore
+                output_zarr_store["longitude"][
+                    start_ping_time_index:end_ping_time_index
+                ] = geospatial.dropna()["longitude"].values
+                #########################################################################
+                #########################################################################
+        except Exception as err:
+            raise RuntimeError(f"Problem with resample_regrid, {err}")
+        finally:
+            print("Exiting resample_regrid.")
+            # TODO: read across times and verify dataset was written?
+
+    #######################################################
+
+
+###########################################################

water_column_sonar_processing/geometry/__init__.py

@@ -0,0 +1,11 @@
+from .elevation_manager import ElevationManager
+from .geometry_manager import GeometryManager
+from .line_simplification import LineSimplification
+from .pmtile_generation import PMTileGeneration
+
+__all__ = [
+    "ElevationManager",
+    "GeometryManager",
+    "LineSimplification",
+    "PMTileGeneration",
+]

water_column_sonar_processing/geometry/elevation_manager.py

@@ -0,0 +1,111 @@
+"""
+https://gis.ngdc.noaa.gov/arcgis/rest/services/DEM_mosaics/DEM_global_mosaic/ImageServer/identify?geometry=-31.70235%2C13.03332&geometryType=esriGeometryPoint&returnGeometry=false&returnCatalogItems=false&f=json
+
+https://gis.ngdc.noaa.gov/arcgis/rest/services/DEM_mosaics/DEM_global_mosaic/ImageServer/
+    identify?
+        geometry=-31.70235%2C13.03332
+        &geometryType=esriGeometryPoint
+        &returnGeometry=false
+        &returnCatalogItems=false
+        &f=json
+{"objectId":0,"name":"Pixel","value":"-5733","location":{"x":-31.702349999999999,"y":13.03332,"spatialReference":{"wkid":4326,"latestWkid":4326}},"properties":null,"catalogItems":null,"catalogItemVisibilities":[]}
+-5733
+
+(base) rudy:deleteME rudy$ curl https://api.opentopodata.org/v1/gebco2020?locations=13.03332,-31.70235
+{
+  "results": [
+    {
+      "dataset": "gebco2020",
+      "elevation": -5729.0,
+      "location": {
+        "lat": 13.03332,
+        "lng": -31.70235
+      }
+    }
+  ],
+  "status": "OK"
+}
+"""
+
+import json
+import time
+from collections.abc import Generator
+
+import requests
+
+
+def chunked(ll: list, n: int) -> Generator:
+    # Yields successively n-sized chunks from ll.
+    for i in range(0, len(ll), n):
+        yield ll[i : i + n]
+
+
+class ElevationManager:
+    #######################################################
+    def __init__(
+        self,
+    ):
+        self.DECIMAL_PRECISION = 5  # precision for GPS coordinates
+        self.TIMOUT_SECONDS = 10
+
+    #######################################################
+    def get_arcgis_elevation(
+        self,
+        lngs: list,
+        lats: list,
+        chunk_size: int = 500,  # I think this is the api limit
+    ) -> int:
+        # Reference: https://developers.arcgis.com/rest/services-reference/enterprise/map-to-image/
+        # Info: https://www.arcgis.com/home/item.html?id=c876e3c96a8642ab8557646a3b4fa0ff
+        ### 'https://gis.ngdc.noaa.gov/arcgis/rest/services/DEM_mosaics/DEM_global_mosaic/ImageServer/identify?geometry={"points":[[-31.70235,13.03332],[-32.70235,14.03332]]}&geometryType=esriGeometryMultipoint&returnGeometry=false&returnCatalogItems=false&f=json'
+        if len(lngs) != len(lats):
+            raise ValueError("lngs and lats must have same length")
+
+        geometryType = "esriGeometryMultipoint"  # TODO: allow single point?
+
+        depths = []
+
+        list_of_points = [list(elem) for elem in list(zip(lngs, lats))]
+        for chunk in chunked(list_of_points, chunk_size):
+            time.sleep(0.1)
+            # order: (lng, lat)
+            geometry = f'{{"points":{str(chunk)}}}'
+            url = f"https://gis.ngdc.noaa.gov/arcgis/rest/services/DEM_mosaics/DEM_global_mosaic/ImageServer/identify?geometry={geometry}&geometryType={geometryType}&returnGeometry=false&returnCatalogItems=false&f=json"
+            result = requests.get(url, timeout=self.TIMOUT_SECONDS)
+            res = json.loads(result.content.decode("utf8"))
+            if "results" in res:
+                for element in res["results"]:
+                    depths.append(float(element["value"]))
+            elif "value" in res:
+                depths.append(float(res["value"]))
+
+        return depths
+
+    # def get_gebco_bathymetry_elevation(self) -> int:
+    #     # Documentation: https://www.opentopodata.org/datasets/gebco2020/
+    #     latitude = 13.03332
+    #     longitude = -31.70235
+    #     dataset = "gebco2020"
+    #     url = f"https://api.opentopodata.org/v1/{dataset}?locations={latitude},{longitude}"
+    #     pass
+
+    # def get_elevation(
+    #         self,
+    #         df,
+    #         lat_column,
+    #         lon_column,
+    # ) -> int:
+    #     """Query service using lat, lon. add the elevation values as a new column."""
+    #     url = r'https://epqs.nationalmap.gov/v1/json?'
+    #     elevations = []
+    #     for lat, lon in zip(df[lat_column], df[lon_column]):
+    #         # define rest query params
+    #         params = {
+    #             'output': 'json',
+    #             'x': lon,
+    #             'y': lat,
+    #             'units': 'Meters'
+    #         }
+    #         result = requests.get((url + urllib.parse.urlencode(params)))
+    #         elevations.append(result.json()['value'])
+    #     return elevations