@reekon-tools/boldr-cad 0.1.0 → 1.0.0

package/src/tools/annotate.ts

@@ -1,3 +1,5 @@
+import { targetImage } from '../editor/project';
+import { imageById } from '../model/images';
 import { strokeToLines } from './freehand';
 import { afterEdit } from '../app/edit';
 import { ed } from '../app/state';
@@ -5,10 +7,12 @@ import { hyp } from '../model/geom';
 import { dropHistory, pushHistory } from '../model/history';
 import { uid } from '../model/ids';
 import { page, SK } from '../model/store';
-import type { NoteType } from '../model/types';
+import { dashFor, DEFAULT_NOTE_WIDTH, NOTE_TEXT_IN, noteLook, shapeOutline } from '../model/markup';
+import type { Note, NoteType } from '../model/types';
 import { cloudPath } from '../render/draw';
+import { strokeMarkup, strokeOutline } from '../render/markup';
 import { TH } from '../render/theme';
-import { fitView, mainT, requestDraw, S, s2w, underlayH } from '../render/view';
+import { fitView, mainT, requestDraw, requestOverlayDraw, S, s2w, underlayH } from '../render/view';
 import { tools, type PEv, type Tool } from './registry';
 import { hitAny } from '../render/hit';
 import { selectTool } from './select';
@@ -16,6 +20,15 @@ import { setMode } from '../editor/mode';
 import { hideNoteInput, openKeypad, setCursor, showNoteInput, toast, updateHint } from '../editor/ports';
 import { selectionHint } from '../editor/selection';
 
+/** A new note in the current markup look (text takes no stroke width). */
+function newNote(type: NoteType, id = ''): Note {
+  const n: Note = { id, type, color: ed.noteColor };
+  if (type !== 'text' && ed.noteWidth !== DEFAULT_NOTE_WIDTH) n.width = ed.noteWidth;
+  if (type === 'text' && ed.noteTextIn !== NOTE_TEXT_IN) n.ts = ed.noteTextIn;
+  if (ed.noteStyle !== 'solid') n.style = ed.noteStyle;
+  return n;
+}
+
 /** Markup select: the draft select tool with its own state and hint. */
 export const makeAselectTool = (): Tool => Object.assign({}, selectTool, {
   st: {},
@@ -41,12 +54,9 @@ export const penTool = {
   prev() {
     const pts = this.st!.pts;
     ed.preview = (c, T) => {
-      c.save(); c.strokeStyle = ed.noteColor; c.lineWidth = 3; c.lineCap = 'round'; c.lineJoin = 'round';
-      c.beginPath();
-      pts.forEach((p, i) => { const [x, y] = S(T, p[0], p[1]); i ? c.lineTo(x, y) : c.moveTo(x, y); });
-      c.stroke(); c.restore();
+      strokeMarkup(c, pts.map(p => S(T, p[0], p[1])), noteLook(newNote('pen')));
     };
-    requestDraw();
+    requestOverlayDraw();
   },
   up() {
     if (!this.st) return;
@@ -55,14 +65,16 @@ export const penTool = {
     if (pts.length < 2) { requestDraw(); return; }
     pushHistory();
     const id = uid('n');
-    SK().notes.push({ id, type: 'pen', pts, color: ed.noteColor });
-    ed.sel = [{ type: 'note', id }];
+    SK().notes.push({ ...newNote('pen'), id, pts });
+    // (drawn, not selected: nothing new is highlighted — tap it with Select to change it)
+    ed.sel = [];
     afterEdit();
   },
   hint() { return 'Draw freehand markup. Select a stroke to turn it into straight, constrained lines.'; },
 };
 
-function dragShapeTool(type: Extract<NoteType, 'arrow' | 'cloud'>, hintText: string) {
+/** Markup drawn by a drag: a line or arrow from end to end, or a cloud or shape filling the box the drag makes. */
+function dragShapeTool(type: Exclude<NoteType, 'pen' | 'text'>, hintText: string) {
   return {
     st: null as { a: [number, number]; b: [number, number] } | null,
     reset() { this.st = null; ed.preview = null; },
@@ -74,24 +86,27 @@ function dragShapeTool(type: Extract<NoteType, 'arrow' | 'cloud'>, hintText: str
       this.st.b = s2w(ev.sx, ev.sy);
       const { a, b } = this.st as { a: [number, number]; b: [number, number] };
       ed.preview = (c, T) => {
-        c.save(); c.strokeStyle = ed.noteColor; c.fillStyle = ed.noteColor; c.lineWidth = type === 'cloud' ? 2.5 : 3; c.lineCap = 'round';
-        const [x1, y1] = S(T, a[0], a[1]), [x2, y2] = S(T, b[0], b[1]);
-        if (type === 'cloud') { cloudPath(c, Math.min(x1, x2), Math.min(y1, y2), Math.abs(x2 - x1), Math.abs(y2 - y1)); c.stroke(); }
-        else { c.beginPath(); c.moveTo(x1, y1); c.lineTo(x2, y2); c.stroke(); }
-        c.restore();
+        const look = noteLook(newNote(type)), [x1, y1] = S(T, a[0], a[1]), [x2, y2] = S(T, b[0], b[1]);
+        const outline = shapeOutline({ ...newNote(type), pts: [a, b] });
+        if (outline) strokeOutline(c, outline.map(p => S(T, p[0], p[1])), look);
+        else if (type === 'cloud') {
+          c.save(); c.strokeStyle = look.color; c.lineWidth = look.width; c.lineCap = 'round'; c.setLineDash(dashFor(look.style, look.width));
+          cloudPath(c, Math.min(x1, x2), Math.min(y1, y2), Math.abs(x2 - x1), Math.abs(y2 - y1)); c.stroke();
+          c.restore();
+        } else strokeMarkup(c, [[x1, y1], [x2, y2]], look);
       };
-      requestDraw();
+      requestOverlayDraw();
     },
     up() {
       if (!this.st) return;
       const { a, b } = this.st as { a: [number, number]; b: [number, number] };
       this.reset!();
       const T = mainT();
-      if (hyp(a[0] - b[0], a[1] - b[1]) * T.s < 10) { requestDraw(); if (type === 'arrow') toast('Drag to draw an arrow.'); return; }
+      if (hyp(a[0] - b[0], a[1] - b[1]) * T.s < 10) { requestDraw(); if (type !== 'cloud') toast('Drag to draw ' + DRAG_NAME[type] + '.', { warn: true }); return; }
       pushHistory();
       const id = uid('n');
-      SK().notes.push({ id, type, pts: [a, b], color: ed.noteColor });
-      ed.sel = [{ type: 'note', id }];
+      SK().notes.push({ ...newNote(type), id, pts: [a, b] });
+      ed.sel = [];
       afterEdit();
     },
     hint() { return hintText; },
@@ -100,6 +115,13 @@ function dragShapeTool(type: Extract<NoteType, 'arrow' | 'cloud'>, hintText: str
 
 export const arrowTool = dragShapeTool('arrow', 'Drag from the note toward what it points at.');
 export const cloudTool = dragShapeTool('cloud', 'Drag a box around the area to flag. Revision clouds read like a red pen on paper.');
+export const markLineTool = dragShapeTool('line', 'Drag from one end of the line to the other.');
+export const markRectTool = dragShapeTool('rect', 'Drag from one corner of the rectangle to the opposite one.');
+export const markTriangleTool = dragShapeTool('triangle', 'Drag a box for the triangle to fill, its point at the top.');
+export const markCircleTool = dragShapeTool('ellipse', 'Drag a box for the circle to fill (an oval when the box isn’t square).');
+
+/** What a drag too short to draw anything was meant to draw ('Drag to draw …'). */
+const DRAG_NAME: Record<string, string> = { arrow: 'an arrow', line: 'a line', rect: 'a rectangle', triangle: 'a triangle', ellipse: 'a circle' };
 
 export const textTool = {
   reset() { hideNoteInput(); },
@@ -112,19 +134,26 @@ export const textTool = {
       if (!txt) return;
       pushHistory();
       const id = uid('n');
-      SK().notes.push({ id, type: 'text', x, y, text: txt, color: ed.noteColor });
-      ed.sel = [{ type: 'note', id }];
+      SK().notes.push({ ...newNote('text'), id, x, y, text: txt });
+      ed.sel = [];
       afterEdit();
     });
   },
   hint() { return 'Tap where the note goes, type, then press Enter.'; },
 };
 
-/** Two-point underlay calibration: tap two points, type the real distance, the image rescales. */
+/**
+ * Two-point image calibration: tap two points, type the real distance, the image rescales. It scales the image that
+ * was selected when it started (or the page's only image); the others keep their own scale.
+ */
 export const calibTool = {
-  st: { pts: [] as [number, number][] },
-  enter() { if (!page().underlay) toast('Add a photo or plan first, then calibrate it.'); },
-  reset() { this.st = { pts: [] }; ed.preview = null; },
+  st: { pts: [] as [number, number][], id: null as string | null },
+  enter() {
+    const u = targetImage();
+    this.st = { pts: [], id: u?.id ?? null };
+    if (!u) toast(page().underlays.length ? 'Select the image to scale first, then Set scale.' : 'Add a photo or plan first, then calibrate it.', { warn: true });
+  },
+  reset() { this.st = { pts: [], id: this.st?.id ?? null }; ed.preview = null; },
   busy() { return this.st.pts.length > 0; },
   hover(ev: PEv) {
     if (this.st.pts.length === 1) {
@@ -134,14 +163,14 @@ export const calibTool = {
         c.save(); c.strokeStyle = TH.purple; c.lineWidth = 2; c.setLineDash([6, 4]);
         c.beginPath(); c.moveTo(x1, y1); c.lineTo(x2, y2); c.stroke(); c.restore();
       };
-      requestDraw();
+      requestOverlayDraw();
     }
   },
   down() {},
   move(ev: PEv) { this.hover(ev); },
   up(ev: PEv) {
-    const u = page().underlay;
-    if (!u) { toast('Add a photo or plan first.'); return; }
+    const u = this.st.id ? imageById(this.st.id) : undefined;
+    if (!u) { toast(page().underlays.length ? 'Select the image to scale first, then Set scale.' : 'Add a photo or plan first.', { warn: true }); return; }
     this.st.pts.push(s2w(ev.sx, ev.sy));
     updateHint();
     if (this.st.pts.length < 2) { this.hover(ev); return; }
@@ -172,7 +201,7 @@ export function convertNote(id: string): void {
   if (!n || !n.pts) return;
   pushHistory();
   const r = strokeToLines(n.pts.map(p => ({ x: p[0], y: p[1] })));
-  if (!r) { dropHistory(); toast('That stroke is too small to turn into lines.'); return; }
+  if (!r) { dropHistory(); toast('That stroke is too small to turn into lines.', { warn: true }); return; }
   sk.notes = sk.notes.filter(x => x.id !== id);
   setMode('draft');
   ed.sel = r.lines.map(id => ({ type: 'line' as const, id }));

package/src/tools/chamfer.ts

@@ -0,0 +1,103 @@
+import { afterEdit, tryAddConstraint } from '../app/edit';
+import { ed } from '../app/state';
+import { dropHistory, pushHistory } from '../model/history';
+import { addLine } from '../model/sketch';
+import { replaceSK, SK } from '../model/store';
+import type { Sketch } from '../model/types';
+import { requestDraw } from '../render/view';
+import { solver } from '../solver';
+import { fmtLen } from '../units';
+import { closeKeypad, openKeypad, toast, updateCtx } from '../editor/ports';
+import { cornerAt, cutCorner } from './corner';
+
+/*
+  Chamfer: cut a corner off straight. Both lines stop a distance back from the corner — the same on both sides
+  unless it's set as unequal — and a straight cut joins them (a wall of the same thickness between two walls). A
+  chamfer is measured from its corner, so the corner stays as a virtual sharp (dashed lines out to it): the distance
+  back along one side is a driving dimension, and "equal" holds the other side to it (or a second dimension, unequal).
+*/
+
+/** The corner's two lines, if it can be cut off. */
+export const chamferable = (sk: Sketch, pid: string): boolean => !!cornerAt(sk, pid);
+
+/** The most a corner can be cut back along each line. */
+export function maxChamfer(sk: Sketch, pid: string): [number, number] {
+  const k = cornerAt(sk, pid);
+  return k ? [k.len1, k.len2] : [0, 0];
+}
+
+/** Show which side a distance is along while it's entered (the line selected). */
+function showSide(lid: string | null): void { ed.sel = lid ? [{ type: 'line', id: lid }] : []; updateCtx(); requestDraw(); }
+
+/** The Chamfer action: the keypad for the distance back from the corner (Unequal: one for each side), then the corner is cut off. */
+export function chamferPrompt(pid: string): void {
+  const sk = SK(), k = cornerAt(sk, pid);
+  if (!k) { toast('Select a corner where two lines meet to cut it off.', { warn: true }); return; }
+  const most = Math.min(k.len1, k.len2), start = Math.round(Math.min(6, most * 0.5) * 16) / 16;
+  openKeypad({
+    title: 'Chamfer', sub: 'Back from the corner along each side — up to ' + fmtLen(most), initial: fmtLen(start), selectAll: true, laser: true,
+    extras: () => [{ label: 'Unequal', ariaLabel: 'Unequal: a distance for each side', onPress: () => { closeKeypad(); unequal(pid); } }],
+    onDone: d => { chamferCorner(pid, d, d); },
+  });
+}
+
+/** Unequal: the distance along one side (selected while it's entered), then along the other. */
+function unequal(pid: string): void {
+  const k = cornerAt(SK(), pid);
+  if (!k) return;
+  const back = ed.sel;
+  showSide(k.l1);
+  openKeypad({
+    title: 'Chamfer · first side', sub: 'Along the selected line — up to ' + fmtLen(k.len1), initial: fmtLen(Math.round(Math.min(6, k.len1 * 0.5) * 16) / 16), selectAll: true, laser: true,
+    onClose: () => { if (ed.sel.length === 1 && ed.sel[0].id === k.l1) { ed.sel = back; updateCtx(); requestDraw(); } },
+    onDone: d1 => {
+      showSide(k.l2);
+      openKeypad({
+        title: 'Chamfer · second side', sub: 'Along the selected line — up to ' + fmtLen(k.len2), initial: fmtLen(Math.round(Math.min(6, k.len2 * 0.5) * 16) / 16), selectAll: true, laser: true,
+        onClose: () => { if (ed.sel.length === 1 && ed.sel[0].id === k.l2) { ed.sel = back; updateCtx(); requestDraw(); } },
+        onDone: d2 => { chamferCorner(pid, d1, d2); },
+      });
+    },
+  });
+}
+
+/**
+ * Cut corner `pid` off: `d1` back along its first line, `d2` along its second (the same: an equal chamfer, held equal).
+ * Returns the cut's line id, or null (and says why) if it can't.
+ */
+export function chamferCorner(pid: string, d1: number, d2: number = d1): string | null {
+  const sk = SK(), k = cornerAt(sk, pid);
+  if (!k) { toast('Select a corner where two lines meet to cut it off.', { warn: true }); return null; }
+  if (!(d1 > 0) || !(d2 > 0)) return null;
+  if (d1 >= k.len1 - 1e-6 || d2 >= k.len2 - 1e-6) {
+    const most = d1 === d2 ? fmtLen(Math.min(k.len1, k.len2)) : fmtLen(d1 >= k.len1 - 1e-6 ? k.len1 : k.len2);
+    toast('That’s more than this corner’s side: ' + most + ' at most.', { warn: true });
+    return null;
+  }
+  pushHistory();
+  const before = JSON.stringify(sk), L1 = sk.lines[k.l1], L2 = sk.lines[k.l2], wall = L1.kind === 'wall' && L2.kind === 'wall';
+  const cut = cutCorner(sk, k, d1, d2, (t1, t2) => {
+    const id = addLine(sk, t1, t2, { kind: wall ? 'wall' : 'line', constr: L1.constr && L2.constr, thick: wall ? L1.thick : undefined });
+    return id;
+  }, true);
+  const { c1, c2 } = cut.sharp!;
+  // the distance back along the first side drives it; the second is equal to it, or its own
+  const cons = [
+    ...cut.cons,
+    { type: 'dist' as const, a: cut.t1, b: pid, line: c1, value: d1, driving: true },
+    d1 === d2 ? { type: 'eq' as const, l1: c1, l2: c2 } : { type: 'dist' as const, a: cut.t2, b: pid, line: c2, value: d2, driving: true },
+  ];
+  for (const cn of cons) tryAddConstraint(cn, { silent: true });
+  if (!solver.solve(sk).ok) {
+    replaceSK(JSON.parse(before) as Sketch);
+    dropHistory();
+    toast('That corner can’t be cut off with the constraints it has.', { warn: true });
+    afterEdit();
+    return null;
+  }
+  ed.sel = [{ type: 'line', id: cut.edge }];
+  afterEdit();
+  updateCtx(); requestDraw();
+  toast('Corner cut off: ' + (d1 === d2 ? fmtLen(d1) + ' each side' : fmtLen(d1) + ' × ' + fmtLen(d2)));
+  return cut.edge;
+}

package/src/tools/corner.ts

@@ -0,0 +1,99 @@
+import { cornerLines } from '../editor/selection';
+import { hyp } from '../model/geom';
+import { roomEdges } from '../model/rooms';
+import { addLine, addPoint } from '../model/sketch';
+import type { Constraint, Sketch, WallFace, XY } from '../model/types';
+
+/*
+  Cutting a corner back, for Fillet and Chamfer: where two lines (or walls) meet, each line stops a distance short of
+  the corner and something new joins the two ends (an arc, a straight cut). What hangs on the lines follows: doors
+  and windows keep their place, level/plumb moves to the new ends, a space around the corner takes the new edge.
+  Whatever was measured to the corner keeps its meaning: the corner stays as a "virtual sharp" — dashed lines from
+  the new ends out to where the two lines would meet.
+*/
+
+const norm = (x: number, y: number): XY => { const L = hyp(x, y) || 1; return { x: x / L, y: y / L }; };
+
+/** A corner where two lines meet: the point, the two lines with their far ends, directions away from the corner and lengths, and the angle between them. */
+export interface Corner {
+  pid: string; P: XY;
+  l1: string; l2: string; q1: string; q2: string;
+  u1: XY; u2: XY; len1: number; len2: number;
+  /** the angle between the lines, radians (0 < th < π) */
+  th: number;
+}
+
+/** The corner at `pid`, if it can be cut back: two lines meet there, not in a straight line, neither of them a wall face's own edge. */
+export function cornerAt(sk: Sketch, pid: string): Corner | null {
+  const pair = cornerLines(sk, pid), P = sk.points[pid];
+  if (!pair || !P || P.anchor || pair.some(id => sk.lines[id].anchor)) return null;
+  const [l1, l2] = pair, L1 = sk.lines[l1], L2 = sk.lines[l2];
+  const q1 = L1.a === pid ? L1.b : L1.a, q2 = L2.a === pid ? L2.b : L2.a, Q1 = sk.points[q1], Q2 = sk.points[q2];
+  const u1 = norm(Q1.x - P.x, Q1.y - P.y), u2 = norm(Q2.x - P.x, Q2.y - P.y);
+  const th = Math.acos(Math.max(-1, Math.min(1, u1.x * u2.x + u1.y * u2.y)));
+  if (!(th > 0.5 * Math.PI / 180 && th < 179.5 * Math.PI / 180)) return null;
+  return { pid, P, l1, l2, q1, q2, u1, u2, len1: hyp(Q1.x - P.x, Q1.y - P.y), len2: hyp(Q2.x - P.x, Q2.y - P.y), th };
+}
+
+/** Whether anything besides its two lines hangs on the corner (dimensions, constraints, curves, door/window dimensions, a cabinet). */
+function cornerUsed(sk: Sketch, k: Corner): boolean {
+  const { pid, l1, l2 } = k;
+  return Object.values(sk.cons).some(cn => cn.a === pid || cn.b === pid || cn.p === pid || (cn.type === 'angle' && [cn.l1, cn.l2].includes(l1) && [cn.l1, cn.l2].includes(l2)))
+    || Object.values(sk.circles).some(ci => ci.c === pid) || Object.values(sk.arcs).some(a => [a.c, a.a, a.b].includes(pid))
+    || Object.values(sk.openings).some(o => (o.dims || []).some(dm => 'pt' in dm.ref && dm.ref.pt === pid))
+    || Object.values((sk as WallFace).cabs ?? {}).some(cb => [cb.bl, cb.br, cb.tr, cb.tl].includes(pid));
+}
+
+export interface Cut {
+  /** the new ends of the two lines */
+  t1: string; t2: string;
+  /** what joins them */
+  edge: string;
+  /** the virtual sharp's dashed lines (new end → corner), when the corner is kept */
+  sharp: { c1: string; c2: string } | null;
+  /** constraints to add for the cut (the dashed lines staying on the lines' lines) */
+  cons: Constraint[];
+}
+
+/**
+ * Cut corner `k` back: line 1 stops `d1` short of it, line 2 `d2`, and `join(t1, t2)` makes what joins the new ends
+ * (returning its id). `keepSharp`: keep the corner as a virtual sharp even when nothing else hangs on it (a chamfer
+ * is measured from it). The caller has pushed history; it adds the returned constraints and its own, and solves.
+ */
+export function cutCorner(sk: Sketch, k: Corner, d1: number, d2: number, join: (t1: string, t2: string) => string, keepSharp = false): Cut {
+  const { pid, P, l1, l2, q1, q2, u1, u2 } = k, L1 = sk.lines[l1], L2 = sk.lines[l2];
+  // the spaces around the corner, as they are now (their sides are found from the corner's lines)
+  const rooms = Object.entries(sk.rooms).map(([id, rm]) => ({ id, i: rm.loop.indexOf(pid), edges: rm.loop.includes(pid) ? roomEdges(sk, rm) : null })).filter(x => x.i >= 0 && x.edges);
+  const t1 = addPoint(sk, P.x + u1.x * d1, P.y + u1.y * d1), t2 = addPoint(sk, P.x + u2.x * d2, P.y + u2.y * d2);
+  // doors and windows keep their place along a line whose start moves
+  for (const o of Object.values(sk.openings)) {
+    if (o.line === l1 && L1.a === pid) o.at -= d1;
+    if (o.line === l2 && L2.a === pid) o.at -= d2;
+  }
+  // level/plumb on a line, set between the corner and its other end: between the new end and that end now
+  for (const cn of Object.values(sk.cons)) {
+    if (cn.type !== 'h' && cn.type !== 'v') continue;
+    if ((cn.a === pid && cn.b === q1) || (cn.b === pid && cn.a === q1)) { if (cn.a === pid) cn.a = t1; else cn.b = t1; }
+    else if ((cn.a === pid && cn.b === q2) || (cn.b === pid && cn.a === q2)) { if (cn.a === pid) cn.a = t2; else cn.b = t2; }
+  }
+  if (L1.a === pid) L1.a = t1; else L1.b = t1;
+  if (L2.a === pid) L2.a = t2; else L2.b = t2;
+  const keep = keepSharp || cornerUsed(sk, k);
+  const edge = join(t1, t2), cons: Constraint[] = [];
+  let sharp: Cut['sharp'] = null;
+  if (keep) {
+    const c1 = addLine(sk, t1, pid, { constr: true }), c2 = addLine(sk, t2, pid, { constr: true });
+    sharp = { c1, c2 };
+    cons.push({ type: 'col', l1, l2: c1 }, { type: 'col', l1: l2, l2: c2 });
+    // an angle at the corner is between the dashed lines now (they still meet there)
+    for (const cn of Object.values(sk.cons)) if (cn.type === 'angle' && [cn.l1, cn.l2].includes(l1) && [cn.l1, cn.l2].includes(l2)) { cn.l1 = cn.l1 === l1 ? c1 : c2; cn.l2 = cn.l2 === l2 ? c2 : c1; }
+  }
+  // spaces: the corner becomes the two new ends, with the new edge between them
+  for (const rm of rooms) {
+    const room = sk.rooms[rm.id], i = rm.i, n = room.loop.length, edges = rm.edges!;
+    const into = edges[(i - 1 + n) % n], tIn = into === l1 ? t1 : t2, tOut = into === l1 ? t2 : t1;
+    room.loop = [...room.loop.slice(0, i), tIn, tOut, ...room.loop.slice(i + 1)];
+    room.edges = [...edges.slice(0, i), edge, ...edges.slice(i)];
+  }
+  return { t1, t2, edge, sharp, cons };
+}