Agent handoff 4 / 4 self-contained — no vault access needed

Implement asphalt-edge extraction — new repo

2026-07-10 · for a fresh implementation agent on a machine with repo + Nexus access, without the knowledge vault · all research findings inlined · biggest head start of the four: the road surface is already extracted upstream

Continuation target: new repo that turns the already-extracted road surface (surface point clouds + .ply meshes from iolabs-point-cloud-filtering-surface) into left/right asphalt-edge CAD polylines: boundary of the surface → station-wise edge sampling along the axis → cross-profile multi-signal refinement → smoothing/simplification → XML/DXF export. No ML in v1. German Autobahn edges are mostly curbless: the cue is texture, not height.

Project context (inlined)

Pipeline: LAS highway scans → trajectory → segments along the road axis (numpy .npz; XYZ + intensity + RGB) → per-segment detectors → XML for CAD. Lane markings ship this way already; the outermost detected lane line is a useful sanity bound for your edge.
Your primary input — how the road surface is made (8-step upstream procedure, so you know what you're consuming): RSPD planar-patch detection (Open3D detect_planar_patches; patches ≥10 m², ≤30° from vertical normal) → division into 1×1 m cells (15 m tall) → reject cells with std(z) > 0.02 m or <500 points → optional plane splitting → Delaunay triangulation → mesh culling (high-angle triangles) → mesh extension → point filtering. Output per segment: filtered road-surface point clouds + surface meshes (.ply). Key implication: the surface is a flatness-based selection — it may include flat non-asphalt (compacted gravel, concrete gutters) and exclude rough/worn asphalt.
Data prerequisite: ask Miro to ship 3–5 sample "Abschnitt 1" segments incl. trajectory + surface outputs.

Research findings (inlined — compiled & verified 2026-07-07)

Signal reliability for curbless asphalt-vs-shoulder (the ranking to implement):

Roughness / plane-fit deviation — strongest cue: asphalt is locally planar and smooth; grass/gravel has high surface variation (PDAL covariancefeatures: scattering, surface variation; filters.planefit).
Point density — sampling/returns change at vegetation/gravel boundaries.
Slope / crossfall change — useful at gutters, shoulder drops, embankments; fixed thresholds fail on slopes.
Laser intensity / RGB — supporting only, and strictly local per profile: MLS intensity depends on material and range, incidence angle, sensor, campaign [Schwab & Kolbe 2026]. "This side darker than that side, right here" is safe; a global "asphalt < X" threshold is a trap.
Height step — mostly absent on the Autobahn (no curb); only helps at Rinne/gutter transitions.

Curb-literature lessons [Xu 2016]: single-feature detectors fail on low steps, slopes, occlusions; the robust pattern is a voxel density-gradient candidate search + least-cost-path / continuity refinement (their urban result: 78.6% completeness, 83.3% correctness). Adapt as an asphalt→non-asphalt transition search, not a curb-height search. Reference road-extraction accuracy with skeleton refinement: 67→73% IoU [Wang 2025] — road-region, not edge-specific.

Hard constraints: no global intensity thresholds (verified non-stationarity); never bridge exits/on-ramps — the edge genuinely branches at gore areas, emit an explicit gap; occlusion holes (parked vehicles) must produce flagged gaps or flagged interpolations, never silent straight lines.

Open questions — answered by the day-1 QC experiment: does the upstream surface bleed onto compacted gravel shoulders (flat + smooth, exactly what a flatness filter likes)? Are concrete gutter channels (Rinne) included in the surface — if yes, the asphalt edge is a material boundary inside one smooth surface and local intensity contrast gets promoted to a primary signal.

Artifacts to reuse

Nexus index: https://nexus.iolabs.ch/repository/pypi-private/simple (copy [tool.uv.sources] from 3dai.lanefinder). Flat naming: iolabs-point-cloud-* → import iolabs_point_cloud_*. Update: uv lock --upgrade-package … && uv sync.

Artifact	Use for
`iolabs-point-cloud-filtering-surface` (Nexus)	Your input: road-surface points + `.ply` meshes per segment
`iolabs-point-cloud-segmentation-trajectory` · `iolabs-geometry-geometry` (Nexus)	Segment planes, axis spline, station/offset sampling, perpendicular profiles
PDAL `filters.hexbin` (boundary output) or `alphashape`/CGAL `Alpha_shape_2`	Initial surface outline — don't hand-roll concave hulls
PDAL `filters.covariancefeatures`, `filters.planefit`	Roughness/scattering/density for profile refinement
shapely (`simplify`, linear referencing) · scipy (`savgol_filter`) · sklearn (`RANSACRegressor`)	Polyline post-processing to CAD quality
`iolabs-point-cloud-modelling-export` · `iolabs-geometry-visualization` · `io_orchestrator.ray_step`	XML out (mirror lines schema), QC overlays, pipeline step; `ezdxf` if surveyors want DXF directly

Suggested repo/package: 3dai.iolabs.pointcloud.asphaltedge / iolabs-point-cloud-detection-asphaltedge — confirm remote/org with Miro.

Algorithm to implement

Day-1 QC experiment (before pipeline code): outline the existing road surface on the sample segments (hexbin/alpha-shape) and visually compare against the true edge. Decides how much refinement is needed; answers the gravel-bleed and Rinne questions.
Initial boundary: project surface points to XY, compute the concave boundary; split left/right by side-of-axis.
Station sampling: every 0.5–1.0 m along the axis, intersect the perpendicular with the boundary → initial edge point per side.
Profile refinement: in a ±1–2 m window around each initial edge point, score the strongest combined transition (surface-membership drop + roughness rise + density gradient + slope change + local intensity/RGB contrast); snap the edge to the best offset.
Polyline hygiene: robust outlier rejection on lateral offset vs station → Savitzky-Golay smoothing → shapely.simplify (topology-preserving).
Gaps & ramps: interpolate only short gaps where both ends agree in offset + heading; explicit gaps at ramps/gores.
Export: left/right polylines as XML via modelling-export; optional DXF via ezdxf.

Verification

Visual overlays per segment from day one; then quantitative: hand-digitize the true edge on 2–3 segments, report mean/max lateral deviation (target <10 cm mean on clean stretches) and correct gap behavior at every ramp in the test set.
Invariant test: the outermost detected lane-marking line must always lie inside the asphalt polygon.

References (inlined)

Xu, Wang & Zheng (2016). Road Curb Extraction from Mobile LiDAR Point Clouds. arXiv:1610.04673 (IEEE TGRS)
Schwab & Kolbe (2026). Radiometric fingerprinting of object surfaces using MLS. arXiv:2603.11252
Wang, Ibrahim, Mansoor et al. (2025). Automated Road Extraction and Centreline Fitting in LiDAR. arXiv:2502.07486
Zhao et al. (2024). CurbNet. arXiv:2403.16794 — only its class-imbalance/post-processing ideas apply here
Tooling: CGAL Alpha_shape_2 · PDAL hexbin/covariancefeatures/planefit (pdal.io) · shapely simplify · scipy savgol_filter

Public research briefs: asphalt-edge brief · all 30 sources.

Conventions

UV project, Python ≥3.11, lint/test setup copied from an existing 3dai.iolabs.* repo.
Release = version bump → uv build → publish to Nexus pypi-private → commit tagged with the Jira issue (project AI3D).
No vault on this machine: report findings/decisions back to Miro in your final summary.