geop_ops_plastic/

lip.rs

//! [`lip`] and [`groove`]: the joint between the two halves of an
//! enclosure — a raised strip along one half's rim, and the recess in the
//! other's that takes it.
//!
//! Both are a band along a chain of the rim face's edges (see
//! [`crate::band`]), swept square off the rim: a lip `width` wide from the
//! edges into the rim and `height` high, joined to the solid; a groove as
//! wide as the lip and a `clearance` more, as deep as the lip is high and
//! a `clearance` more, cut from it. The lip stands flush with the wall the
//! edges are on, so on the edges of a shelled enclosure's rim towards its
//! inside it carries the inner wall on up, and the groove on the mating
//! half takes the inner part of its wall away. The cut reaches past the
//! rim and past the wall into the air, `width` both ways, so that none of
//! its faces lies on a face of the solid.
//!
//! A groove runs along any edges, a lip along straight and circular ones
//! (see [`lip`]); corners between straight edges are mitred, other
//! corners refused, and where the chain runs on smoothly is told by its
//! walls. The rim has to be planar, and every edge of the chain convex:
//! the wall falls away from the rim along it, so the space beside the
//! edge, over the wall, is air.

use geop_core_geometry::contains::surface::surface_could_contain;
use geop_core_geometry::intersection::curve_curve_overlaps_and_crossings;
use geop_core_geometry::nurb_curve::{NurbCurve2D, flatten_point};
use geop_core_geometry::search::{MAX_NODES, min_subdivision_size};
use geop_core_math::{
    geop_error::{GeopError, GeopResult, WithContext},
    primitives::CoordinateSystem,
    scalars::Scalar,
    vector::{Vector2, Vector3},
    with_context,
};
use geop_core_topology::{
    EdgeId, FaceId,
    build::{BodySpec, CoedgeOn, CoedgeSpec},
    contains::face::{PointClassification, face_contains},
};
use geop_lib_booleans::{Reach, combine_tools};
use geop_lib_sweep::{SweepLoop, extrude};
use geop_ops_model::{Combine, Tool};
use geop_ops_model::{NamedModel, Namer, frame_along};

use crate::{
    band::{Chain, Piece},
    common::halfway,
};

/// The chain of `face`'s edges `edges` — or, if none, its one hole — in
/// the plane of the face: its frame, `w` the face's outward normal, and
/// the chain in it, the face on its left. Fails for a face that is not
/// planar, edges that are not one chain along one of its loops, edges that
/// are neither straight nor circular, and edges the solid is not convex
/// along.
pub fn rim_chain(
    part: &NamedModel,
    face: FaceId,
    edges: &[EdgeId],
) -> GeopResult<(CoordinateSystem, Chain)> {
    let model = part.topology();
    let name = |id: geop_ops_model::RefId| part.name_of(id).unwrap_or("?").to_string();
    let solid = part.solid_of_face(face, "a rim is a face of a solid")?;
    let plane = part.plane_of_face(face, "a lip or groove runs along a flat rim")?;
    let faces = model.solid_faces(solid)?;
    let (spec, sources) = model.body_spec(&faces, true)?;
    let f = sources
        .faces
        .iter()
        .position(|&x| x == face)
        .expect("a face of its solid");
    let frame = frame_along(plane.point, &plane.normal)?;
    let loops = spec.faces[f].loops();
    let edge_index = |e: EdgeId| sources.edges.iter().position(|&x| x == e);

    // The loop, and which of its coedges the chain runs along.
    let (lp, picked): (&Vec<CoedgeSpec>, Vec<bool>) = if edges.is_empty() {
        match spec.faces[f].holes.as_slice() {
            [hole] => (hole, vec![true; hole.len()]),
            holes => {
                return Err(GeopError::new(format!(
                    "face {} has {} holes: pick the edges to run along",
                    name(face.into()),
                    holes.len()
                )));
            }
        }
    } else {
        let wanted: Vec<usize> = edges
            .iter()
            .map(|&e| {
                edge_index(e).ok_or_else(|| {
                    GeopError::new(format!(
                        "edge {} is not an edge of face {}",
                        name(e.into()),
                        name(face.into())
                    ))
                })
            })
            .collect::<GeopResult<_>>()?;
        let on = |c: &CoedgeSpec| matches!(c.on, CoedgeOn::Edge(e, _) if wanted.contains(&e));
        let lp = loops.iter().find(|lp| lp.iter().any(on)).ok_or_else(|| {
            GeopError::new(format!(
                "edge {} does not bound face {}",
                name(edges[0].into()),
                name(face.into())
            ))
        })?;
        let picked: Vec<bool> = lp.iter().map(on).collect();
        if picked.iter().filter(|&&p| p).count() != wanted.len() {
            return Err(GeopError::new(format!(
                "the edges picked do not all run along one loop of face {}",
                name(face.into())
            )));
        }
        (lp, picked)
    };
    let n = lp.len();
    let closed = picked.iter().all(|&p| p);
    // An open chain starts after a coedge not picked; and is one run.
    let first = if closed {
        0
    } else {
        (0..n)
            .find(|&k| picked[k] && !picked[(k + n - 1) % n])
            .expect("some picked, some not")
    };
    let run: Vec<usize> = (0..n)
        .map(|i| (first + i) % n)
        .take_while(|&k| picked[k])
        .collect();
    if run.len() != picked.iter().filter(|&&p| p).count() {
        return Err(GeopError::new(format!(
            "the edges picked along face {} are not one chain: they leave gaps",
            name(face.into())
        )));
    }

    // The wall along coedge `k`: the face across its edge from the rim.
    let uses = spec.edge_uses();
    let wall = |k: usize| -> GeopResult<FaceId> {
        let CoedgeOn::Edge(e, _) = lp[k].on else {
            return Err(GeopError::new(format!(
                "face {} has a loop that is a single point",
                name(face.into())
            )));
        };
        let g = uses[e]
            .iter()
            .map(|&(g, ..)| g)
            .find(|&g| g != f)
            .ok_or_else(|| GeopError::new("the edge bounds the rim alone"))?;
        Ok(sources.faces[g])
    };
    // Whether the loop runs on smoothly from coedge `a` into coedge `b`:
    // their walls tangent at the vertex between them. Asked of the faces,
    // whose normals the surfaces state there (see
    // `geop_ops_model::tangent`), not of the edges' tangents, which a
    // traced edge only encloses.
    let smooth = |a: usize, b: usize| -> GeopResult<bool> {
        let (vertex, _) = spec.ends(lp[b].on)?;
        let vertex = sources.vertices[vertex];
        let p = model.normal_at_vertex(wall(a)?, vertex)?;
        let q = model.normal_at_vertex(wall(b)?, vertex)?;
        Ok(p.could_be_parallel(&q) && p.prod_dot(&q).definitely_greater(Scalar::ZERO))
    };
    let to_plane = |p: &Vector3| frame.to_uv(p);
    let mut smooths = Vec::with_capacity(run.len());
    let mut pieces = Vec::with_capacity(run.len());
    let mut joints = Vec::with_capacity(run.len() + 1);
    for &k in &run {
        let CoedgeOn::Edge(e, sense) = lp[k].on else {
            return Err(GeopError::new(format!(
                "face {} has a loop that is a single point",
                name(face.into())
            )));
        };
        let edge_name = name(sources.edges[e].into());
        let curve = sense.orient(&spec.edges[e].curve);
        let center = curve.as_arc()?.map(|arc| to_plane(&arc.circle.center));
        convex_along(&spec, e, f, &curve, &plane.normal)
            .map_err(|err| err.with_context(format!("edge {edge_name} of the rim")))?;
        // Into the plane's `(u, v)`, homogeneous: an affine map.
        let flat = curve
            .control_points
            .iter()
            .map(|cp| flatten_point(cp, frame.origin(), frame.u(), frame.v()))
            .collect();
        let mut curve2 = NurbCurve2D::try_new(curve.degree, flat, curve.knot_vector.clone())?;
        if curve.as_line()?.is_some() {
            // A line, however it was given: the band offsets and mitres it
            // as one.
            curve2 = NurbCurve2D::line(curve2.start()?, curve2.end()?)?;
        }
        let (start, _) = spec.ends(lp[k].on)?;
        joints.push(name(sources.vertices[start].into()));
        smooths.push((closed || k != first) && smooth((k + n - 1) % n, k)?);
        pieces.push(Piece {
            curve: curve2,
            center,
            name: edge_name,
        });
    }
    if !closed {
        let (_, end) = spec.ends(lp[*run.last().unwrap()].on)?;
        joints.push(name(sources.vertices[end].into()));
        // An open chain ends square to its last edge. At a corner of the
        // loop that end lies in the plane of the next edge's wall, along
        // that edge: a face on an edge that already exists. Only where the
        // loop runs on smoothly does it cross the rim cleanly.
        let last = *run.last().unwrap();
        for (before, after, joint) in [
            ((first + n - 1) % n, first, &joints[0]),
            (last, (last + 1) % n, joints.last().unwrap()),
        ] {
            if !smooth(before, after)? {
                return Err(GeopError::new(format!(
                    "the edges picked end at vertex {joint}, a corner of face {}: a lip or groove along part of a loop has to end where the loop runs on smoothly — pick the whole loop, or end the chain at a round",
                    name(face.into())
                )));
            }
        }
    }
    // The pieces have to meet exactly: each starts where the one before
    // ended, as the vertex between them.
    let mut chain = Chain {
        pieces,
        joints,
        smooth: smooths,
        closed,
    };
    stitch(&mut chain)?;
    Ok((frame, chain))
}

/// Makes each piece of `chain` start exactly where the one before ends:
/// both ends were mapped from the same vertex, each by its own control
/// point; the two enclosures of the one point are intersected.
fn stitch(chain: &mut Chain) -> GeopResult<()> {
    let n = chain.pieces.len();
    let count = if chain.closed { n } else { n - 1 };
    for i in 0..count {
        let j = (i + 1) % n;
        let end = *chain.pieces[i].curve.control_points.last().unwrap();
        let start = chain.pieces[j].curve.control_points[0];
        let (a, b) = (end.dehomogenized()?, start.dehomogenized()?);
        if !a.could_be_equal(&b) {
            return Err(GeopError::new(format!(
                "{} does not end where {} starts",
                chain.pieces[i].name, chain.pieces[j].name
            )));
        }
        let at = Vector2::from_array([a[0].intersect(b[0]), a[1].intersect(b[1])]);
        let set = |h: &mut Vector3| *h = at.homogeneous(h[2]);
        set(chain.pieces[i].curve.control_points.last_mut().unwrap());
        set(&mut chain.pieces[j].curve.control_points[0]);
    }
    Ok(())
}

/// Fails unless the solid is convex along edge `e` of the rim face `f`
/// (outward normal `up`), which `curve` runs along the way `f`'s loop
/// does: the other face's outward normal, halfway along, points away from
/// the rim — to the right of the edge, the rim lying on its left.
fn convex_along(
    spec: &BodySpec,
    e: usize,
    f: usize,
    curve: &geop_core_topology::Curve3,
    up: &Vector3,
) -> GeopResult<()> {
    let other = spec.edge_uses()[e]
        .iter()
        .map(|&(g, ..)| g)
        .find(|&g| g != f)
        .ok_or_else(|| GeopError::new("the edge bounds the rim alone"))?;
    let (point, along) = halfway(curve)?;
    let right = along.prod_cross(up);
    let normal = spec.faces[other]
        .surface
        .normal_at(&point, MAX_NODES, min_subdivision_size())?;
    if !normal.prod_dot(&right).definitely_greater(Scalar::ZERO) {
        return Err(GeopError::new(
            "the solid is not convex along it: a lip or groove runs along an edge where the wall falls away from the rim",
        ));
    }
    Ok(())
}

/// Fails unless the band along `chain` reaches no further than `far` into
/// the rim face `face`, the plane `frame` holds it in, without meeting
/// another of its edges: a lip or groove `what` that wide has to stand on
/// the rim. Its far side crossing none of the rim's edges lies inside the
/// rim or out of it all along, and one point of it says which.
fn fits_on_rim(
    part: &NamedModel,
    face: FaceId,
    frame: &CoordinateSystem,
    chain: &Chain,
    far: Scalar,
    what: &str,
) -> GeopResult<()> {
    let model = part.topology();
    let name = |id: geop_ops_model::RefId| part.name_of(id).unwrap_or("?").to_string();
    let refuse = |why: String| {
        GeopError::new(format!(
            "a {what} {:?} wide does not fit on the rim, face {}: {why} — make it narrower than the rim",
            far.to_f64(),
            name(face.into())
        ))
    };
    let far_side = chain.offset(far)?;
    for coedge in model.iterate_face_coedges(face) {
        let edge = model.get_coedge(coedge)?.edge()?;
        let curve = &model.get_edge(edge)?.curve;
        let flat = curve
            .control_points
            .iter()
            .map(|cp| flatten_point(cp, frame.origin(), frame.u(), frame.v()))
            .collect();
        let flat = NurbCurve2D::try_new(curve.degree, flat, curve.knot_vector.clone())?;
        for side in &far_side {
            let (overlaps, crossings) = curve_curve_overlaps_and_crossings(
                side,
                &flat,
                Scalar::ZERO,
                MAX_NODES,
                min_subdivision_size(),
            )?;
            if !(overlaps.is_empty() && crossings.is_empty()) {
                return Err(refuse(format!(
                    "its far side meets the rim's edge {}",
                    name(edge.into())
                )));
            }
        }
    }
    let side = &far_side[0];
    let at = side.evaluate(side.mid_parameter()?)?;
    let point = frame
        .origin()
        .add(&frame.u().prod_scalar(at[0]))
        .add(&frame.v().prod_scalar(at[1]));
    let surface = &model.get_face(face)?.surface;
    let inside = match surface_could_contain(surface, &point, MAX_NODES, min_subdivision_size())? {
        Some((u, v)) => face_contains(
            model,
            face,
            u,
            v,
            MAX_NODES,
            min_subdivision_size(),
            RIM_SEED,
        )?,
        None => PointClassification::Outside,
    };
    if inside != PointClassification::Inside {
        return Err(refuse("its far side lies past the rim's other edge".into()));
    }
    Ok(())
}

/// Seeds the ray directions [`fits_on_rim`] asks the rim with.
const RIM_SEED: u64 = 0x5249_4D00_0000_0001;

/// The sizes of a lip, or of the lip a groove takes.
#[derive(Clone, Copy, Debug)]
pub struct LipSize {
    pub width: Scalar,
    pub height: Scalar,
}

fn check_size(what: &str, value: Scalar) -> GeopResult<()> {
    if !value.definitely_greater(Scalar::ZERO) {
        return Err(GeopError::new(format!(
            "a lip's {what} is more than zero, not {:?}",
            value.to_f64()
        )));
    }
    Ok(())
}

/// Raises a lip along the edges `edges` of the rim face `face` (see the
/// module docs), joined to its solid, for the operation `operation_id`
/// whose names `namer` builds: the result is named `namer`'s root, the
/// lip's faces along an edge `E` `N(E)` (on the wall) and `N(E,far)`
/// (inside the rim), its top `N(end)`.
pub fn lip(
    part: &mut NamedModel,
    namer: &Namer,
    operation_id: &str,
    face: FaceId,
    edges: &[EdgeId],
    size: LipSize,
) -> GeopResult<()> {
    let ctx = with_context!(
        "lip({}, face={face}, edges={edges:?}, {size:?})",
        namer.root()
    );
    check_size("width", size.width).with_context(ctx)?;
    check_size("height", size.height).with_context(ctx)?;
    let target = part
        .solid_name_of_face(face, "a rim is a face of a solid")
        .with_context(ctx)?;
    let (frame, chain) = rim_chain(part, face, edges).with_context(ctx)?;
    // The lip's face along an edge stands flush with the wall, the edge
    // swept up. Along a line or an arc that is the wall's own surface
    // carried on; along any other curve, a traced edge only enclosing
    // where the wall meets the rim, it is a surface a hair off the wall's,
    // which the union cannot join to it.
    if let Some(piece) = chain
        .pieces
        .iter()
        .find(|p| !p.is_straight() && p.center.is_none())
    {
        return Err(GeopError::new(format!(
            "edge {} is neither straight nor circular: a lip stands flush with the wall along it, and its face there would only approximate the wall's surface — a lip runs along straight and circular edges, a groove along any",
            piece.name
        )))
        .with_context(ctx);
    }
    fits_on_rim(part, face, &frame, &chain, size.width, "lip").with_context(ctx)?;
    let loops: Vec<SweepLoop> = chain
        .band(Scalar::ZERO, size.width)
        .with_context(ctx)?
        .into_iter()
        .map(SweepLoop::plain)
        .collect();
    let built = extrude(
        part,
        namer,
        Some(&namer.name(&["tool"])),
        &frame,
        &[Scalar::ZERO, size.height],
        &loops,
    )
    .with_context(ctx)?;
    let tool = Tool::whole(built.solid.expect("extruded as a solid"));
    let combine = Combine::join(target);
    combine_tools(part, namer, operation_id, &[tool], &combine)
        .and_then(Reach::stopped)
        .with_context(ctx)
}

/// Cuts the groove that takes a lip of `size` along the edges `edges` of
/// the rim face `face` (see the module docs), `clearance` wider and deeper,
/// from its solid; named like a [`lip`].
pub fn groove(
    part: &mut NamedModel,
    namer: &Namer,
    operation_id: &str,
    face: FaceId,
    edges: &[EdgeId],
    size: LipSize,
    clearance: Scalar,
) -> GeopResult<()> {
    let ctx = with_context!(
        "groove({}, face={face}, edges={edges:?}, {size:?}, clearance={clearance:?})",
        namer.root()
    );
    check_size("width", size.width).with_context(ctx)?;
    check_size("height", size.height).with_context(ctx)?;
    if clearance.definitely_less(Scalar::ZERO) {
        return Err(GeopError::new(format!(
            "a groove's clearance is not less than zero, not {:?}",
            clearance.to_f64()
        )))
        .with_context(ctx);
    }
    let target = part
        .solid_name_of_face(face, "a rim is a face of a solid")
        .with_context(ctx)?;
    let (frame, chain) = rim_chain(part, face, edges).with_context(ctx)?;
    fits_on_rim(
        part,
        face,
        &frame,
        &chain,
        size.width.add(clearance),
        "groove",
    )
    .with_context(ctx)?;
    // Past the wall into the air, and above the rim, by the lip's width: a
    // free choice, only so no face of the cut lies on one of the solid.
    let air = size.width;
    let loops: Vec<SweepLoop> = chain
        .band(air.neg(), size.width.add(clearance))
        .with_context(ctx)?
        .into_iter()
        .map(SweepLoop::plain)
        .collect();
    let built = extrude(
        part,
        namer,
        Some(&namer.name(&["tool"])),
        &frame,
        &[air, size.height.add(clearance).neg()],
        &loops,
    )
    .with_context(ctx)?;
    let tool = Tool::whole(built.solid.expect("extruded as a solid"));
    let combine = Combine::cut(target);
    combine_tools(part, namer, operation_id, &[tool], &combine)
        .and_then(Reach::stopped)
        .with_context(ctx)
}