GitCorner

Code

ossartcraftcadcraft🌐
a770fa5a5e5f
//! HATCH, GRADIENT, BOUNDARY, REGION: boundaries from pick points or selected closed objects.

mod patfile;
pub(super) use edit::{set_pattern, takes_pattern};
pub(super) use patfile::run_patterns;
pub use patfile::{PatternChoice, pattern_choices};

use cadcraft_color::Color;
use cadcraft_doc::{Drawing, Entity, EntityKind, Gradient, Handle, Hatch, HatchLoop, Space, entity_bounds};
use cadcraft_geom::{Bounds2, PolyVertex, Polyline, Vec2, point_in_polygon};
use serde_json::{Value, json};

use super::helpers::lwpoly;
use super::machines::SelectRun;
use super::{CommandSpec, bad, bool_or, f64_or, point_param, points_param, size_param, str_param, targets};

use crate::{Accept, EngineError, Input, Interactive, Picker, Prompt, Result, Session, Step};

mod assoc;
pub(crate) use assoc::detach;
mod edit;
mod pick;
use super::has_doc;
pub(crate) use assoc::update as refill_associative;
pub use pick::{HatchPicks, PickMode};

pub fn specs() -> Vec<CommandSpec> {
    vec![
        CommandSpec::new("hatch", "Hatch...", run_hatch).menu(&["Draw", "Hatch..."]).alias(&["h", "bh", "-hatch"]).params("{points?: [[x,y]] (internal points) and/or handles?: [hex] (closed objects), pattern?: \"ANSI31\" (built in, or defined by patternFile | patternText), patternFile?: path to a .pat file | patternText?: its contents (loads the patterns it defines), scale?, angle? (degrees), associative? (HPASSOC), separate? (HPSEPARATE: a hatch per point/object), origin?: [x,y] (HPORIGIN) | originMode?: \"current\"|\"bottomLeft\"|\"bottomRight\"|\"topLeft\"|\"topRight\"|\"center\" (HPORIGINMODE), style?: \"normal\"|\"outer\"|\"ignore\" (HPISLANDDETECTION)} — gaps up to HPGAPTOL close").interactive(|s| Ok(Box::new(HatchM::new(s, false)))),
        CommandSpec::new("gradient", "Gradient...", run_gradient).menu(&["Draw", "Gradient..."]).alias(&["gd"]).params("{points? and/or handles?, name?: \"LINEAR\"|\"CYLINDER\"|\"CURVED\"|\"SPHERICAL\"|\"HEMISPHERICAL\" or INV… (colours swapped), color1?, color2?, angle? (degrees), centered? (default true)}").interactive(|s| Ok(Box::new(HatchM::new(s, true)))),
        CommandSpec::new("boundary", "Boundary...", run_boundary).menu(&["Draw", "Boundary..."]).alias(&["bo", "bpoly"]).params("{points: [[x,y]]}").interactive(|_| Ok(Box::new(BoundaryM { region: false }))),
        CommandSpec::new("region", "Region", run_region)
            .menu(&["Draw", "Region"])
            .alias(&["reg"])
            .params("{handles?}")
            // Typed with nothing selected it asks for objects, as in AutoCAD, rather than converting none.
            .interactive(|_| Ok(Box::new(SelectRun::new("region", "REGION")))),
        CommandSpec::new("hatchedit", "Hatch Edit", edit::run_hatchedit).menu(&["Modify", "Object", "Hatch..."]).alias(&["he", "-hatchedit"]).params("{handles?, pattern?, scale?, angle?, gradient?: {name?, color1?, color2?, angle? (degrees), centered?} (makes or changes a gradient fill; `pattern` turns it back), associative?: bool (false unlinks; true links each loop to a closed object of the same shape, or to `boundary` objects), boundary?: [hex], addPoints?: [[x,y]], addBoundary?: [hex], removeLoops?: [zero-based index] (geometry edits require one hatch), style?, origin? | originMode?, separate?: true, recreate?: \"polyline\"|\"region\", associate?: bool (link to the recreated boundary)}").interactive(|s| Ok(Box::new(edit::HatchEditM::new(s)))),
        CommandSpec::new("hatchpick", "Hatch Pick", pick::run_hatchpick)
            .params("{points?: [[x,y]] (internal points), handles?: [hex] (closed objects)} (typed: Points, Objects, oRigin or Hatch, then the picks): the Hatch and Gradient dialog's picks, kept in the session; changes nothing")
            .enabled(has_doc)
            .noundo()
            .interactive(|_| Ok(Box::new(pick::HatchPickM::default()))),
    ]
}

/// The tolerance curves are flattened with for boundary tracing, in a space with extents `ext`.
pub(super) fn outline_tol(ext: Bounds2) -> f64 {
    (ext.width() + ext.height()).max(1e-9) / 20000.0
}

/// Tessellated outlines of every visible curve in the space (hatch boundary candidates), each
/// with the handle of the object it came from.
fn outlines(d: &Drawing, space: &Space, near: Option<Bounds2>) -> (Vec<Vec<Vec2>>, Vec<Handle>) {
    let Some(store) = d.space(space) else { return (Vec::new(), Vec::new()) };
    let ext = d.extents(space);
    let tol = outline_tol(ext);
    let mut out = Vec::new();
    let mut owners = Vec::new();
    for e in store.iter() {
        if !d.is_visible(e) || matches!(e.kind, EntityKind::Hatch(_) | EntityKind::Text(_) | EntityKind::MText(_) | EntityKind::Dimension(_)) {
            continue;
        }
        if let Some(n) = near
            && !matches!(e.kind, EntityKind::XLine(_) | EntityKind::Ray(_))
            && !entity_bounds(d, e, 0).intersects(&n)
        {
            continue;
        }
        let polys = object_polys(d, e, tol, ext);
        owners.extend(std::iter::repeat_n(e.handle, polys.len()));
        out.extend(polys);
    }
    (out, owners)
}

/// An object's outline as polylines (tolerance `tol`), infinite lines clipped to a generous
/// box around the extents `ext`.
fn object_polys(d: &Drawing, e: &Entity, tol: f64, ext: Bounds2) -> Vec<Vec<Vec2>> {
    let mut polys = crate::select::hit_polylines(d, e, tol);
    if matches!(e.kind, EntityKind::XLine(_) | EntityKind::Ray(_)) {
        let r = (ext.width() + ext.height()).max(1.0) * 4.0;
        for pl in &mut polys {
            if let [a, b] = pl.as_slice() {
                let m = a.mid(*b);
                let dir = (*b - *a).normalized();
                *pl = vec![m - dir * r, m + dir * r];
            }
        }
    }
    polys
}

/// The objects behind input polylines (indices into `owners`), without repeats.
fn handles_of(owners: &[Handle], idx: &[usize]) -> Vec<Handle> {
    let mut hs: Vec<Handle> = idx.iter().filter_map(|&i| owners.get(i).copied()).collect();
    hs.sort_unstable();
    hs.dedup();
    hs
}

/// Closed loops of entities that are closed curves (for islands and "select objects").
fn closed_loop(d: &Drawing, e: &Entity) -> Option<Vec<PolyVertex>> {
    match &e.kind {
        EntityKind::Circle(c) => {
            let ctr = c.center.xy();
            Some(vec![PolyVertex::with_bulge(ctr - Vec2::X * c.radius, 1.0), PolyVertex::with_bulge(ctr + Vec2::X * c.radius, 1.0)])
        }
        EntityKind::LwPolyline(p) if p.closed || p.vertices.first().zip(p.vertices.last()).is_some_and(|(a, b)| a.p.near(b.p, 1e-9)) => {
            Some(p.vertices.clone())
        }
        EntityKind::Ellipse(el) => {
            let ge = cadcraft_geom::Ellipse { center: el.center.xy(), major: el.major.xy(), ratio: el.ratio, start: el.start, end: el.end };
            if !ge.is_full() {
                return None;
            }
            let mut pts = Vec::new();
            ge.tessellate(el.major.xy().len() * 1e-3, &mut pts);
            pts.pop();
            Some(pts.into_iter().map(PolyVertex::new).collect())
        }
        EntityKind::Spline(sp) if sp.closed => Some(sp.tessellate(1e-3).into_iter().map(PolyVertex::new).collect()),
        _ => {
            let _ = d;
            None
        }
    }
}

/// Open curves that can make up an island together (a square drawn as four LINEs, two ARCs
/// forming a circle, the inner lines of multiline walls around a room). Closed objects are
/// islands on their own (see `closed_loop`).
fn island_curve(d: &Drawing, e: &Entity) -> bool {
    matches!(
        e.kind,
        EntityKind::Line(_)
            | EntityKind::Arc(_)
            | EntityKind::Ellipse(_)
            | EntityKind::LwPolyline(_)
            | EntityKind::Polyline3d(_)
            | EntityKind::Spline(_)
            | EntityKind::MLine(_)
    ) && closed_loop(d, e).is_none()
}

/// HPGAPTOL: the widest gap between curve ends that still closes a boundary (0–5000).
fn gap_tolerance(d: &Drawing) -> f64 {
    let g = d.header.f64("HPGAPTOL", 0.0);
    if g.is_finite() { g.clamp(0.0, 5000.0) } else { 0.0 }
}

/// Where a pattern starts (HPORIGINMODE): the stored origin, or a corner or the centre of the
/// hatch's extents.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub(crate) enum OriginMode {
    #[default]
    Current,
    BottomLeft,
    BottomRight,
    TopRight,
    TopLeft,
    Center,
}

impl OriginMode {
    pub(crate) fn from_index(i: i64) -> Self {
        match i {
            1 => OriginMode::BottomLeft,
            2 => OriginMode::BottomRight,
            3 => OriginMode::TopRight,
            4 => OriginMode::TopLeft,
            5 => OriginMode::Center,
            _ => OriginMode::Current,
        }
    }
    pub(crate) fn index(self) -> i64 {
        self as i64
    }
    pub(crate) fn parse(t: &str) -> Option<Self> {
        Some(match t.trim().to_ascii_lowercase().replace([' ', '_', '-'], "").as_str() {
            "current" | "usecurrent" => OriginMode::Current,
            "bottomleft" => OriginMode::BottomLeft,
            "bottomright" => OriginMode::BottomRight,
            "topright" => OriginMode::TopRight,
            "topleft" => OriginMode::TopLeft,
            "center" | "centre" => OriginMode::Center,
            _ => return None,
        })
    }
    /// The origin for loops: `current` when the mode keeps it.
    pub(crate) fn origin(self, loops: &[HatchLoop], current: Vec2) -> Vec2 {
        let b = Bounds2::from_points(loops.iter().flat_map(|l| l.vertices.iter().map(|v| v.p)).filter(|p| p.is_finite()));
        if b.is_empty() {
            return current;
        }
        match self {
            OriginMode::Current => current,
            OriginMode::BottomLeft => b.min,
            OriginMode::BottomRight => Vec2::new(b.max.x, b.min.y),
            OriginMode::TopRight => b.max,
            OriginMode::TopLeft => Vec2::new(b.min.x, b.max.y),
            OriginMode::Center => b.center(),
        }
    }
}

/// Island detection style by name (HPISLANDDETECTION 0 normal, 1 outer, 2 ignore).
pub(crate) fn island_style(t: &str) -> Option<u8> {
    match t.trim().to_ascii_lowercase().as_str() {
        "normal" | "n" | "0" => Some(0),
        "outer" | "o" | "1" => Some(1),
        "ignore" | "i" | "2" => Some(2),
        _ => None,
    }
}

/// Boundary loops (outer + islands) around an internal point.
pub(crate) fn loops_at(s: &Session, p: Vec2) -> Result<Vec<HatchLoop>> {
    let d = s.doc()?;
    let space = s.space();
    let ext = d.extents(&space);
    let tol = ((ext.width() + ext.height()) * 1e-9).max(1e-9);
    let (polys, owners) = outlines(d, &space, None);
    // A line that ends on a flattened curve (an ellipse) can stop short of its chords.
    let polys = cadcraft_geom::region::snap_ends(&polys, outline_tol(ext), tol);
    let found = cadcraft_geom::region::boundary_at_gap(&polys, p, tol, gap_tolerance(d))
        .ok_or_else(|| EngineError::Other("Valid hatch boundary not found.".into()))?;
    let outer = found.outer;
    let ob = Bounds2::from_points(outer.iter().copied());
    let sources = handles_of(&owners, &found.outer_sources);
    let mut loops = vec![HatchLoop { vertices: outer.iter().map(|q| PolyVertex::new(*q)).collect(), outer: true, sources }];
    // Islands: closed objects entirely inside the outer loop that don't contain the pick point.
    if let Some(store) = d.space(&space) {
        for e in store.iter() {
            if !d.is_visible(e) {
                continue;
            }
            let eb = entity_bounds(d, e, 0);
            if !ob.contains_box(&eb) {
                continue;
            }
            if let Some(vs) = closed_loop(d, e) {
                let pts = Polyline { vertices: vs.clone(), closed: true }.tessellate(tol.max(eb.width() * 1e-3));
                let inside = pts.iter().all(|q| point_in_polygon(&outer, *q) || outer.iter().any(|o| o.near(*q, tol * 10.0)));
                let same_as_outer = (cadcraft_geom::shoelace(&pts).abs() - cadcraft_geom::shoelace(&outer).abs()).abs() < tol.max(1e-6) * 1000.0;
                if inside && !same_as_outer && !point_in_polygon(&pts, p) {
                    loops.push(HatchLoop { vertices: vs, outer: false, sources: vec![e.handle] });
                }
            }
        }
    }
    // Islands made of separate open curves (four LINEs around a square). Groups that include a
    // closed object were handled above, object by object.
    for island in found.islands {
        let open_curves = !island.sources.is_empty()
            && island.sources.iter().all(|&i| owners.get(i).and_then(|h| d.entity(*h)).is_some_and(|e| island_curve(d, e)));
        if open_curves {
            let sources = handles_of(&owners, &island.sources);
            loops.push(HatchLoop { vertices: island.outline.into_iter().map(PolyVertex::new).collect(), outer: false, sources });
        }
    }
    Ok(loops)
}

pub(crate) fn loops_from_handles(s: &Session, hs: &[Handle]) -> Result<Vec<HatchLoop>> {
    let d = s.doc()?;
    let mut loops = Vec::new();
    for h in hs {
        if let Some(vs) = d.entity(*h).and_then(|e| closed_loop(d, e)) {
            loops.push(HatchLoop { vertices: vs, outer: loops.is_empty(), sources: vec![*h] });
        }
    }
    if loops.is_empty() {
        return Err(EngineError::Other("No closed boundary objects selected.".into()));
    }
    Ok(loops)
}

/// Gradient fills by name: the shapes the renderer draws (`render/src/hatch.rs`); the INV forms
/// swap the two colours.
pub(crate) const GRADIENT_NAMES: [&str; 10] =
    ["LINEAR", "CYLINDER", "CURVED", "SPHERICAL", "HEMISPHERICAL", "INVLINEAR", "INVCYLINDER", "INVCURVED", "INVSPHERICAL", "INVHEMISPHERICAL"];

/// A gradient name as stored (upper case), or None when it isn't one of [`GRADIENT_NAMES`].
pub(crate) fn gradient_name(t: &str) -> Option<&'static str> {
    let up = t.trim().to_ascii_uppercase();
    GRADIENT_NAMES.iter().copied().find(|n| *n == up)
}

#[derive(Clone)]
struct HatchSettings {
    pattern: String,
    scale: f64,
    angle: f64,
    gradient: Option<Gradient>,
    associative: bool,
    /// HPSEPARATE: one hatch per picked point or selected object.
    separate: bool,
    origin: Vec2,
    origin_mode: OriginMode,
    style: u8,
}

impl HatchSettings {
    fn from(s: &Session, p: &Value, gradient: bool) -> Self {
        let hdr = s.doc().map(|d| (d.header.str("HPNAME", "ANSI31"), d.header.f64("HPSCALE", 1.0), d.header.f64("HPANG", 0.0))).unwrap_or((
            "ANSI31".into(),
            1.0,
            0.0,
        ));
        let pattern = str_param(p, "pattern").map(str::to_ascii_uppercase).unwrap_or(hdr.0);
        let g = gradient.then(|| Gradient {
            name: str_param(p, "name").and_then(gradient_name).unwrap_or("LINEAR").to_string(),
            color1: str_param(p, "color1").and_then(Color::parse).unwrap_or(Color::Index(5)),
            color2: str_param(p, "color2").and_then(Color::parse).unwrap_or(Color::Index(7)),
            angle: f64_or(p, "angle", 0.0).to_radians(),
            centered: bool_or(p, "centered", true),
        });
        HatchSettings {
            pattern,
            scale: f64_or(p, "scale", hdr.1).max(1e-9),
            angle: p.get("angle").and_then(Value::as_f64).map(f64::to_radians).unwrap_or(hdr.2),
            gradient: g,
            associative: bool_or(p, "associative", s.doc().map_or(true, |d| d.header.i64("HPASSOC", 1) != 0)),
            separate: bool_or(p, "separate", s.doc().is_ok_and(|d| d.header.i64("HPSEPARATE", 0) != 0)),
            origin: point_param(p, "origin").filter(|o| o.is_finite()).unwrap_or_else(|| {
                s.doc().ok().and_then(|d| d.header.point("HPORIGIN")).map(|o| o.xy()).filter(|o| o.is_finite()).unwrap_or(Vec2::ZERO)
            }),
            origin_mode: if point_param(p, "origin").is_some() {
                OriginMode::Current
            } else {
                str_param(p, "originMode")
                    .and_then(OriginMode::parse)
                    .unwrap_or_else(|| OriginMode::from_index(s.doc().map_or(0, |d| d.header.i64("HPORIGINMODE", 0))))
            },
            style: str_param(p, "style")
                .and_then(island_style)
                .unwrap_or_else(|| s.doc().map_or(0, |d| d.header.i64("HPISLANDDETECTION", 0).clamp(0, 2) as u8)),
        }
    }
    fn hatch(&self, mut loops: Vec<HatchLoop>) -> EntityKind {
        if !self.associative {
            loops.iter_mut().for_each(|l| l.sources.clear());
        }
        let solid = self.gradient.is_some() || self.pattern == "SOLID";
        EntityKind::Hatch(Hatch {
            pattern: if self.gradient.is_some() { "SOLID".into() } else { self.pattern.clone() },
            solid,
            origin: self.origin_mode.origin(&loops, self.origin),
            loops,
            scale: self.scale,
            angle: self.angle,
            associative: self.associative,
            style: self.style,
            elevation: 0.0,
            gradient: self.gradient.clone(),
            background: None,
            pattern_lines: patfile::lines_for(&self.pattern),
        })
    }
}

fn make(s: &mut Session, p: &Value, gradient: bool) -> Result<Value> {
    // A zero or negative pattern scale would be clamped to a near-zero spacing.
    size_param(if gradient { "gradient" } else { "hatch" }, p, "scale", false)?;
    let cmd = if gradient { "gradient" } else { "hatch" };
    if str_param(p, "style").is_some_and(|t| island_style(t).is_none()) {
        return Err(bad(cmd, "`style` is \"normal\", \"outer\" or \"ignore\""));
    }
    if str_param(p, "originMode").is_some_and(|t| OriginMode::parse(t).is_none()) {
        return Err(bad(cmd, "unknown `originMode`"));
    }
    if gradient && str_param(p, "name").is_some_and(|t| gradient_name(t).is_none()) {
        return Err(bad(cmd, format!("unknown gradient `name`; use one of {}", GRADIENT_NAMES.join(", "))));
    }
    let st = HatchSettings::from(s, p, gradient);
    // Loops by picked point or selected object: one hatch each when separate.
    let mut groups: Vec<Vec<HatchLoop>> = Vec::new();
    // Internal points and boundary objects can come together (the dialog's Pick points and
    // Select objects); points alone don't fall back to the selection.
    let pts = points_param(p, "points");
    let given = |k: &str| p.get(k).is_some_and(|v| !v.is_null());
    let objects = pts.is_none() || given("handles") || given("handle");
    for q in pts.into_iter().flatten() {
        groups.push(loops_at(s, q)?);
    }
    if objects {
        let hs = targets(s, p)?;
        if st.separate {
            groups.extend(loops_from_handles(s, &hs)?.into_iter().map(|l| vec![HatchLoop { outer: true, ..l }]));
        } else {
            groups.push(loops_from_handles(s, &hs)?);
        }
    }
    if groups.iter().all(Vec::is_empty) {
        return Err(bad("hatch", "give internal `points` or boundary `handles`"));
    }
    let hs = add_hatches(s, &st, groups)?;
    let hex: Vec<String> = hs.iter().map(|h| h.hex()).collect();
    Ok(json!({ "handle": hex.first(), "handles": hex }))
}

/// True when two loops have the same vertex sequence (ignoring cyclic shift and winding order).
fn same_loop(a: &HatchLoop, b: &HatchLoop) -> bool {
    if a.vertices.len() != b.vertices.len() {
        return false;
    }
    let n = a.vertices.len();
    if n == 0 {
        return true;
    }
    let near = |v1: &PolyVertex, v2: &PolyVertex| v1.p.near(v2.p, 1e-6) && (v1.bulge - v2.bulge).abs() < 1e-6;
    (0..n).any(|k| (0..n).all(|i| near(&a.vertices[i], &b.vertices[(i + k) % n])))
        || (0..n).any(|k| {
            (0..n).all(|i| {
                let j = (k + n - (i % n)) % n;
                let prev_j = (j + n - 1) % n;
                a.vertices[i].p.near(b.vertices[j].p, 1e-6) && (a.vertices[i].bulge + b.vertices[prev_j].bulge).abs() < 1e-6
            })
        })
}

/// Deduplicate boundary loops that describe the same boundary.
fn dedup_loops(loops: &mut Vec<HatchLoop>) {
    let mut unique: Vec<HatchLoop> = Vec::with_capacity(loops.len());
    for l in loops.drain(..) {
        if let Some(existing) = unique.iter_mut().find(|u| same_loop(u, &l)) {
            for s in l.sources {
                if !existing.sources.contains(&s) {
                    existing.sources.push(s);
                }
            }
            existing.outer = existing.outer || l.outer;
        } else {
            unique.push(l);
        }
    }
    *loops = unique;
}

/// Add the hatches for groups of loops: one per group when separate, otherwise one for all.
fn add_hatches(s: &mut Session, st: &HatchSettings, groups: Vec<Vec<HatchLoop>>) -> Result<Vec<Handle>> {
    let groups: Vec<Vec<HatchLoop>> = if st.separate {
        let mut unique_groups: Vec<Vec<HatchLoop>> = Vec::new();
        for mut g in groups {
            dedup_loops(&mut g);
            if g.is_empty() {
                continue;
            }
            if !unique_groups.iter().any(|u| u.len() == g.len() && u.iter().zip(&g).all(|(a, b)| same_loop(a, b))) {
                unique_groups.push(g);
            }
        }
        unique_groups
    } else {
        let mut all: Vec<HatchLoop> = groups.into_iter().flatten().collect();
        dedup_loops(&mut all);
        vec![all]
    };
    let mut out = Vec::new();
    for loops in groups.into_iter().filter(|g| !g.is_empty()) {
        let h = s.add_entity(st.hatch(loops))?;
        // Hatches go under other objects (HPDRAWORDER = behind boundary).
        let space = s.space();
        if let Some(store) = s.doc_mut()?.space_mut(&space) {
            store.send_to_back(h);
        }
        out.push(h);
    }
    Ok(out)
}

fn run_hatch(s: &mut Session, p: &Value) -> Result<Value> {
    patfile::load_param(p)?;
    // Like the prompt: a name without a definition would be drawn as ANSI31.
    if let Some(up) = str_param(p, "pattern").map(str::to_ascii_uppercase)
        && cadcraft_doc::library::pattern(&up).is_none()
        && patfile::user_pattern(&up).is_none()
    {
        return Err(bad("hatch", format!("unknown pattern {up}: not built in; load it with patternFile or patternText (a .pat file)")));
    }
    make(s, p, false)
}
fn run_gradient(s: &mut Session, p: &Value) -> Result<Value> {
    make(s, p, true)
}

fn boundary_at(s: &mut Session, q: Vec2) -> Result<Vec<Handle>> {
    let loops = loops_at(s, q)?;
    let mut out = Vec::new();
    for l in loops {
        out.push(s.add_entity(lwpoly(l.vertices, true))?);
    }
    Ok(out)
}

/// Most internal points one BOUNDARY call accepts (checked before the list is copied).
const MAX_BOUNDARY_POINTS: usize = 256;
/// Most polylines one BOUNDARY call may create. Each pick adds polylines the next pick traces
/// against, so this bounds the aggregate tracing work of the batch.
const MAX_BOUNDARY_OUTPUT: usize = 1024;

fn run_boundary(s: &mut Session, p: &Value) -> Result<Value> {
    let raw = p.get("points").and_then(Value::as_array).ok_or_else(|| bad("boundary", "`points` is required"))?;
    if raw.len() > MAX_BOUNDARY_POINTS {
        return Err(bad("boundary", format!("at most {MAX_BOUNDARY_POINTS} points per call (got {})", raw.len())));
    }
    let pts = points_param(p, "points").ok_or_else(|| bad("boundary", "`points` is required"))?;
    let before = s.state()?.doc.clone();
    let mut out = Vec::new();
    for q in pts {
        out.extend(boundary_at(s, q)?.into_iter().map(|h| h.hex()));
        if out.len() > MAX_BOUNDARY_OUTPUT {
            // The refused call leaves no partial result behind.
            s.state_mut()?.doc = before;
            return Err(bad("boundary", format!("more than {MAX_BOUNDARY_OUTPUT} boundary polylines in one call; split the work")));
        }
    }
    Ok(json!({ "handles": out, "message": format!("BOUNDARY created {} polyline(s)", out.len()) }))
}

/// REGION: each closed object becomes a region bounded by it (and replaces it).
fn run_region(s: &mut Session, p: &Value) -> Result<Value> {
    let hs = targets(s, p)?;
    let mut n = 0;
    for h in hs {
        let vs = {
            let d = s.doc()?;
            d.entity(h).and_then(|e| closed_loop(d, e).map(|v| (v, e.common.clone())))
        };
        if let Some((vs, common)) = vs {
            let d = s.doc_mut()?;
            d.modify_entity(h, |e| {
                e.kind = EntityKind::Region(cadcraft_doc::Region::from_loop(vs));
                e.common = common;
            })?;
            n += 1;
        }
    }
    Ok(json!({ "message": format!("{n} Region(s) created.") }))
}

/// Whether the upper-case `name` is a pattern: a standard one or a loaded one.
fn pattern_exists(name: &str) -> bool {
    cadcraft_doc::library::pattern(name).is_some() || patfile::user_pattern(name).is_some()
}

/// The existing pattern `name` means, typed at the pattern prompt: read upper-cased, else a loaded
/// pattern's own name when only its Greek spelling differs in case or accent (σολιδ for ΣΟΛΙΔ).
pub(crate) fn pattern_named(name: &str) -> Option<String> {
    let name = name.trim();
    let up = name.to_ascii_uppercase();
    if pattern_exists(&up) { Some(up) } else { patfile::user_pattern_name(name) }
}

/// The origin sub-prompt's keywords (a point sets a new origin).
const ORIGIN_KW: [&str; 6] = ["Bottom left", "bottom Right", "Top left", "top riGht", "Center", "Use current"];

/// What a HATCH sub-prompt asks for.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum HatchAsk {
    Pattern,
    Scale,
    Angle,
    Origin,
}

struct HatchM {
    gradient: bool,
    settings: HatchSettings,
    /// Loops by pick (one hatch each when separate).
    loops: Vec<Vec<HatchLoop>>,
    asking: Option<HatchAsk>,
    /// The pattern was asked by the Pattern option: its scale and angle follow, as at AutoCAD's
    /// -HATCH Properties.
    properties: bool,
    /// "Select objects" mode instead of "Pick internal point"; the next HATCH starts in it again.
    selecting: bool,
}

impl HatchM {
    fn new(s: &Session, gradient: bool) -> Self {
        HatchM {
            gradient,
            settings: HatchSettings::from(s, &Value::Null, gradient),
            loops: Vec::new(),
            asking: None,
            properties: false,
            selecting: s.last_used.hatch_select,
        }
    }
    fn set_mode(&mut self, s: &mut Session, selecting: bool) {
        self.selecting = selecting;
        s.last_used.hatch_select = selecting;
    }
    fn finish(&mut self, s: &mut Session) -> Result<Step> {
        add_hatches(s, &self.settings, std::mem::take(&mut self.loops))?;
        Ok(Step::Done)
    }
    fn set_origin(&mut self, s: &mut Session, origin: Option<Vec2>, mode: OriginMode) -> Result<()> {
        let h = &mut s.doc_mut()?.header;
        if let Some(o) = origin.filter(|o| o.is_finite()) {
            self.settings.origin = o;
            h.set("HPORIGIN", cadcraft_doc::HVal::Point(o.to3(0.0)));
        }
        self.settings.origin_mode = mode;
        h.set_i64("HPORIGINMODE", mode.index());
        Ok(())
    }
    /// Take an answer to sub-prompt `a`; false when it was refused.
    fn answer(&mut self, s: &mut Session, a: HatchAsk, t: &str) -> Result<bool> {
        match a {
            HatchAsk::Pattern => {
                let up = match patfile::typed_file(s, t.trim()) {
                    // Nothing loaded from it: the pattern is asked again.
                    Some(n) if n.is_empty() => return Ok(false),
                    Some(n) => n,
                    None => t.trim().to_ascii_uppercase(),
                };
                if pattern_exists(&up) {
                    self.settings.pattern = up.clone();
                    s.doc_mut()?.header.set_str("HPNAME", &up);
                } else {
                    s.echo(format!("Unknown pattern {up}. Available: {}", patfile::names().join(", ")));
                    return Ok(false);
                }
            }
            HatchAsk::Scale => {
                let Some(v) = super::machines::number(t).filter(|v| v.is_finite() && *v > 0.0) else { return Ok(false) };
                self.settings.scale = v;
                s.doc_mut()?.header.set_f64("HPSCALE", v);
            }
            HatchAsk::Angle => {
                // Turns the pattern from the X axis (not from ANGBASE), clockwise when ANGDIR is 1.
                let Some(a) = s.angle_settings().rotation(t).filter(|a| a.is_finite()) else { return Ok(false) };
                self.settings.angle = a;
                s.doc_mut()?.header.set_f64("HPANG", a);
            }
            HatchAsk::Origin => {
                let mode = match t {
                    "Bottom left" => OriginMode::BottomLeft,
                    "bottom Right" => OriginMode::BottomRight,
                    "Top left" => OriginMode::TopLeft,
                    "top riGht" => OriginMode::TopRight,
                    "Center" => OriginMode::Center,
                    _ => OriginMode::Current,
                };
                self.set_origin(s, None, mode)?;
            }
        }
        Ok(true)
    }

    /// The sub-prompt that follows `a` (`taken`: its answer was taken). The Pattern option goes
    /// on, as AutoCAD 2024's -HATCH Properties does, from the pattern name to its scale and then
    /// its angle (a solid fill has neither), and asks again for a pattern or a value it refused.
    fn after(&self, a: HatchAsk, taken: bool) -> Option<HatchAsk> {
        if !self.properties {
            return None;
        }
        match a {
            _ if !taken => Some(a),
            HatchAsk::Pattern if self.settings.pattern != "SOLID" => Some(HatchAsk::Scale),
            HatchAsk::Scale => Some(HatchAsk::Angle),
            _ => None,
        }
    }
}

impl Interactive for HatchM {
    fn name(&self) -> &'static str {
        if self.gradient { "GRADIENT" } else { "HATCH" }
    }
    fn begin(&mut self, s: &mut Session) -> Result<Step> {
        s.echo(format!(
            "Current pattern: {}  Scale: {:.4}  Angle: {:.0}",
            self.settings.pattern,
            self.settings.scale,
            self.settings.angle.to_degrees()
        ));
        Ok(Step::Continue)
    }
    fn prompt(&self, s: &Session) -> Prompt {
        // The sub-prompts offer the current value: Enter keeps it.
        match self.asking {
            Some(HatchAsk::Pattern) => {
                let p = Prompt::new("Enter a pattern name", Accept::TEXT)
                    .default(self.settings.pattern.clone())
                    .picker(Picker::HatchPattern(self.settings.pattern.clone()));
                return if self.gradient { p } else { p.kw(&["Solid"]) };
            }
            Some(HatchAsk::Scale) => {
                return Prompt::new("Specify a scale for the hatch pattern", Accept::NUMBER).default(format!("{:.4}", self.settings.scale));
            }
            Some(HatchAsk::Angle) => {
                let (au, ap) = s.doc().map(|d| (d.header.i64("AUNITS", 0), d.header.i64("AUPREC", 0))).unwrap_or((0, 0));
                // Offered as it would be typed: clockwise is positive when ANGDIR is 1.
                let a = if s.angle_settings().clockwise { -self.settings.angle } else { self.settings.angle };
                let d = crate::units::format_angle(a, au, ap);
                return Prompt::new("Specify an angle for the hatch pattern", Accept::NUMBER).default(d);
            }
            Some(HatchAsk::Origin) => return Prompt::new("Specify the pattern origin", Accept::POINT).kw(&ORIGIN_KW).default("Use current"),
            None => {}
        }
        // The pattern picker stays offered while boundaries are picked: a choice sets the pattern.
        let picker = |p: Prompt| if self.gradient { p } else { p.picker(Picker::HatchPattern(self.settings.pattern.clone())) };
        if self.selecting {
            return picker(Prompt::new("Select objects", Accept::SELECT).kw(&[
                "picK internal point",
                "Undo",
                "seTtings",
                "sCale",
                "Angle",
                "Origin",
                "sEparate",
            ]));
        }
        picker(Prompt::new("Pick internal point", Accept::POINT).kw(&[
            "Select objects",
            "Undo",
            "seTtings",
            "Pattern",
            "sCale",
            "Angle",
            "Origin",
            "sEparate",
        ]))
    }
    fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
        if let Some(a) = self.asking.take() {
            let taken = match &i {
                Input::Point(p) if a == HatchAsk::Origin => {
                    self.set_origin(s, Some(*p), OriginMode::Current)?;
                    true
                }
                Input::Keyword(k) if a == HatchAsk::Pattern && k == "Solid" => self.answer(s, a, "SOLID")?,
                Input::Text(t) | Input::Keyword(t) => self.answer(s, a, t)?,
                // Enter keeps the current value; a point or a pick answers none of these prompts.
                Input::Enter => true,
                _ => false,
            };
            self.asking = self.after(a, taken);
            self.properties &= self.asking.is_some();
            return Ok(Step::Continue);
        }
        match i {
            Input::Point(p) if !self.selecting => {
                match loops_at(s, p) {
                    Ok(l) => {
                        s.echo(format!("Analyzing the selected data... {} loop(s)", l.len()));
                        self.loops.push(l);
                    }
                    Err(e) => s.echo(e.to_string()),
                }
                Ok(Step::Continue)
            }
            Input::Pick(hs) => {
                match loops_from_handles(s, &hs) {
                    Ok(l) => {
                        s.echo(format!("{} found", hs.len()));
                        if self.settings.separate {
                            self.loops.extend(l.into_iter().map(|l| vec![HatchLoop { outer: true, ..l }]));
                        } else {
                            self.loops.push(l);
                        }
                    }
                    Err(e) => s.echo(e.to_string()),
                }
                Ok(Step::Continue)
            }
            Input::Keyword(k) => {
                match k.as_str() {
                    "Select objects" => self.set_mode(s, true),
                    "picK internal point" => self.set_mode(s, false),
                    "Undo" => self.loops.clear(),
                    "Pattern" | "seTtings" => {
                        self.asking = Some(HatchAsk::Pattern);
                        self.properties = !self.gradient;
                    }
                    "sCale" => self.asking = Some(HatchAsk::Scale),
                    "Angle" => self.asking = Some(HatchAsk::Angle),
                    "Origin" => self.asking = Some(HatchAsk::Origin),
                    "sEparate" => {
                        self.settings.separate = !self.settings.separate;
                        s.doc_mut()?.header.set_i64("HPSEPARATE", i64::from(self.settings.separate));
                        s.echo(if self.settings.separate { "Separate hatches: on" } else { "Separate hatches: off" });
                    }
                    _ => {}
                }
                Ok(Step::Continue)
            }
            // A pattern chosen in the picker while boundaries are picked.
            Input::Text(t) if !self.gradient => {
                let _ = self.answer(s, HatchAsk::Pattern, &t)?;
                Ok(Step::Continue)
            }
            // Enter ends boundary picking in either mode and creates the hatch.
            Input::Enter => self.finish(s),
            _ => Ok(Step::Continue),
        }
    }
    fn preview(&self, _s: &Session, _c: Vec2) -> Vec<EntityKind> {
        if self.loops.is_empty() {
            return Vec::new();
        }
        vec![self.settings.hatch(self.loops.iter().flatten().cloned().collect())]
    }
}

struct BoundaryM {
    region: bool,
}

impl Interactive for BoundaryM {
    fn name(&self) -> &'static str {
        if self.region { "REGION" } else { "BOUNDARY" }
    }
    fn prompt(&self, _s: &Session) -> Prompt {
        Prompt::new("Pick internal point", Accept::POINT)
    }
    fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
        match i {
            Input::Point(p) => {
                match boundary_at(s, p) {
                    Ok(hs) => s.echo(format!("BOUNDARY created {} polyline(s)", hs.len())),
                    Err(e) => s.echo(e.to_string()),
                }
                Ok(Step::Continue)
            }
            Input::Enter => Ok(Step::Done),
            _ => Ok(Step::Continue),
        }
    }
}

#[cfg(test)]
mod tests {
    use serde_json::json;

    use super::*;

    /// The drawing's only hatch and its handle (hatches go to the back of the draw order, so not the last entity).
    fn only_hatch(s: &Session) -> (String, Hatch) {
        let d = s.doc().unwrap();
        d.model.iter().find_map(|e| if let EntityKind::Hatch(h) = &e.kind { Some((e.handle.hex(), h.clone())) } else { None }).unwrap()
    }

    #[test]
    fn hatchedit_pattern_replaces_gradient() {
        let mut s = Session::new();
        s.execute("rectang", &json!({ "p1": [0, 0], "p2": [10, 10] })).unwrap();
        s.execute("gradient", &json!({ "points": [[5, 5]], "color1": "1", "color2": "3" })).unwrap();
        let (h, hatch) = only_hatch(&s);
        assert!(hatch.gradient.is_some());
        // Scale-only and angle-only edits keep the gradient.
        s.execute("hatchedit", &json!({ "handles": [h.clone()], "scale": 2, "angle": 30 })).unwrap();
        assert!(only_hatch(&s).1.gradient.is_some());
        s.execute("hatchedit", &json!({ "handles": [h], "pattern": "ANSI31" })).unwrap();
        let hatch = only_hatch(&s).1;
        assert_eq!(hatch.pattern, "ANSI31");
        assert!(!hatch.solid);
        assert!(hatch.gradient.is_none());
    }

    #[test]
    fn hatchedit_solid_replaces_gradient() {
        let mut s = Session::new();
        s.execute("rectang", &json!({ "p1": [0, 0], "p2": [10, 10] })).unwrap();
        s.execute("gradient", &json!({ "points": [[5, 5]], "color1": "1", "color2": "3" })).unwrap();
        let (h, before) = only_hatch(&s);
        assert!(before.gradient.is_some());
        s.execute("hatchedit", &json!({ "handles": [h.clone()], "pattern": "SOLID" })).unwrap();
        let (h2, hatch) = only_hatch(&s);
        assert_eq!(h2, h);
        assert!(hatch.solid);
        assert!(hatch.gradient.is_none(), "SOLID is a plain fill, not the gradient");
        assert_eq!(hatch.loops, before.loops);
    }

    #[test]
    fn the_pattern_picker_is_offered_and_its_choice_sets_the_pattern() {
        let mut s = Session::new();
        s.execute("rectang", &json!({ "p1": [0, 0], "p2": [10, 10] })).unwrap();
        s.start("hatch").unwrap();
        let picker = s.current_prompt().and_then(|p| p.picker);
        assert_eq!(picker, Some(Picker::HatchPattern(HatchSettings::from(&s, &Value::Null, false).pattern)));
        // A choice made in the picker while boundaries are picked.
        s.input(Input::Text("AR-CONC".into())).unwrap();
        assert_eq!(s.current_prompt().and_then(|p| p.picker), Some(Picker::HatchPattern("AR-CONC".into())));
        // And at the pattern prompt.
        s.input(Input::Keyword("Pattern".into())).unwrap();
        assert!(s.current_prompt().unwrap().picker.is_some());
        s.input(Input::Text("BRICK".into())).unwrap();
        // Its scale and angle follow; Enter keeps them.
        s.input(Input::Enter).unwrap();
        s.input(Input::Enter).unwrap();
        s.input(Input::Point(Vec2::new(5.0, 5.0))).unwrap();
        s.input(Input::Enter).unwrap();
        assert_eq!(only_hatch(&s).1.pattern, "BRICK");
        // An unknown name keeps the pattern.
        s.start("hatch").unwrap();
        s.input(Input::Text("NO-SUCH".into())).unwrap();
        assert_eq!(s.current_prompt().and_then(|p| p.picker), Some(Picker::HatchPattern("BRICK".into())));
        // GRADIENT offers no pattern picker.
        s.cancel();
        s.start("gradient").unwrap();
        assert!(s.current_prompt().unwrap().picker.is_none());
    }

    /// -HATCH's Properties as AutoCAD 2024 takes them from AutoLISP's `command` (accoreconsole, the
    /// hatch read back with `entget`): a pattern name, then its scale and angle (Enter keeps them);
    /// Solid (`S`, `_S` or SOLID) asks neither; an unknown name is asked again.
    #[test]
    fn hatch_properties_ask_pattern_scale_and_angle_as_autocad() {
        // (properties given, pattern, solid, scale, angle in degrees)
        let cases: [(&str, &str, bool, f64, f64); 7] = [
            ("\"ANSI31\" 2 45 \"_S\" (entlast) \"\"", "ANSI31", false, 2.0, 45.0),
            ("\"_S\" \"_S\" (entlast) \"\"", "SOLID", true, 1.0, 0.0),
            ("\"ANSI37\" 0.5 30 '(5.0 5.0)", "ANSI37", false, 0.5, 30.0),
            ("\"ANSI31\" \"\" \"\" '(5.0 5.0)", "ANSI31", false, 1.0, 0.0),
            ("\"S\" '(5.0 5.0)", "SOLID", true, 1.0, 0.0),
            ("\"SOLID\" '(5.0 5.0)", "SOLID", true, 1.0, 0.0),
            ("\"XYZ\" \"ANSI31\" 1 0 '(5.0 5.0)", "ANSI31", false, 1.0, 0.0),
        ];
        for (props, pattern, solid, scale, angle) in cases {
            let mut s = Session::new();
            s.execute("circle", &json!({ "center": [20, 15], "radius": 8 })).unwrap();
            s.execute("rectang", &json!({ "p1": [0, 0], "p2": [40, 30] })).unwrap();
            s.cmdline("(setvar \"HPNAME\" \"ANSI31\")").unwrap();
            s.cmdline("(setvar \"HPSCALE\" 1.0)").unwrap();
            s.cmdline("(setvar \"HPANG\" 0.0)").unwrap();
            s.cmdline(&format!("(command \"_.-HATCH\" \"_P\" {props} \"\")")).unwrap();
            assert!(s.running.is_none(), "{props}: {}", s.prompt_text());
            let h = only_hatch(&s).1;
            assert!(
                h.pattern == pattern && h.solid == solid && (h.scale - scale).abs() < 1e-12 && (h.angle - angle.to_radians()).abs() < 1e-12,
                "{props}: {} {} {} {}",
                h.pattern,
                h.solid,
                h.scale,
                h.angle.to_degrees()
            );
        }
        // An object (an entity name from LISP) answers none of these prompts: each is asked again.
        let mut s = Session::new();
        s.execute("rectang", &json!({ "p1": [0, 0], "p2": [40, 30] })).unwrap();
        let h = s.doc().unwrap().model.handles()[0];
        s.cmdline("(command \"_.-HATCH\" \"_P\")").unwrap();
        s.input(crate::Input::Pick(vec![h])).unwrap();
        assert!(s.prompt_text().contains("Enter a pattern name"), "{}", s.prompt_text());
        s.cmdline("ANSI31").unwrap();
        s.input(crate::Input::Pick(vec![h])).unwrap();
        assert!(s.prompt_text().contains("Specify a scale for the hatch pattern"), "{}", s.prompt_text());
        s.cancel();
    }

    #[test]
    fn unknown_pattern_error_and_catalog_name_the_pat_file_route() {
        let mut s = Session::new();
        s.execute("rectang", &json!({ "p1": [0, 0], "p2": [10, 10] })).unwrap();
        let e = s.execute("hatch", &json!({ "points": [[5, 5]], "pattern": "GRAVEL" })).unwrap_err();
        assert!(e.to_string().contains("patternFile"), "{e}");
        let spec = specs().into_iter().find(|c| c.id == "hatch").unwrap();
        assert!(spec.params.contains("patternFile") && spec.params.contains("patternText"), "{}", spec.params);
    }

    #[test]
    fn json_hatch_refuses_an_undefined_pattern() {
        let mut s = Session::new();
        s.execute("rectang", &json!({ "p1": [0, 0], "p2": [10, 10] })).unwrap();
        let e = s.execute("hatch", &json!({ "points": [[5, 5]], "pattern": "NOPE" })).unwrap_err();
        assert!(e.to_string().contains("unknown pattern NOPE"), "{e}");
        assert_eq!(s.doc().unwrap().model.len(), 1, "only the rectangle");
        for name in ["ansi31", "SOLID"] {
            s.execute("hatch", &json!({ "points": [[5, 5]], "pattern": name })).unwrap();
        }
        assert_eq!(s.doc().unwrap().model.len(), 3);
    }

    #[test]
    fn pattern_choices_list_the_library_with_its_lines() {
        let all = pattern_choices();
        assert_eq!(all.first().map(|c| c.name.as_str()), Some("SOLID"));
        assert!(all[0].lines.is_empty());
        let ansi31 = all.iter().find(|c| c.name == "ANSI31").unwrap();
        assert_eq!(ansi31.lines.len(), 1);
        assert!(!ansi31.description.is_empty());
    }

    #[test]
    fn repeated_picks_and_handles_in_one_region_do_not_produce_duplicate_loops() {
        // One internal point
        let mut s = Session::new();
        s.execute("rectang", &json!({ "p1": [0, 0], "p2": [10, 10] })).unwrap();
        s.execute("hatch", &json!({ "points": [[5, 5]], "pattern": "SOLID" })).unwrap();
        let (_, h1) = only_hatch(&s);
        assert_eq!(h1.loops.len(), 1);

        // Two different points in the same rectangle
        let mut s = Session::new();
        s.execute("rectang", &json!({ "p1": [0, 0], "p2": [10, 10] })).unwrap();
        s.execute("hatch", &json!({ "points": [[2, 2], [8, 8]], "pattern": "SOLID" })).unwrap();
        let (_, h2) = only_hatch(&s);
        assert_eq!(h2.loops.len(), 1, "two points in same region must deduplicate loops");

        // The same point twice
        let mut s = Session::new();
        s.execute("rectang", &json!({ "p1": [0, 0], "p2": [10, 10] })).unwrap();
        s.execute("hatch", &json!({ "points": [[5, 5], [5, 5]], "pattern": "SOLID" })).unwrap();
        let (_, h3) = only_hatch(&s);
        assert_eq!(h3.loops.len(), 1, "identical points must deduplicate loops");

        // Three points in the same rectangle
        let mut s = Session::new();
        s.execute("rectang", &json!({ "p1": [0, 0], "p2": [10, 10] })).unwrap();
        s.execute("hatch", &json!({ "points": [[2, 2], [5, 5], [8, 8]], "pattern": "SOLID" })).unwrap();
        let (_, h4) = only_hatch(&s);
        assert_eq!(h4.loops.len(), 1);

        // Same boundary handle twice
        let mut s = Session::new();
        let r = s.execute("rectang", &json!({ "p1": [0, 0], "p2": [10, 10] })).unwrap();
        let handle = r["handle"].as_str().unwrap();
        s.execute("hatch", &json!({ "handles": [handle, handle], "pattern": "SOLID" })).unwrap();
        let (_, h5) = only_hatch(&s);
        assert_eq!(h5.loops.len(), 1, "repeated boundary handle must deduplicate loops");

        // Two points in disjoint rectangles: both regions preserved
        let mut s = Session::new();
        s.execute("rectang", &json!({ "p1": [0, 0], "p2": [10, 10] })).unwrap();
        s.execute("rectang", &json!({ "p1": [20, 0], "p2": [30, 10] })).unwrap();
        s.execute("hatch", &json!({ "points": [[5, 5], [25, 5]], "pattern": "SOLID" })).unwrap();
        let (_, h6) = only_hatch(&s);
        assert_eq!(h6.loops.len(), 2, "disjoint rectangles must both be kept");

        // Gradient with duplicate points in the same rectangle
        let mut s = Session::new();
        s.execute("rectang", &json!({ "p1": [0, 0], "p2": [10, 10] })).unwrap();
        s.execute("gradient", &json!({ "points": [[2, 2], [8, 8]], "color1": "1", "color2": "3" })).unwrap();
        let (_, hg) = only_hatch(&s);
        assert_eq!(hg.loops.len(), 1, "gradient with repeated picks in same region must deduplicate loops");
    }
}