subsurface-terra 2025.1.0rc14__py3-none-any.whl → 2025.1.0rc16__py3-none-any.whl

subsurface/core/geological_formats/boreholes/_combine_trajectories.py

@@ -1,117 +1,117 @@
-import enum
-import numpy as np
-import pandas as pd
-
-from .collars import Collars
-from .survey import Survey
-from ...structs import LineSet
-from ...structs.base_structures import UnstructuredData
-
-
-class MergeOptions(enum.Enum):
-    RAISE = enum.auto()
-    INTERSECT = enum.auto()
-
-
-def create_combined_trajectory(collars: Collars, survey: Survey, merge_option: MergeOptions, slice_: slice):
-    collar_df = _create_collar_df(collars, slice_, survey.well_id_mapper)
-    survey_df_vertex = _create_survey_df(survey)
-
-    if merge_option == MergeOptions.RAISE:
-        raise NotImplementedError("RAISE merge option not implemented")
-        _validate_matching_ids(collar_df, survey_df_vertex)
-    elif merge_option == MergeOptions.INTERSECT:
-        return _Intersect.process_intersection(collar_df, survey_df_vertex, survey)
-    else:
-        raise ValueError("Unsupported merge option")
-
-
-def _create_collar_df(collars, slice_, well_id_mapper: dict ):
-    collar_df = pd.DataFrame(collars.collar_loc.points[slice_], columns=['X', 'Y', 'Z'])
-    selected_collars:list = collars.ids[slice_]
-    collar_df['well_id'] = pd.Series(selected_collars).map(well_id_mapper)
-    return collar_df
-
-
-def _create_survey_df(survey):
-    survey_df_vertex = pd.DataFrame(survey.survey_trajectory.data.vertex, columns=['X', 'Y', 'Z'])
-    vertex_attrs = survey.survey_trajectory.data.points_attributes
-    id_int_vertex = vertex_attrs['well_id']
-    survey_df_vertex['well_id'] = id_int_vertex.map(pd.Series(survey.ids))
-    return survey_df_vertex
-
-
-def _validate_matching_ids(collar_df, survey_df_vertex):
-    missing_from_survey = set(collar_df['well_id']) - set(survey_df_vertex['well_id'])
-    missing_from_collar = set(survey_df_vertex['well_id']) - set(collar_df['well_id'])
-    if missing_from_survey or missing_from_collar:
-        raise ValueError(f"Collars and survey ids do not match. Missing in survey: {missing_from_survey}, Missing in collars: {missing_from_collar}")
-
-
-class _Intersect:
-    """This class is just to create a namespace for the intersection method"""
-    @staticmethod
-    def process_intersection(collar_df: pd.DataFrame, survey_df_vertex: pd.DataFrame, survey: Survey) -> LineSet:
-        
-        combined_df_vertex = pd.merge(
-            left=survey_df_vertex,
-            right=collar_df,
-            how='outer',
-            indicator=True,
-            on='well_id',
-            suffixes=('_collar', '_survey')
-        )
-        combined_df_vertex = combined_df_vertex[combined_df_vertex['_merge'].isin(['left_only', 'both']) ]
-
-        vertex_attrs = survey.survey_trajectory.data.points_attributes
-        if len(combined_df_vertex) != len(vertex_attrs):
-            raise ValueError("Vertex and vertex attributes have different lengths")
-        _Intersect._add_collar_coordinates(combined_df_vertex)
-
-        combined_df_cells = _Intersect._generate_cells(combined_df_vertex, survey)
-        cell_attributes = survey.survey_trajectory.data.cell_attributes
-        if len(combined_df_cells) != len(cell_attributes):
-            raise ValueError("Cells and cell attributes have different lengths")
-
-        line_set: LineSet = _Intersect._create_line_set(combined_df_vertex, combined_df_cells, survey)
-
-        line_set.data.data.attrs.update(survey.survey_trajectory.data.data.attrs)
-        line_set.data.data.attrs.update(collar_df.attrs)
-        
-        return line_set
-
-    @staticmethod
-    def _add_collar_coordinates(combined_df_vertex: pd.DataFrame):
-        combined_df_vertex['X_survey'] += combined_df_vertex['X_collar']
-        combined_df_vertex['Y_survey'] += combined_df_vertex['Y_collar']
-        combined_df_vertex['Z_survey'] += combined_df_vertex['Z_collar']
-
-    @staticmethod
-    def _generate_cells(combined_df_vertex: pd.DataFrame, survey: Survey) -> pd.DataFrame:
-        combined_df_cells = []
-        previous_index = 0
-        for e, well_id in enumerate(survey.ids):
-            df_vertex_well = combined_df_vertex[combined_df_vertex['well_id'] == well_id]
-            indices = np.arange(len(df_vertex_well)) + previous_index
-            previous_index += len(df_vertex_well)
-            cells = np.array([indices[:-1], indices[1:]]).T
-            df_cells_well = pd.DataFrame(cells, columns=['cell1', 'cell2'])
-            df_cells_well['well_id'] = well_id
-            df_cells_well['well_id_int'] = e
-            combined_df_cells.append(df_cells_well)
-
-        return pd.concat(combined_df_cells, ignore_index=True)
-
-    @staticmethod
-    def _create_line_set(combined_df_vertex: pd.DataFrame, combined_df_cells: pd.DataFrame, survey: Survey) -> LineSet:
-        vertex_attrs = survey.survey_trajectory.data.points_attributes
-        cell_attributes = survey.survey_trajectory.data.cell_attributes
-
-        combined_trajectory_unstruct = UnstructuredData.from_array(
-            vertex=combined_df_vertex[['X_survey', 'Y_survey', 'Z_survey']].values,
-            cells=combined_df_cells[['cell1', 'cell2']].values,
-            vertex_attr=vertex_attrs,
-            cells_attr=cell_attributes
-        )
-
-        return LineSet(data=combined_trajectory_unstruct, radius=500)
+import enum
+import numpy as np
+import pandas as pd
+
+from .collars import Collars
+from .survey import Survey
+from ...structs import LineSet
+from ...structs.base_structures import UnstructuredData
+
+
+class MergeOptions(enum.Enum):
+    RAISE = enum.auto()
+    INTERSECT = enum.auto()
+
+
+def create_combined_trajectory(collars: Collars, survey: Survey, merge_option: MergeOptions, slice_: slice):
+    collar_df = _create_collar_df(collars, slice_, survey.well_id_mapper)
+    survey_df_vertex = _create_survey_df(survey)
+
+    if merge_option == MergeOptions.RAISE:
+        raise NotImplementedError("RAISE merge option not implemented")
+        _validate_matching_ids(collar_df, survey_df_vertex)
+    elif merge_option == MergeOptions.INTERSECT:
+        return _Intersect.process_intersection(collar_df, survey_df_vertex, survey)
+    else:
+        raise ValueError("Unsupported merge option")
+
+
+def _create_collar_df(collars, slice_, well_id_mapper: dict ):
+    collar_df = pd.DataFrame(collars.collar_loc.points[slice_], columns=['X', 'Y', 'Z'])
+    selected_collars:list = collars.ids[slice_]
+    collar_df['well_id'] = pd.Series(selected_collars).map(well_id_mapper)
+    return collar_df
+
+
+def _create_survey_df(survey):
+    survey_df_vertex = pd.DataFrame(survey.survey_trajectory.data.vertex, columns=['X', 'Y', 'Z'])
+    vertex_attrs = survey.survey_trajectory.data.points_attributes
+    id_int_vertex = vertex_attrs['well_id']
+    survey_df_vertex['well_id'] = id_int_vertex.map(pd.Series(survey.ids))
+    return survey_df_vertex
+
+
+def _validate_matching_ids(collar_df, survey_df_vertex):
+    missing_from_survey = set(collar_df['well_id']) - set(survey_df_vertex['well_id'])
+    missing_from_collar = set(survey_df_vertex['well_id']) - set(collar_df['well_id'])
+    if missing_from_survey or missing_from_collar:
+        raise ValueError(f"Collars and survey ids do not match. Missing in survey: {missing_from_survey}, Missing in collars: {missing_from_collar}")
+
+
+class _Intersect:
+    """This class is just to create a namespace for the intersection method"""
+    @staticmethod
+    def process_intersection(collar_df: pd.DataFrame, survey_df_vertex: pd.DataFrame, survey: Survey) -> LineSet:
+        
+        combined_df_vertex = pd.merge(
+            left=survey_df_vertex,
+            right=collar_df,
+            how='outer',
+            indicator=True,
+            on='well_id',
+            suffixes=('_collar', '_survey')
+        )
+        combined_df_vertex = combined_df_vertex[combined_df_vertex['_merge'].isin(['left_only', 'both']) ]
+
+        vertex_attrs = survey.survey_trajectory.data.points_attributes
+        if len(combined_df_vertex) != len(vertex_attrs):
+            raise ValueError("Vertex and vertex attributes have different lengths")
+        _Intersect._add_collar_coordinates(combined_df_vertex)
+
+        combined_df_cells = _Intersect._generate_cells(combined_df_vertex, survey)
+        cell_attributes = survey.survey_trajectory.data.cell_attributes
+        if len(combined_df_cells) != len(cell_attributes):
+            raise ValueError("Cells and cell attributes have different lengths")
+
+        line_set: LineSet = _Intersect._create_line_set(combined_df_vertex, combined_df_cells, survey)
+
+        line_set.data.data.attrs.update(survey.survey_trajectory.data.data.attrs)
+        line_set.data.data.attrs.update(collar_df.attrs)
+        
+        return line_set
+
+    @staticmethod
+    def _add_collar_coordinates(combined_df_vertex: pd.DataFrame):
+        combined_df_vertex['X_survey'] += combined_df_vertex['X_collar']
+        combined_df_vertex['Y_survey'] += combined_df_vertex['Y_collar']
+        combined_df_vertex['Z_survey'] += combined_df_vertex['Z_collar']
+
+    @staticmethod
+    def _generate_cells(combined_df_vertex: pd.DataFrame, survey: Survey) -> pd.DataFrame:
+        combined_df_cells = []
+        previous_index = 0
+        for e, well_id in enumerate(survey.ids):
+            df_vertex_well = combined_df_vertex[combined_df_vertex['well_id'] == well_id]
+            indices = np.arange(len(df_vertex_well)) + previous_index
+            previous_index += len(df_vertex_well)
+            cells = np.array([indices[:-1], indices[1:]]).T
+            df_cells_well = pd.DataFrame(cells, columns=['cell1', 'cell2'])
+            df_cells_well['well_id'] = well_id
+            df_cells_well['well_id_int'] = e
+            combined_df_cells.append(df_cells_well)
+
+        return pd.concat(combined_df_cells, ignore_index=True)
+
+    @staticmethod
+    def _create_line_set(combined_df_vertex: pd.DataFrame, combined_df_cells: pd.DataFrame, survey: Survey) -> LineSet:
+        vertex_attrs = survey.survey_trajectory.data.points_attributes
+        cell_attributes = survey.survey_trajectory.data.cell_attributes
+
+        combined_trajectory_unstruct = UnstructuredData.from_array(
+            vertex=combined_df_vertex[['X_survey', 'Y_survey', 'Z_survey']].values,
+            cells=combined_df_cells[['cell1', 'cell2']].values,
+            vertex_attr=vertex_attrs,
+            cells_attr=cell_attributes
+        )
+
+        return LineSet(data=combined_trajectory_unstruct, radius=500)

subsurface/core/geological_formats/boreholes/_map_attrs_to_survey.py

@@ -0,0 +1,236 @@
+import numpy as np
+import pandas as pd
+import xarray as xr
+from typing import Tuple, Optional, Union, List, Any
+
+from subsurface import optional_requirements
+from ...structs.base_structures import UnstructuredData
+from ...structs.base_structures._unstructured_data_constructor import raw_attributes_to_dict_data_arrays
+from ...structs.unstructured_elements import LineSet
+
+
+def combine_survey_and_attrs(attrs: pd.DataFrame, survey_trajectory: LineSet,well_id_mapper: dict[str, int]) -> UnstructuredData:
+    # Import moved to top for clarity and possibly avoiding repeated imports if called multiple times
+
+    # Ensure all columns in lith exist in new_attrs, if not, add them as NaN
+    new_attrs = _map_attrs_to_measured_depths(attrs, survey_trajectory, well_id_mapper)
+
+    # Construct the final xarray dict without intermediate variable
+    points_attributes_xarray_dict: dict[str, xr.DataArray] = raw_attributes_to_dict_data_arrays(
+        default_attributes_name="vertex_attrs",
+        n_items=survey_trajectory.data.data["vertex_attrs"].shape[0],  # TODO: Can I look this on new_attrs to remove line 11?
+        dims=["points", "vertex_attr"],
+        raw_attributes=new_attrs
+    )
+
+    # Inline construction of UnstructuredData
+    return UnstructuredData.from_data_arrays_dict(
+        xarray_dict={
+                "vertex"      : survey_trajectory.data.data["vertex"],
+                "cells"       : survey_trajectory.data.data["cells"],
+                "vertex_attrs": points_attributes_xarray_dict["vertex_attrs"],
+                "cell_attrs"  : survey_trajectory.data.data["cell_attrs"]
+        },
+        xarray_attributes=survey_trajectory.data.data.attrs,
+        default_cells_attributes_name=survey_trajectory.data.cells_attr_name,
+        default_points_attributes_name=survey_trajectory.data.vertex_attr_name
+    )
+
+
+def _prepare_categorical_data(attrs: pd.DataFrame) -> pd.DataFrame:
+    """
+    Prepare categorical data for interpolation by converting categorical columns to numeric IDs.
+
+    Args:
+        attrs: DataFrame containing attribute data
+
+    Returns:
+        Modified DataFrame with categorical data prepared for interpolation
+    """
+    # Create a copy to avoid modifying the original
+    attrs_copy = attrs.copy()
+
+    # If component lith exists but lith_ids doesn't, create lith_ids
+    if 'component lith' in attrs_copy.columns and 'lith_ids' not in attrs_copy.columns:
+        attrs_copy['lith_ids'], _ = pd.factorize(attrs_copy['component lith'], use_na_sentinel=True)
+
+    return attrs_copy
+
+
+def _prepare_new_attributes(attrs: pd.DataFrame, survey_trajectory: LineSet) -> pd.DataFrame:
+    """
+    Prepare the new attributes DataFrame by adding missing columns from attrs.
+
+    Args:
+        attrs: DataFrame containing attribute data
+        survey_trajectory: LineSet containing trajectory data
+
+    Returns:
+        New attributes DataFrame with all necessary columns
+    """
+    # Start with a copy of the existing attributes DataFrame
+    new_attrs = survey_trajectory.data.points_attributes.copy()
+
+    # Add missing columns from attrs, preserving their dtypes
+    for col in attrs.columns.difference(new_attrs.columns):
+        new_attrs[col] = np.nan if pd.api.types.is_numeric_dtype(attrs[col]) else None
+
+    return new_attrs
+
+
+def _get_interpolation_locations(attrs_well: pd.DataFrame, well_name: str) -> np.ndarray:
+    """
+    Determine the locations to use for interpolation based on top and base values.
+
+    Args:
+        attrs_well: DataFrame containing well attribute data
+        well_name: Name of the current well
+
+    Returns:
+        Array of location values to use for interpolation
+    """
+    if "base" not in attrs_well.columns:
+        raise ValueError(f"Base column must be present in the file for well '{well_name}'.")
+    elif "top" not in attrs_well.columns:
+        return attrs_well['base'].values
+    else:
+        return ((attrs_well['top'] + attrs_well['base']) / 2).values
+
+
+def _nearest_neighbor_categorical_interpolation(
+    x_locations: np.ndarray,
+    y_values: np.ndarray,
+    target_depths: np.ndarray
+) -> np.ndarray:
+    """
+    Custom nearest neighbor interpolation for categorical data.
+
+    This function finds the nearest source point for each target point
+    and assigns the corresponding categorical value.
+
+    Args:
+        x_locations: Array of source locations
+        y_values: Array of categorical values at source locations
+        target_depths: Array of target depths for interpolation
+
+    Returns:
+        Array of interpolated categorical values
+    """
+    # Initialize output array with NaN or None values
+    result = np.full(target_depths.shape, np.nan, dtype=object)
+
+    # For each target depth, find the nearest source location
+    for i, depth in enumerate(target_depths):
+        # Calculate distances to all source locations
+        distances = np.abs(x_locations - depth)
+
+        # Find the index of the minimum distance
+        if len(distances) > 0:
+            nearest_idx = np.argmin(distances)
+            result[i] = y_values[nearest_idx]
+
+    return result
+
+
+def _interpolate_attribute(
+    attr_values: pd.Series, 
+    x_locations: np.ndarray, 
+    target_depths: np.ndarray, 
+    column_name: str,
+    is_categorical: bool
+) -> np.ndarray:
+    """
+    Interpolate attribute values to target depths.
+
+    Args:
+        attr_values: Series containing attribute values
+        x_locations: Array of source locations for interpolation
+        target_depths: Array of target depths for interpolation
+        column_name: Name of the column being interpolated
+        is_categorical: Whether the attribute is categorical
+
+    Returns:
+        Array of interpolated values
+    """
+    # For categorical data or specific columns, use custom nearest neighbor interpolation
+    if is_categorical or column_name in ['lith_ids', 'component lith']:
+        return _nearest_neighbor_categorical_interpolation(
+            x_locations=x_locations,
+            y_values=attr_values.values,
+            target_depths=target_depths
+        )
+    else:
+        # For numerical data, use scipy's interp1d with linear interpolation
+        scipy = optional_requirements.require_scipy()
+        interp_func = scipy.interpolate.interp1d(
+            x=x_locations,
+            y=attr_values.values,
+            bounds_error=False,
+            fill_value=np.nan,
+            kind='linear'
+        )
+        return interp_func(target_depths)
+
+
+def _map_attrs_to_measured_depths(attrs: pd.DataFrame, survey_trajectory: LineSet, well_id_mapper: dict[str, int]) -> pd.DataFrame:
+    """
+    Map attributes to measured depths for each well.
+
+    Args:
+        attrs: DataFrame containing attribute data
+        survey_trajectory: LineSet containing trajectory data
+        well_id_mapper: Dictionary mapping well names to IDs
+
+    Returns:
+        DataFrame with attributes mapped to measured depths
+    """
+    # Extract trajectory data
+    trajectory: xr.DataArray = survey_trajectory.data.data["vertex_attrs"]
+    trajectory_well_id: xr.DataArray = trajectory.sel({'vertex_attr': 'well_id'})
+    measured_depths: np.ndarray = trajectory.sel({'vertex_attr': 'measured_depths'}).values.astype(np.float64)
+
+    # Prepare data
+    attrs: pd.DataFrame = _prepare_categorical_data(attrs)
+    new_attrs: pd.DataFrame = _prepare_new_attributes(attrs, survey_trajectory)
+
+    # Process each well
+    for well_name in well_id_mapper:
+        # Skip wells not in the attributes DataFrame
+        if well_name not in attrs.index:
+            print(f"Well '{well_name}' does not exist in the attributes DataFrame.")
+            continue
+
+        # Get well data
+        attrs_well = attrs.loc[[well_name]]
+        well_id = well_id_mapper.get(well_name)
+        well_mask = (trajectory_well_id == well_id).values
+        well_depths = measured_depths[well_mask]
+
+        # Get interpolation locations
+        interp_locations = _get_interpolation_locations(attrs_well, well_name)
+
+        # Interpolate each attribute
+        for col in attrs_well.columns:
+            # Skip location and ID columns
+            if col in ['top', 'base', 'well_id']:
+                continue
+
+            attr_values = attrs_well[col]
+            is_categorical = attr_values.dtype == 'O' or isinstance(attr_values.dtype, pd.CategoricalDtype)
+
+            # Skip columns that can't be interpolated and aren't categorical
+            if is_categorical and col not in ['lith_ids', 'component lith']:
+                continue
+
+            # Interpolate and assign values
+            interpolated_values = _interpolate_attribute(
+                attr_values, 
+                interp_locations, 
+                well_depths, 
+                col,
+                is_categorical
+            )
+
+            new_attrs.loc[well_mask, col] = interpolated_values
+
+    return new_attrs

subsurface/core/geological_formats/boreholes/_survey_to_unstruct.py

@@ -0,0 +1,163 @@
+from typing import Hashable, Optional
+
+import numpy as np
+import pandas as pd
+
+from subsurface import optional_requirements
+from ...structs.base_structures import UnstructuredData
+
+
+def data_frame_to_unstructured_data(survey_df: 'pd.DataFrame', number_nodes: int, attr_df: Optional['pd.DataFrame'] = None,
+                                     duplicate_attr_depths: bool = False) -> UnstructuredData:
+    wp = optional_requirements.require_wellpathpy()
+
+    cum_vertex: np.ndarray = np.empty((0, 3), dtype=np.float32)
+    cells: np.ndarray = np.empty((0, 2), dtype=np.int_)
+    cell_attr: pd.DataFrame = pd.DataFrame(columns=['well_id'], dtype=np.float32)
+    vertex_attr: pd.DataFrame = pd.DataFrame()
+
+    for e, (borehole_id, data) in enumerate(survey_df.groupby(level=0)):
+        dev = wp.deviation(
+            md=data['md'].values,
+            inc=data['inc'].values,
+            azi=data['azi'].values
+        )
+
+        md_min = dev.md.min()
+        md_max = dev.md.max()
+
+        attr_depths = _grab_depths_from_attr(
+            attr_df=attr_df,
+            borehole_id=borehole_id,
+            duplicate_attr_depths=duplicate_attr_depths,
+            md_max=md_max,
+            md_min=md_min
+        )
+
+        # Now combine attr_depths with depths
+        md_min = dev.md.min()
+        md_max = dev.md.max()
+        depths = np.linspace(md_min, md_max, number_nodes)
+        depths = np.union1d(depths, attr_depths)
+        depths.sort()
+
+        # Resample positions at depths
+        pos = dev.minimum_curvature().resample(depths=depths)
+        vertex_count = cum_vertex.shape[0]
+
+        this_well_vertex = np.vstack([pos.easting, pos.northing, pos.depth]).T
+        cum_vertex = np.vstack([cum_vertex, this_well_vertex])
+        measured_depths = _calculate_distances(array_of_vertices=this_well_vertex)
+
+        n_vertex_shift_0 = np.arange(0, len(pos.depth) - 1, dtype=np.int_)
+        n_vertex_shift_1 = np.arange(1, len(pos.depth), dtype=np.int_)
+        cell_per_well = np.vstack([n_vertex_shift_0, n_vertex_shift_1]).T + vertex_count
+        cells = np.vstack([cells, cell_per_well])
+
+        attribute_values = np.isin(depths, attr_depths)
+
+        vertex_attr_per_well = pd.DataFrame({
+                'well_id'        : [e] * len(pos.depth),
+                'measured_depths': measured_depths,
+                'is_attr_point'  : attribute_values,
+        })
+
+        vertex_attr = pd.concat([vertex_attr, vertex_attr_per_well], ignore_index=True)
+
+        # Add the id (e), to cell_attr
+        cell_attr = pd.concat([cell_attr, pd.DataFrame({'well_id': [e] * len(cell_per_well)})], ignore_index=True)
+
+    unstruct = UnstructuredData.from_array(
+        vertex=cum_vertex,
+        cells=cells.astype(int),
+        vertex_attr=vertex_attr.reset_index(drop=True),
+        cells_attr=cell_attr.reset_index(drop=True)
+    )
+
+    unstruct.data.attrs["well_id_mapper"] = {well_id: e for e, well_id in enumerate(survey_df.index.unique(level=0))}
+
+    return unstruct
+
+
+def _grab_depths_from_attr(
+        attr_df: pd.DataFrame,
+        borehole_id: Hashable,
+        duplicate_attr_depths: bool,
+        md_max: float,
+        md_min: float
+) -> np.ndarray:
+    # Initialize attr_depths and attr_labels as empty arrays
+    attr_depths = np.array([], dtype=float)
+    attr_labels = np.array([], dtype='<U4')  # Initialize labels for 'top' and 'base'
+
+    if attr_df is None or ("top" not in attr_df.columns and "base" not in attr_df.columns):
+        return attr_depths
+
+    try:
+        vals = attr_df.loc[borehole_id]
+
+        tops = np.array([], dtype=float)
+        bases = np.array([], dtype=float)
+
+        if 'top' in vals:
+            if isinstance(vals, pd.DataFrame):
+                tops = vals['top'].values.flatten()
+            else:
+                tops = np.array([vals['top']])
+            # Convert to float and remove NaNs
+            tops = tops.astype(float)
+            tops = tops[~np.isnan(tops)]
+            # Clip to within md range
+            tops = tops[(tops >= md_min) & (tops <= md_max)]
+
+        if 'base' in vals:
+            if isinstance(vals, pd.DataFrame):
+                bases = vals['base'].values.flatten()
+            else:
+                bases = np.array([vals['base']])
+            # Convert to float and remove NaNs
+            bases = bases.astype(float)
+            bases = bases[~np.isnan(bases)]
+            # Clip to within md range
+            bases = bases[(bases >= md_min) & (bases <= md_max)]
+
+        # Combine tops and bases into attr_depths with labels
+        attr_depths = np.concatenate((tops, bases))
+        attr_labels = np.array(['top'] * len(tops) + ['base'] * len(bases))
+
+        # Drop duplicates while preserving order
+        _, unique_indices = np.unique(attr_depths, return_index=True)
+        attr_depths = attr_depths[unique_indices]
+        attr_labels = attr_labels[unique_indices]
+
+    except KeyError:
+        # No attributes for this borehole_id or missing columns
+        attr_depths = np.array([], dtype=float)
+        attr_labels = np.array([], dtype='<U4')
+
+    # If duplicate_attr_depths is True, duplicate attr_depths with a tiny offset
+    if duplicate_attr_depths and len(attr_depths) > 0:
+        tiny_offset = (md_max - md_min) * 1e-6  # A tiny fraction of the depth range
+        # Create offsets: +tiny_offset for 'top', -tiny_offset for 'base'
+        offsets = np.where(attr_labels == 'top', tiny_offset, -tiny_offset)
+        duplicated_attr_depths = attr_depths + offsets
+        # Ensure the duplicated depths are within the md range
+        valid_indices = (duplicated_attr_depths >= md_min) & (duplicated_attr_depths <= md_max)
+        duplicated_attr_depths = duplicated_attr_depths[valid_indices]
+        # Original attribute depths
+        original_attr_depths = attr_depths
+        # Combine originals and duplicates
+        attr_depths = np.hstack([original_attr_depths, duplicated_attr_depths])
+
+    return attr_depths
+
+
+def _calculate_distances(array_of_vertices: np.ndarray) -> np.ndarray:
+    # Calculate the differences between consecutive points
+    differences = np.diff(array_of_vertices, axis=0)
+
+    # Calculate the Euclidean distance for each pair of consecutive points
+    distances = np.linalg.norm(differences, axis=1)
+    # Insert a 0 at the beginning to represent the starting point at the surface
+    measured_depths = np.insert(np.cumsum(distances), 0, 0)
+    return measured_depths