pyadps 0.2.0b0__py3-none-any.whl → 0.3.0b0__py3-none-any.whl

pyadps/utils/cutbin.py

@@ -1,413 +0,0 @@
-import matplotlib as mpl
-import matplotlib.pyplot as plt
-import numpy as np
-from matplotlib.widgets import Button, RadioButtons, RectangleSelector, Slider
-
-from pyadps.utils import readrdi as rd
-
-
-class CutBins:
-    def __init__(
-        self, data, mask, newmask=False, t1=0, t2=200, tinc=500, z1=0, z2=-1, zinc=0
-    ):
-        # DATA SETUP
-        self.orig_data = data
-        self.orig_shape = np.shape(self.orig_data)
-        self.fill = 999
-        self.maskarray = mask
-        if not newmask:
-            self.orig_data[self.maskarray == 1] = self.fill
-
-        self.t1, self.t2, self.tinc = t1, t2, tinc
-        self.z1, self.z2, self.zinc = z1, z2, zinc
-        if z2 == -1:
-            self.z2 = self.orig_shape[0]
-
-        self.data = self.orig_data[self.z1 : self.z2, self.t1 : self.t2]
-        self.orig_subset = self.orig_data[self.z1 : self.z2, self.t1 : self.t2]
-        self.datacopy = np.copy(self.orig_data)
-        self.datamin = np.min(self.orig_data)
-        self.datamax = np.max(self.orig_data)
-        self.shape = np.shape(self.data)
-
-        # PLOT SETUP
-        self.t = np.arange(self.t1, self.t2)
-        self.z = np.arange(self.z1, self.z2)
-        self.tickinterval = int((self.t2 - self.t1) / 5)
-        self.xticks = np.arange(self.t1, self.t2, self.tickinterval)
-        self.X, self.Y = np.meshgrid(self.t, self.z)
-        self.fig, self.axs = plt.subplot_mosaic(
-            [["a", "b"], ["c", "b"]],
-            figsize=(12, 10),
-            width_ratios=[2, 1],
-            height_ratios=[1.75, 1],
-        )
-        self.fig.set_facecolor("darkgrey")
-        plt.subplots_adjust(top=0.82, right=0.95)
-
-        # ADDING WIDGET AXES
-        self.ax_clear_button = self.fig.add_axes(rect=(0.125, 0.90, 0.08, 0.025))
-        self.ax_delete_button = self.fig.add_axes(rect=(0.225, 0.90, 0.08, 0.025))
-        self.ax_refill_button = self.fig.add_axes(rect=(0.325, 0.90, 0.08, 0.025))
-        self.ax_next_button = self.fig.add_axes(rect=(0.630, 0.65, 0.02, 0.050))
-        self.ax_previous_button = self.fig.add_axes(rect=(0.075, 0.65, 0.02, 0.050))
-        self.ax_radio_button = self.fig.add_axes(rect=(0.725, 0.87, 0.10, 0.10))
-        self.ax_exit_button = self.fig.add_axes(rect=(0.825, 0.025, 0.08, 0.035))
-        self.ax_hslider = self.fig.add_axes(rect=(0.125, 0.85, 0.50, 0.03))
-        self.ax_vslider = self.fig.add_axes(rect=(0.04, 0.25, 0.03, 0.50))
-
-        self.ax_delete_button.set_visible(False)
-        self.ax_refill_button.set_visible(False)
-
-        # --- Slider settings ---
-        # Initial slider settings
-        self.hevent = 0
-        self.vevent = 0
-
-        # Slider options
-        self.hslider = Slider(
-            ax=self.ax_hslider,
-            label="Ensemble",
-            valmin=self.t1,
-            valmax=self.t2,
-            valinit=self.hevent,
-            valfmt="%i",
-            valstep=1,
-        )
-
-        self.vslider = Slider(
-            ax=self.ax_vslider,
-            label="Bins",
-            valmin=self.z1,
-            valmax=self.z2,
-            valinit=self.vevent,
-            valfmt="%i",
-            valstep=1,
-            orientation="vertical",
-        )
-
-        # Button Labels
-        self.clear_button = Button(self.ax_clear_button, "Clear")
-        self.delete_button = Button(self.ax_delete_button, "Delete")
-        self.refill_button = Button(self.ax_refill_button, "Refill")
-        self.previous_button = Button(self.ax_previous_button, "<")
-        self.next_button = Button(self.ax_next_button, ">")
-        self.exit_button = Button(self.ax_exit_button, "Save & Exit")
-        # self.cell_button = Button(self.ax_cell_button, "Cell")
-        # self.ensemble_button = Button(self.ax_ensemble_button, "Ensemble")
-        self.radio_button = RadioButtons(
-            self.ax_radio_button, ("Bin", "Ensemble", "Cell", "Region")
-        )
-
-        # --------------PLOTS---------------------
-
-        # Settings colorbar extreme to black
-        cmap = mpl.cm.turbo.with_extremes(over="k")
-        # FILL PLOT
-        self.mesh = self.axs["a"].pcolormesh(
-            self.X, self.Y, self.data, cmap=cmap, picker=True, vmin=0, vmax=255
-        )
-        plt.colorbar(self.mesh, orientation="horizontal")
-        self.axs["a"].set_xlim([self.t1, self.t2])
-        self.axs["a"].set_ylim([self.z1, self.z2])
-        # Draw vertical and horizontal lines
-        (self.vline,) = self.axs["a"].plot(
-            [self.t1, self.t1], [self.z1, self.z2], color="r", linewidth=2.5
-        )
-        (self.hline,) = self.axs["a"].plot(
-            [self.t1, self.t2], [self.z1, self.z1], color="r", linewidth=2.5
-        )
-
-        # PROFILE
-        (self.profile,) = self.axs["b"].plot(
-            self.data[self.z1 : self.z2, self.t1 + self.hevent], range(self.z1, self.z2)
-        )
-
-        self.axs["b"].set_xlim([self.datamin, self.datamax])
-        self.profile_text = self.axs["b"].text(
-            0.95,
-            0.95,
-            f"Ensemble No.: {self.t1 + self.hevent}",
-            verticalalignment="bottom",
-            horizontalalignment="right",
-            transform=self.axs["b"].transAxes,
-            color="k",
-            fontsize=12,
-        )
-
-        # TIME SERIES
-        (self.tseries,) = self.axs["c"].plot(
-            range(self.t1, self.t2), self.data[self.z1 + self.vevent, self.t1 : self.t2]
-        )
-        self.axs["c"].set_ylim([self.datamin, self.datamax])
-        self.tseries_text = self.axs["c"].text(
-            0.90,
-            0.90,
-            f"Bin No.: {self.z1 + self.vevent}",
-            verticalalignment="bottom",
-            horizontalalignment="right",
-            transform=self.axs["c"].transAxes,
-            color="k",
-            fontsize=12,
-        )
-        # --------------END PLOTS---------------------
-
-        # EVENTS
-        self.onclick = self.onclick_bin
-        self.hslider.on_changed(self.hupdate)
-        self.vslider.on_changed(self.vupdate)
-        self.clear_button.on_clicked(self.clear)
-        self.radio_button.on_clicked(self.radio)
-        self.cid = self.fig.canvas.mpl_connect("pick_event", self.onclick)
-
-        self.delete_button.on_clicked(self.boxdelete)
-        self.refill_button.on_clicked(self.boxrefill)
-        self.next_button.on_clicked(self.next)
-        self.previous_button.on_clicked(self.previous)
-        self.exit_button.on_clicked(self.exit)
-
-    def next(self, event):
-        if self.t2 <= self.orig_shape[1]:
-            # Next works till the last subset. The if statement checks for last subset.
-            self.t1 = self.t1 + self.tinc
-            self.t2 = self.t2 + self.tinc
-            if self.t2 > (self.orig_shape[1]):
-                # If in last subset create a dummy data set with missing value.
-                self.data = self.datacopy[
-                    self.z1 : self.z2, self.t1 : self.orig_shape[1]
-                ]
-                self.orig_subset = self.orig_data[
-                    self.z1 : self.z2, self.t1 : self.orig_shape[1]
-                ]
-                self.missing = (
-                    np.ones((self.z2 - self.z1, self.t2 - self.orig_shape[1]))
-                    * self.fill
-                )
-                # self.data consist of data along with flagged value
-                self.data = np.append(self.data, self.missing, axis=1)
-                # self.orig_subset contains only the subset of the original data
-                # Useful for plotting time series and profiles
-                self.orig_subset = np.append(self.orig_subset, self.missing, axis=1)
-            else:
-                self.data = self.datacopy[self.z1 : self.z2, self.t1 : self.t2]
-                self.orig_subset = self.orig_data[self.z1 : self.z2, self.t1 : self.t2]
-
-            self.mesh.set_array(self.data)
-            self.tick = np.arange(self.t1, self.t2, self.tickinterval)
-            self.axs["a"].set_xticks(self.xticks, self.tick)
-
-            self.profile.set_xdata(self.orig_subset[:, self.hevent])
-            self.profile_text.set_text(f"Ensemble No.: {self.t1 + self.hevent}")
-            self.vline.set_xdata([self.hevent, self.hevent])
-
-            self.tseries.set_ydata(self.orig_subset[self.vevent, :])
-            self.tseries_text.set_text(f"Bin No.: {self.z1 + self.vevent}")
-            self.hline.set_ydata([self.vevent, self.vevent])
-
-            self.fig.canvas.draw()
-
-    def previous(self, event):
-        if self.t1 >= self.tinc:
-            self.t1 = self.t1 - self.tinc
-            self.t2 = self.t2 - self.tinc
-            self.tick = np.arange(self.t1, self.t2, self.tickinterval)
-            self.data = self.datacopy[self.z1 : self.z2, self.t1 : self.t2]
-            self.axs["a"].set_xticks(self.xticks, self.tick)
-            self.mesh.set_array(self.data)
-
-            # Reset sliders
-            self.profile.set_xdata(self.orig_data[self.z1 : self.z2, self.hevent])
-            self.profile_text.set_text(f"Ensemble No.: {self.hevent}")
-            self.vline.set_xdata([self.hevent, self.hevent])
-
-            self.tseries.set_ydata(self.orig_data[self.vevent, self.t1 : self.t2])
-            self.tseries_text.set_text(f"Bin No.: {self.z1 + self.vevent}")
-            self.hline.set_ydata([self.vevent, self.vevent])
-
-            self.fig.canvas.draw()
-
-    def radio(self, event):
-        self.fig.canvas.mpl_disconnect(self.cid)
-        if event == "Bin":
-            self.cid = self.fig.canvas.mpl_connect("pick_event", self.onclick_bin)
-        elif event == "Ensemble":
-            self.cid = self.fig.canvas.mpl_connect("pick_event", self.onclick_ens)
-        elif event == "Cell":
-            self.cid = self.fig.canvas.mpl_connect("pick_event", self.onclick_cell)
-        else:
-            self.rid = RectangleSelector(
-                self.axs["a"],
-                self.onclick_box,
-                useblit=True,
-                minspanx=2,
-                minspany=2,
-                interactive=True,
-            )
-
-    def clear(self, event):
-        if event.button == 1:
-            self.datacopy = np.copy(self.orig_data)
-            if self.t2 >= (self.orig_shape[1]):
-                test = self.datacopy[self.z1 : self.z2, self.t1 : self.t2]
-                test = np.append(test, self.missing, axis=1)
-            else:
-                test = self.datacopy[self.z1 : self.z2, self.t1 : self.t2]
-
-            # self.mesh.set_array(self.datacopy[self.z1 : self.z2, self.t1 : self.t2])
-            self.mesh.set_array(test)
-            self.fig.canvas.draw()
-
-    def hupdate(self, event):
-        self.hevent = event
-        self.profile.set_xdata(self.orig_subset[:, self.hevent])
-        self.profile_text.set_text(f"Ensemble No.: {self.t1 + self.hevent}")
-        self.vline.set_xdata([self.hevent, self.hevent])
-
-    def vupdate(self, event):
-        self.vevent = event
-        self.tseries.set_ydata(self.orig_subset[self.vevent, :])
-        self.tseries_text.set_text(f"Bin No.: {self.z1 + self.vevent}")
-        self.hline.set_ydata([self.vevent, self.vevent])
-
-    def onclick_bin(self, event):
-        ind = event.ind
-        x = ind // (self.t[-1] + 1)
-        # y = ind % (self.t[-1] + 1)
-        xx = self.z1 + x
-        # yy = self.t1 + y
-        if np.all(self.datacopy[xx, :] == self.fill):
-            self.datacopy[xx, :] = np.copy(self.orig_data[xx, :])
-
-        else:
-            self.datacopy[xx, :] = self.fill
-
-        if self.t2 >= (self.orig_shape[1]):
-            test = self.datacopy[self.z1 : self.z2, self.t1 : self.t2]
-            test = np.append(test, self.missing, axis=1)
-        else:
-            test = self.datacopy[self.z1 : self.z2, self.t1 : self.t2]
-
-        # self.mesh.set_array(self.datacopy[self.z1 : self.z2, self.t1 : self.t2])
-        self.mesh.set_array(test)
-        self.hline.set_ydata([x, x])
-        self.vslider.set_val(x[0])
-        self.fig.canvas.draw()
-
-    def onclick_ens(self, event):
-        ind = event.ind
-        if np.size(ind) != 1:
-            return
-        # x = ind // (self.t[-1] + 1)
-        y = ind % (self.t[-1] + 1)
-        yy = self.t1 + y
-
-        if yy < self.orig_shape[1]:
-            if np.all(self.datacopy[:, yy] == self.fill):
-                self.datacopy[:, yy] = np.copy(self.orig_data[:, yy])
-            else:
-                self.datacopy[:, yy] = self.fill
-
-        if self.t2 >= (self.orig_shape[1]):
-            test = self.datacopy[self.z1 : self.z2, self.t1 : self.t2]
-            test = np.append(test, self.missing, axis=1)
-        else:
-            test = self.datacopy[self.z1 : self.z2, self.t1 : self.t2]
-        # self.mesh.set_array(self.datacopy[self.z1 : self.z2, self.t1 : self.t2])
-        self.mesh.set_array(test)
-        self.hline.set_xdata([y, y])
-        self.hslider.set_val(y[0])
-        self.fig.canvas.draw()
-
-    def onclick_cell(self, event):
-        ind = event.ind
-        if np.size(ind) != 1:
-            return
-        x = ind // (self.t[-1] + 1)
-        y = ind % (self.t[-1] + 1)
-        xx = self.z1 + x
-        yy = self.t1 + y
-
-        if yy < self.orig_shape[1]:
-            if self.datacopy[xx, yy] == self.fill:
-                self.datacopy[xx, yy] = np.copy(self.orig_data[x, y])
-            else:
-                self.datacopy[xx, yy] = self.fill
-
-        if self.t2 > (self.orig_shape[1]):
-            test = self.datacopy[self.z1 : self.z2, self.t1 : self.t2]
-            test = np.append(test, self.missing, axis=1)
-        else:
-            test = self.datacopy[self.z1 : self.z2, self.t1 : self.t2]
-
-        # self.mesh.set_array(self.datacopy[self.z1 : self.z2, self.t1 : self.t2])
-        self.mesh.set_array(test)
-        self.vline.set_xdata([y, y])
-        self.hline.set_ydata([x, x])
-        self.hslider.set_val(y[0])
-        self.vslider.set_val(x[0])
-        self.fig.canvas.draw()
-
-    def onclick_box(self, eclick, erelease):
-        self.ax_delete_button.set_visible(True)
-        self.ax_refill_button.set_visible(True)
-        plt.gcf().canvas.draw()
-        self.x11, self.y11 = int(eclick.xdata), int(eclick.ydata)
-        self.x22, self.y22 = int(erelease.xdata) + 1, int(erelease.ydata) + 1
-
-        print(
-            f"({self.x11:3.2f}, {self.y11:3.2f}) --> ({self.x22:3.2f}, {self.y22:3.2f})"
-        )
-        print(f" The buttons you used were: {eclick.button} {erelease.button}")
-
-    def boxdelete(self, event):
-        z1 = self.z1 + self.y11 + 1
-        z2 = self.z1 + self.y22
-        t1 = self.t1 + self.x11 + 1
-        t2 = self.t1 + self.x22
-        self.datacopy[z1:z2, t1:t2] = self.fill
-
-        if self.t2 > (self.orig_shape[1]):
-            test = self.datacopy[self.z1 : self.z2, self.t1 : self.t2]
-            test = np.append(test, self.missing, axis=1)
-        else:
-            test = self.datacopy[self.z1 : self.z2, self.t1 : self.t2]
-
-        # self.mesh.set_array(self.datacopy[self.z1 : self.z2, self.t1 : self.t2])
-        self.mesh.set_array(test)
-        self.fig.canvas.draw()
-
-    def boxrefill(self, event):
-        z1 = self.z1 + self.y11 + 1
-        z2 = self.z1 + self.y22
-        t1 = self.t1 + self.x11 + 1
-        t2 = self.t1 + self.x22
-        self.datacopy[z1:z2, t1:t2] = self.orig_data[z1:z2, t1:t2]
-
-        if self.t2 > (self.orig_shape[1]):
-            test = self.datacopy[self.z1 : self.z2, self.t1 : self.t2]
-            test = np.append(test, self.missing, axis=1)
-        else:
-            test = self.datacopy[self.z1 : self.z2, self.t1 : self.t2]
-        # self.mesh.set_array(self.datacopy[self.z1 : self.z2, self.t1 : self.t2])
-        self.mesh.set_array(test)
-        self.fig.canvas.draw()
-
-    def exit(self, event):
-        plt.close()
-
-    def mask(self):
-        self.maskarray[self.datacopy == self.fill] = 1
-        return self.maskarray
-
-
-# filename = "BGS11000.000"
-# ds = rd.echo(filename, run="fortran")
-# echo = ds[0, :, :]
-# shape = echo.shape
-# mask = np.zeros(shape)
-
-# manual = CutBins(echo, mask)
-# plt.show()
-# mask = manual.mask()
-# plt.pcolormesh(mask)
-# plt.show()

pyadps/utils/regrid.py

@@ -1,279 +0,0 @@
-import numpy as np
-import scipy as sp
-
-# import readrdi as rd
-
-
-def regrid2d(
-    flobj,
-    vlobj,
-    data,
-    fill_value,
-    end_bin_option="cell",
-    trimends=None,
-    method="nearest",
-    orientation="default",
-    boundary_limit=0,
-):
-    """
-    Regrids 2D data onto a new grid based on specified parameters.
-
-    Parameters:
-    -----------
-    flobj : object
-        The fixed leader object that contains information 
-        about the fixed leader data.
-        
-    vlobj : object
-        The variable leader object that contains information 
-        about the variable leader data.
-        
-    data : array-like
-        The 2D data array to be regridded.
-        
-    fill_value : scalar
-        The value used to fill missing or undefined grid points.
-        
-    end_bin_option : str or float, optional, default="cell"
-        The depth of the last bin or boundary for the grid.
-        Options include:
-        - "cell" : Calculates the depth of the default last bin for the grid.
-                   Truncates to surface for upward ADCP.
-        - "surface": The data is gridded till the surface  
-        - "manual": User-defined depth for the grid.
-                      Use boundary_limit option to provide the value. 
-        otherwise, a specific numerical depth value can be provided.
-        
-    trimends : tuple of floats, optional, default=None
-        If provided, defines the ensemble range (start, end) for 
-        calculating the maximum/minimum transducer depth. 
-        Helps avoiding the deployment or retrieval data.
-        E.g. (10, 3000)
-        
-    method : str, optional, default="nearest"
-        The interpolation method to use for regridding based
-        on scipy.interpolate.interp1d. 
-        Options include:
-        - "nearest" : Nearest neighbor interpolation.
-        - "linear" : Linear interpolation.
-        - "cubic" : Cubic interpolation.
-        
-    orientation : str, optional, default="up"
-        Defines the direction of the regridding for an upward/downward looking ADCP. Options include:
-        - "up" : Regrid upwards (for upward-looking ADCP).
-        - "down" : Regrid downwards (for downward-looking ADCP).
-        
-    boundary_limit : float, optional, default=0
-        The limit for the boundary depth. This restricts the grid regridding to depths beyond the specified limit.
-        
-    Returns:
-    --------
-    z: regridded depth
-    regridded_data : array-like
-        The regridded 2D data array, based on the specified method, 
-        orientation, and other parameters.
-    
-    Notes:
-    ------
-    - If `end_bin_option == boundary`, then `boundary_limit` is used to regrid the data.
-    - This function allows for flexible regridding of 2D data to fit a new grid, supporting different interpolation methods.
-    - The `boundary_limit` parameter helps restrict regridding to depths above or below a certain threshold.
-    """
-   
-    # Get values and convert to 'm'
-    bin1dist = flobj.field()["Bin 1 Dist"] / 100
-    transdepth = vlobj.vleader["Depth of Transducer"] / 10
-    depth_interval = flobj.field()["Depth Cell Len"] / 100
-    bins = flobj.field()["Cells"]
-    ensembles = flobj.ensembles
-
-    if orientation.lower() == "default":
-        orientation = flobj.system_configuration()['Beam Direction']
-
-    if orientation.lower() == "up":
-        sgn = -1 
-    else:
-        sgn = 1
-
-    # Create a regular grid
-
-    # Find depth of first cell
-    depth = transdepth + sgn*bin1dist
-
-    # Find the maximum and minimum depth for first cell for upward 
-    # looking ADCP (minimum and maximum for downward looking)
-    if trimends is not None:
-        max_depth = abs(np.min(sgn*depth[trimends[0] : trimends[1]]))
-        min_depth = abs(np.max(sgn*depth[trimends[0] : trimends[1]]))
-    else:
-        max_depth = abs(np.min(sgn*depth))
-        min_depth = abs(np.max(sgn*depth))
-
-    # FIRST CELL
-    # Convert the first cell depth to the first regular grid depth 
-    depthfirstcell = max_depth - max_depth % depth_interval
-
-    # LAST CELL
-    # Convert the last cell depth to last regular grid depth 
-    if end_bin_option.lower() == "surface":
-        # Added one additional negative cell to accomodate 0 m.
-        depthlastcell = sgn * depth_interval
-    elif end_bin_option.lower() == "cell":
-        min_depth_regrid = min_depth - sgn*min_depth % depth_interval
-        depthlastcell = min_depth_regrid  + sgn* (bins+1) * depth_interval
-        # Check if this is required. Use 'surface' option
-        if depthlastcell < 0:
-            depthlastcell = sgn*depth_interval 
-    elif end_bin_option.lower() == "manual":
-        if sgn < 0 and boundary_limit > depthfirstcell:
-            print("ERROR: For upward looking ADCP, boundary limit should be less than transducer depth")
-            return
-        if sgn > 0 and boundary_limit < depthfirstcell:
-            print("ERROR: For downward looking ADCP, boundary limit should be greater than transducer depth")
-            return
-        # Set the last grid cell depth
-        depthlastcell = boundary_limit 
-    else:
-        print("ERROR: `end_bin_option` not recognized.")
-        return
-  
-    # Negative used for upward and positive for downward.
-    z = np.arange(sgn * depthfirstcell, sgn * depthlastcell, depth_interval)
-    regbins = len(z)
-
-    regridded_data = np.zeros((regbins, ensembles))
-
-    # Create original depth array
-    for i, d in enumerate(depth):
-        n = d + sgn*depth_interval * bins
-        # np.arange may include unexpected elements due to floating-point 
-        # precision issues at the stopping point. Changed to np.linspace.
-        #
-        # depth_bins = np.arange(sgn*d, sgn*n, depth_interval)
-        depth_bins = np.linspace(sgn*d, sgn*n, bins)
-        f = sp.interpolate.interp1d(
-            depth_bins,
-            data[:, i],
-            kind=method,
-            fill_value=fill_value,
-            bounds_error=False,
-        )
-        gridz = f(z)
-
-        regridded_data[:, i] = gridz
-
-    return abs(z), regridded_data
-
-
-def regrid3d(
-    flobj,
-    vlobj,
-    data,
-    fill_value,
-    end_bin_option="cell",
-    trimends=None,
-    method="nearest",
-    orientation="up",
-    boundary_limit=0,
-):
-    """
-    Regrids 3D data onto a new grid based on specified parameters.
-
-    Parameters:
-    -----------
-    flobj : object
-        The fixed leader object that contains information 
-        about the fixed leader data.
-        
-    vlobj : object
-        The variable leader object that contains information 
-        about the variable leader data.
-        
-    data : array-like
-        The 3D data array to be regridded, with dimensions 
-        typically representing time, depth, and another axis (e.g., ensembles).
-        
-    fill_value : scalar
-        The value used to fill missing or undefined grid points.
-        
-    end_bin_option : str or float, optional, default="cell"
-        The depth of the last bin or boundary for the grid.
-        Options include:
-        - "cell" : Calculates the depth of the default last bin for the grid.
-                   Truncates to surface for upward ADCP.
-        - "surface" : The data is gridded till the surface.  
-        - "manual" : User-defined depth for the grid.
-                      Use boundary_limit option to provide the value. 
-        Otherwise, a specific numerical depth value can be provided.
-        
-    trimends : tuple of floats, optional, default=None
-        If provided, defines the ensemble range (start, end) for 
-        calculating the maximum/minimum transducer depth. 
-        Helps avoiding the deployment or retrieval data.
-        E.g., (10, 3000)
-        
-    method : str, optional, default="nearest"
-        The interpolation method to use for regridding based
-        on scipy.interpolate.interp1d. 
-        Options include:
-        - "nearest" : Nearest neighbor interpolation.
-        - "linear" : Linear interpolation.
-        - "cubic" : Cubic interpolation.
-        
-    orientation : str, optional, default="up"
-        Defines the direction of the regridding for an upward/downward looking ADCP. Options include:
-        - "up" : Regrid upwards (for upward-looking ADCP).
-        - "down" : Regrid downwards (for downward-looking ADCP).
-        
-    boundary_limit : float, optional, default=0
-        The limit for the boundary depth. This restricts the grid regridding to depths beyond the specified limit.
-        
-    Returns:
-    --------
-    z : array-like
-        The regridded depth array.
-    regridded_data : array-like
-        The regridded 3D data array, based on the specified method, 
-        orientation, and other parameters.
-    
-    Notes:
-    ------
-    - If `end_bin_option == boundary`, then `boundary_limit` is used to regrid the data.
-    - This function allows for flexible regridding of 3D data to fit a new grid, supporting different interpolation methods.
-    - The `boundary_limit` parameter helps restrict regridding to depths above or below a certain threshold.
-    - This function is an extension of 2D regridding to handle the time dimension or other additional axes in the data.
-    """
-
-    beams = flobj.field()["Beams"]
-    z, data_dummy = regrid2d(
-        flobj,
-        vlobj,
-        data[0, :, :],
-        fill_value,
-        end_bin_option=end_bin_option,
-        trimends=trimends,
-        method=method,
-        orientation=orientation,
-        boundary_limit=boundary_limit,
-    )
-
-    newshape = np.shape(data_dummy)
-    regridded_data = np.zeros((beams, newshape[0], newshape[1]))
-    regridded_data[0, :, :] = data_dummy
-
-    for i in range(beams - 1):
-        z, data_dummy = regrid2d(
-            flobj,
-            vlobj,
-            data[i + 1, :, :],
-            fill_value,
-            end_bin_option=end_bin_option,
-            trimends=trimends,
-            method=method,
-            orientation=orientation,
-            boundary_limit=boundary_limit,
-        )
-        regridded_data[i + 1, :, :] = data_dummy
-
-    return z, regridded_data
-