@dailies-studio/shot-editor 0.1.0 → 0.2.0

package/src/stage/splineStage.ts

@@ -0,0 +1,632 @@
+import {
+  defaultSplinePrimitive,
+  splineFrameScale,
+  splineProfileAt,
+  splineSampleTable,
+} from "@dailies-studio/shot/doc";
+import type { SplinePoint3D, SplinePrimitive } from "@dailies-studio/shot/doc";
+import { Matrix4, Plane, Vector3 } from "three";
+import type { Camera, Ray } from "three";
+import type { ResolvedWorkPlane, SplinePointPart, WorkPlaneTarget } from "../bridgeTypes.js";
+import type { LayerFrame, ScreenQuad } from "./project.js";
+import { toScreen } from "./project.js";
+import type { WorkingView } from "./workingView.js";
+import { viewBasis } from "./workingView.js";
+
+export interface ScreenSplinePoint {
+  id: string;
+  p: readonly [number, number];
+  in?: readonly [number, number];
+  out?: readonly [number, number];
+  selected: boolean;
+}
+
+export interface ScreenSplineStation {
+  at: readonly [number, number];
+  /** Canonical full-curve arc progress, suitable for `sampleSpline`. */
+  arcProgress: number;
+  /** Authored span index plus local span progress. */
+  curveT: number;
+  /**
+   * Conservative projected reach of the rendered profile around the
+   * centreline. It includes taper and profile offset. Guide-only splines and
+   * drafts keep this at zero because they render a centreline, not a loft.
+   */
+  profileRadiusPx?: number;
+}
+
+export interface ScreenSpline {
+  line: readonly (readonly [number, number])[];
+  stations: readonly ScreenSplineStation[];
+  points: readonly ScreenSplinePoint[];
+  cursor: readonly [number, number] | null;
+  closed: boolean;
+  closeHot: boolean;
+  editing: boolean;
+  /** Largest station reach, for bridge selection shapes. */
+  profileRadiusPx?: number;
+}
+
+export interface SplineControlHit {
+  pointId: string;
+  part: SplinePointPart;
+}
+
+export interface SplineSpanHit {
+  /** The authored anchor whose outgoing span was hit. */
+  spanIndex: number;
+  /** Local progress inside that authored span. */
+  spanProgress: number;
+  /** Canonical full-curve arc progress, suitable for `sampleSpline`. */
+  arcProgress: number;
+}
+
+const WORLD_XY: ResolvedWorkPlane = {
+  target: { kind: "xy" },
+  origin: [0, 0, 0],
+  xAxis: [1, 0, 0],
+  yAxis: [0, 1, 0],
+  normal: [0, 0, 1],
+  fallback: false,
+};
+
+/** Resolve an editor construction plane in schema coordinates. */
+export function resolveWorkPlane(
+  target: WorkPlaneTarget,
+  workingView: WorkingView,
+  frames: readonly LayerFrame[] | null,
+): ResolvedWorkPlane {
+  switch (target.kind) {
+    case "xy":
+      return WORLD_XY;
+    case "xz":
+      return {
+        target,
+        origin: [0, 0, 0],
+        xAxis: [1, 0, 0],
+        yAxis: [0, 0, 1],
+        normal: [0, -1, 0],
+        fallback: false,
+      };
+    case "yz":
+      return {
+        target,
+        origin: [0, 0, 0],
+        xAxis: [0, 1, 0],
+        yAxis: [0, 0, 1],
+        normal: [1, 0, 0],
+        fallback: false,
+      };
+    case "view": {
+      const basis = viewBasis(workingView);
+      const x = worldVectorToDesign(basis.right);
+      // Plane y follows the display downward, opposite the camera's world up.
+      const y = worldVectorToDesign([-basis.up[0], -basis.up[1], -basis.up[2]]);
+      return planeRecord(
+        target,
+        worldPointToDesign(workingView.target),
+        x,
+        y,
+        false,
+      );
+    }
+    case "selection": {
+      const frame = frames?.find((candidate) => candidate.id === target.layerId);
+      if (frame === undefined) return { ...WORLD_XY, target, fallback: true };
+      const e = frame.matrixWorld.elements;
+      return planeRecord(
+        target,
+        [e[12]!, -e[13]!, -e[14]!],
+        [e[0]!, -e[1]!, -e[2]!],
+        [-e[4]!, e[5]!, e[6]!],
+        false,
+      );
+    }
+  }
+}
+
+/**
+ * The plane shown by the construction grid and used by the next anchor.
+ * Once a draft exists its plane wins by identity: orbiting a View plane or
+ * moving a Selection plane cannot rotate geometry already being authored.
+ */
+export function splineWorkPlaneForDraft(
+  live: ResolvedWorkPlane,
+  frozen: ResolvedWorkPlane | null,
+): ResolvedWorkPlane {
+  return frozen ?? live;
+}
+
+/**
+ * Project the working-view focus onto a plane and snap the finite grid patch
+ * to that plane's own cell coordinates. The plane origin and basis remain the
+ * coordinate system, so panning moves the patch only by whole cells and the
+ * grid never appears to slide under an in-progress curve.
+ */
+export function workPlaneGridCenter(
+  plane: ResolvedWorkPlane,
+  focus: readonly [number, number, number],
+  step: number,
+): [number, number, number] {
+  const safeStep = Number.isFinite(step) && step > 0 ? step : 1;
+  const delta: [number, number, number] = [
+    focus[0] - plane.origin[0],
+    focus[1] - plane.origin[1],
+    focus[2] - plane.origin[2],
+  ];
+  const u = Math.round(dot3(delta, plane.xAxis) / safeStep) * safeStep;
+  const v = Math.round(dot3(delta, plane.yAxis) / safeStep) * safeStep;
+  return [
+    plane.origin[0] + plane.xAxis[0] * u + plane.yAxis[0] * v,
+    plane.origin[1] + plane.xAxis[1] * u + plane.yAxis[1] * v,
+    plane.origin[2] + plane.xAxis[2] * u + plane.yAxis[2] * v,
+  ];
+}
+
+/** Intersect a stage ray with a resolved work plane and return design coords. */
+export function pointOnWorkPlane(ray: Ray | null, plane: ResolvedWorkPlane): [number, number, number] | null {
+  if (ray === null) return null;
+  const normal = designVectorToWorld(plane.normal);
+  const origin = designPointToWorld(plane.origin);
+  const hit = ray.intersectPlane(new Plane().setFromNormalAndCoplanarPoint(normal, origin), new Vector3());
+  return hit === null || !finiteVector(hit) ? null : [cleanZero(hit.x), cleanZero(-hit.y), cleanZero(-hit.z)];
+}
+
+/** Project a world-design spline draft into the working pane. */
+export function projectSplineDraft(
+  points: readonly SplinePoint3D[],
+  basis: "bezier" | "catmull-rom",
+  closed: boolean,
+  cursor: readonly [number, number, number] | null,
+  camera: Camera | null,
+  width: number,
+  height: number,
+): ScreenSpline | null {
+  if (points.length === 0 || camera === null || width <= 0 || height <= 0) return null;
+  const primitive = {
+    ...defaultSplinePrimitive([1, 1], points.map(copyPoint)),
+    basis,
+    closed,
+  };
+  const project = (point: readonly [number, number, number]): [number, number] =>
+    toScreen(designPointToWorld(point), camera, width, height);
+  const first = project(points[0]!.p);
+  const cursorScreen = cursor === null ? null : project(cursor);
+  const stations = splineSampleTable(primitive).stations.map((station) => ({
+    at: project(station.position),
+    arcProgress: station.arcProgress,
+    curveT: station.curveT,
+    profileRadiusPx: 0,
+  }));
+  return {
+    line: stations.map((station) => station.at),
+    stations,
+    points: points.map((point) => ({
+      id: point.id,
+      p: project(point.p),
+      ...(point.in === undefined ? {} : { in: project(point.in) }),
+      ...(point.out === undefined ? {} : { out: project(point.out) }),
+      selected: false,
+    })),
+    cursor: cursorScreen,
+    closed,
+    closeHot:
+      points.length >= 3 &&
+      cursorScreen !== null &&
+      Math.hypot(cursorScreen[0] - first[0], cursorScreen[1] - first[1]) <= 8,
+    editing: false,
+    profileRadiusPx: 0,
+  };
+}
+
+/** Project a committed spline's centreline and controls from layer-local space. */
+export function projectSplineLayer(
+  spline: SplinePrimitive,
+  frame: LayerFrame,
+  camera: Camera | null,
+  width: number,
+  height: number,
+  selectedPointIds: readonly string[],
+  includeProfile = true,
+): ScreenSpline | null {
+  if (camera === null || width <= 0 || height <= 0) return null;
+  const scale = splineFrameScale(spline, frame.size);
+  const project = (point: readonly [number, number, number]): [number, number] =>
+    toScreen(splineLocalToWorld(point, scale, frame.matrixWorld), camera, width, height);
+  const selected = new Set(selectedPointIds);
+  let profileRadiusPx = 0;
+  const stations = splineSampleTable(spline).stations.map((station) => {
+    const world = splineLocalToWorld(station.position, scale, frame.matrixWorld);
+    const radius = includeProfile
+      ? projectedProfileRadius(
+          spline,
+          station.arcProgress,
+          scale[2],
+          frame.matrixWorld,
+          world,
+          camera,
+          width,
+          height,
+        )
+      : 0;
+    profileRadiusPx = Math.max(profileRadiusPx, radius);
+    return {
+      at: toScreen(world, camera, width, height),
+      arcProgress: station.arcProgress,
+      curveT: station.curveT,
+      profileRadiusPx: radius,
+    };
+  });
+  return {
+    line: stations.map((station) => station.at),
+    stations,
+    points: spline.points.map((point) => ({
+      id: point.id,
+      p: project(point.p),
+      ...(point.in === undefined ? {} : { in: project(point.in) }),
+      ...(point.out === undefined ? {} : { out: project(point.out) }),
+      selected: selected.has(point.id),
+    })),
+    cursor: null,
+    closed: spline.closed === true,
+    closeHot: false,
+    editing: true,
+    profileRadiusPx,
+  };
+}
+
+/** Nearest editable control, with handles ahead of anchors at overlaps. */
+export function splineControlAt(
+  spline: ScreenSpline | null,
+  point: readonly [number, number],
+): SplineControlHit | null {
+  if (spline === null || !spline.editing) return null;
+  let bestHit: SplineControlHit | null = null;
+  let bestDistance = Number.POSITIVE_INFINITY;
+  const consider = (pointId: string, part: SplinePointPart, at: readonly [number, number], radius: number): void => {
+    const distance = Math.hypot(point[0] - at[0], point[1] - at[1]);
+    if (distance > radius || distance >= bestDistance) return;
+    bestDistance = distance;
+    bestHit = { pointId, part };
+  };
+  for (const control of spline.points) {
+    if (control.in !== undefined) consider(control.id, "in", control.in, 7);
+    if (control.out !== undefined) consider(control.id, "out", control.out, 7);
+  }
+  for (const control of spline.points) consider(control.id, "anchor", control.p, 9);
+  return bestHit;
+}
+
+/** Map a work-plane hit back into a spline layer's authored local coordinates. */
+export function splineLocalPoint(
+  worldDesign: readonly [number, number, number],
+  spline: SplinePrimitive,
+  frame: LayerFrame,
+): [number, number, number] | null {
+  const inverse = new Matrix4().copy(frame.matrixWorld).invert();
+  const local = designPointToWorld(worldDesign).applyMatrix4(inverse);
+  const scale = splineFrameScale(spline, frame.size);
+  if (scale.some((value) => !Number.isFinite(value) || Math.abs(value) < 1e-9)) return null;
+  return [local.x / scale[0], -local.y / scale[1], -local.z / scale[2]];
+}
+
+export function splineWorldPoint(
+  local: readonly [number, number, number],
+  spline: SplinePrimitive,
+  frame: LayerFrame,
+): [number, number, number] {
+  const world = splineLocalToWorld(local, splineFrameScale(spline, frame.size), frame.matrixWorld);
+  return [world.x, -world.y, -world.z];
+}
+
+export function workPlaneThrough(
+  plane: ResolvedWorkPlane,
+  origin: readonly [number, number, number],
+): ResolvedWorkPlane {
+  return { ...plane, origin: [origin[0], origin[1], origin[2]] };
+}
+
+/** The nearest sampled centreline edge, carrying both authored and arc domains. */
+export function nearestSplineSpan(
+  spline: ScreenSpline | null,
+  point: readonly [number, number],
+  radius = 8,
+): SplineSpanHit | null {
+  if (spline === null || spline.stations.length < 2) return null;
+  let bestIndex = -1;
+  let bestT = 0;
+  let bestDistance = Number.POSITIVE_INFINITY;
+  const slop = Math.max(0, radius);
+  for (let i = 0; i < spline.stations.length - 1; i += 1) {
+    const a = spline.stations[i]!;
+    const b = spline.stations[i + 1]!;
+    const nearest = pointSegmentNearest(point, a.at, b.at);
+    const reach = slop + Math.max(stationProfileRadius(a), stationProfileRadius(b));
+    if (nearest.distance <= reach && nearest.distance < bestDistance) {
+      bestDistance = nearest.distance;
+      bestIndex = i;
+      bestT = nearest.t;
+    }
+  }
+  if (bestIndex < 0) return null;
+  const a = spline.stations[bestIndex]!;
+  const b = spline.stations[bestIndex + 1]!;
+  const curveT = lerp(a.curveT, b.curveT, bestT);
+  const segmentCount = Math.max(1, Math.ceil(spline.stations[spline.stations.length - 1]!.curveT));
+  const spanIndex = Math.min(segmentCount - 1, Math.max(0, Math.floor(curveT)));
+  return {
+    spanIndex,
+    spanProgress: Math.max(0, Math.min(1, curveT - spanIndex)),
+    arcProgress: lerp(a.arcProgress, b.arcProgress, bestT),
+  };
+}
+
+/** Centreline hit used by StageTools instead of the mesh layer's loose box. */
+export function splineScreenHit(
+  spline: ScreenSpline | null,
+  point: readonly [number, number],
+  radius = 8,
+): boolean {
+  return nearestSplineSpan(spline, point, radius) !== null;
+}
+
+/** Marquee intersection, including a band that crosses between sample points. */
+export function splineScreenIntersectsRect(
+  spline: ScreenSpline | null,
+  rect: { x0: number; y0: number; x1: number; y1: number },
+  radius = 0,
+): boolean {
+  if (spline === null || spline.line.length === 0) return false;
+  const baseMinX = Math.min(rect.x0, rect.x1);
+  const baseMaxX = Math.max(rect.x0, rect.x1);
+  const baseMinY = Math.min(rect.y0, rect.y1);
+  const baseMaxY = Math.max(rect.y0, rect.y1);
+  const slop = Math.max(0, radius);
+  const inside = (point: readonly [number, number], reach: number): boolean =>
+    point[0] >= baseMinX - reach &&
+    point[0] <= baseMaxX + reach &&
+    point[1] >= baseMinY - reach &&
+    point[1] <= baseMaxY + reach;
+  if (
+    spline.line.some((point, index) =>
+      inside(point, slop + stationProfileRadius(spline.stations[index])),
+    )
+  ) {
+    return true;
+  }
+  for (let index = 0; index < spline.line.length - 1; index += 1) {
+    const a = spline.line[index]!;
+    const b = spline.line[index + 1]!;
+    const reach =
+      slop +
+      Math.max(
+        stationProfileRadius(spline.stations[index]),
+        stationProfileRadius(spline.stations[index + 1]),
+      );
+    const minX = baseMinX - reach;
+    const maxX = baseMaxX + reach;
+    const minY = baseMinY - reach;
+    const maxY = baseMaxY + reach;
+    if (
+      segmentsIntersect(a, b, [minX, minY], [maxX, minY]) ||
+      segmentsIntersect(a, b, [maxX, minY], [maxX, maxY]) ||
+      segmentsIntersect(a, b, [maxX, maxY], [minX, maxY]) ||
+      segmentsIntersect(a, b, [minX, maxY], [minX, minY])
+    ) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/** Axis-aligned projected bounds for hover and non-edit selection furniture. */
+export function splineScreenBounds(spline: ScreenSpline | null, padding = 0): ScreenQuad | null {
+  if (spline === null || spline.line.length === 0) return null;
+  let minX = Number.POSITIVE_INFINITY;
+  let minY = Number.POSITIVE_INFINITY;
+  let maxX = Number.NEGATIVE_INFINITY;
+  let maxY = Number.NEGATIVE_INFINITY;
+  for (const [index, point] of spline.line.entries()) {
+    const reach = Math.max(0, padding) + stationProfileRadius(spline.stations[index]);
+    minX = Math.min(minX, point[0] - reach);
+    minY = Math.min(minY, point[1] - reach);
+    maxX = Math.max(maxX, point[0] + reach);
+    maxY = Math.max(maxY, point[1] + reach);
+  }
+  return [minX, minY, maxX, minY, maxX, maxY, minX, maxY];
+}
+
+function stationProfileRadius(station: ScreenSplineStation | undefined): number {
+  const radius = station?.profileRadiusPx;
+  return typeof radius === "number" && Number.isFinite(radius) ? Math.max(0, radius) : 0;
+}
+
+/** A sphere around the centreline conservatively contains every profile kind. */
+function projectedProfileRadius(
+  spline: SplinePrimitive,
+  progress: number,
+  frameScale: number,
+  matrixWorld: Matrix4,
+  worldCenter: Vector3,
+  camera: Camera,
+  width: number,
+  height: number,
+): number {
+  const profile = splineProfileAt(spline, progress);
+  const halfExtent =
+    profile.kind === "tube"
+      ? profile.radiusPx
+      : profile.kind === "ribbon"
+        ? profile.widthPx / 2
+        : Math.hypot(profile.widthPx / 2, profile.heightPx / 2);
+  const authoredReach = Math.hypot(profile.offset[0], profile.offset[1]) + halfExtent;
+  const worldReach = authoredReach * Math.max(0, frameScale) * affineScaleBound(matrixWorld);
+  return screenSphereRadius(worldCenter, worldReach, camera, width, height);
+}
+
+/** Upper bound for an affine transform, exact for orthogonal scale columns. */
+function affineScaleBound(matrix: Matrix4): number {
+  const e = matrix.elements;
+  const columns = [
+    [e[0]!, e[1]!, e[2]!],
+    [e[4]!, e[5]!, e[6]!],
+    [e[8]!, e[9]!, e[10]!],
+  ] as const;
+  // The largest singular value squared is the largest eigenvalue of A^T A.
+  // Gershgorin's row-sum bound contains it, remains conservative under shear,
+  // and still returns exactly 1 for a rigid transform instead of sqrt(3).
+  let boundSquared = 0;
+  for (let row = 0; row < 3; row += 1) {
+    let rowSum = 0;
+    for (let column = 0; column < 3; column += 1) {
+      rowSum += Math.abs(dot3(columns[row]!, columns[column]!));
+    }
+    boundSquared = Math.max(boundSquared, rowSum);
+  }
+  return Math.sqrt(boundSquared);
+}
+
+/** Project a world-space sphere to one conservative screen-space radius. */
+function screenSphereRadius(
+  center: Vector3,
+  radius: number,
+  camera: Camera,
+  width: number,
+  height: number,
+): number {
+  if (!(radius > 0) || !Number.isFinite(radius)) return 0;
+  const projection = camera.projectionMatrix.elements;
+  const scaleX = Math.abs(projection[0]!) * width / 2;
+  const scaleY = Math.abs(projection[5]!) * height / 2;
+  // Orthographic projection has w=1. A sphere stays an ellipse and its largest
+  // screen radius is exactly the larger camera-axis scale.
+  if (Math.abs(projection[11]!) < 1e-9) return radius * Math.max(scaleX, scaleY);
+
+  const cameraPoint = center.clone().applyMatrix4(camera.matrixWorldInverse);
+  const distance = -cameraPoint.z;
+  if (!(distance > radius + 1e-6)) return Math.hypot(width, height);
+  // Bound the perspective denominator by the sphere's nearest point and the
+  // numerator with one vector norm. This stays conservative off axis without
+  // turning an on-axis tube into the diagonal of a projected cube.
+  const focal = Math.max(scaleX, scaleY);
+  const offAxis = Math.hypot(scaleX * cameraPoint.x, scaleY * cameraPoint.y);
+  return radius * (distance * focal + offAxis) / (distance * (distance - radius));
+}
+
+function pointSegmentNearest(
+  point: readonly [number, number],
+  a: readonly [number, number],
+  b: readonly [number, number],
+): { distance: number; t: number } {
+  const dx = b[0] - a[0];
+  const dy = b[1] - a[1];
+  const length2 = dx * dx + dy * dy;
+  const t = length2 <= 1e-9 ? 0 : Math.max(0, Math.min(1, ((point[0] - a[0]) * dx + (point[1] - a[1]) * dy) / length2));
+  return { distance: Math.hypot(point[0] - (a[0] + t * dx), point[1] - (a[1] + t * dy)), t };
+}
+
+function segmentsIntersect(
+  a: readonly [number, number],
+  b: readonly [number, number],
+  c: readonly [number, number],
+  d: readonly [number, number],
+): boolean {
+  if (
+    Math.max(a[0], b[0]) < Math.min(c[0], d[0]) ||
+    Math.max(c[0], d[0]) < Math.min(a[0], b[0]) ||
+    Math.max(a[1], b[1]) < Math.min(c[1], d[1]) ||
+    Math.max(c[1], d[1]) < Math.min(a[1], b[1])
+  ) {
+    return false;
+  }
+  const cross2 = (p: readonly [number, number], q: readonly [number, number], r: readonly [number, number]): number =>
+    (q[0] - p[0]) * (r[1] - p[1]) - (q[1] - p[1]) * (r[0] - p[0]);
+  const abC = cross2(a, b, c);
+  const abD = cross2(a, b, d);
+  const cdA = cross2(c, d, a);
+  const cdB = cross2(c, d, b);
+  return abC * abD <= 0 && cdA * cdB <= 0;
+}
+
+function lerp(a: number, b: number, t: number): number {
+  return a + (b - a) * t;
+}
+
+function splineLocalToWorld(
+  point: readonly [number, number, number],
+  scale: readonly [number, number, number],
+  matrix: Matrix4,
+): Vector3 {
+  return new Vector3(point[0] * scale[0], -point[1] * scale[1], -point[2] * scale[2]).applyMatrix4(matrix);
+}
+
+function planeRecord(
+  target: WorkPlaneTarget,
+  origin: readonly [number, number, number],
+  xAxis: readonly [number, number, number],
+  yAxis: readonly [number, number, number],
+  fallback: boolean,
+): ResolvedWorkPlane {
+  const x = normalize(xAxis, [1, 0, 0]);
+  const yCandidate = normalize(yAxis, [0, 1, 0]);
+  const normal = normalize(cross(x, yCandidate), [0, 0, 1]);
+  const y = normalize(cross(normal, x), yCandidate);
+  return { target, origin: [...origin], xAxis: x, yAxis: y, normal, fallback };
+}
+
+function normalize(
+  value: readonly [number, number, number],
+  fallback: readonly [number, number, number],
+): [number, number, number] {
+  const length = Math.hypot(value[0], value[1], value[2]);
+  return length > 1e-9 && Number.isFinite(length)
+    ? [value[0] / length, value[1] / length, value[2] / length]
+    : [fallback[0], fallback[1], fallback[2]];
+}
+
+function cross(
+  a: readonly [number, number, number],
+  b: readonly [number, number, number],
+): [number, number, number] {
+  return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+}
+
+function dot3(
+  a: readonly [number, number, number],
+  b: readonly [number, number, number],
+): number {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+
+function designPointToWorld(point: readonly [number, number, number]): Vector3 {
+  return new Vector3(point[0], -point[1], -point[2]);
+}
+
+function worldPointToDesign(point: readonly [number, number, number]): [number, number, number] {
+  return [point[0], -point[1], -point[2]];
+}
+
+function designVectorToWorld(point: readonly [number, number, number]): Vector3 {
+  return new Vector3(point[0], -point[1], -point[2]).normalize();
+}
+
+function worldVectorToDesign(point: readonly [number, number, number]): [number, number, number] {
+  return normalize([point[0], -point[1], -point[2]], [1, 0, 0]);
+}
+
+function finiteVector(point: Vector3): boolean {
+  return Number.isFinite(point.x) && Number.isFinite(point.y) && Number.isFinite(point.z);
+}
+
+function cleanZero(value: number): number {
+  return Object.is(value, -0) ? 0 : value;
+}
+
+function copyPoint(point: SplinePoint3D): SplinePoint3D {
+  return {
+    id: point.id,
+    p: [...point.p],
+    ...(point.in === undefined ? {} : { in: [...point.in] }),
+    ...(point.out === undefined ? {} : { out: [...point.out] }),
+  };
+}