bedrock-ge 0.2.4__py3-none-any.whl → 0.3.1__py3-none-any.whl

bedrock_ge/gi/ags/transform.py

@@ -1,264 +0,0 @@
-"""Transforms, i.e. maps, AGS data to Bedrock's schema."""
-
-from typing import Dict
-
-import pandas as pd
-import pandera as pa
-from pandera.typing import DataFrame
-from pyproj import CRS
-
-from bedrock_ge.gi.ags.schemas import Ags3HOLE, Ags3SAMP, BaseSAMP
-from bedrock_ge.gi.schemas import BaseInSitu, BaseLocation, BaseSample, Project
-from bedrock_ge.gi.validate import check_foreign_key
-
-
-# What this function really does, is add the CRS and Bedrock columns:
-# - `project_uid`
-# - `location_uid`
-# - `sample_id`
-# - `sample_uid`
-# - `depth_to_`
-# There really isn't any mapping going on here...
-# TODO: Make sure that the name of the function and docstrings reflect this.
-def ags3_db_to_no_gis_brgi_db(
-    ags3_db: Dict[str, pd.DataFrame], crs: CRS
-) -> Dict[str, pd.DataFrame]:
-    """Maps a database with GI data from a single AGS 3 file to a database with Bedrock's schema.
-
-    This function converts an AGS 3 formatted geotechnical database into Bedrock's
-    internal database format, maintaining data relationships and structure. It handles
-    various types of geotechnical data including project information, locations,
-    samples, lab tests, and in-situ measurements.
-
-    The mapping process:
-    1. Project Data: Converts AGS 3 'PROJ' group to Bedrock's 'Project' table
-    2. Location Data: Converts AGS 3 'HOLE' group to Bedrock's 'Location' table
-    3. Sample Data: Converts AGS 3 'SAMP' group to Bedrock's 'Sample' table
-    4. Other Data: Handles lab tests, in-situ measurements, and miscellaneous tables
-
-    Args:
-        ags3_db (Dict[str, pd.DataFrame]): A dictionary containing AGS 3 data tables,
-            where keys are table names and values are pandas DataFrames.
-        crs (CRS): Coordinate Reference System for the project data.
-
-    Returns:
-        Dict[str, pd.DataFrame]: A dictionary containing Bedrock GI database tables,
-            where keys are table names and values are transformed pandas DataFrames.
-
-    Note:
-        The function creates a copy of the input database to avoid modifying the original data.
-        It performs foreign key checks to maintain data integrity during the mapping.
-    """
-    # Make sure that the AGS 3 database is not changed outside this function.
-    ags3_db = ags3_db.copy()
-
-    print("Transforming AGS 3 groups to Bedrock tables...")
-
-    # Instantiate Bedrock dictionary of pd.DataFrames
-    brgi_db = {}
-
-    # Project
-    print("Transforming AGS 3 group 'PROJ' to Bedrock GI 'Project' table...")
-    brgi_db["Project"] = ags_proj_to_brgi_project(ags3_db["PROJ"], crs)
-    project_uid = brgi_db["Project"]["project_uid"].item()
-    del ags3_db["PROJ"]
-
-    # Locations
-    if "HOLE" in ags3_db.keys():
-        print("Transforming AGS 3 group 'HOLE' to Bedrock GI 'Location' table...")
-        brgi_db["Location"] = ags3_hole_to_brgi_location(ags3_db["HOLE"], project_uid)  # type: ignore
-        del ags3_db["HOLE"]
-    else:
-        print(
-            "Your AGS 3 data doesn't contain a HOLE group, i.e. Ground Investigation locations."
-        )
-
-    # Samples
-    if "SAMP" in ags3_db.keys():
-        print("Transforming AGS 3 group 'SAMP' to Bedrock GI 'Sample' table...")
-        check_foreign_key("HOLE_ID", brgi_db["Location"], ags3_db["SAMP"])
-        ags3_db["SAMP"] = generate_sample_ids_for_ags3(ags3_db["SAMP"])  # type: ignore
-        brgi_db["Sample"] = ags3_samp_to_brgi_sample(ags3_db["SAMP"], project_uid)  # type: ignore
-        del ags3_db["SAMP"]
-    else:
-        print("Your AGS 3 data doesn't contain a SAMP group, i.e. samples.")
-
-    # The rest of the tables: 1. Lab Tests 2. In-Situ Measurements 3. Other tables
-    for group, group_df in ags3_db.items():
-        if "SAMP_REF" in ags3_db[group].columns:
-            print(f"Project {project_uid} has lab test data: {group}.")
-            brgi_db[group] = group_df  # type: ignore
-        elif "HOLE_ID" in ags3_db[group].columns:
-            print(
-                f"Transforming AGS 3 group '{group}' to Bedrock GI 'InSitu_{group}' table..."
-            )
-            check_foreign_key("HOLE_ID", brgi_db["Location"], group_df)
-            brgi_db[f"InSitu_{group}"] = ags3_in_situ_to_brgi_in_situ(  # type: ignore
-                group, group_df, project_uid
-            )
-        else:
-            brgi_db[group] = ags3_db[group]  # type: ignore
-
-    print(
-        "Done",
-        "The Bedrock database contains the following tables:",
-        list(brgi_db.keys()),
-        sep="\n",
-        end="\n\n",
-    )
-    return brgi_db  # type: ignore
-
-
-@pa.check_types(lazy=True)
-def ags_proj_to_brgi_project(ags_proj: pd.DataFrame, crs: CRS) -> DataFrame[Project]:
-    """Maps the AGS 3 'PROJ' group to a Bedrock GI 'Project' table.
-
-    Args:
-        ags_proj (pd.DataFrame): The AGS 3 'PROJ' group.
-        crs (CRS): The coordinate reference system of the project.
-
-    Returns:
-        DataFrame[Project]: The Bedrock GI 'Project' table.
-    """
-    if "project_uid" not in ags_proj.columns:
-        ags_proj["project_uid"] = ags_proj["PROJ_ID"]
-
-    ags_proj["crs_wkt"] = crs.to_wkt()
-
-    return ags_proj  # type: ignore
-
-
-@pa.check_types(lazy=True)
-def ags3_hole_to_brgi_location(
-    ags3_hole: DataFrame[Ags3HOLE], project_uid: str
-) -> DataFrame[BaseLocation]:
-    brgi_location = ags3_hole
-    brgi_location["project_uid"] = project_uid
-    brgi_location["location_source_id"] = ags3_hole["HOLE_ID"]
-    brgi_location["location_uid"] = (
-        ags3_hole["HOLE_ID"] + "_" + ags3_hole["project_uid"]
-    )
-    brgi_location["location_type"] = ags3_hole["HOLE_TYPE"]
-    brgi_location["easting"] = ags3_hole["HOLE_NATE"]
-    brgi_location["northing"] = ags3_hole["HOLE_NATN"]
-    brgi_location["ground_level_elevation"] = ags3_hole["HOLE_GL"]
-    brgi_location["depth_to_base"] = ags3_hole["HOLE_FDEP"]
-
-    return ags3_hole  # type: ignore
-
-
-@pa.check_types(lazy=True)
-def ags3_samp_to_brgi_sample(
-    ags3_samp: DataFrame[Ags3SAMP],
-    project_uid: str,
-) -> DataFrame[BaseSample]:
-    brgi_sample = ags3_samp
-    brgi_sample["project_uid"] = project_uid
-    brgi_sample["location_source_id"] = ags3_samp["HOLE_ID"]
-    brgi_sample["location_uid"] = ags3_samp["HOLE_ID"] + "_" + ags3_samp["project_uid"]
-    brgi_sample["sample_source_id"] = ags3_samp["sample_id"]
-    brgi_sample["sample_uid"] = ags3_samp["sample_id"] + "_" + ags3_samp["project_uid"]
-    brgi_sample["depth_to_top"] = ags3_samp["SAMP_TOP"]
-    brgi_sample["depth_to_base"] = ags3_samp["SAMP_BASE"]
-
-    return brgi_sample  # type: ignore
-
-
-@pa.check_types(lazy=True)
-def ags3_in_situ_to_brgi_in_situ(
-    group_name: str, ags3_in_situ: pd.DataFrame, project_uid: str
-) -> DataFrame[BaseInSitu]:
-    """Maps AGS 3 in-situ measurement data to Bedrock's in-situ data schema.
-
-    Args:
-        group_name (str): The AGS 3 group name.
-        ags3_data (pd.DataFrame): The AGS 3 data.
-        project_uid (str): The project uid.
-
-    Returns:
-        DataFrame[BaseInSitu]: The Bedrock in-situ data.
-    """
-    brgi_in_situ = ags3_in_situ
-    brgi_in_situ["project_uid"] = project_uid
-    brgi_in_situ["location_uid"] = ags3_in_situ["HOLE_ID"] + "_" + project_uid
-
-    top_depth = f"{group_name}_TOP"
-    base_depth = f"{group_name}_BASE"
-
-    if group_name == "CDIA":
-        top_depth = "CDIA_CDEP"
-    elif group_name == "FLSH":
-        top_depth = "FLSH_FROM"
-        base_depth = "FLSH_TO"
-    elif group_name == "CORE":
-        base_depth = "CORE_BOT"
-    elif group_name == "HDIA":
-        top_depth = "HDIA_HDEP"
-    elif group_name == "PTIM":
-        top_depth = "PTIM_DEP"
-    elif group_name == "IVAN":
-        top_depth = "IVAN_DPTH"
-    elif group_name == "STCN":
-        top_depth = "STCN_DPTH"
-    elif group_name == "POBS" or group_name == "PREF":
-        top_depth = "PREF_TDEP"
-    elif group_name == "DREM":
-        top_depth = "DREM_DPTH"
-    elif group_name == "PRTD" or group_name == "PRTG" or group_name == "PRTL":
-        top_depth = "PRTD_DPTH"
-    elif group_name == "IPRM":
-        if top_depth not in ags3_in_situ.columns:
-            print(
-                "\n🚨 CAUTION: The IPRM group in this AGS 3 file does not contain a 'IPRM_TOP' heading!",
-                "🚨 CAUTION: Making the 'IPRM_BASE' heading the 'depth_to_top'...",
-                sep="\n",
-                end="\n\n",
-            )
-            top_depth = "IPRM_BASE"
-            base_depth = "None"
-
-    brgi_in_situ["depth_to_top"] = ags3_in_situ[top_depth]
-    brgi_in_situ["depth_to_base"] = ags3_in_situ.get(base_depth)
-
-    return brgi_in_situ  # type: ignore
-
-
-@pa.check_types(lazy=True)
-def generate_sample_ids_for_ags3(
-    ags3_with_samp: DataFrame[BaseSAMP],
-) -> DataFrame[Ags3SAMP]:
-    ags3_with_samp["sample_id"] = (
-        ags3_with_samp["SAMP_REF"].astype(str)
-        + "_"
-        + ags3_with_samp["SAMP_TYPE"].astype(str)
-        + "_"
-        + ags3_with_samp["SAMP_TOP"].astype(str)
-        + "_"
-        + ags3_with_samp["HOLE_ID"].astype(str)
-    )
-    # try:
-    #     # SAMP_REF really should not be able to be null... Right?
-    #     # Maybe SAMP_REF can be null when the
-    #     Ags3SAMP_REF.validate(ags3_samp)
-    #     print(
-    #         "Generating unique sample IDs for AGS 3 data: 'sample_id'='{SAMP_REF}_{HOLE_ID}'"
-    #     )
-    #     ags3_samp["sample_id"] = (
-    #         ags3_samp["SAMP_REF"].astype(str) + "_" + ags3_samp["HOLE_ID"].astype(str)
-    #     )
-    # except pa.errors.SchemaError as exc:
-    #     print(f"🚨 CAUTION: The AGS 3 SAMP group contains rows without SAMP_REF:\n{exc}")
-
-    #     if "non-nullable series 'SAMP_REF'" in str(exc):
-    #         print(
-    #             "\nTo ensure unique sample IDs: 'sample_id'='{SAMP_REF}_{SAMP_TOP}_{HOLE_ID}'\n"
-    #         )
-    #         ags3_samp["sample_id"] = (
-    #             ags3_samp["SAMP_REF"].astype(str)
-    #             + "_"
-    #             + ags3_samp["SAMP_TOP"].astype(str)
-    #             + "_"
-    #             + ags3_samp["HOLE_ID"].astype(str)
-    #         )
-
-    return ags3_with_samp  # type: ignore

bedrock_ge/gi/ags/validate.py

@@ -1,25 +0,0 @@
-import pandas as pd
-
-
-def check_ags_proj_group(ags_proj: pd.DataFrame) -> bool:
-    """Checks if the AGS 3 or AGS 4 PROJ group is correct.
-
-    Args:
-        ags_proj (pd.DataFrame): The DataFrame with the PROJ group.
-
-    Raises:
-        ValueError: If AGS 3 of AGS 4 PROJ group is not correct.
-
-    Returns:
-        bool: Returns True if the AGS 3 or AGS 4 PROJ group is correct.
-    """
-    if len(ags_proj) != 1:
-        raise ValueError("The PROJ group must contain exactly one row.")
-
-    project_id = ags_proj["PROJ_ID"].iloc[0]
-    if not project_id:
-        raise ValueError(
-            'The project ID ("PROJ_ID" in the "PROJ" group) is missing from the AGS data.'
-        )
-
-    return True

bedrock_ge/gi/brgi-schema.json

@@ -1,36 +0,0 @@
-{
-  "Location": {
-    "attributes": {},
-    "geometry_type": "Point / 3D LineString",
-    "children": {
-      "MaterialClassification": {
-        "attributes": {},
-        "geometry_type": "3D LineString"
-      },
-      "SPT": {
-        "attributes": {},
-        "geometry_type": "3D Point"
-      },
-      "RQD": {
-        "attributes": {},
-        "geometry_type": "3D LineString"
-      },
-      "OtherInSituTests": {
-        "attributes": {},
-        "geometry_type": "3D Point or 3D LineString"
-      },
-      "Sample": {
-        "attributes": {},
-        "geometry_type": "3D Point",
-        "children": {
-          "grainSizeDistribution": {},
-          "atterbergLimits": {},
-          "oedometerTest": {},
-          "triaxialTest": {},
-          "unconfinedCompressiveStrength": {},
-          "otherLabTests": {}
-        }
-      }
-    }
-  }
-}

bedrock_ge/gi/concatenate.py

@@ -1,38 +0,0 @@
-from typing import Dict, Union
-
-import geopandas as gpd
-import pandas as pd
-
-
-def concatenate_databases(
-    db1: Dict[str, Union[pd.DataFrame, gpd.GeoDataFrame]],
-    db2: Dict[str, Union[pd.DataFrame, gpd.GeoDataFrame]],
-) -> Dict[str, pd.DataFrame]:
-    """Concatenates two dictionaries of DataFrames into one dict of DataFrames.
-
-    The function concatenates the pandas DataFrames of the second dict of
-    DataFrames to the first dict of DataFrames for the keys they have in common.
-    Keys that are unique to either dictionary will be included in the final
-    concatenated dictionary.
-
-    Args:
-        db1 (Dict[str, pd.DataFrame]): A dictionary of pandas DataFrames, i.e. a database.
-        db2 (Dict[str, pd.DataFrame]): A dictionary of pandas DataFrames, i.e. a database.
-
-    Returns:
-        concatenated_dict (Dict[str, pd.DataFrame]): A dictionary of concatenated pandas DataFrames.
-    """
-    # Create a new dict to store the concatenated dataframes
-    concatenated_dict = {key: df.dropna(axis=1, how="all") for key, df in db1.items()}
-
-    # Iterate over the keys in the second dict
-    for key, df in db2.items():
-        df = df.dropna(axis=1, how="all")
-        # If the key is also in the first dict, concatenate the dataframes
-        if key in db1:
-            concatenated_dict[key] = pd.concat([db1[key], df], ignore_index=True)
-        # If the key is not in the first dict, just add it to the new dict
-        else:
-            concatenated_dict[key] = df
-
-    return concatenated_dict

bedrock_ge/gi/gis_geometry.py

@@ -1,282 +0,0 @@
-from typing import Dict, Tuple, Union
-
-import geopandas as gpd
-import numpy as np
-import pandas as pd
-from pyproj import Transformer
-from pyproj.crs import CRS
-from shapely.geometry import LineString, Point
-
-# TODO: change function type hints, such that pandera checks the dataframes against the Bedrock schemas
-
-
-def calculate_gis_geometry(
-    no_gis_brgi_db: Dict[str, Union[pd.DataFrame, gpd.GeoDataFrame]],
-    verbose: bool = True,
-) -> Dict[str, gpd.GeoDataFrame]:
-    """Calculates GIS geometry for tables in a Bedrock Ground Investigation database.
-
-    This function processes a dictionary of DataFrames containing Ground Investigation (GI) data,
-    adding appropriate GIS geometry to each table. It handles both 2D and 3D geometries,
-    including vertical boreholes and sampling locations.
-
-    Args:
-        no_gis_brgi_db (Dict[str, Union[pd.DataFrame, gpd.GeoDataFrame]]): Dictionary containing
-            the Bedrock GI database tables without GIS geometry. Keys are table names,
-            values are either pandas DataFrames or GeoDataFrames.
-        verbose (bool, optional): Whether to print progress information. Defaults to True.
-
-    Returns:
-        Dict[str, gpd.GeoDataFrame]: Dictionary containing the Bedrock GI database tables
-            with added GIS geometry. All tables are converted to GeoDataFrames with
-            appropriate CRS and geometry columns.
-
-    Raises:
-        ValueError: If the projects in the database use different Coordinate Reference Systems (CRS).
-
-    Note:
-        The function performs the following operations:
-
-        1. Verifies all projects use the same CRS
-        2. Calculates GIS geometry for the 'Location' table
-        3. Creates a 'LonLatHeight' table for 2D visualization
-        4. Processes 'Sample' table if present
-        5. Processes all tables starting with "InSitu_"
-    """
-    # Make sure that the Bedrock database is not changed outside this function.
-    brgi_db = no_gis_brgi_db.copy()
-
-    if verbose:
-        print("Calculating GIS geometry for the Bedrock GI database tables...")
-
-    # Check if all projects have the same CRS
-    if not brgi_db["Project"]["crs_wkt"].nunique() == 1:
-        raise ValueError(
-            "All projects must have the same CRS (Coordinate Reference System).\n"
-            "Raise an issue on GitHub in case you need to be able to combine GI data that was acquired in multiple different CRS's."
-        )
-
-    crs = CRS.from_wkt(brgi_db["Project"]["crs_wkt"].iloc[0])
-
-    # Calculate GIS geometry for the 'Location' table
-    if verbose:
-        print("Calculating GIS geometry for the Bedrock GI 'Location' table...")
-    brgi_db["Location"] = calculate_location_gis_geometry(brgi_db["Location"], crs)
-
-    # Create the 'LonLatHeight' table.
-    # The 'LonLatHeight' table makes it easier to visualize the GIS geometry on 2D maps,
-    # because vertical lines are often very small or completely hidden in 2D.
-    # This table only contains the 3D of the GI locations at ground level,
-    # in WGS84 (Longitude, Latitude, Height) coordinates.
-    if verbose:
-        print(
-            "Creating 'LonLatHeight' table with GI locations in WGS84 geodetic coordinates...",
-            "    WGS84 geodetic coordinates: (Longitude, Latitude, Ground Level Ellipsoidal Height)",
-            sep="\n",
-        )
-    brgi_db["LonLatHeight"] = create_lon_lat_height_table(brgi_db["Location"], crs)
-
-    # Create GIS geometry for tables that have In-Situ GIS geometry.
-    # These are the 'Sample' table and 'InSitu_...' tables.
-    # These tables are children of the Location table,
-    # i.e. have the 'Location' table as the parent table.
-    if "Sample" in brgi_db.keys():
-        if verbose:
-            print("Calculating GIS geometry for the Bedrock GI 'Sample' table...")
-        brgi_db["Sample"] = calculate_in_situ_gis_geometry(
-            brgi_db["Sample"], brgi_db["Location"], crs
-        )
-
-    for table_name, table in brgi_db.items():
-        if table_name.startswith("InSitu_"):
-            if verbose:
-                print(
-                    f"Calculating GIS geometry for the Bedrock GI '{table_name}' table..."
-                )
-            brgi_db[table_name] = calculate_in_situ_gis_geometry(
-                table, brgi_db["Location"], crs
-            )
-
-    return brgi_db
-
-
-def calculate_location_gis_geometry(
-    brgi_location: Union[pd.DataFrame, gpd.GeoDataFrame], crs: CRS
-) -> gpd.GeoDataFrame:
-    """Calculates GIS geometry for a set of Ground Investigation locations.
-
-    Args:
-        brgi_location (Union[pd.DataFrame, gpd.GeoDataFrame]): The GI locations to calculate GIS geometry for.
-        crs (pyproj.CRS): The Coordinate Reference System (CRS) to use for the GIS geometry.
-
-    Returns:
-        gpd.GeoDataFrame: The GIS geometry for the given GI locations, with additional columns:
-            - longitude: The longitude of the location in the WGS84 CRS.
-            - latitude: The latitude of the location in the WGS84 CRS.
-            - wgs84_ground_level_height: The height of the ground level of the location in the WGS84 CRS.
-            - elevation_at_base: The elevation at the base of the location.
-            - geometry: The GIS geometry of the location.
-    """
-    # Calculate Elevation at base of GI location
-    brgi_location["elevation_at_base"] = (
-        brgi_location["ground_level_elevation"] - brgi_location["depth_to_base"]
-    )
-
-    # Make a gpd.GeoDataFrame from the pd.DataFrame by creating GIS geometry
-    brgi_location = gpd.GeoDataFrame(
-        brgi_location,
-        geometry=brgi_location.apply(
-            lambda row: LineString(
-                [
-                    (row["easting"], row["northing"], row["ground_level_elevation"]),
-                    (row["easting"], row["northing"], row["elevation_at_base"]),
-                ]
-            ),
-            axis=1,
-        ),
-        crs=crs,
-    )
-
-    # Calculate WGS84 geodetic coordinates
-    brgi_location[["longitude", "latitude", "wgs84_ground_level_height"]] = (
-        brgi_location.apply(
-            lambda row: calculate_wgs84_coordinates(
-                from_crs=crs,
-                easting=row["easting"],
-                northing=row["northing"],
-                elevation=row["ground_level_elevation"],
-            ),
-            axis=1,
-            result_type="expand",
-        )
-    )
-
-    return brgi_location
-
-
-def calculate_wgs84_coordinates(
-    from_crs: CRS, easting: float, northing: float, elevation: Union[float, None] = None
-) -> Tuple[float, float, (float | None)]:
-    """Transforms coordinates from an arbitrary Coordinate Reference System (CRS) to the WGS84 CRS, which is the standard for geodetic coordinates.
-
-    Args:
-        from_crs (pyproj.CRS): The pyproj.CRS object of the CRS to transform from.
-        easting (float): The easting coordinate of the point to transform.
-        northing (float): The northing coordinate of the point to transform.
-        elevation (float or None, optional): The elevation of the point to
-            transform. Defaults to None.
-
-    Returns:
-        Tuple[float, float, (float | None)]: A tuple containing the longitude, latitude
-            and WGS84 height of the transformed point, in that order.
-            The height is None if no elevation was given, or if the provided CRS doesn't
-            have a proper datum defined.
-    """
-    transformer = Transformer.from_crs(from_crs, 4326, always_xy=True)
-    if elevation:
-        lon, lat, wgs84_height = transformer.transform(easting, northing, elevation)
-    else:
-        lon, lat = transformer.transform(easting, northing)
-        wgs84_height = None
-
-    return (lon, lat, wgs84_height)
-
-
-def create_lon_lat_height_table(
-    brgi_location: gpd.GeoDataFrame, crs: CRS
-) -> gpd.GeoDataFrame:
-    """Creates a GeoDataFrame with GI locations in WGS84 (lon, lat, height) coordinates.
-
-    The 'LonLatHeight' table makes it easier to visualize the GIS geometry on 2D maps,
-    because vertical lines are often very small or completely hidden in 2D. This table
-    only contains the 3D point of the GI locations at ground level, in WGS84 (Longitude,
-    Latitude, Height) coordinates. Other attributes, such as the location type, sample
-    type, geology description, etc., can be attached to this table by joining, i.e.
-    merging those tables on the location_uid key.
-
-    Args:
-        brgi_location (GeoDataFrame): The GeoDataFrame with the GI locations.
-        crs (CRS): The Coordinate Reference System of the GI locations.
-
-    Returns:
-        gpd.GeoDataFrame: The 'LonLatHeight' GeoDataFrame.
-    """
-    lon_lat_height = gpd.GeoDataFrame(
-        brgi_location[
-            [
-                "project_uid",
-                "location_uid",
-            ]
-        ],
-        geometry=brgi_location.apply(
-            lambda row: Point(
-                row["longitude"], row["latitude"], row["wgs84_ground_level_height"]
-            ),
-            axis=1,
-        ),
-        crs=4326,
-    )
-    return lon_lat_height
-
-
-def calculate_in_situ_gis_geometry(
-    brgi_in_situ: Union[pd.DataFrame, gpd.GeoDataFrame],
-    brgi_location: Union[pd.DataFrame, gpd.GeoDataFrame],
-    crs: CRS,
-) -> gpd.GeoDataFrame:
-    """Calculates GIS geometry for a set of Ground Investigation in-situ data.
-
-    Args:
-        brgi_in_situ (Union[pd.DataFrame, gpd.GeoDataFrame]): The in-situ data to calculate GIS geometry for.
-        brgi_location (Union[pd.DataFrame, gpd.GeoDataFrame]): The location data to merge with the in-situ data.
-        crs (CRS): The Coordinate Reference System of the in-situ data.
-
-    Returns:
-        gpd.GeoDataFrame: The GIS geometry for the given in-situ data, with additional columns:
-            - elevation_at_top: The elevation at the top of the in-situ data.
-            - elevation_at_base: The elevation at the base of the in-situ data.
-            - geometry: The GIS geometry of the in-situ data.
-    """
-    location_child = brgi_in_situ.copy()
-
-    # Merge the location data into the in-situ data to get the location coordinates
-    location_child = pd.merge(
-        location_child,
-        brgi_location[
-            ["location_uid", "easting", "northing", "ground_level_elevation"]
-        ],
-        on="location_uid",
-        how="left",
-    )
-
-    # Calculate the elevation at the top of the Sample or in-situ test
-    location_child["elevation_at_top"] = (
-        location_child["ground_level_elevation"] - location_child["depth_to_top"]
-    )
-    brgi_in_situ["elevation_at_top"] = location_child["elevation_at_top"]
-
-    # Calculate the elevation at the base of the Sample or in-situ test
-    if "depth_to_base" in location_child.columns:
-        location_child["elevation_at_base"] = (
-            location_child["ground_level_elevation"] - location_child["depth_to_base"]
-        )
-        brgi_in_situ["elevation_at_base"] = location_child["elevation_at_base"]
-
-    # Create the in-situ data as a GeoDataFrame with LineString GIS geometry for
-    # Samples or in-situ tests that have an elevation at the base of the Sample or in-situ test.
-    brgi_in_situ = gpd.GeoDataFrame(
-        brgi_in_situ,
-        geometry=location_child.apply(
-            lambda row: LineString(
-                [
-                    (row["easting"], row["northing"], row["elevation_at_top"]),
-                    (row["easting"], row["northing"], row["elevation_at_base"]),
-                ]
-            )
-            if "elevation_at_base" in row and not np.isnan(row["elevation_at_base"])
-            else Point((row["easting"], row["northing"], row["elevation_at_top"])),
-            axis=1,
-        ),
-        crs=crs,
-    )
-    return brgi_in_situ

bedrock_ge-0.2.4.dist-info/RECORD

@@ -1,21 +0,0 @@
-bedrock_ge/__init__.py,sha256=9zw1B8qBymbOqc4p2OJ3e8chmXEihHSBt1Fs1BtnvkQ,89
-bedrock_ge/plot.py,sha256=C95aj8CXjFVZRGYYBssJMm5MyljLbdt_TKyvmQyWZBE,149
-bedrock_ge/gi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bedrock_ge/gi/brgi-schema.json,sha256=XaumYqouiflu4Nc8ChyFSHpmpJW4YPG0hsyeSxkuIWQ,850
-bedrock_ge/gi/concatenate.py,sha256=ewPXau86yDTGE92DlbNlQ7gprBHkqBottzHsPbXbEg0,1519
-bedrock_ge/gi/gis_geometry.py,sha256=QXNjWIGANh_M035Lbc94eOZnNry9f778E8wg_7KgAQo,11669
-bedrock_ge/gi/schemas.py,sha256=ZA2wFQOevXtN57XglY-M70TzbZY2RyLHJDRUkmz47_M,2871
-bedrock_ge/gi/sqlmodels.py,sha256=_h3H9UP91I_1Ya_SZuL6gZbqL7uNCd5Y-u-yTf7CNto,2253
-bedrock_ge/gi/validate.py,sha256=riUa9AaHngJDX0VtUrOEKKfr-sZxybrGqJFmq4kRFnA,7080
-bedrock_ge/gi/write.py,sha256=eCfijylreJ5oNMJqqx_k-Y30FNIHys2NccHilrFm0X4,4319
-bedrock_ge/gi/ags/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bedrock_ge/gi/ags/ags3_data_dictionary.json,sha256=Wx20_oJRdAlzEo-cKD6FgN9B9zOMDTcsp5dgc8QWofI,188588
-bedrock_ge/gi/ags/ags4_data_dictionary.json,sha256=XE5XJNo8GBPZTUPgvVr3QgO1UfEIAxzlSeXi-P1VLTs,609670
-bedrock_ge/gi/ags/read.py,sha256=FCeMX1R7IGcZY0heqrHPzs13rytelkmmFaJRklPB7EM,7114
-bedrock_ge/gi/ags/schemas.py,sha256=y36n9SCKqFfoIQ_7-MTEdfArA5vAqZdRpY3wC4fdjy4,7451
-bedrock_ge/gi/ags/transform.py,sha256=NeeR6e3awDf3ITWSxAUW1bXspUXaj-dM7xi1g-Ppxhc,9988
-bedrock_ge/gi/ags/validate.py,sha256=ZfBS7AP_CTguLQCbGeyy4Krz32th2yCmtdG9rvX0MOU,703
-bedrock_ge-0.2.4.dist-info/METADATA,sha256=T2dwdFOQ2OLLEN_vNY_HQ_UVfX_iq1ATlbgDLVmXk7E,11727
-bedrock_ge-0.2.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-bedrock_ge-0.2.4.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-bedrock_ge-0.2.4.dist-info/RECORD,,