@reekon-tools/boldr-cad 1.1.0 → 1.3.0

package/src/tools/survey.ts

@@ -0,0 +1,260 @@
+import { afterEdit, analyze, tryAddConstraint } from '../app/edit';
+import { ed } from '../app/state';
+import { measure } from '../model/constraints';
+import { hyp } from '../model/geom';
+import { pushHistory } from '../model/history';
+import { maybeRoom, roomGeom } from '../model/rooms';
+import { onSessionReset, sessionState } from '../model/session';
+import { addLine, addPoint, gc, lineBetween, pinnedPoints } from '../model/sketch';
+import { page, SK, store } from '../model/store';
+import type { Constraint, XY } from '../model/types';
+import { TH } from '../render/theme';
+import { requestDraw, requestOverlayDraw, S, V } from '../render/view';
+import { fmtArea, fmtLen } from '../units';
+import { elevOpen } from '../editor/elevation';
+import { keypadOpen } from '../editor/keypad';
+import type { KeyIn } from '../editor/keys';
+import { drawsWalls, setMode } from '../editor/mode';
+import { toast, updateCtx, updateHint } from '../editor/ports';
+import { close3d } from '../editor/view3d';
+import { is3d } from '../editor/view3dState';
+import { anchorMark, lengthPreview, setTool, type Tool } from './registry';
+
+/*
+  The templator: points measured by a device in the host app (BOLDR's T1R) build the drawing directly. Each point joins
+  the last with a line (or a wall, with the Walls toggle on), and the drawing holds what was measured: a driving
+  length on every edge, and a driving angle at every corner. That fixes the shape's FORM — a later drag moves it
+  whole, it doesn't flex it — while leaving it free to be moved and turned into place. On a closed shape the last
+  edge and the corners either side of it are already set by the rest, so they come out as reference dimensions
+  (grey, in parentheses) rather than being refused: rule 3, and the closing edge's length still shows.
+
+  Where it lands: the device measures from itself, not from the page. The first point taken on a page puts its frame
+  there — that point at the middle of the screen — and every later point keeps its true place relative to it, for
+  the rest of the session. Kept per page and not per run on purpose: a cutout taken after its outline, from the same
+  setup, has to land where it really is relative to the outline, or templating it was pointless.
+
+  Points come in on the plan's own axes — x to the right, y up (render/view.ts's S) — and are placed as given. Which
+  way a device's angle turns is the host's business, not the editor's: the host turns its device's frame into this
+  one, and that's where a mirror gets in or doesn't. BOLDR's T1R turns clockwise, so the app negates y
+  (templatorPlanInches); passing its x = r·cos θ, y = r·sin θ straight in drew every template mirrored (seen on a device,
+  2026-10-28).
+*/
+
+/** How close a point has to land to the first one to close the shape: about 50 mm, inside the device's own error. */
+export const SURVEY_CLOSE_IN = 2;
+/** A point this close to the last one is the same point taken twice (a double press), not a new corner. */
+export const SURVEY_SAME_IN = 1 / 16;
+
+interface SurveyState {
+  /** the run's points, in order */
+  chain: string[];
+  /** each point's host record (surveyPoint's `capture`), kept with the dimensions it sets */
+  captures: Record<string, unknown>;
+}
+
+export interface SurveyTool extends Tool {
+  st: SurveyState;
+  closeShape(): void;
+  finish(): void;
+}
+
+/** Each page's frame for the session: what's added to a device point to place it on the plan. */
+const frames = sessionState(() => ({ byPage: {} as Record<string, { dx: number; dy: number }> }));
+
+const fresh = (): SurveyState => ({ chain: [], captures: {} });
+const withCapture = (capture: unknown) => (capture !== undefined ? { capture } : {});
+
+/** A driving length on line `lid`, as the two points it joins are now (so nothing moves). */
+function holdLength(lid: string, a: string, b: string, capture: unknown): void {
+  const sk = SK(), pa = sk.points[a], pb = sk.points[b];
+  if (!pa || !pb) return;
+  tryAddConstraint({ type: 'dist', a, b, kind: 'al', value: hyp(pb.x - pa.x, pb.y - pa.y), line: lid, driving: true, off: 0, ...withCapture(capture) }, { silent: true });
+}
+
+/**
+ * A corner this close to dead straight (or folded right back) is held as Collinear, not as an angle: the angle's
+ * equation turns on |cross|, whose slope vanishes there, so the solver reads a 180° angle as adding nothing (a
+ * reference dimension) and the corner is left as a hinge. Collinear says the same thing and holds it. 1e-4° is far
+ * outside where that happens (about 2e-6°) and far inside any real capture's spread, so a measured corner is never
+ * squared off by it — over a 30" edge it's a micrometre.
+ */
+const STRAIGHT_DEG = 1e-4;
+
+/** A driving angle at the corner where `l1` and `l2` meet, as it is now (Collinear, if it's straight). */
+function holdAngle(l1: string | undefined, l2: string | undefined, capture: unknown): void {
+  if (!l1 || !l2 || l1 === l2) return;
+  const c: Constraint = { type: 'angle', l1, l2, value: 0, driving: true };
+  c.value = measure(SK(), c);
+  if (c.value < STRAIGHT_DEG || c.value > 180 - STRAIGHT_DEG) { tryAddConstraint({ type: 'col', l1, l2 }, { silent: true }); return; }
+  tryAddConstraint({ ...c, ...withCapture(capture) }, { silent: true });
+}
+
+export const surveyTool: SurveyTool = {
+  st: fresh(),
+  /** Picked up (by a point arriving with another tool in hand): a new run. */
+  enter() { this.st = fresh(); },
+  /**
+   * Put down by cancelTool. Deliberately NOT the end of the run: undo cancels the tool in hand before it steps back,
+   * and ending the run there would leave a gap after every bad point undone. The run ends on Finish, Close shape,
+   * Esc or Enter (key, below) — which also put the templator down — or when another tool is picked up; either way the
+   * next point starts a new run (enter).
+   */
+  reset() { ed.preview = null; },
+  busy() { return false; },
+  /** Esc and Enter finish the run here, before the generic Esc (which can't tell itself from undo's cancel). */
+  key(e: KeyIn) {
+    if ((e.key === 'Escape' || e.key === 'Enter') && this.st.chain.length) { this.finish(); return true; }
+    return false;
+  },
+  /**
+   * End the run: the shape stays as drawn, and the templator is put down (back to Select). Left in hand it would
+   * swallow every tap — it has no pointer handling, its points come from the device — so the shape just made couldn't
+   * be selected, and a phone's bar, which drops the "Templator" label, wouldn't even say why. The next point picks it
+   * up again, in the same frame. A run of one point leaves nothing (a point on its own isn't a shape).
+   */
+  finish() {
+    const first = this.st.chain[0];
+    if (first) pinnedPoints.delete(first);
+    this.st = fresh();
+    ed.preview = null;
+    if (store.project) { gc(SK()); analyze(); }
+    if (ed.tool === 'survey') setTool('select');
+    updateCtx(); updateHint(); requestDraw();
+  },
+  /** Close the run back to its first point (the bar's Close shape, or a point taken there). */
+  closeShape() {
+    if (liveChain().length < 3) return;
+    pushHistory();
+    closeRun(undefined);
+    afterEdit();
+  },
+  hint() {
+    return this.st.chain.length
+      ? 'Take the next point with your templator. Take one back at the first point to close the shape.'
+      : 'Take points with your templator: each one joins the last.';
+  },
+};
+
+/** The run's points that are still in the drawing (an undo since can have taken the last few back). */
+function liveChain(): string[] {
+  const sk = SK(), st = surveyTool.st;
+  const keep = st.chain.filter(id => sk.points[id]);
+  if (keep.length !== st.chain.length) st.chain = keep;
+  return keep;
+}
+
+/**
+ * The run's first and last points, marked — where the next point joins, and where one would close the shape — and,
+ * while the device streams its live point (setSurveyCursor), the edge the next point would make: dashed from the last
+ * point to it, with its length, as the tool's own screen draws it. Worked out as the overlay paints, so it follows
+ * the live point (and a point undone) without being set again.
+ */
+function showRun(): void {
+  ed.preview = (c, T) => {
+    const sk = SK(), ch = surveyTool.st.chain.filter(id => sk.points[id]);
+    if (!ch.length) return;
+    const last = sk.points[ch[ch.length - 1]], cur = ed.surveyCursor;
+    if (cur && cur.page === page().id) {
+      const [x1, y1] = S(T, last.x, last.y), [x2, y2] = S(T, cur.x, cur.y);
+      c.save(); c.strokeStyle = TH.blue; c.lineWidth = 1.5; c.setLineDash([6, 5]);
+      c.beginPath(); c.moveTo(x1, y1); c.lineTo(x2, y2); c.stroke(); c.restore();
+      lengthPreview(c, T, last, cur);
+    }
+    for (const id of new Set([ch[0], ch[ch.length - 1]])) { const p = sk.points[id]; const [x, y] = S(T, p.x, p.y); anchorMark(c, x, y); }
+  };
+  requestOverlayDraw();
+}
+
+/**
+ * A device point on the current page's plan: the page's frame added. The page's first point or first live point,
+ * whichever comes first, sets the frame — that point at the middle of the screen — so the first point taken lands
+ * under the cursor that was showing it. (The caller has made sure no wall view is open: V() would be the wall's.)
+ */
+function onPlan(x: number, y: number): XY {
+  const pg = page().id;
+  if (!frames.byPage[pg]) { const v = V(); frames.byPage[pg] = { dx: v.cx - x, dy: v.cy - y }; }
+  const f = frames.byPage[pg];
+  return { x: x + f.dx, y: y + f.dy };
+}
+
+/**
+ * The device's live point, in inches on the plan's axes as takeSurveyPoint takes one, or null to hide it: a ring
+ * where its next point would land (render/draw.ts), plus the would-be edge while a run is open (showRun). Overlay
+ * only — it never touches the drawing, the undo history or React, so a host can call it many times a second.
+ * Whether it's showing afterwards: never in a wall view (its points belong to the plan) or a view-only drawing.
+ */
+export function setSurveyCursor(p: XY | null): boolean {
+  if (!p || ed.readOnly || elevOpen() || !store.project) {
+    if (ed.surveyCursor) { ed.surveyCursor = null; requestOverlayDraw(); }
+    return false;
+  }
+  const at = onPlan(p.x, p.y);
+  ed.surveyCursor = { x: at.x, y: at.y, page: page().id };
+  // (an undo cancels the tool's preview: the run's would-be edge comes back with the next live point)
+  if (ed.tool === 'survey' && !ed.preview && surveyTool.st.chain.length) showRun();
+  else requestOverlayDraw();
+  return true;
+}
+
+/** Close the run: the last edge back to the first point, its length, the two corners it makes, and a space. */
+function closeRun(capture: unknown): void {
+  const sk = SK(), st = surveyTool.st, ch = st.chain;
+  const first = ch[0], last = ch[ch.length - 1];
+  const lid = addLine(sk, last, first, { kind: drawsWalls() ? 'wall' : 'line', constr: !drawsWalls() && ed.drawConstr });
+  // (already set by the rest of the shape: these come out as reference dimensions)
+  holdLength(lid, last, first, capture ?? st.captures[first]);
+  holdAngle(lineBetween(sk, ch[ch.length - 2], last), lid, st.captures[last]);
+  holdAngle(lid, lineBetween(sk, first, ch[1]), st.captures[first]);
+  const n = ch.length, rid = drawsWalls() || !ed.drawConstr ? maybeRoom(sk, ch.slice()) : null;
+  surveyTool.finish();
+  toast(rid ? sk.rooms[rid].name + ' added — ' + fmtArea(roomGeom(sk, sk.rooms[rid]).area) : 'Closed shape, ' + n + ' sides');
+}
+
+/**
+ * A point from the host's device, in inches, on the plan's axes — y up (see the note at the top). Starts the
+ * templator if it isn't in hand, and the run's frame on a page with none yet. False when the drawing can't take it
+ * now (the toast says why).
+ */
+export function takeSurveyPoint(x: number, y: number, capture?: unknown): boolean {
+  if (ed.readOnly) return false;
+  if (elevOpen()) { toast('Back out of the wall view to take templator points on the plan.', { warn: true }); return false; }
+  if (keypadOpen()) { toast('Close the keypad, then take the point again.', { warn: true }); return false; }
+  // (the templator works on the plan: from the 3D tab or Annotate, back to Draft)
+  if (is3d()) close3d();
+  if (ed.mode !== 'draft') setMode('draft');
+  if (ed.tool !== 'survey') setTool('survey');
+
+  const sk = SK(), st = surveyTool.st, ch = liveChain();
+  const { x: wx, y: wy } = onPlan(x, y);
+
+  const last = ch.length ? sk.points[ch[ch.length - 1]] : null;
+  if (last && hyp(wx - last.x, wy - last.y) < SURVEY_SAME_IN) { toast('Same point as the last one — move the templator, then take the next.', { warn: true }); return false; }
+  if (ch.length >= 3) {
+    const p0 = sk.points[ch[0]];
+    if (hyp(wx - p0.x, wy - p0.y) < SURVEY_CLOSE_IN) { pushHistory(); closeRun(capture); afterEdit(); return true; }
+  }
+
+  pushHistory();
+  const id = addPoint(sk, wx, wy);
+  if (capture !== undefined) st.captures[id] = capture;
+  if (!ch.length) {
+    // (on its own until the next point, garbage collection would take it: kept until the run ends)
+    pinnedPoints.add(id);
+  } else {
+    const prev = ch[ch.length - 1];
+    const lid = addLine(sk, prev, id, { kind: drawsWalls() ? 'wall' : 'line', constr: !drawsWalls() && ed.drawConstr });
+    holdLength(lid, prev, id, capture);
+    if (ch.length >= 2) holdAngle(lineBetween(sk, ch[ch.length - 2], prev), lid, st.captures[prev]);
+  }
+  st.chain.push(id);
+  ed.sel = [];
+  afterEdit();
+  showRun();
+  updateHint();
+  const n = st.chain.length, a = sk.points[st.chain[n - 2]];
+  toast(n === 1 ? 'Templator: point 1, at the middle of the screen' : 'Point ' + n + ' · ' + fmtLen(hyp(wx - a.x, wy - a.y)));
+  return true;
+}
+
+// a new session (another drawing): every page's frame and the run start again
+onSessionReset(() => { surveyTool.st = fresh(); });