diff --git a/crates/geom/src/shapes.rs b/crates/geom/src/shapes.rs index d194fcac4e..419c2b8ddf 100644 --- a/crates/geom/src/shapes.rs +++ b/crates/geom/src/shapes.rs @@ -371,8 +371,9 @@ pub fn circle_through_points(points: &[Point]) -> Option<(Point, f64)> { /// circle, as [`circle_through_points`] gives it) plus as many more as split each arc between two /// of them into equal parts of at most a quarter turn. The path starts at the first point and runs /// as [`ellipse`] does (left, top, right on the page); each curve's handles are 4/3·tan(θ/4) of -/// the radius along the tangents at its ends (θ, its turn). A point given twice is one anchor; -/// with no points it starts at the left, as [`ellipse`] does. +/// the radius along the tangents at its ends (θ, its turn). Two points with `center` at their +/// midpoint give four anchors. A point given twice is one anchor; with no points it starts at the +/// left, as [`ellipse`] does. pub fn circle_with_anchors_at(center: Point, radius: f64, points: &[Point]) -> PathData { let quarter = PI / 2.0; let angle = |p: Point| (p.y - center.y).atan2(p.x - center.x); @@ -381,6 +382,13 @@ pub fn circle_with_anchors_at(center: Point, radius: f64, points: &[Point]) -> P let mut placed: Vec<(f64, Point)> = points.iter().map(|p| ((angle(*p) - start).rem_euclid(TAU), *p)).collect(); placed.sort_by(|a, b| a.0.total_cmp(&b.0)); placed.dedup_by(|a, b| a.1 == b.1); + // Two points with the center at their midpoint are the ends of a diameter: the second is half a + // turn from the first, also where rounding moves the angle from the center off it. + if let [(_, a), (turn, b)] = placed.as_mut_slice() + && a.midpoint(*b) == center + { + *turn = PI; + } if placed.is_empty() { placed.push((0.0, Point::new(center.x - radius, center.y))); } @@ -861,6 +869,20 @@ mod tests { } } + /// The two ends of a diameter give four anchors, also where the midpoint rounds off it: at + /// x = 10⁶, steps of 2⁻³³ put the second point more than half a turn from the first, seen from + /// the rounded center. + #[test] + fn a_diameter_gives_four_anchors_where_its_midpoint_rounds() { + let u = 2f64.powi(-33); + let (a, b) = (Point::new(1_000_000.0, 0.0), Point::new(1_000_000.0 + 9.0 * u, 8.0 * u)); + let (center, radius) = circle_through_points(&[a, b]).expect("a circle"); + let path = circle_with_anchors_at(center, radius, &[a, b]); + let sub = &path.subpaths[0]; + assert_eq!(sub.anchors.len(), 4, "{sub:?}"); + assert_eq!((sub.anchors[0].p, sub.anchors[2].p), (a, b)); + } + /// Nearly on one line: a point 10⁻⁴ off a chord 2000 long still gives the circle (its sagitta /// formula `r = (h² + (L/2)²) / 2h`), and its center sits on the chord's perpendicular /// bisector; a point 10⁻¹² off it does not. diff --git a/crates/tools/src/circle.rs b/crates/tools/src/circle.rs index fb19af46e0..9e08f79d49 100644 --- a/crates/tools/src/circle.rs +++ b/crates/tools/src/circle.rs @@ -205,8 +205,16 @@ impl CircleTool { fn points(&self) -> Vec { let mut out: Vec = self.first.into_iter().collect(); if let Some((b, _)) = self.second { - out.push(b); - out.extend(self.pointer); + match self.press { + // Let go where it was pressed, a press on the first point draws nothing and one on + // the second point draws the circle on the two. + Some(Press::Third { on_first: true, dragged: false, .. }) => {} + Some(Press::Third { on_second: true, dragged: false, .. }) => out.push(b), + _ => { + out.push(b); + out.extend(self.pointer); + } + } return out; } match self.press { @@ -302,9 +310,16 @@ impl Tool for CircleTool { PointerKind::Down => { if let (Some(a), Some((b, clicked))) = (self.first, self.second) { let at = self.snap.press(cx, ev.pos, &[], None); - let on = |q: Point| at == q || ev.pos.distance(q) <= cx.tol(REACH_PX); - let on_second = on(b) || ev.pos.distance(clicked) <= cx.tol(REACH_PX); - self.press = Some(Press::Third { at, from: ev.pos, on_first: on(a), on_second, dragged: false }); + let reach = cx.tol(REACH_PX); + let to_second = ev.pos.distance(b).min(ev.pos.distance(clicked)); + let (mut on_first, mut on_second) = (at == a || ev.pos.distance(a) <= reach, at == b || to_second <= reach); + // A press in reach of both points is on the one it snapped to, otherwise on the + // nearer one. + if on_first && on_second { + let first = if (at == a) != (at == b) { at == a } else { ev.pos.distance(a) < to_second }; + (on_first, on_second) = (first, !first); + } + self.press = Some(Press::Third { at, from: ev.pos, on_first, on_second, dragged: false }); self.pointer = Some(at); return vec![]; } @@ -332,17 +347,22 @@ impl Tool for CircleTool { match &mut self.press { // With `dragThird` off, the second point follows the pointer as it does before // the press. + // The point stays where it was pressed until the press is a drag. Some(Press::Second { at, snapped, from, on_first: false, dragged }) if !drag_third => { *dragged |= ev.pos.distance(*from) >= cx.tol(DRAG_PX); - let leave = first.map(|a| Leave::segment(cx, a, ev.mods.shift)); - *snapped = self.snap.drag(cx, ev.pos, leave.as_ref()); - *at = first.map_or(*snapped, |a| round_diameter(cx, a, *snapped, ev.mods)); - self.pointer = Some(*at); + if *dragged { + let leave = first.map(|a| Leave::segment(cx, a, ev.mods.shift)); + *snapped = self.snap.drag(cx, ev.pos, leave.as_ref()); + *at = first.map_or(*snapped, |a| round_diameter(cx, a, *snapped, ev.mods)); + self.pointer = Some(*at); + } } Some(Press::Third { at, from, dragged, .. }) => { *dragged |= ev.pos.distance(*from) >= cx.tol(DRAG_PX); - *at = self.snap.drag(cx, ev.pos, None); - self.pointer = Some(*at); + if *dragged { + *at = self.snap.drag(cx, ev.pos, None); + self.pointer = Some(*at); + } } Some(Press::First { at, from, dragged }) => { *dragged |= ev.pos.distance(*from) >= cx.tol(DRAG_PX); @@ -443,7 +463,12 @@ impl Tool for CircleTool { let points = self.points(); let color = crate::draw2::FEEDBACK; if let Some((c, r)) = drawn_circle(&points, self.options.standard_anchors) { - let path = shapes::ellipse(Rect::new(c.x - r, c.y - r, c.x + r, c.y + r)).to_bezpath(); + // The path the release draws: with `standardAnchors` off, the one with an anchor at each point. + let path = if self.options.standard_anchors { + shapes::ellipse(Rect::new(c.x - r, c.y - r, c.x + r, c.y + r)).to_bezpath() + } else { + shapes::circle_with_anchors_at(c, r, &points).to_bezpath() + }; // The canvas draws a dashed outline dash by dash along its whole length: a circle longer // than DASHED_PX on screen is drawn solid instead. let dashed = std::f64::consts::TAU * r <= cx.tol(DASHED_PX); @@ -489,6 +514,11 @@ impl Tool for CircleTool { }) } + /// Takes the values [`check_options`] takes. + fn check_option(&self, key: &str, value: &Value) -> Result<(), String> { + check_options(&Map::from_iter([(key.to_string(), value.clone())])) + } + /// Sets one option; a value the option does not take leaves it as it was. Switching /// `dragThird` drops the points placed so far. fn set_option(&mut self, key: &str, value: &Value) { diff --git a/crates/tools/src/circle/tests.rs b/crates/tools/src/circle/tests.rs index 40be85c4e7..e526f044a5 100644 --- a/crates/tools/src/circle/tests.rs +++ b/crates/tools/src/circle/tests.rs @@ -162,6 +162,25 @@ fn anchors_at_the_points_asks_for_them() { assert_eq!(acts, vec![Action::Exec("shape.circleThroughPoints".into(), json!({"points": points, "anchors": "points"}))]); } +/// With `standardAnchors` off, the tool shows the path with an anchor at each point, the one its +/// release draws. +#[test] +fn anchors_at_the_points_show_the_path_they_draw() { + let (d, _) = doc_with_rect(); + let (s, p) = (Selection::default(), paint()); + let cx = ToolContext { smart_guides: false, ..cx(&d, &s, &p) }; + let mut t = CircleTool::default(); + t.set_option("standardAnchors", &json!(false)); + click(&mut t, &cx, (300.0, 300.0)); + t.pointer(&cx, &ev(PointerKind::Down, (380.0, 300.0), Mods::default())); + t.pointer(&cx, &ev(PointerKind::Drag, (310.0, 340.0), Mods::default())); + let points = [Point::new(300.0, 300.0), Point::new(380.0, 300.0), Point::new(310.0, 340.0)]; + let (c, r) = circle_of(&points).expect("a circle"); + let want = shapes::circle_with_anchors_at(c, r, &points).to_bezpath(); + let o = t.overlays(&cx); + assert!(o.iter().any(|o| matches!(o, Overlay::Path { path, .. } if *path == want)), "{o:?}"); +} + /// With `standardAnchors` off, a circle within 1 pt of the canvas edge whose path with anchors at /// the points curves past that edge is not shown and not drawn; with standard anchors it is. #[test] @@ -180,10 +199,67 @@ fn anchors_at_the_points_keep_the_path_on_the_canvas() { click(&mut t, &cx, points[0]); t.pointer(&cx, &ev(PointerKind::Down, points[1], Mods::default())); t.pointer(&cx, &ev(PointerKind::Drag, points[2], Mods::default())); - assert_eq!(preview(&t.overlays(&cx)), None); + // No outline at all: at this size the tool would draw it solid, not dashed. + let o = t.overlays(&cx); + assert!(!o.iter().any(|o| matches!(o, Overlay::Path { .. })), "{o:?}"); assert_eq!(t.pointer(&cx, &ev(PointerKind::Up, points[2], Mods::default())), vec![]); } +/// With `dragThird` off, a click in reach of both placed points is on the nearer one: nearer the +/// first point it places nothing, nearer the second it draws the circle on the two. +#[test] +fn with_third_point_by_dragging_off_a_click_near_both_points_takes_the_nearer() { + let (d, _) = doc_with_rect(); + let (s, p) = (Selection::default(), paint()); + let cx = ToolContext { smart_guides: false, ..cx(&d, &s, &p) }; + let mut t = CircleTool::default(); + t.set_option("dragThird", &json!(false)); + click(&mut t, &cx, (100.0, 100.0)); + assert_eq!(click(&mut t, &cx, (104.0, 100.0)), vec![]); + assert_eq!(click(&mut t, &cx, (101.0, 100.0)), vec![]); + assert_eq!(click(&mut t, &cx, (103.0, 100.0)), circle(&[(100.0, 100.0), (104.0, 100.0)])); +} + +/// With `dragThird` off, a press on the second point shows the circle on the two points, which its +/// release draws, and a press on the first point shows none. +#[test] +fn with_third_point_by_dragging_off_a_press_shows_the_circle_its_release_draws() { + let (d, _) = doc_with_rect(); + let (s, p) = (Selection::default(), paint()); + let cx = ToolContext { smart_guides: false, ..cx(&d, &s, &p) }; + let mut t = CircleTool::default(); + t.set_option("dragThird", &json!(false)); + click(&mut t, &cx, (100.0, 100.0)); + click(&mut t, &cx, (200.0, 100.0)); + t.pointer(&cx, &ev(PointerKind::Down, (101.0, 101.0), Mods::default())); + assert_eq!(preview(&t.overlays(&cx)), None); + assert_eq!(t.pointer(&cx, &ev(PointerKind::Up, (101.0, 101.0), Mods::default())), vec![]); + t.pointer(&cx, &ev(PointerKind::Down, (202.0, 101.0), Mods::default())); + let o = t.overlays(&cx); + assert!(near(preview(&o).expect("the circle is shown"), Rect::new(100.0, 50.0, 200.0, 150.0)), "{o:?}"); + assert_eq!(t.pointer(&cx, &ev(PointerKind::Up, (202.0, 101.0), Mods::default())), circle(&[(100.0, 100.0), (200.0, 100.0)])); +} + +/// With `dragThird` off, a press that moves less than 2 screen points keeps the point where it was +/// pressed, for the second point and for the third. +#[test] +fn with_third_point_by_dragging_off_a_short_move_keeps_the_pressed_point() { + let (d, _) = doc_with_rect(); + let (s, p) = (Selection::default(), paint()); + let cx = ToolContext { smart_guides: false, ..cx(&d, &s, &p) }; + let (down, drag, up) = (PointerKind::Down, PointerKind::Drag, PointerKind::Up); + let mut t = CircleTool::default(); + t.set_option("dragThird", &json!(false)); + click(&mut t, &cx, (100.0, 100.0)); + t.pointer(&cx, &ev(down, (200.0, 100.0), Mods::default())); + t.pointer(&cx, &ev(drag, (201.0, 100.0), Mods::default())); + assert_eq!(t.pointer(&cx, &ev(up, (200.0, 100.0), Mods::default())), vec![]); + t.pointer(&cx, &ev(down, (150.0, 200.0), Mods::default())); + t.pointer(&cx, &ev(drag, (151.0, 200.0), Mods::default())); + let three = circle(&[(100.0, 100.0), (200.0, 100.0), (150.0, 200.0)]); + assert_eq!(t.pointer(&cx, &ev(up, (150.0, 200.0), Mods::default())), three); +} + /// With `dragThird` off, a second click places the second point and a third click draws the circle /// through the three; a click on the second point again (as a double-click there does) draws the /// circle on the two; a second point let go on the first places nothing; a drag from the first @@ -300,6 +376,9 @@ fn an_alt_click_places_the_second_point_where_it_is_shown() { fn check_options_takes_only_the_values_the_options_take() { let ok = json!({"center": false, "radii": true, "diameter": false, "color": "gray", "standardAnchors": false, "dragThird": false}); assert_eq!(check_options(ok.as_object().unwrap()), Ok(())); + // The tool's own check, which `tool.setOption` also runs, takes the same values. + let tool = CircleTool::default(); + assert_eq!(tool.check_options(ok.as_object().unwrap()), Ok(())); for (bad, error) in [ (json!({"center": 1}), "`center` must be true or false"), (json!({"dragThird": null}), "`dragThird` must be true or false"), @@ -307,6 +386,7 @@ fn check_options_takes_only_the_values_the_options_take() { (json!({"colour": "red"}), "unknown Circle tool option `colour`"), ] { assert_eq!(check_options(bad.as_object().unwrap()), Err(error.to_string()), "{bad}"); + assert_eq!(tool.check_options(bad.as_object().unwrap()), Err(error.to_string()), "{bad}"); } } diff --git a/docs/mcp.md b/docs/mcp.md index 63a0215986..445c52ec3d 100644 --- a/docs/mcp.md +++ b/docs/mcp.md @@ -6582,8 +6582,9 @@ slider back to the Auto-Smooth level. ## Circle through two or three points -`shape.circleThroughPoints {points?: [[x, y], [x, y]] or [[x, y], [x, y], [x, y]]}` draws the circle whose edge passes -through the points, as a live ellipse with the current paint, and selects it. Two points are the ends of a diameter. +`shape.circleThroughPoints {points?: [[x, y], [x, y]] or [[x, y], [x, y], [x, y]], anchors?}` draws the circle whose +edge passes through the points, with the current paint, and selects it: a live ellipse with the default +`anchors: "standard"`, and a plain path with `anchors: "points"`. Two points are the ends of a diameter. Without `points`, it uses the two or three selected anchor points, from one path or several: anchor points selected with Direct Selection, or all the anchor points of a path selected whole, such as a triangle. The ends of selected segments do not count. The result is `{id, cx, cy, radius}`, and one undo removes the circle. The circle is not pixel-aligned,