brep_kernel/blending/blend/edge/

open.rs

use super::*;

/// How one support-curve crossing at an end corner resolves during surgery.
struct SideCross {
    /// The rim vertex: an existing vertex when the boundary is consumed
    /// (`consumed == true`), else 0 — a fresh vertex is created during resolve.
    vertex: u64,
    /// True when a prior fillet already consumed this whole boundary edge (the
    /// crossing landed at the boundary's far endpoint), so it is deleted and
    /// the transverse curve takes over its role on the prior blend face.
    consumed: bool,
}

/// General OPEN-edge rolling-ball fillet or chamfer: §4.9 march +
/// §6.9 surgery with transverse edges on the two end faces.
pub fn blend_open_edge(
    solid: &BrepSolid,
    edge_id: u64,
    radius: f64,
    chamfer: bool,
    name: Option<&str>,
) -> Result<BrepSolid, String> {
    if !(radius > 0.0) || !radius.is_finite() {
        return Err("blend: radius must be positive".into());
    }
    blend_open_edge_impl(solid, edge_id, &|_| radius, chamfer, name)
}

pub(super) fn blend_open_edge_impl(
    solid: &BrepSolid,
    edge_id: u64,
    radius_at: &dyn Fn(f64) -> f64,
    chamfer: bool,
    name: Option<&str>,
) -> Result<BrepSolid, String> {
    let edge = solid
        .edges
        .iter()
        .find(|edge| edge.id == edge_id)
        .ok_or_else(|| format!("blend: edge {edge_id} not found"))?;
    if edge.start_vertex_id == edge.end_vertex_id {
        return Err("blend: blend_open_edge requires an open edge".into());
    }
    let (first_face, first_loop, first_coedge) = locate_mate(solid, edge_id, None)?;
    let (second_face, second_loop, second_coedge) =
        locate_mate(solid, edge_id, Some((first_face.id, first_loop)))?;
    let mid_radius = radius_at(edge.t0 + (edge.t1 - edge.t0) * 0.5);
    let (rho1, rho2) = signed_radii(
        edge,
        first_face,
        first_coedge,
        second_face,
        second_coedge,
        mid_radius,
    )?;
    let first_mate = BlendMate {
        face: first_face,
        coedge: first_coedge,
        loop_index: first_loop,
        rho: rho1,
    };
    let second_mate = BlendMate {
        face: second_face,
        coedge: second_coedge,
        loop_index: second_loop,
        rho: rho2,
    };
    // End topology: boundary edges of both mates at each end vertex, the
    // single face across the corner, and the support crossings.  When a
    // prior fillet has already consumed one of the end corners, the support
    // crossing can land at the very rim of the marched rows (the prior
    // blend's transverse arc meets our contact line right at its base).
    // March with a growing overshoot until every crossing lands strictly
    // inside the fitted-row domain so the surgery can trim cleanly.
    let debug = std::env::var("BREP_DEBUG_BLEND_MARCH").is_ok();
    if debug {
        let sp = edge.curve.evaluate(edge.t0);
        let ep = edge.curve.evaluate(edge.t1);
        eprintln!(
            "OPEN edge {} v{}->v{} first_face {} second_face {} p0={:?} p1={:?}",
            edge.id,
            edge.start_vertex_id,
            edge.end_vertex_id,
            first_face.id,
            second_face.id,
            sp,
            ep
        );
    }
    let compute = |overshoot_fraction: f64| -> Result<(FittedRows, Vec<EndSurgery>, bool), String> {
        let stations = march_open_stations(
            edge,
            &first_mate,
            &second_mate,
            radius_at,
            overshoot_fraction,
        )?;
        let parameters = station_parameters(&stations);
        let rows = fit_open_rows(&stations, &parameters, chamfer)?;
        let mut ends = Vec::with_capacity(2);
        let mut in_range = true;
        for (vertex, at_start) in [(edge.start_vertex_id, true), (edge.end_vertex_id, false)] {
            let first_edge_id = boundary_edge_at_vertex(solid, first_face, vertex, edge_id)?;
            let second_edge_id = boundary_edge_at_vertex(solid, second_face, vertex, edge_id)?;
            if first_edge_id == second_edge_id {
                return Err("blend: mates share their end boundary edge (unsupported)".into());
            }
            let end_face = end_face_id(
                solid,
                first_face.id,
                second_face.id,
                first_edge_id,
                second_edge_id,
            )?;
            let first_boundary = solid
                .edges
                .iter()
                .find(|candidate| candidate.id == first_edge_id)
                .ok_or("blend: end boundary edge missing")?;
            let second_boundary = solid
                .edges
                .iter()
                .find(|candidate| candidate.id == second_edge_id)
                .ok_or("blend: end boundary edge missing")?;
            let first_boundary_coedge = first_face
                .loops
                .iter()
                .flat_map(|loop_record| &loop_record.coedges)
                .find(|coedge| coedge.edge_id == first_edge_id)
                .ok_or("blend: mate does not use its end boundary edge")?;
            let second_boundary_coedge = second_face
                .loops
                .iter()
                .flat_map(|loop_record| &loop_record.coedges)
                .find(|coedge| coedge.edge_id == second_edge_id)
                .ok_or("blend: mate does not use its end boundary edge")?;
            let (cr_parameter, first_edge_parameter) =
                match support_crossing(&rows.cr, first_boundary, at_start) {
                    Ok((s, t, _)) => (s, t),
                    Err(_) => support_crossing_uv(
                        &rows.cr_pcurve,
                        first_boundary,
                        first_boundary_coedge,
                        at_start,
                    )?,
                };
            let (cs_parameter, second_edge_parameter) =
                match support_crossing(&rows.cs, second_boundary, at_start) {
                    Ok((s, t, _)) => (s, t),
                    Err(_) => support_crossing_uv(
                        &rows.cs_pcurve,
                        second_boundary,
                        second_boundary_coedge,
                        at_start,
                    )?,
                };
            // Crossings must land strictly inside the row domain [0, 1] so
            // the surgery can split the support rows.  The start end sits
            // near 0, the finish end near 1.
            const RIM_MARGIN: f64 = 2.0e-3;
            let side_in_range = if at_start {
                cr_parameter >= RIM_MARGIN && cs_parameter >= RIM_MARGIN
            } else {
                cr_parameter <= 1.0 - RIM_MARGIN && cs_parameter <= 1.0 - RIM_MARGIN
            };
            in_range &= side_in_range;
            let end_record = solid
                .shells
                .iter()
                .flat_map(|shell| &shell.faces)
                .find(|face| face.id == end_face)
                .ok_or("blend: end face missing")?;
            if debug {
                eprintln!(
                    "  [os {overshoot_fraction:.2}] end v{vertex} at_start={at_start} end_face={end_face} first_boundary={first_edge_id}(t={first_edge_parameter:.4}) second_boundary={second_edge_id}(t={second_edge_parameter:.4}) cr={cr_parameter:.4} cs={cs_parameter:.4} in_range={side_in_range}"
                );
            }
            let clamp01 = |value: f64| value.clamp(0.0, 1.0);
            let (transverse, blend_pcurve, end_pcurve) = transverse_curve(
                &rows,
                end_record,
                clamp01(cr_parameter),
                clamp01(cs_parameter),
            )?;
            ends.push(EndSurgery {
                cr_parameter,
                cs_parameter,
                first_edge_id,
                first_edge_parameter,
                second_edge_id,
                second_edge_parameter,
                end_face_id: end_face,
                transverse_curve: transverse,
                transverse_blend_pcurve: blend_pcurve,
                transverse_end_pcurve: end_pcurve,
            });
        }
        Ok((rows, ends, in_range))
    };

    // Retry with a growing overshoot; keep the first attempt whose crossings
    // are all in range, else fall back to the widest march tried.
    let mut chosen: Option<(FittedRows, Vec<EndSurgery>)> = None;
    let mut last_error: Option<String> = None;
    for &overshoot_fraction in &[0.08f64, 0.16, 0.28, 0.45] {
        match compute(overshoot_fraction) {
            Ok((rows, ends, in_range)) => {
                let fallback = chosen.is_none();
                if in_range {
                    chosen = Some((rows, ends));
                    break;
                } else if fallback {
                    chosen = Some((rows, ends));
                }
            }
            Err(error) => last_error = Some(error),
        }
    }
    let (rows, ends) = chosen.ok_or_else(|| {
        last_error.unwrap_or_else(|| "blend: open march failed at every overshoot".into())
    })?;

    build_open_surgery(solid, edge, &first_mate, &second_mate, rows, ends, name)
}

fn build_open_surgery(
    solid: &BrepSolid,
    edge: &EdgeRecord,
    first: &BlendMate,
    second: &BlendMate,
    rows: FittedRows,
    ends: Vec<EndSurgery>,
    name: Option<&str>,
) -> Result<BrepSolid, String> {
    let mut result = solid.clone();
    let mut next_id = solid
        .vertices
        .iter()
        .map(|vertex| vertex.id)
        .chain(solid.edges.iter().map(|edge| edge.id))
        .chain(
            solid
                .shells
                .iter()
                .flat_map(|shell| &shell.faces)
                .flat_map(|face| {
                    face.loops
                        .iter()
                        .map(|loop_record| loop_record.id)
                        .chain(face.loops.iter().flat_map(|loop_record| {
                            loop_record.coedges.iter().map(|coedge| coedge.id)
                        }))
                        .chain(std::iter::once(face.id))
                }),
        )
        .max()
        .unwrap_or(0)
        + 1;
    let mut take_id = || {
        let id = next_id;
        next_id += 1;
        id
    };
    let [start_end, finish_end] = match ends.try_into() {
        Ok(pair) => pair,
        Err(_) => return Err("blend: open surgery needs exactly two ends".into()),
    };
    let start_end: EndSurgery = start_end;
    let finish_end: EndSurgery = finish_end;

    // Trim the support rows to the crossing window.
    let trim_row = |row: &NurbsCurve, a: f64, b: f64| -> Result<NurbsCurve, String> {
        let (_, tail) = row.split(a)?;
        let (middle, _) = tail.split(b)?;
        Ok(middle)
    };
    let cr = trim_row(&rows.cr, start_end.cr_parameter, finish_end.cr_parameter)?;
    let cr_pcurve = trim_row(
        &rows.cr_pcurve,
        start_end.cr_parameter,
        finish_end.cr_parameter,
    )?;
    let cs = trim_row(&rows.cs, start_end.cs_parameter, finish_end.cs_parameter)?;
    let cs_pcurve = trim_row(
        &rows.cs_pcurve,
        start_end.cs_parameter,
        finish_end.cs_parameter,
    )?;

    let cr_domain = cr.domain()?;
    let cs_domain = cs.domain()?;
    let old_start = edge.start_vertex_id;
    let old_finish = edge.end_vertex_id;

    // Classify each of the four support crossings.  A crossing that lands at
    // the FAR endpoint of the boundary edge it meets (the end away from the
    // corner) means a prior fillet already consumed that whole boundary: the
    // new blend reuses the existing vertex there and the boundary edge is
    // deleted (its role is taken over by the new transverse curve on the
    // prior blend face).  An interior crossing is the pristine case — a fresh
    // vertex with the boundary trimmed to it.
    let classify =
        |boundary_id: u64, boundary_param: f64, corner: u64| -> Result<SideCross, String> {
            let boundary = result
                .edges
                .iter()
                .find(|candidate| candidate.id == boundary_id)
                .ok_or("blend: end boundary edge missing during surgery")?;
            let span = (boundary.t1 - boundary.t0).abs().max(1e-12);
            let far_vertex = if boundary.start_vertex_id == corner {
                Some((boundary.end_vertex_id, boundary.t1))
            } else if boundary.end_vertex_id == corner {
                Some((boundary.start_vertex_id, boundary.t0))
            } else {
                None
            };
            if let Some((far_id, far_t)) = far_vertex {
                if (boundary_param - far_t).abs() <= span * 0.02 {
                    // Sanity: the reused vertex must exist.
                    if !result
                        .vertices
                        .iter()
                        .any(|candidate| candidate.id == far_id)
                    {
                        return Err("blend: consumed boundary far vertex missing".into());
                    }
                    return Ok(SideCross {
                        vertex: far_id,
                        consumed: true,
                    });
                }
            }
            Ok(SideCross {
                vertex: 0,
                consumed: false,
            })
        };
    let start_first = classify(
        start_end.first_edge_id,
        start_end.first_edge_parameter,
        old_start,
    )?;
    let start_second = classify(
        start_end.second_edge_id,
        start_end.second_edge_parameter,
        old_start,
    )?;
    let finish_first = classify(
        finish_end.first_edge_id,
        finish_end.first_edge_parameter,
        old_finish,
    )?;
    let finish_second = classify(
        finish_end.second_edge_id,
        finish_end.second_edge_parameter,
        old_finish,
    )?;

    // Resolve the four rim vertices: reuse the existing vertex for a consumed
    // side, else create a fresh vertex at the support-row endpoint.
    let mut resolve = |cross: &SideCross, point: Result<Vec3, String>| -> Result<u64, String> {
        if cross.consumed {
            Ok(cross.vertex)
        } else {
            let id = take_id();
            result.vertices.push(VertexRecord { id, point: point? });
            Ok(id)
        }
    };
    let w1a = resolve(&start_first, cr.evaluate(cr_domain[0]))?;
    let w1b = resolve(&finish_first, cr.evaluate(cr_domain[1]))?;
    let w2a = resolve(&start_second, cs.evaluate(cs_domain[0]))?;
    let w2b = resolve(&finish_second, cs.evaluate(cs_domain[1]))?;

    let cr_edge_id = take_id();
    let cs_edge_id = take_id();
    result.edges.push(EdgeRecord {
        id: cr_edge_id,
        curve: cr.clone(),
        t0: cr_domain[0],
        t1: cr_domain[1],
        start_vertex_id: w1a,
        end_vertex_id: w1b,
        degenerate: false,
        name: None,
    });
    result.edges.push(EdgeRecord {
        id: cs_edge_id,
        curve: cs.clone(),
        t0: cs_domain[0],
        t1: cs_domain[1],
        start_vertex_id: w2a,
        end_vertex_id: w2b,
        degenerate: false,
        name: None,
    });
    let transverse_a_id = take_id();
    let transverse_b_id = take_id();
    let ta_domain = start_end.transverse_curve.domain()?;
    let tb_domain = finish_end.transverse_curve.domain()?;
    result.edges.push(EdgeRecord {
        id: transverse_a_id,
        curve: start_end.transverse_curve.clone(),
        t0: ta_domain[0],
        t1: ta_domain[1],
        start_vertex_id: w1a,
        end_vertex_id: w2a,
        degenerate: false,
        name: None,
    });
    result.edges.push(EdgeRecord {
        id: transverse_b_id,
        curve: finish_end.transverse_curve.clone(),
        t0: tb_domain[0],
        t1: tb_domain[1],
        start_vertex_id: w1b,
        end_vertex_id: w2b,
        degenerate: false,
        name: None,
    });

    // Replace the blended edge in both mates' loops, remembering the
    // traversal senses — the blend face's loop direction is forced by
    // manifold pairing with F1's use of cr.
    let mut first_use_forward = true;
    for (mate, new_edge_id, pcurve_forward, remember) in [
        (first, cr_edge_id, &cr_pcurve, true),
        (second, cs_edge_id, &cs_pcurve, false),
    ] {
        let face = result
            .shells
            .iter_mut()
            .flat_map(|shell| &mut shell.faces)
            .find(|face| face.id == mate.face.id)
            .ok_or("blend: mate face lost during surgery")?;
        let loop_record = &mut face.loops[mate.loop_index];
        let position = loop_record
            .coedges
            .iter()
            .position(|coedge| coedge.edge_id == edge.id)
            .ok_or("blend: edge coedge lost during surgery")?;
        let old_forward = loop_record.coedges[position].forward;
        if remember {
            first_use_forward = old_forward;
        }
        loop_record.coedges[position] = CoedgeRecord {
            id: loop_record.coedges[position].id,
            edge_id: new_edge_id,
            forward: old_forward,
            pcurve: if old_forward {
                pcurve_forward.clone()
            } else {
                pcurve_forward.reversed()?
            },
        };
    }

    // Drop consumed boundary edges from the mate loop they share with the
    // blended edge: the fresh support coedge already begins at the reused far
    // vertex, so removing the fully-covered boundary keeps the loop closed.
    let mut consumed_edges: Vec<u64> = Vec::new();
    for (mate, sides) in [
        (
            first,
            [
                (&start_first, start_end.first_edge_id),
                (&finish_first, finish_end.first_edge_id),
            ],
        ),
        (
            second,
            [
                (&start_second, start_end.second_edge_id),
                (&finish_second, finish_end.second_edge_id),
            ],
        ),
    ] {
        for (cross, boundary_id) in sides {
            if !cross.consumed {
                continue;
            }
            let face = result
                .shells
                .iter_mut()
                .flat_map(|shell| &mut shell.faces)
                .find(|face| face.id == mate.face.id)
                .ok_or("blend: mate face lost during surgery")?;
            face.loops[mate.loop_index]
                .coedges
                .retain(|coedge| coedge.edge_id != boundary_id);
            if !consumed_edges.contains(&boundary_id) {
                consumed_edges.push(boundary_id);
            }
        }
    }

    // Locate the corner junction on each end face BEFORE trimming (the two
    // boundary coedges that meet at the old corner vertex) — edge ids alone
    // are ambiguous on two-coedge cap loops, so the meeting must be at the
    // corner.
    let traversal_vertices = |result: &BrepSolid, coedge: &CoedgeRecord| -> Option<(u64, u64)> {
        let edge = result
            .edges
            .iter()
            .find(|candidate| candidate.id == coedge.edge_id)?;
        Some(if coedge.forward {
            (edge.start_vertex_id, edge.end_vertex_id)
        } else {
            (edge.end_vertex_id, edge.start_vertex_id)
        })
    };
    // (end, transverse_id, corner, first_consumed, second_consumed) -> plan
    let mut end_plans = Vec::with_capacity(2);
    for (end, transverse_id, corner, first_consumed, second_consumed) in [
        (
            &start_end,
            transverse_a_id,
            old_start,
            start_first.consumed,
            start_second.consumed,
        ),
        (
            &finish_end,
            transverse_b_id,
            old_finish,
            finish_first.consumed,
            finish_second.consumed,
        ),
    ] {
        let face = result
            .shells
            .iter()
            .flat_map(|shell| &shell.faces)
            .find(|face| face.id == end.end_face_id)
            .ok_or("blend: end face lost during surgery")?;
        let mut located = None;
        'search: for (loop_index, loop_record) in face.loops.iter().enumerate() {
            let count = loop_record.coedges.len();
            for index in 0..count {
                let this = &loop_record.coedges[index];
                let next = &loop_record.coedges[(index + 1) % count];
                let this_pair = (this.edge_id, next.edge_id);
                let matches_pair = this_pair == (end.first_edge_id, end.second_edge_id)
                    || this_pair == (end.second_edge_id, end.first_edge_id);
                if !matches_pair {
                    continue;
                }
                let Some((_, this_end)) = traversal_vertices(&result, this) else {
                    continue;
                };
                let Some((next_start, _)) = traversal_vertices(&result, next) else {
                    continue;
                };
                if this_end == corner && next_start == corner {
                    // Key on stable coedge ids (not indices) so processing one
                    // end can't invalidate another that shares this face.
                    located = Some((
                        loop_index,
                        this.id,
                        next.id,
                        this.edge_id == end.first_edge_id,
                    ));
                    break 'search;
                }
            }
        }
        let Some((loop_index, x_coedge_id, y_coedge_id, x_is_first)) = located else {
            return Err("blend: end-face corner (adjacent boundary coedges) not found".into());
        };
        end_plans.push((
            end.end_face_id,
            transverse_id,
            end.transverse_end_pcurve.clone(),
            loop_index,
            x_coedge_id,
            y_coedge_id,
            x_is_first,
            first_consumed,
            second_consumed,
        ));
    }

    // Trim the boundary edges at their support crossings (consumed sides are
    // deleted instead of trimmed).
    for (cross, boundary_id, boundary_param, corner, rim) in [
        (
            &start_first,
            start_end.first_edge_id,
            start_end.first_edge_parameter,
            old_start,
            w1a,
        ),
        (
            &start_second,
            start_end.second_edge_id,
            start_end.second_edge_parameter,
            old_start,
            w2a,
        ),
        (
            &finish_first,
            finish_end.first_edge_id,
            finish_end.first_edge_parameter,
            old_finish,
            w1b,
        ),
        (
            &finish_second,
            finish_end.second_edge_id,
            finish_end.second_edge_parameter,
            old_finish,
            w2b,
        ),
    ] {
        if cross.consumed {
            continue;
        }
        trim_edge_at(&mut result, boundary_id, boundary_param, corner, rim)?;
    }

    // Rebuild each end face's corner: drop the consumed boundary coedge(s) and
    // splice in the transverse coedge between the (trimmed) boundaries.
    for (
        end_face,
        transverse_id,
        transverse_end_pcurve,
        loop_index,
        x_coedge_id,
        y_coedge_id,
        x_is_first,
        first_consumed,
        second_consumed,
    ) in end_plans
    {
        let forward = x_is_first;
        let pcurve = if forward {
            transverse_end_pcurve
        } else {
            transverse_end_pcurve.reversed()?
        };
        let x_consumed = if x_is_first {
            first_consumed
        } else {
            second_consumed
        };
        let y_consumed = if x_is_first {
            second_consumed
        } else {
            first_consumed
        };
        let coedge_id = take_id();
        let mut transverse_coedge = Some(CoedgeRecord {
            id: coedge_id,
            edge_id: transverse_id,
            forward,
            pcurve,
        });
        let face = result
            .shells
            .iter_mut()
            .flat_map(|shell| &mut shell.faces)
            .find(|face| face.id == end_face)
            .ok_or("blend: end face lost during surgery")?;
        let loop_record = &mut face.loops[loop_index];
        let count = loop_record.coedges.len();
        // Re-find the corner pair by stable coedge id (indices can shift when a
        // sibling end shares this face).
        let seg_index = loop_record
            .coedges
            .iter()
            .position(|coedge| coedge.id == x_coedge_id)
            .ok_or("blend: end-face corner coedge lost during surgery")?;
        let y_index = (seg_index + 1) % count;
        if loop_record.coedges[y_index].id != y_coedge_id {
            return Err("blend: end-face corner pair no longer adjacent".into());
        }
        let mut rebuilt = Vec::with_capacity(count + 1);
        for index in 0..count {
            if index == seg_index {
                if !x_consumed {
                    rebuilt.push(loop_record.coedges[index].clone());
                }
                rebuilt.push(transverse_coedge.take().expect("transverse spliced once"));
            } else if index == y_index {
                if !y_consumed {
                    rebuilt.push(loop_record.coedges[index].clone());
                }
            } else {
                rebuilt.push(loop_record.coedges[index].clone());
            }
        }
        loop_record.coedges = rebuilt;
    }

    // Blend face: cr fwd -> TB -> cs rev -> TA rev in (t, z) space.
    let mid_u = (cr_domain[0] + cr_domain[1]) * 0.5;
    let blend_normal = raw_normal(&rows.surface, mid_u, 0.0)?;
    let station_uv = cr_pcurve.evaluate(mid_u)?;
    let n1 = raw_normal(&first.face.surface, station_uv.x, station_uv.y)?;
    let out1 = if first.face.same_sense {
        n1
    } else {
        n1.scale(-1.0)
    };
    let same_sense = blend_normal.dot(out1) >= 0.0;
    let loop_id = take_id();
    // Manifold pairing: the blend's use of cr must oppose F1's.
    let blend_cr_forward = !first_use_forward;
    let coedges = if blend_cr_forward {
        vec![
            CoedgeRecord {
                id: take_id(),
                edge_id: cr_edge_id,
                forward: true,
                pcurve: crate::sweep_topology::parameter_line(
                    cr_domain[0],
                    0.0,
                    cr_domain[1],
                    0.0,
                )?,
            },
            CoedgeRecord {
                id: take_id(),
                edge_id: transverse_b_id,
                forward: true,
                pcurve: finish_end.transverse_blend_pcurve.clone(),
            },
            CoedgeRecord {
                id: take_id(),
                edge_id: cs_edge_id,
                forward: false,
                pcurve: cs_blend_pcurve_reversed(&cs_domain)?,
            },
            CoedgeRecord {
                id: take_id(),
                edge_id: transverse_a_id,
                forward: false,
                pcurve: start_end.transverse_blend_pcurve.reversed()?,
            },
        ]
    } else {
        vec![
            CoedgeRecord {
                id: take_id(),
                edge_id: cr_edge_id,
                forward: false,
                pcurve: crate::sweep_topology::parameter_line(
                    cr_domain[1],
                    0.0,
                    cr_domain[0],
                    0.0,
                )?,
            },
            CoedgeRecord {
                id: take_id(),
                edge_id: transverse_a_id,
                forward: true,
                pcurve: start_end.transverse_blend_pcurve.clone(),
            },
            CoedgeRecord {
                id: take_id(),
                edge_id: cs_edge_id,
                forward: true,
                pcurve: crate::sweep_topology::parameter_line(
                    cs_domain[0],
                    1.0,
                    cs_domain[1],
                    1.0,
                )?,
            },
            CoedgeRecord {
                id: take_id(),
                edge_id: transverse_b_id,
                forward: false,
                pcurve: finish_end.transverse_blend_pcurve.reversed()?,
            },
        ]
    };
    let blend_face = FaceRecord {
        id: take_id(),
        surface: rows.surface,
        same_sense,
        loops: vec![LoopRecord {
            id: loop_id,
            coedges,
        }],
        name: name.map(|value| value.to_string()),
    };
    let shell_index = result
        .shells
        .iter()
        .position(|shell| shell.faces.iter().any(|face| face.id == first.face.id))
        .ok_or("blend: mate shell lost during surgery")?;
    result.shells[shell_index].faces.push(blend_face);

    result.edges.retain(|candidate| candidate.id != edge.id);
    // Delete the boundary edges a prior fillet's corner had left behind that
    // this blend fully consumed.
    result
        .edges
        .retain(|candidate| !consumed_edges.contains(&candidate.id));
    // Prune every vertex no longer referenced by any edge (the old corner
    // vertices and any freed by consumed boundaries).
    let used: rustc_hash::FxHashSet<u64> = result
        .edges
        .iter()
        .flat_map(|candidate| [candidate.start_vertex_id, candidate.end_vertex_id])
        .collect();
    result
        .vertices
        .retain(|candidate| used.contains(&candidate.id));
    Ok(result)
}

fn cs_blend_pcurve_reversed(cs_domain: &[f64; 2]) -> Result<NurbsCurve, String> {
    crate::sweep_topology::parameter_line(cs_domain[1], 1.0, cs_domain[0], 1.0)
}