@7365admin1/layer-common 4.49.0 → 4.51.0

package/utils/rmf-editor.ts

@@ -0,0 +1,756 @@
+/**
+ * The map editor <-> the building's HERO Fleet Core data (the map's `rmf`
+ * part: world metres, y up, vertices shared by walls / doors / lanes). Pure
+ * functions - the editor and the 3D view only draw what these return, and
+ * `test/rmf-editor.test.mjs` pins them.
+ *
+ * The data model follows Open-RMF's building format (rmf_traffic_editor
+ * building.yaml: levels with vertices, walls, doors, lanes on graphs 0-8,
+ * measurements and fiducials; lifts with cabin doors and the doors that open
+ * on each level). The level alignment below is a port of
+ * rmf_building_map_tools transform.py `set_from_fiducials`. Those projects are
+ * Copyright Open Source Robotics Foundation, licensed under the Apache
+ * License, Version 2.0.
+ */
+import {
+  DEFAULT_FRAME,
+  shapesFromMap,
+  shareToWorld,
+  worldToShare,
+  type TEditorShape,
+  type TFrame,
+  type TPlanPlacement,
+  type TRouteGraph,
+} from "./robot-building";
+import { floorName } from "./robot-display";
+
+type TPt = { x: number; y: number };
+const r3 = (v: number) => Math.round(v * 1000) / 1000;
+const r2 = (p: TPt) => ({ x: Math.round(p.x * 100) / 100, y: Math.round(p.y * 100) / 100 });
+/** Shares with sub-millimetre precision for any frame up to 5 km (what a map opens with; an edit rounds what it moves). */
+const r6 = (p: TPt) => ({ x: Math.round(p.x * 1e6) / 1e6, y: Math.round(p.y * 1e6) / 1e6 });
+const WELD_M = 0.01;
+
+export const VERTEX_PARAMS = [
+  "is_charger", "is_parking_spot", "is_holding_point", "is_passthrough_point", "is_cleaning_zone",
+  "dock_name", "spawn_robot_name", "spawn_robot_type", "pickup_dispenser", "dropoff_ingestor",
+  "lift_cabin", "merge_radius", "mutex", "human_goal_set_name",
+] as const;
+export const DOOR_TYPES = ["hinged", "double_hinged", "sliding", "double_sliding"] as const;
+export const LIFT_DOOR_TYPES = ["sliding", "double_sliding", "telescope", "double_telescope"] as const;
+
+/** The door types in plain words (the building file's names stay in the data). */
+export const DOOR_TYPE_LABEL: Record<string, string> = {
+  hinged: "Single swing",
+  double_hinged: "Double swing",
+  sliding: "Single sliding",
+  double_sliding: "Double sliding",
+};
+export const LIFT_DOOR_TYPE_LABEL: Record<string, string> = {
+  sliding: "Single sliding",
+  double_sliding: "Double sliding",
+  telescope: "Single telescopic",
+  double_telescope: "Double telescopic",
+};
+
+/* -------------------------------------------------------------- frames */
+
+/** A floor plan's four corners in world metres (top-left at (tx, -ty), turned yawRad about it). */
+export function planCorners(p: { widthPx: number; heightPx: number } & TPlanPlacement): TPt[] {
+  const w = p.widthPx * p.metersPerPixel;
+  const h = p.heightPx * p.metersPerPixel;
+  const a = p.yawRad ?? 0;
+  const o = { x: p.tx, y: -p.ty };
+  // Image x runs along +x turned by yaw; image y (down) runs along -y turned by yaw.
+  const at = (u: number, v: number) => ({ x: o.x + u * Math.cos(a) + v * Math.sin(a), y: o.y + u * Math.sin(a) - v * Math.cos(a) });
+  return [at(0, 0), at(w, 0), at(w, h), at(0, h)];
+}
+
+const union = (a: TFrame | null, xs: number[], ys: number[]): TFrame | null => {
+  if (!xs.length) return a;
+  const minX = Math.min(...xs, ...(a ? [a.minX] : []));
+  const maxX = Math.max(...xs, ...(a ? [a.minX + a.w] : []));
+  const minY = Math.min(...ys, ...(a ? [a.maxY - a.h] : []));
+  const maxY = Math.max(...ys, ...(a ? [a.maxY] : []));
+  return { minX: r3(minX), maxY: r3(maxY), w: r3(maxX - minX), h: r3(maxY - minY) };
+};
+
+/**
+ * The frame the editor opens with: every floor's stored plan frame (a map
+ * drawn before the building-file work: the 40 x 26 m frame), grown to take in
+ * every floor plan image - so a big plan is never cut off.
+ */
+export function frameForMap(map: Record<string, any> | null | undefined, plans: Array<{ widthPx: number; heightPx: number } & TPlanPlacement> = []): TFrame {
+  let f: TFrame | null = null;
+  for (const lv of (map?.rmf?.levels ?? []) as Array<Record<string, any>>) {
+    const pf = lv.planFrame;
+    if (pf && pf.maxX > pf.minX && pf.maxY > pf.minY) f = union(f, [pf.minX, pf.maxX], [pf.minY, pf.maxY]);
+  }
+  if (!f) f = { ...DEFAULT_FRAME };
+  return growFrame(f, plans);
+}
+
+/** The frame grown (never shrunk) to take in these floor plans. */
+export function growFrame(f: TFrame, plans: Array<{ widthPx: number; heightPx: number } & TPlanPlacement>): TFrame {
+  const xs: number[] = [];
+  const ys: number[] = [];
+  for (const p of plans) for (const c of planCorners(p)) xs.push(c.x), ys.push(c.y);
+  const g = union(f, xs, ys)!;
+  return g.minX === f.minX && g.maxY === f.maxY && g.w === f.w && g.h === f.h ? f : g;
+}
+
+/** The frame fitted round everything drawn and every plan, 2 m round, at least 10 m a side. */
+export function fitFrame(shapes: TEditorShape[], f: TFrame, plans: Array<{ widthPx: number; heightPx: number } & TPlanPlacement> = [], pad = 2): TFrame {
+  const xs: number[] = [];
+  const ys: number[] = [];
+  for (const s of shapes) for (const p of s.points) {
+    const w = shareToWorld(f, p);
+    xs.push(w.x);
+    ys.push(w.y);
+  }
+  for (const p of plans) for (const c of planCorners(p)) xs.push(c.x), ys.push(c.y);
+  if (!xs.length) return f;
+  let minX = Math.min(...xs) - pad;
+  let maxX = Math.max(...xs) + pad;
+  let minY = Math.min(...ys) - pad;
+  let maxY = Math.max(...ys) + pad;
+  if (maxX - minX < 10) [minX, maxX] = [(minX + maxX) / 2 - 5, (minX + maxX) / 2 + 5];
+  if (maxY - minY < 10) [minY, maxY] = [(minY + maxY) / 2 - 5, (minY + maxY) / 2 + 5];
+  return { minX: r3(minX), maxY: r3(maxY), w: r3(maxX - minX), h: r3(maxY - minY) };
+}
+
+/**
+ * Where a floor plan sits over the editor's plan, in shares of the frame
+ * (the editor draws everything in %), and its turn in degrees for CSS
+ * (clockwise on screen).
+ */
+export function planBoxIn(f: TFrame, p: { widthPx: number; heightPx: number } & TPlanPlacement) {
+  const tl = worldToShare(f, { x: p.tx, y: -p.ty });
+  return {
+    left: tl.x,
+    top: tl.y,
+    width: ((p.widthPx * p.metersPerPixel) / f.w) * 100,
+    height: ((p.heightPx * p.metersPerPixel) / f.h) * 100,
+    rotateDeg: -((p.yawRad ?? 0) * 180) / Math.PI,
+  };
+}
+
+/**
+ * A stored floor plan's placement in world metres. A plan placed by this
+ * editor says so (`space: "world"`). An older placement is in the floor's
+ * 40 x 26 m plan frame, which for a map with an rmf part stands for that
+ * floor's `planFrame` - it is converted through it (the older view stretched
+ * a non-40:26 frame; the width's scale is used). Maps drawn in the default
+ * frame read the same either way.
+ */
+export function placementInWorld<T extends TPlanPlacement & { space?: string }>(p: T, planFrame?: { minX: number; maxX: number; minY: number; maxY: number } | null): T {
+  if (p.space === "world" || !planFrame) return p;
+  const w = planFrame.maxX - planFrame.minX;
+  const h = planFrame.maxY - planFrame.minY;
+  if (!(w > 0 && h > 0) || (planFrame.minX === 0 && planFrame.maxY === 0 && w === 40 && h === 26)) return p;
+  const sx = w / 40;
+  const sy = h / 26;
+  return { ...p, metersPerPixel: p.metersPerPixel * sx, tx: planFrame.minX + p.tx * sx, ty: -(planFrame.maxY - p.ty * sy) };
+}
+
+/** Every floor plan of a map, placed in world metres (see `placementInWorld`). */
+export function worldPlans(map: Record<string, any> | null | undefined) {
+  const frames = new Map(((map?.rmf?.levels ?? []) as Array<Record<string, any>>).map((l) => [Number(l.floorNo), l.planFrame]));
+  return ((map?.floorPlans ?? []) as Array<Record<string, any>>).map((p) =>
+    placementInWorld({ floorNo: Number(p.floorNo), widthPx: p.widthPx, heightPx: p.heightPx, metersPerPixel: p.metersPerPixel, tx: p.tx, ty: p.ty, yawRad: p.yawRad ?? 0, space: p.space }, frames.get(Number(p.floorNo))),
+  );
+}
+
+/** A new plan fitted inside the frame, top-left aligned, aspect kept. */
+export function fitPlanIn(f: TFrame, widthPx: number, heightPx: number): TPlanPlacement {
+  return { metersPerPixel: Math.round(Math.min(f.w / widthPx, f.h / heightPx) * 1e6) / 1e6, tx: f.minX, ty: -f.maxY, yawRad: 0 };
+}
+
+/* ---------------------------------------------------- measure and align */
+
+type TXform = { scale: number; rot: number; tx: number; ty: number };
+type TNamed = TPt & { name: string };
+
+/** transform.py transform_point: rotate, scale, then shift. */
+export const applyXform = (t: TXform, p: TPt) => ({
+  x: (p.x * Math.cos(t.rot) - p.y * Math.sin(t.rot)) * t.scale + t.tx,
+  y: (p.x * Math.sin(t.rot) + p.y * Math.cos(t.rot)) * t.scale + t.ty,
+});
+
+/**
+ * transform.py set_from_fiducials: the transform that puts the floor being
+ * aligned (`pairs[i][1]`) onto the reference floor (`pairs[i][0]`): turn =
+ * circular mean of the bearing differences, scale = mean distance ratio,
+ * shift = mean offset. Null with fewer than two pairs.
+ */
+export function fiducialTransform(pairs: Array<[TNamed, TNamed]>, refScale = 1): TXform | null {
+  const bearings: Array<[number, number]> = [];
+  const distances: Array<[number, number]> = [];
+  for (let i = 0; i < pairs.length; i++) {
+    for (let j = i + 1; j < pairs.length; j++) {
+      const [a0, a1] = pairs[i]!;
+      const [b0, b1] = pairs[j]!;
+      bearings.push([Math.atan2(b0.y - a0.y, b0.x - a0.x), Math.atan2(b1.y - a1.y, b1.x - a1.x)]);
+      distances.push([Math.hypot(b0.x - a0.x, b0.y - a0.y), Math.hypot(b1.x - a1.x, b1.y - a1.y)]);
+    }
+  }
+  if (!bearings.length) return null;
+  let sin = 0;
+  let cos = 0;
+  for (const [ref, target] of bearings) {
+    sin += Math.sin(target - ref);
+    cos += Math.cos(target - ref);
+  }
+  const rot = -Math.atan2(sin, cos);
+  const rel = distances.reduce((n, [ref, target]) => n + target / (ref || 1e-9), 0) / distances.length;
+  if (!(rel > 0) || !Number.isFinite(rel)) return null;
+  let tx = 0;
+  let ty = 0;
+  for (const [f0, f1] of pairs) {
+    const q = { x: (f1.x / rel) * Math.cos(rot) - (f1.y / rel) * Math.sin(rot), y: (f1.x / rel) * Math.sin(rot) + (f1.y / rel) * Math.cos(rot) };
+    tx += q.x - f0.x;
+    ty += q.y - f0.y;
+  }
+  return { scale: refScale / rel, rot, tx: (tx * -refScale) / pairs.length, ty: (ty * -refScale) / pairs.length };
+}
+
+/** A floor plan placement moved by a world transform (its corner moves; it scales and turns with it). */
+export function transformPlacement(p: TPlanPlacement, t: TXform): TPlanPlacement {
+  const o = applyXform(t, { x: p.tx, y: -p.ty });
+  return { metersPerPixel: Math.round(p.metersPerPixel * t.scale * 1e6) / 1e6, tx: r3(o.x), ty: r3(-o.y), yawRad: Math.round(((p.yawRad ?? 0) + t.rot) * 10000) / 10000 };
+}
+
+/**
+ * Line one floor up with another: the fiducials the two floors share by name
+ * (at least two) give the turn, scale and shift. The result also says how far
+ * off the marks still are after it (metres), in plain words for the panel.
+ */
+export function alignFloor(shapes: TEditorShape[], f: TFrame, floorNo: number, refFloorNo: number) {
+  const marks = (fl: number) =>
+    shapes.filter((s) => s.kind === "fiducial" && s.floorNo === fl && s.name).map((s) => ({ ...shareToWorld(f, s.points[0]!), name: s.name! }));
+  const ref = marks(refFloorNo);
+  const mine = marks(floorNo);
+  const pairs: Array<[TNamed, TNamed]> = [];
+  for (const a of ref) for (const b of mine) if (a.name === b.name) pairs.push([a, b]);
+  if (pairs.length < 2) {
+    return { error: `Place at least two fiducials with the same names on ${floorName(floorNo)} and ${floorName(refFloorNo)} first (they share ${pairs.length}).` } as const;
+  }
+  const t = fiducialTransform(pairs, 1)!;
+  const residual = Math.max(...pairs.map(([a, b]) => {
+    const q = applyXform(t, b);
+    return Math.hypot(q.x - a.x, q.y - a.y);
+  }));
+  return { t, pairs: pairs.length, residual, text: `${floorName(floorNo)} lined up with ${floorName(refFloorNo)} on ${pairs.length} fiducials: turned ${((t.rot * 180) / Math.PI).toFixed(1)}°, scaled ${(t.scale * 100).toFixed(1)}%, largest mismatch ${residual.toFixed(2)} m.` } as const;
+}
+
+/**
+ * Scale by measurement: the measured line's real length gives the factor;
+ * the floor's plan (and, when asked, what is drawn on it) grows or shrinks
+ * about the plan's top-left corner - so the plan and the drawing stay
+ * together. Null factor with a reason when it cannot be done.
+ */
+export function measureScale(f: TFrame, measure: TEditorShape, realM: number, placement: TPlanPlacement | null) {
+  if (!(realM > 0) || !Number.isFinite(realM)) return { error: "Enter the real length in metres (more than 0)." } as const;
+  const [a, b] = measure.points.map((p) => shareToWorld(f, p));
+  const drawn = Math.hypot(b!.x - a!.x, b!.y - a!.y);
+  if (drawn < 0.05) return { error: "The two ends are too close together - measure a longer length." } as const;
+  const k = realM / drawn;
+  if (placement && (placement.metersPerPixel * k < 0.0001 || placement.metersPerPixel * k > 10)) {
+    return { error: "That length gives an impossible scale. Check the two ends and the number." } as const;
+  }
+  const o = placement ? { x: placement.tx, y: -placement.ty } : { x: f.minX, y: f.maxY };
+  // x' = k (x - o) + o, as a transform (no turn).
+  const t = { scale: k, rot: 0, tx: o.x * (1 - k), ty: o.y * (1 - k) };
+  return { k, t, placement: placement ? { ...placement, metersPerPixel: Math.round(placement.metersPerPixel * k * 1e6) / 1e6 } : null } as const;
+}
+
+/* ------------------------------------------------------- lift cabin doors */
+
+export type TCabinDoor = { name: string; type: (typeof LIFT_DOOR_TYPES)[number]; x: number; y: number; widthM: number; axisYawRad: number };
+export type TLiftSide = "front" | "back" | "left" | "right";
+export const LIFT_SIDES: TLiftSide[] = ["front", "back", "right", "left"];
+export const LIFT_SIDE_LABEL: Record<TLiftSide, string> = { front: "Front", back: "Back", right: "Right", left: "Left" };
+
+/** A cabin door on one side of the cabin (cabin frame: x across the width, y along the depth; lift.py sides). */
+export function cabinDoorOn(side: TLiftSide, widthM: number, depthM: number, door: Partial<TCabinDoor> = {}): TCabinDoor {
+  const width = Math.min(door.widthM ?? Math.min(1.2, (side === "front" || side === "back" ? widthM : depthM) * 0.8), 10);
+  const pos: Record<TLiftSide, { x: number; y: number; a: number }> = {
+    front: { x: 0, y: depthM / 2, a: 0 },
+    back: { x: 0, y: -depthM / 2, a: 0 },
+    right: { x: widthM / 2, y: 0, a: Math.PI / 2 },
+    left: { x: -widthM / 2, y: 0, a: Math.PI / 2 },
+  };
+  const p = pos[side];
+  return { name: door.name ?? side, type: door.type ?? "double_sliding", x: r3(p.x), y: r3(p.y), widthM: r3(width), axisYawRad: r3(p.a) };
+}
+
+/** Which side of the cabin a door is on - lift.py's rule (nearest side wall). */
+export function cabinDoorSide(d: Pick<TCabinDoor, "x" | "y">, widthM: number, depthM: number): TLiftSide {
+  const dx = Math.abs(Math.abs(d.x) - widthM / 2);
+  const dy = Math.abs(Math.abs(d.y) - depthM / 2);
+  if (dx <= dy) return d.x > 0 ? "right" : "left";
+  return d.y > 0 ? "front" : "back";
+}
+
+/** A lift's default cabin door, as the server gives a lift saved without one (core `mergeLegacyIntoRmf`). */
+export const defaultCabinDoor = (widthM: number, depthM: number): TCabinDoor => ({
+  name: "door1",
+  type: "double_sliding",
+  x: r3(widthM / 2),
+  y: 0,
+  widthM: r3(Math.min(1.2, depthM * 0.8)),
+  axisYawRad: r3(Math.PI / 2),
+});
+
+/* --------------------------------------------------- map -> editor model */
+
+export type TLevelMeta = { floorNo: number; name: string; elevationM: number; floors: string[][]; holes: string[][]; floorPolys: TPt[][]; holePolys: TPt[][] };
+export type TEditorModel = {
+  shapes: TEditorShape[];
+  frame: TFrame;
+  graphs: TRouteGraph[];
+  /** Per floor: name, height and the floor / hole outlines the editor does not draw (kept on save). */
+  levels: Record<string, { name: string; elevationM: number; floorPolys: TPt[][]; holePolys: TPt[][] }>;
+  referenceLevel?: string;
+  source?: string;
+};
+
+let seq = 0;
+const nid = (k: string) => `${k}${(seq++).toString(36)}`;
+
+/**
+ * A saved map as the editor's shapes. A map with an `rmf` part opens from it
+ * (lanes, waypoints, fiducials, measurements, door types, lift angle and
+ * cabin doors); an older map opens from its walls, zones, doors and lifts in
+ * the 40 x 26 m frame, exactly as before.
+ */
+export function editorModelFromMap(map: Record<string, any> | null | undefined, frame?: TFrame): TEditorModel {
+  const rmf = map?.rmf;
+  const levels: TEditorModel["levels"] = {};
+  if (!rmf?.levels?.length) {
+    const shapes = shapesFromMap(map).map((s) => {
+      if (s.kind === "lift") {
+        const w = (shapeW(s) * 40) / 100;
+        const d = (shapeH(s) * 26) / 100;
+        const door = defaultCabinDoor(w, d);
+        return { ...s, meta: { ...(s.meta ?? {}), yawRad: 0, doors: [door], levelDoors: Object.fromEntries((s.floors ?? []).map((fl) => [String(fl), [door.name]])) } };
+      }
+      return s;
+    });
+    for (const l of (map?.levels ?? []) as Array<Record<string, any>>) {
+      levels[String(l.floorNo)] = { name: String(l.name || floorName(l.floorNo)), elevationM: typeof l.elevationM === "number" ? l.elevationM : l.floorNo * 4, floorPolys: [], holePolys: [] };
+    }
+    const f0 = frame ?? { ...DEFAULT_FRAME };
+    return { shapes: f0 === DEFAULT_FRAME || sameFrame(f0, DEFAULT_FRAME) ? shapes : reframe(shapes, DEFAULT_FRAME, f0), frame: f0, graphs: [], levels };
+  }
+  const f = frame ?? frameForMap(map);
+  const at = (p: TPt) => r6(worldToShare(f, p));
+  const shapes: TEditorShape[] = [];
+  for (const lv of rmf.levels as Array<Record<string, any>>) {
+    const floorNo = Number(lv.floorNo);
+    const vx = new Map<string, Record<string, any>>((lv.vertices ?? []).map((v: any) => [String(v.id), v]));
+    const p = (id: string) => {
+      const v = vx.get(id);
+      return v ? at(v as TPt) : null;
+    };
+    for (const w of lv.walls ?? []) {
+      const a = p(w.v1);
+      const b = p(w.v2);
+      if (!a || !b) continue;
+      const { v1: _a, v2: _b, ...look } = w;
+      shapes.push({ id: nid("w"), kind: "wall", floorNo, points: [a, b], ...(Object.keys(look).length ? { meta: look } : {}) });
+    }
+    for (const z of lv.zones ?? []) {
+      const pts = (z.vertices ?? []).map(p).filter(Boolean) as TPt[];
+      if (pts.length >= 3) shapes.push({ id: nid("z"), kind: "zone", floorNo, name: String(z.name ?? ""), points: pts });
+    }
+    for (const d of lv.doors ?? []) {
+      const a = p(d.v1);
+      const b = p(d.v2);
+      if (!a || !b) continue;
+      const { v1: _a, v2: _b, ...meta } = d;
+      shapes.push({ id: nid("d"), kind: "door", floorNo, points: [a, b], meta });
+    }
+    // A waypoint for every vertex a lane uses or that has a name / settings.
+    const wp = new Map<string, string>();
+    const used = new Set<string>((lv.lanes ?? []).flatMap((l: any) => [String(l.v1), String(l.v2)]));
+    for (const v of lv.vertices ?? []) {
+      const id = String(v.id);
+      const params = v.params && Object.keys(v.params).length ? v.params : null;
+      if (!used.has(id) && !v.name && !params) continue;
+      const sid = nid("p");
+      wp.set(id, sid);
+      shapes.push({ id: sid, kind: "waypoint", floorNo, points: [at(v)], name: String(v.name ?? ""), meta: { params: { ...(params ?? {}) } } });
+    }
+    for (const l of lv.lanes ?? []) {
+      const a = wp.get(String(l.v1));
+      const b = wp.get(String(l.v2));
+      const pa = p(l.v1);
+      const pb = p(l.v2);
+      if (!a || !b || !pa || !pb) continue;
+      const { v1: _a, v2: _b, ...opts } = l;
+      shapes.push({ id: nid("n"), kind: "lane", floorNo, points: [pa, pb], meta: { ...opts, from: a, to: b } });
+    }
+    for (const m of lv.measurements ?? []) {
+      const a = p(m.v1);
+      const b = p(m.v2);
+      if (a && b) shapes.push({ id: nid("m"), kind: "measure", floorNo, points: [a, b], meta: { distanceM: Number(m.distanceM) } });
+    }
+    for (const fd of lv.fiducials ?? []) shapes.push({ id: nid("f"), kind: "fiducial", floorNo, points: [at(fd)], name: String(fd.name ?? "") });
+    const poly = (list: any[]) => (list ?? []).map((x: any) => (x.vertices ?? []).map((id: string) => vx.get(String(id))).filter(Boolean).map((v: any) => ({ x: v.x, y: v.y })));
+    levels[String(floorNo)] = { name: String(lv.name), elevationM: Number(lv.elevationM ?? 0), floorPolys: poly(lv.floors), holePolys: poly(lv.holes) };
+  }
+  const floorOf = new Map((rmf.levels as Array<Record<string, any>>).map((l) => [String(l.name), Number(l.floorNo)]));
+  for (const l of (rmf.lifts ?? []) as Array<Record<string, any>>) {
+    const c = worldToShare(f, { x: Number(l.x), y: Number(l.y) });
+    const w = (Number(l.widthM) / f.w) * 100;
+    const h = (Number(l.depthM) / f.h) * 100;
+    const floors: number[] = [...new Set<number>((l.levelDoors ?? []).map((x: any) => floorOf.get(String(x.level))).filter((n: unknown): n is number => typeof n === "number"))].sort((a, b) => a - b);
+    const levelDoors = Object.fromEntries((l.levelDoors ?? []).flatMap((x: any) => (floorOf.has(String(x.level)) ? [[String(floorOf.get(String(x.level))), [...(x.doors ?? [])]]] : [])));
+    shapes.push({
+      id: nid("l"),
+      kind: "lift",
+      floorNo: floors[0] ?? 1,
+      floors,
+      points: [
+        { x: c.x - w / 2, y: c.y - h / 2 },
+        { x: c.x + w / 2, y: c.y - h / 2 },
+        { x: c.x + w / 2, y: c.y + h / 2 },
+        { x: c.x - w / 2, y: c.y + h / 2 },
+      ].map(r6),
+      meta: {
+        name: l.name,
+        yawRad: Number(l.yawRad ?? 0),
+        doors: (l.doors ?? []).map((d: any) => ({ ...d })),
+        levelDoors,
+        ...(l.referenceFloor ? { referenceFloor: l.referenceFloor } : {}),
+        ...(l.initialFloor ? { initialFloor: l.initialFloor } : {}),
+        ...(l.lowestFloor ? { lowestFloor: l.lowestFloor } : {}),
+        ...(l.highestFloor ? { highestFloor: l.highestFloor } : {}),
+        ...(l.plugins === false ? { plugins: false } : {}),
+      },
+    });
+  }
+  return {
+    shapes,
+    frame: f,
+    graphs: ((rmf.graphs ?? []) as TRouteGraph[]).map((g) => ({ idx: g.idx, name: g.name, brands: [...(g.brands ?? [])] })),
+    levels,
+    referenceLevel: rmf.referenceLevel,
+    source: rmf.source,
+  };
+}
+
+const shapeW = (s: TEditorShape) => Math.max(...s.points.map((p) => p.x)) - Math.min(...s.points.map((p) => p.x));
+const shapeH = (s: TEditorShape) => Math.max(...s.points.map((p) => p.y)) - Math.min(...s.points.map((p) => p.y));
+const sameFrame = (a: TFrame, b: TFrame) => a.minX === b.minX && a.maxY === b.maxY && a.w === b.w && a.h === b.h;
+function reframe(shapes: TEditorShape[], from: TFrame, to: TFrame) {
+  return shapes.map((s) => ({ ...s, points: s.points.map((p) => r6(worldToShare(to, shareToWorld(from, p)))) }));
+}
+
+/* --------------------------------------------------- editor model -> map */
+
+/**
+ * The editor's shapes as the map's `rmf` part - what a save sends (the server
+ * derives the older walls / doors / lifts from it for every existing reader).
+ * Points closer than 1 cm share one vertex (a door on a wall's end, a lane
+ * ending on a waypoint); every floor gets the editor's frame as its plan frame.
+ */
+export function rmfFromEditor(model: {
+  shapes: TEditorShape[];
+  frame: TFrame;
+  graphs: TRouteGraph[];
+  levels?: TEditorModel["levels"];
+  floors?: number[];
+  referenceLevel?: string;
+  source?: string;
+}) {
+  const f = model.frame;
+  const planFrame = { minX: r3(f.minX), maxX: r3(f.minX + f.w), minY: r3(f.maxY - f.h), maxY: r3(f.maxY) };
+  const floorSet = new Set<number>([
+    ...Object.keys(model.levels ?? {}).map(Number),
+    ...model.shapes.filter((s) => s.kind !== "lift").map((s) => s.floorNo),
+    ...model.shapes.filter((s) => s.kind === "lift").flatMap((s) => s.floors ?? []),
+  ]);
+  const floors = [...floorSet].filter(Number.isFinite).sort((a, b) => a - b);
+  const levelName = (fl: number) => model.levels?.[String(fl)]?.name || floorName(fl);
+  // Centimetres in a frame up to 40 x 26 m (its shares are 2-decimal, as the older save body was), millimetres in a bigger one.
+  const rw = f.w > 40 || f.h > 26 ? r3 : (v: number) => Math.round(v * 100) / 100;
+  const world = (p: TPt) => {
+    const w = shareToWorld(f, p);
+    return { x: rw(w.x), y: rw(w.y) };
+  };
+  const doorNames: string[] = model.shapes.filter((s) => s.kind === "door" && s.meta?.name).map((s) => String(s.meta!.name));
+  const liftNames: string[] = model.shapes.filter((s) => s.kind === "lift" && s.meta?.name).map((s) => String(s.meta!.name));
+  const nextName = (list: string[], word: string, alpha: boolean) => {
+    for (let i = 1; ; i++) {
+      const n = `${word} ${alpha ? String.fromCharCode(64 + (((i - 1) % 26) + 1)) + (i > 26 ? Math.ceil(i / 26) : "") : i}`;
+      if (!list.includes(n)) {
+        list.push(n);
+        return n;
+      }
+    }
+  };
+
+  const levels = floors.map((floorNo) => {
+    const meta = model.levels?.[String(floorNo)];
+    const vertices: Array<{ id: string; x: number; y: number; name?: string; params?: Record<string, unknown> }> = [];
+    let next = 1;
+    const vid = (p: TPt, extra?: { name?: string; params?: Record<string, unknown> }) => {
+      const q = { x: r3(p.x), y: r3(p.y) };
+      const hit = vertices.find((v) => Math.abs(v.x - q.x) < WELD_M && Math.abs(v.y - q.y) < WELD_M);
+      if (hit) {
+        if (extra?.name && !hit.name) hit.name = extra.name;
+        if (extra?.params && Object.keys(extra.params).length) hit.params = { ...(hit.params ?? {}), ...extra.params };
+        return hit.id;
+      }
+      const v = { id: `v${next++}`, ...q, ...(extra?.name ? { name: extra.name } : {}), ...(extra?.params && Object.keys(extra.params).length ? { params: extra.params } : {}) };
+      vertices.push(v);
+      return v.id;
+    };
+    const mine = model.shapes.filter((s) => s.floorNo === floorNo && s.kind !== "lift");
+    // Waypoints first, so their names and settings sit on the vertex a lane or wall shares.
+    const wpVertex = new Map<string, string>();
+    for (const s of mine.filter((x) => x.kind === "waypoint")) {
+      wpVertex.set(s.id, vid(world(s.points[0]!), { name: (s.name ?? "").trim() || undefined, params: cleanParams(s.meta?.params) }));
+    }
+    const walls = mine.filter((s) => s.kind === "wall").map((s) => ({ v1: vid(world(s.points[0]!)), v2: vid(world(s.points[1]!)), ...wallLook(s.meta) }));
+    const doors = mine
+      .filter((s) => s.kind === "door")
+      .map((s) => {
+        const m = s.meta ?? {};
+        return {
+          name: m.name ? String(m.name) : nextName(doorNames, "Door", false),
+          v1: vid(world(s.points[0]!)),
+          v2: vid(world(s.points[1]!)),
+          type: (DOOR_TYPES as readonly string[]).includes(m.type) ? m.type : "hinged",
+          ...(m.motionAxis === "end" ? { motionAxis: "end" } : {}),
+          ...(m.motionDegrees !== undefined && Number(m.motionDegrees) !== 90 ? { motionDegrees: Number(m.motionDegrees) } : {}),
+          ...(Number(m.motionDirection ?? 1) < 0 ? { motionDirection: -1 } : {}),
+          ...(m.rightLeftRatio !== undefined && Number(m.rightLeftRatio) !== 1 ? { rightLeftRatio: Number(m.rightLeftRatio) } : {}),
+          ...(m.plugin && m.plugin !== "normal" ? { plugin: String(m.plugin) } : {}),
+        };
+      });
+    const lanes = mine
+      .filter((s) => s.kind === "lane")
+      .flatMap((s) => {
+        const m = s.meta ?? {};
+        const v1 = wpVertex.get(String(m.from));
+        const v2 = wpVertex.get(String(m.to));
+        if (!v1 || !v2 || v1 === v2) return [];
+        return [{
+          v1,
+          v2,
+          graphIdx: Math.max(0, Math.min(8, Number(m.graphIdx ?? 0))),
+          bidirectional: m.bidirectional !== false,
+          ...(m.orientation === "forward" || m.orientation === "backward" ? { orientation: m.orientation } : {}),
+          ...(Number(m.speedLimit) > 0 ? { speedLimit: Number(m.speedLimit) } : {}),
+          ...(m.mutex ? { mutex: String(m.mutex).trim() } : {}),
+          ...(m.demoMockFloorName ? { demoMockFloorName: String(m.demoMockFloorName).trim() } : {}),
+          ...(m.demoMockLiftName ? { demoMockLiftName: String(m.demoMockLiftName).trim() } : {}),
+        }];
+      });
+    const measurements = mine
+      .filter((s) => s.kind === "measure" && Number(s.meta?.distanceM) >= 0.01)
+      .map((s) => ({ v1: vid(world(s.points[0]!)), v2: vid(world(s.points[1]!)), distanceM: Math.round(Number(s.meta!.distanceM) * 1000) / 1000 }));
+    const zones = mine.filter((s) => s.kind === "zone").map((s) => ({ name: (s.name ?? "").trim(), vertices: s.points.map((p) => vid(world(p))) }));
+    const floorsPoly = (meta?.floorPolys ?? []).map((poly) => ({ vertices: poly.map((p) => vid(p)) })).filter((x) => x.vertices.length >= 3);
+    const holesPoly = (meta?.holePolys ?? []).map((poly) => ({ vertices: poly.map((p) => vid(p)) })).filter((x) => x.vertices.length >= 3);
+    const fiducials = mine.filter((s) => s.kind === "fiducial").map((s) => ({ name: (s.name ?? "").trim() || "fiducial", ...world(s.points[0]!) }));
+    return {
+      name: levelName(floorNo),
+      floorNo,
+      elevationM: meta?.elevationM ?? floorNo * 4,
+      planFrame: { ...planFrame },
+      vertices,
+      walls,
+      floors: floorsPoly,
+      holes: holesPoly,
+      doors,
+      lanes,
+      measurements,
+      fiducials,
+      zones,
+    };
+  });
+
+  const nameOf = new Map(levels.map((l) => [l.floorNo, l.name]));
+  const lifts = model.shapes
+    .filter((s) => s.kind === "lift")
+    .map((s) => {
+      const m = s.meta ?? {};
+      const xs = s.points.map((p) => p.x);
+      const ys = s.points.map((p) => p.y);
+      const c = world({ x: (Math.min(...xs) + Math.max(...xs)) / 2, y: (Math.min(...ys) + Math.max(...ys)) / 2 });
+      const widthM = r3(Math.min(20, Math.max(0.3, ((Math.max(...xs) - Math.min(...xs)) / 100) * f.w)));
+      const depthM = r3(Math.min(20, Math.max(0.3, ((Math.max(...ys) - Math.min(...ys)) / 100) * f.h)));
+      const doors: TCabinDoor[] = (Array.isArray(m.doors) && m.doors.length ? m.doors : [defaultCabinDoor(widthM, depthM)]).slice(0, 8);
+      const doorSet = new Set(doors.map((d) => d.name));
+      const served = [...new Set(s.floors ?? [])].filter((fl) => nameOf.has(fl)).sort((a, b) => a - b);
+      const levelDoors = served.map((fl) => {
+        const list = (m.levelDoors ?? {})[String(fl)];
+        return { level: nameOf.get(fl)!, doors: (Array.isArray(list) ? list : doors.map((d) => d.name)).filter((d: string) => doorSet.has(d)) };
+      });
+      const servedNames = new Set(levelDoors.map((x) => x.level));
+      const keep = (v: unknown) => (typeof v === "string" && servedNames.has(v) ? v : undefined);
+      return {
+        name: m.name ? String(m.name) : nextName(liftNames, "Lift", true),
+        x: c.x,
+        y: c.y,
+        yawRad: Math.round(Number(m.yawRad ?? 0) * 10000) / 10000,
+        widthM,
+        depthM,
+        referenceFloor: keep(m.referenceFloor) ?? levelDoors[0]?.level ?? "",
+        ...(keep(m.initialFloor) ? { initialFloor: keep(m.initialFloor) } : {}),
+        ...(keep(m.lowestFloor) ? { lowestFloor: keep(m.lowestFloor) } : {}),
+        ...(keep(m.highestFloor) ? { highestFloor: keep(m.highestFloor) } : {}),
+        ...(m.plugins === false ? { plugins: false } : {}),
+        doors: doors.map((d) => ({ name: d.name, type: d.type, x: r3(d.x), y: r3(d.y), widthM: r3(d.widthM), axisYawRad: r3(d.axisYawRad) })),
+        levelDoors,
+      };
+    });
+
+  const usedGraphs = new Set(levels.flatMap((l) => l.lanes.map((x) => x.graphIdx)));
+  const graphs = [...model.graphs.filter((g) => g.idx >= 0 && g.idx <= 8)];
+  for (const idx of usedGraphs) if (!graphs.some((g) => g.idx === idx)) graphs.push({ idx, name: `Graph ${idx}`, brands: [] });
+  graphs.sort((a, b) => a.idx - b.idx);
+  const names = new Set(levels.map((l) => l.name));
+  return {
+    formatVersion: 1 as const,
+    coordinateSystem: "cartesian_meters" as const,
+    source: (model.source === "fleet-core" || model.source === "file" ? model.source : "editor") as "fleet-core" | "file" | "editor",
+    referenceLevel: model.referenceLevel && names.has(model.referenceLevel) ? model.referenceLevel : levels[0]?.name ?? "",
+    graphs: graphs.map((g) => ({ idx: g.idx, name: (g.name || `Graph ${g.idx}`).slice(0, 60), brands: (g.brands ?? []).slice(0, 20) })),
+    levels,
+    lifts,
+  };
+}
+
+function cleanParams(raw: unknown): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  if (!raw || typeof raw !== "object") return out;
+  for (const k of VERTEX_PARAMS) {
+    const v = (raw as Record<string, unknown>)[k];
+    if (v === undefined || v === null || v === "" || v === false) continue;
+    if (k.startsWith("is_")) out[k] = true;
+    else if (k === "merge_radius") {
+      if (Number(v) > 0) out[k] = Math.min(100, Number(v));
+    } else out[k] = String(v).trim().slice(0, 60);
+  }
+  return out;
+}
+
+function wallLook(meta: Record<string, any> | undefined) {
+  const out: Record<string, unknown> = {};
+  for (const k of ["textureName", "alpha", "textureHeight", "textureWidth", "textureScale"]) if (meta?.[k] !== undefined) out[k] = meta[k];
+  return out;
+}
+
+/* ----------------------------------------------- 3D view and mini-map */
+
+export type TRouteOverlay = {
+  lanes: Array<{ a: TPt; b: TPt; oneWay: boolean; graph: number | string }>;
+  waypoints: Array<TPt & { name: string; kind: "charger" | "parking" | "holding" | "point" }>;
+  fiducials: Array<TPt & { name: string }>;
+};
+
+/**
+ * One floor's robot routes for the 3D view and the mini-map, in shares of
+ * the floor's plan frame (the same shares the map's walls are drawn in): the
+ * saved map's lanes and waypoints, or the live HERO Fleet Core building's.
+ */
+export function routeOverlay(map: Record<string, any> | null | undefined, floorNo: number): TRouteOverlay {
+  const out: TRouteOverlay = { lanes: [], waypoints: [], fiducials: [] };
+  if (!map) return out;
+  const kindOf = (p: Record<string, unknown>) => (p.is_charger ? "charger" : p.is_parking_spot ? "parking" : p.is_holding_point ? "holding" : "point");
+  const lv = (map.rmf?.levels ?? []).find((l: any) => Number(l.floorNo) === floorNo);
+  if (lv) {
+    const pf = lv.planFrame ?? { minX: 0, maxX: 40, minY: -26, maxY: 0 };
+    const f: TFrame = { minX: pf.minX, maxY: pf.maxY, w: pf.maxX - pf.minX || 1, h: pf.maxY - pf.minY || 1 };
+    const v = new Map<string, any>((lv.vertices ?? []).map((x: any) => [String(x.id), x]));
+    for (const l of lv.lanes ?? []) {
+      const a = v.get(String(l.v1));
+      const b = v.get(String(l.v2));
+      if (a && b) out.lanes.push({ a: r2(worldToShare(f, a)), b: r2(worldToShare(f, b)), oneWay: l.bidirectional === false, graph: Number(l.graphIdx ?? 0) });
+    }
+    for (const x of lv.vertices ?? []) {
+      if (x.name || (x.params && Object.keys(x.params).length)) out.waypoints.push({ ...r2(worldToShare(f, x)), name: String(x.name ?? ""), kind: kindOf(x.params ?? {}) });
+    }
+    for (const x of lv.fiducials ?? []) out.fiducials.push({ ...r2(worldToShare(f, x)), name: String(x.name ?? "") });
+    return out;
+  }
+  // The live fleet building: lanes and waypoints already in the 40 x 26 m plan frame.
+  const level = (map.levels ?? []).find((l: any) => Number(l.floorNo) === floorNo);
+  const share = (p: TPt) => r2({ x: (p.x / 40) * 100, y: (p.y / 26) * 100 });
+  for (const l of level?.lanes ?? []) out.lanes.push({ a: share(l.start), b: share(l.end), oneWay: !!l.oneWay, graph: l.graph ?? 0 });
+  for (const w of level?.waypoints ?? []) out.waypoints.push({ ...share(w), name: String(w.name ?? ""), kind: w.charger ? "charger" : w.parking ? "parking" : w.holding ? "holding" : "point" });
+  return out;
+}
+
+/** The plan frame a floor's shapes are drawn in, for the 3D view's plane shape: width / height in metres. */
+export function floorAspect(map: Record<string, any> | null | undefined): number {
+  const pf = map?.rmf?.levels?.[0]?.planFrame;
+  if (pf && pf.maxX > pf.minX && pf.maxY > pf.minY) return (pf.maxX - pf.minX) / (pf.maxY - pf.minY);
+  return 40 / 26;
+}
+
+/**
+ * The saved map's doors of one floor for the 3D view, with their Open-RMF
+ * type (the older `doors` list only knows hinged / sliding), and each lift's
+ * cabin doors that open on this floor - in shares of the floor's frame.
+ */
+export function floorDoors(map: Record<string, any> | null | undefined, floorNo: number) {
+  const lv = (map?.rmf?.levels ?? []).find((l: any) => Number(l.floorNo) === floorNo);
+  if (!lv) return null;
+  const pf = lv.planFrame;
+  const f: TFrame = { minX: pf.minX, maxY: pf.maxY, w: pf.maxX - pf.minX || 1, h: pf.maxY - pf.minY || 1 };
+  const v = new Map<string, any>((lv.vertices ?? []).map((x: any) => [String(x.id), x]));
+  const doors = (lv.doors ?? []).flatMap((d: any) => {
+    const a = v.get(String(d.v1));
+    const b = v.get(String(d.v2));
+    return a && b ? [{ id: `${floorNo}-${d.name}`, kind: "door" as const, floorNo, points: [r2(worldToShare(f, a)), r2(worldToShare(f, b))], meta: { ...d } }] : [];
+  });
+  const cabin: Array<{ lift: string; a: TPt; b: TPt }> = [];
+  for (const l of (map?.rmf?.lifts ?? []) as Array<Record<string, any>>) {
+    const open = new Set(((l.levelDoors ?? []).find((x: any) => x.level === lv.name)?.doors ?? []) as string[]);
+    for (const d of (l.doors ?? []) as TCabinDoor[]) {
+      if (!open.has(d.name)) continue;
+      const turn = (p: TPt, a: number) => ({ x: p.x * Math.cos(a) - p.y * Math.sin(a), y: p.x * Math.sin(a) + p.y * Math.cos(a) });
+      const half = turn({ x: d.widthM / 2, y: 0 }, d.axisYawRad);
+      const c = turn({ x: d.x, y: d.y }, Number(l.yawRad ?? 0));
+      const h = turn(half, Number(l.yawRad ?? 0));
+      const mid = { x: Number(l.x) + c.x, y: Number(l.y) + c.y };
+      cabin.push({ lift: String(l.name), a: r2(worldToShare(f, { x: mid.x - h.x, y: mid.y - h.y })), b: r2(worldToShare(f, { x: mid.x + h.x, y: mid.y + h.y })) });
+    }
+  }
+  return { doors, cabin, frame: f };
+}
+
+/**
+ * The lift shafts for the 3D view, in shares of the floor frame: from the
+ * map's `rmf` part when it has one (real size and angle - the older `lifts`
+ * list is squeezed into 40 x 26 m and has no angle), else from `lifts`.
+ */
+export function viewerLifts(map: Record<string, any> | null | undefined): Array<{ name: string; x: number; y: number; w: number; d: number; yawDeg: number; floors: number[] }> {
+  const rmf = map?.rmf;
+  if (rmf?.levels?.length && rmf.lifts?.length) {
+    const byName = new Map((rmf.levels as Array<Record<string, any>>).map((l) => [String(l.name), l]));
+    return (rmf.lifts as Array<Record<string, any>>).map((l) => {
+      const ref = byName.get(String(l.referenceFloor)) ?? rmf.levels[0];
+      const pf = ref.planFrame;
+      const f: TFrame = { minX: pf.minX, maxY: pf.maxY, w: pf.maxX - pf.minX || 1, h: pf.maxY - pf.minY || 1 };
+      const c = worldToShare(f, { x: Number(l.x), y: Number(l.y) });
+      const floors: number[] = (l.levelDoors ?? []).map((x: any) => Number(byName.get(String(x.level))?.floorNo)).filter(Number.isFinite);
+      return { name: String(l.name), x: c.x, y: c.y, w: (Number(l.widthM) / f.w) * 100, d: (Number(l.depthM) / f.h) * 100, yawDeg: (Number(l.yawRad ?? 0) * 180) / Math.PI, floors };
+    });
+  }
+  return ((map?.lifts ?? []) as Array<Record<string, any>>).map((l) => ({
+    name: String(l.name),
+    x: (Number(l.x) / 40) * 100,
+    y: (Number(l.y) / 26) * 100,
+    w: (Number(l.widthM) / 40) * 100,
+    d: (Number(l.depthM) / 26) * 100,
+    yawDeg: 0,
+    floors: [...(l.floors ?? [])],
+  }));
+}