Feature/AlongSection Thickness Calculator

map2loop/data_checks.py

@@ -460,7 +460,7 @@ def check_keys(d: dict, parent_key=""):
  "structure": {
  "orientation_type", "dipdir_column", "dip_column",
  "description_column", "bedding_text", "overturned_column", "overturned_text",
- "objectid_column", "desciption_column",
+ "objectid_column", "desciption_column", "interp_source_column"
  },
  "geology": {
  "unitname_column", "alt_unitname_column", "group_column",

map2loop/thickness_calculator.py

@@ -6,7 +6,11 @@
  multiline_to_line,
  find_segment_strike_from_pt,
  set_z_values_from_raster_df,
- value_from_raster
+ value_from_raster,
+ segment_measure_range,
+ clean_line_geometry,
+ nearest_orientation_to_line,
+ iter_line_segments
 )
 from .interpolators import DipDipDirectionInterpolator
 
@@ -15,11 +19,13 @@
 
 # external imports
 from abc import ABC, abstractmethod
-from typing import Optional
+from typing import Optional, List
+from collections import defaultdict
 import scipy.interpolate
 import beartype
 import numpy
 import scipy
+from scipy.spatial import cKDTree
 import pandas
 import geopandas
 import shapely
@@ -775,3 +781,332 @@ def compute(
  self._check_thickness_percentage_calculations(output_units)
 
  return output_units
+
+
+class AlongSection(ThicknessCalculator):
+ """Thickness calculator that estimates true thicknesses along supplied section lines."""
+
+ def __init__(
+ self,
+ sections: geopandas.GeoDataFrame,
+ dtm_data: Optional[gdal.Dataset] = None,
+ bounding_box: Optional[dict] = None,
+ max_line_length: Optional[float] = None,
+ is_strike: Optional[bool] = False,
+ ):
+ super().__init__(dtm_data, bounding_box, max_line_length, is_strike) # initialise base calculator bits
+ self.thickness_calculator_label = "AlongSection" # label used externally to identify this strategy
+ self.sections = (
+ sections.copy() # keep a copy so editing outside does not mutate our internal state
+ if sections is not None
+ else geopandas.GeoDataFrame({"geometry": []}, geometry="geometry") # ensure predictable structure when no sections supplied
+ )
+ self.section_thickness_records: geopandas.GeoDataFrame = geopandas.GeoDataFrame() # populated as GeoDataFrame during compute
+ self.section_intersection_points: dict = {}
+
+ def type(self):
+ """Return the calculator label."""
+ return self.thickness_calculator_label
+
+ @beartype.beartype
+ def compute(
+ self,
+ units: pandas.DataFrame,
+ stratigraphic_order: list,
+ basal_contacts: geopandas.GeoDataFrame,
+ structure_data: pandas.DataFrame,
+ geology_data: geopandas.GeoDataFrame,
+ sampled_contacts: pandas.DataFrame,
+ ) -> pandas.DataFrame:
+ """Estimate unit thicknesses along cross sections.
+
+ Args:
+ units (pandas.DataFrame): Table of stratigraphic units that will be annotated with
+ thickness statistics. Must expose a ``name`` column used to map aggregated
+ thickness values back to each unit.
+ stratigraphic_order (list): Accepted for API compatibility but not used by this
+ calculator. Retained so the method signature matches the other calculators.
+ basal_contacts (geopandas.GeoDataFrame): Unused placeholder maintained for parity
+ with the other calculators.
+ structure_data (pandas.DataFrame): Orientation measurements containing X/Y columns
+ and one dip column (``DIP``, ``dip`` or ``Dip``). A KD-tree is built from these
+ points so each split section segment can grab the nearest dip when converting its
+ length to true thickness.
+ geology_data (geopandas.GeoDataFrame): Mandatory polygon dataset describing map
+ units. Each section is intersected with these polygons to generate unit-aware
+ line segments whose lengths underpin the thickness calculation.
+ sampled_contacts (pandas.DataFrame): Part of the public interface but not used in
+ this implementation.
+
+ Returns:
+ pandas.DataFrame: Copy of ``units`` with three new columns – ``ThicknessMean``,
+ ``ThicknessMedian`` and ``ThicknessStdDev`` – populated from the accumulated segment
+ thickness samples. Units that never receive a measurement retain the sentinel value
+ ``-1`` in each column.
+
+ Workflow:
+ 1. Validate the presence of section geometries, geology polygons, and a recognizable
+ unit-name column. Reproject sections to match the geology CRS when required.
+ 2. Pre-build helpers: a spatial index over geology polygons for fast section/polygon
+ queries, and (if possible) a KD-tree of orientation points so the closest dip to a
+ split segment can be queried in O(log n).
+ 3. For every section, reduce complex/multi-part geometries to a single `LineString`,
+ intersect it with candidate geology polygons, and collect the resulting split line
+ segments along with their length and measure positions along the parent section.
+ 4. Walk the ordered segments and keep those bounded by two distinct neighbouring units
+ (i.e., the segment sits between different units on either side). Fetch the nearest
+ dip (fallback to 90° once if no structures exist), convert the segment length to
+ true thickness using ``length * sin(dip)``, and store the sample plus provenance in
+ ``self.section_thickness_records``.
+ 5. Aggregate all collected samples per unit (mean/median/std) and return the enriched
+ ``units`` table. The helper ``self.section_intersection_points`` captures the raw
+ split segments grouped by section to aid downstream inspection.
+
+ Notes:
+ - ``stratigraphic_order``, ``basal_contacts`` and ``sampled_contacts`` are retained for
+ interface compatibility but do not influence this algorithm.
+ - When no nearby orientation measurements exist, the method emits a single warning and
+ assumes a vertical dip (90°) for affected segments to avoid silently dropping units.
+ - ``self.section_thickness_records`` is materialised as a ``GeoDataFrame`` so the split
+ segments (geometry column) can be visualised directly in notebooks or GIS clients.
+ """
+
+ if self.sections is None or self.sections.empty:
+ logger.warning("AlongSection: No sections provided; skipping thickness calculation.")
+ return units
+
+ if geology_data is None or geology_data.empty:
+ logger.warning(
+ "AlongSection: Geology polygons are required to split sections; skipping thickness calculation."
+ )
+ return units
+ unit_column = "UNITNAME"
+ sections = self.sections.copy()
+ geology = geology_data.copy()
+
+ if geology.crs is not None:
+ if sections.crs is None:
+ sections = sections.set_crs(geology.crs)
+ elif sections.crs != geology.crs:
+ sections = sections.to_crs(geology.crs)
+ elif sections.crs is not None:
+ geology = geology.set_crs(sections.crs)
+
+ try:
+ geology_sindex = geology.sindex
+ except Exception as e:
+ logger.error("Failed to create spatial index for geology data: %s", e, exc_info=True)
+ geology_sindex = None
+
+ sections_bounds = sections.total_bounds
+ geology_bounds = geology.total_bounds
+ if (
+ sections_bounds[2] < geology_bounds[0]
+ or sections_bounds[0] > geology_bounds[2]
+ or sections_bounds[3] < geology_bounds[1]
+ or sections_bounds[1] > geology_bounds[3]
+ ):
+ logger.warning("AlongSection: Sections do not overlap geology extent; skipping thickness calculation.")
+ return units
+
+ if geology_sindex is None:
+ overlaps = False
+ for geom in sections.geometry:
+ if geom is None or geom.is_empty:
+ continue
+ if geology.intersects(geom).any():
+ overlaps = True
+ break
+ if not overlaps:
+ logger.warning("AlongSection: Sections do not overlap geology; skipping thickness calculation.")
+ return units
+ else:
+ overlaps = False
+ for geom in sections.geometry:
+ if geom is None or geom.is_empty:
+ continue
+ candidate_idx = list(geology_sindex.intersection(geom.bounds))
+ if not candidate_idx:
+ continue
+ if geology.iloc[candidate_idx].intersects(geom).any():
+ overlaps = True
+ break
+ if not overlaps:
+ logger.warning("AlongSection: Sections do not overlap geology; skipping thickness calculation.")
+ return units
+
+ dip_column = next((col for col in ("DIP", "dip", "Dip") if col in structure_data.columns), None)
+ orientation_tree = None
+ orientation_dips = None
+ orientation_coords = None
+ if dip_column is not None and {"X", "Y"}.issubset(structure_data.columns):
+ orient_df = structure_data.dropna(subset=["X", "Y", dip_column]).copy()
+ if not orient_df.empty:
+ orient_df["_dip_value"] = pandas.to_numeric(orient_df[dip_column], errors="coerce")
+ orient_df = orient_df.dropna(subset=["_dip_value"])
+ if not orient_df.empty:
+ try:
+ orientation_coords = orient_df[["X", "Y"]].astype(float).to_numpy()
+ except ValueError:
+ logger.debug(
+ "Failed to convert orientation coordinates to float for %d rows. Data quality issue likely. Example rows: %s",
+ len(orient_df),
+ orient_df[["X", "Y"]].head(3).to_dict(orient="records")
+ )
+ orientation_coords = numpy.empty((0, 2))
+ if orientation_coords.size:
+ orientation_dips = orient_df["_dip_value"].astype(float).to_numpy()
+ try:
+ orientation_tree = cKDTree(orientation_coords)
+ except (ValueError, TypeError) as e:
+ logger.error(f"Failed to construct cKDTree for orientation data: {e}")
+ orientation_tree = None
+ default_dip_warning_emitted = False
+
+ units_lookup = dict(zip(units["name"], units.index))
+ thickness_by_unit = {name: [] for name in units_lookup.keys()}
+ thickness_records: List[dict] = []
+ split_segments_by_section: dict = defaultdict(list)
+
+ for section_idx, section_row in sections.iterrows():
+ line = clean_line_geometry(section_row.geometry)
+ if line is None or line.length == 0:
+ continue
+ section_id = section_row.get("ID", section_idx)
+
+ candidate_idx = (
+ list(geology_sindex.intersection(line.bounds))
+ if geology_sindex is not None
+ else list(range(len(geology)))
+ )
+ if not candidate_idx:
+ continue
+
+ split_segments = []
+ for idx in candidate_idx:
+ poly = geology.iloc[idx]
+ polygon_geom = poly.geometry
+ if polygon_geom is None or polygon_geom.is_empty:
+ continue
+ intersection = line.intersection(polygon_geom)
+ if intersection.is_empty:
+ continue
+ for segment in iter_line_segments(intersection):
+ seg_length = segment.length
+ if seg_length <= 0:
+ continue
+ start_measure, end_measure = segment_measure_range(line, segment)
+ segment_record = {
+ "section_id": section_id,
+ "geometry": segment,
+ "unit": poly[unit_column],
+ "length": seg_length,
+ "start_measure": start_measure,
+ "end_measure": end_measure,
+ }
+ split_segments.append(segment_record)
+ split_segments_by_section[section_id].append(segment_record)
+
+ if len(split_segments) < 1:
+ continue
+
+ split_segments.sort(key=lambda item: (item["start_measure"], item["end_measure"]))
+
+ for idx_segment, segment in enumerate(split_segments):
+ prev_unit = split_segments[idx_segment - 1]["unit"] if idx_segment > 0 else None
+ next_unit = (
+ split_segments[idx_segment + 1]["unit"]
+ if idx_segment + 1 < len(split_segments)
+ else None
+ )
+
+ if prev_unit is None or next_unit is None:
+ continue
+ if prev_unit == segment["unit"] or next_unit == segment["unit"]:
+ continue
+ if prev_unit == next_unit:
+ continue
+
+ dip_value, orientation_idx, orientation_distance = nearest_orientation_to_line(
+ orientation_tree, 
+ orientation_dips,
+ orientation_coords,
+ segment["geometry"]
+ )
+ if numpy.isnan(dip_value):
+ dip_value = 90.0
+ orientation_idx = None
+ orientation_distance = None
+ if not default_dip_warning_emitted:
+ logger.warning(
+ "AlongSection: Missing structure measurements near some sections; assuming vertical dip (90°) for those segments."
+ )
+ default_dip_warning_emitted = True
+
+ thickness = segment["length"] * math.sin(math.radians(dip_value))
+ if thickness <= 0:
+ continue
+
+ unit_name = segment["unit"]
+ if unit_name not in thickness_by_unit:
+ thickness_by_unit[unit_name] = []
+ thickness_by_unit[unit_name].append(thickness)
+
+ thickness_records.append(
+ {
+ "section_id": section_id,
+ "unit_id": unit_name,
+ "thickness": thickness,
+ "segment_length": segment["length"],
+ "dip_used_deg": dip_value,
+ "prev_unit": prev_unit,
+ "next_unit": next_unit,
+ "orientation_index": orientation_idx,
+ "orientation_distance": orientation_distance,
+ "geometry": segment["geometry"],
+ }
+ )
+
+ output_units = units.copy()
+ output_units["ThicknessMean"] = -1.0
+ output_units["ThicknessMedian"] = -1.0
+ output_units["ThicknessStdDev"] = -1.0
+
+ for unit_name, values in thickness_by_unit.items():
+ if not values:
+ continue
+ idx = units_lookup.get(unit_name)
+ if idx is None:
+ continue
+ arr = numpy.asarray(values, dtype=numpy.float64)
+ output_units.at[idx, "ThicknessMean"] = float(numpy.nanmean(arr))
+ output_units.at[idx, "ThicknessMedian"] = float(numpy.nanmedian(arr))
+ output_units.at[idx, "ThicknessStdDev"] = float(numpy.nanstd(arr))
+
+ if thickness_records:
+ self.section_thickness_records = geopandas.GeoDataFrame(
+ thickness_records,
+ geometry="geometry",
+ crs=sections.crs,
+ )
+ else:
+ self.section_thickness_records = geopandas.GeoDataFrame(
+ columns=[
+ "section_id",
+ "unit_id",
+ "thickness",
+ "segment_length",
+ "dip_used_deg",
+ "prev_unit",
+ "next_unit",
+ "orientation_index",
+ "orientation_distance",
+ "geometry",
+ ],
+ geometry="geometry",
+ crs=sections.crs,
+ )
+ self.section_intersection_points = dict(split_segments_by_section)
+ self._check_thickness_percentage_calculations(output_units)
+
+ return output_units

map2loop/utils/__init__.py

@@ -15,4 +15,8 @@
  normal_vector_to_dipdirection_dip,
  strike_dip_vector,
  generate_grid,
+ segment_measure_range,
+ clean_line_geometry,
+ nearest_orientation_to_line,
+ iter_line_segments
 )