@yuzhouu/canvas-kit 0.1.2

package/_vendor/plugin-draw/drawGeometry.ts

@@ -0,0 +1,491 @@
+import { Box, Vec } from "@land/canvas-core";
+import {
+  getDrawSegmentsFromPoints,
+  getFlattenedDrawSegmentPoints,
+} from "./drawPath";
+import {
+  cloneDrawSegments,
+  mapDrawSegmentCoordinates,
+  mapDrawShapeSegmentsToBounds,
+  translateDrawSegments,
+} from "./drawSegments";
+import {
+  mapPageDrawSegmentsToSelectionLocal,
+  mapSelectionLocalDrawSegmentsToPage,
+  mirrorSelectionLocalDrawSegments,
+  type DrawSelectionFlipInput,
+  type DrawSelectionResizeInput,
+} from "./drawSelectionTransform";
+import {
+  createDrawGeometryFromDerivedData,
+  createTranslatedDrawGeometry,
+  getDrawPointGeometry,
+  getDrawSegmentGeometry,
+  type DrawShapeGeometry,
+  type DrawShapeSamplingStats,
+} from "./drawShapeGeometry";
+import type {
+  DrawShapePoint,
+  DrawShapeProps,
+  DrawShapeRecord,
+  DrawShapeSegment,
+} from "./types";
+
+export { getDrawPointGeometry, getDrawSegmentGeometry };
+export type {
+  DrawShapeGeometry,
+  DrawShapeSamplingStats,
+} from "./drawShapeGeometry";
+
+type DrawLocalGeometryCacheKey = Pick<DrawShapeRecord, "props">;
+type DrawPositionedGeometryCacheKey = Pick<DrawShapeRecord, "x" | "y" | "props">;
+type DrawPageGeometryCacheKey = Pick<
+  DrawShapeRecord,
+  "x" | "y" | "rotation" | "scaleX" | "scaleY" | "props"
+>;
+
+export interface DrawShapeDiagnostics extends DrawShapeSamplingStats {
+  hasPath: boolean;
+  hasSelectionPath: boolean;
+  outlineVertexCount: number;
+}
+
+const drawLocalGeometryCache = new WeakMap<object, DrawShapeGeometry>();
+const drawPositionedGeometryCache = new WeakMap<object, DrawShapeGeometry>();
+const drawPageGeometryCache = new WeakMap<object, DrawShapeGeometry>();
+
+function getDrawShapeSourceSegments(
+  props: Pick<DrawShapeProps, "segments">,
+): readonly DrawShapeSegment[] {
+  return props.segments;
+}
+
+function getInsetBounds(
+  bounds: Box,
+  padding: { left: number; right: number; top: number; bottom: number },
+): Box {
+  const width = Math.max(0, bounds.w - padding.left - padding.right);
+  const height = Math.max(0, bounds.h - padding.top - padding.bottom);
+
+  return new Box(bounds.x + padding.left, bounds.y + padding.top, width, height);
+}
+
+function getTargetPointBoundsFromSelectionBounds(
+  currentPointBounds: Box,
+  currentStrokeBounds: Box,
+  nextSelectionBounds: Box,
+): Box {
+  return getInsetBounds(nextSelectionBounds, {
+    left: currentPointBounds.minX - currentStrokeBounds.minX,
+    right: currentStrokeBounds.maxX - currentPointBounds.maxX,
+    top: currentPointBounds.minY - currentStrokeBounds.minY,
+    bottom: currentStrokeBounds.maxY - currentPointBounds.maxY,
+  });
+}
+
+function fitDrawSegmentsToSelectionStrokeBounds({
+  segments,
+  strokeWidth,
+  isPen,
+  isClosed,
+  targetSelectionStrokeBounds,
+}: {
+  segments: readonly DrawShapeSegment[];
+  strokeWidth: number;
+  isPen: boolean;
+  isClosed: boolean;
+  targetSelectionStrokeBounds: Box;
+}): DrawShapeSegment[] {
+  let fittedSegments = cloneDrawSegments(segments);
+
+  for (let pass = 0; pass < 2; pass += 1) {
+    const geometry = getDrawSegmentGeometry(
+      fittedSegments,
+      strokeWidth,
+      isPen,
+      isClosed,
+    );
+    const targetPointBounds = getTargetPointBoundsFromSelectionBounds(
+      geometry.pointBounds,
+      geometry.localBounds,
+      targetSelectionStrokeBounds,
+    );
+    fittedSegments = mapDrawShapeSegmentsToBounds(
+      fittedSegments,
+      geometry.pointBounds,
+      targetPointBounds,
+    );
+  }
+
+  return fittedSegments;
+}
+
+function getDrawShapePageCenter(
+  shape: DrawPageGeometryCacheKey,
+  localGeometry: Pick<DrawShapeGeometry, "localBounds">,
+): Vec {
+  return new Vec(
+    shape.x + localGeometry.localBounds.center.x,
+    shape.y + localGeometry.localBounds.center.y,
+  );
+}
+
+function positionedDrawPointToPagePoint(
+  shape: DrawPageGeometryCacheKey,
+  point: Vec,
+  center: Vec,
+): Vec {
+  if (shape.rotation === 0 && shape.scaleX === 1 && shape.scaleY === 1) {
+    return point;
+  }
+  const offset = point.sub(center);
+
+  return center.add(
+    new Vec(offset.x * shape.scaleX, offset.y * shape.scaleY).rot(
+      shape.rotation,
+    ),
+  );
+}
+
+export interface NormalizedDrawShape {
+  x: number;
+  y: number;
+  segments: DrawShapeSegment[];
+  pointBounds: Box;
+  localBounds: Box;
+  renderBounds: Box;
+  path: string | null;
+  selectionPath: string | null;
+  fillPath: string | null;
+  outlineVertices: Vec[];
+  outlinePolygons: Vec[][];
+  sampling: DrawShapeSamplingStats;
+}
+
+export function getDrawShapeLocalGeometry(
+  shape: DrawLocalGeometryCacheKey,
+): DrawShapeGeometry {
+  const cacheKey = shape as object;
+  const cached = drawLocalGeometryCache.get(cacheKey);
+  if (cached) {
+    return cached;
+  }
+
+  const geometry = getDrawSegmentGeometry(
+    getDrawShapeSourceSegments(shape.props),
+    shape.props.strokeWidth,
+    shape.props.isPen ?? false,
+    shape.props.isClosed,
+  );
+  drawLocalGeometryCache.set(cacheKey, geometry);
+  return geometry;
+}
+
+export function normalizeDrawShapeFromSegmentSet(
+  segments: readonly DrawShapeSegment[],
+  strokeWidth: number,
+  isPen = false,
+  isClosed = false,
+): NormalizedDrawShape {
+  const geometry = getDrawSegmentGeometry(segments, strokeWidth, isPen, isClosed);
+  const pointBounds = geometry.pointBounds;
+  const normalizedSegments = mapDrawSegmentCoordinates(
+    geometry.normalizedSegments,
+    (point) => new Vec(point.x - pointBounds.x, point.y - pointBounds.y),
+  );
+  const normalizedGeometry = getDrawSegmentGeometry(
+    normalizedSegments,
+    strokeWidth,
+    isPen,
+    isClosed,
+  );
+
+  return {
+    x: pointBounds.x,
+    y: pointBounds.y,
+    segments: normalizedGeometry.normalizedSegments,
+    pointBounds: normalizedGeometry.pointBounds,
+    localBounds: normalizedGeometry.localBounds,
+    renderBounds: normalizedGeometry.renderBounds,
+    path: normalizedGeometry.path,
+    selectionPath: normalizedGeometry.selectionPath,
+    fillPath: normalizedGeometry.fillPath,
+    outlineVertices: normalizedGeometry.outlineVertices,
+    outlinePolygons: normalizedGeometry.outlinePolygons,
+    sampling: normalizedGeometry.sampling,
+  };
+}
+
+export function normalizeDrawShapeFromPointSet(
+  points: readonly DrawShapePoint[],
+  strokeWidth: number,
+  isPen = false,
+  isClosed = false,
+): NormalizedDrawShape {
+  return normalizeDrawShapeFromSegmentSet(
+    getDrawSegmentsFromPoints(points),
+    strokeWidth,
+    isPen,
+    isClosed,
+  );
+}
+
+export function normalizeDrawShapeFromPagePoints(
+  pagePoints: readonly DrawShapePoint[],
+  strokeWidth: number,
+  isPen = false,
+  isClosed = false,
+): NormalizedDrawShape {
+  return normalizeDrawShapeFromPointSet(pagePoints, strokeWidth, isPen, isClosed);
+}
+
+export function normalizeDrawShapeFromPageSegments(
+  pageSegments: readonly DrawShapeSegment[],
+  strokeWidth: number,
+  isPen = false,
+  isClosed = false,
+): NormalizedDrawShape {
+  return normalizeDrawShapeFromSegmentSet(
+    pageSegments,
+    strokeWidth,
+    isPen,
+    isClosed,
+  );
+}
+
+export function getDrawShapePositionedSegments(
+  shape: Pick<DrawShapeRecord, "x" | "y" | "props">,
+): DrawShapeSegment[] {
+  return translateDrawSegments(
+    getDrawShapeSourceSegments(shape.props),
+    shape.x,
+    shape.y,
+  );
+}
+
+export function getDrawShapePositionedPoints(
+  shape: Pick<DrawShapeRecord, "x" | "y" | "props">,
+): DrawShapePoint[] {
+  return getFlattenedDrawSegmentPoints(getDrawShapePositionedSegments(shape));
+}
+
+export function getDrawShapePositionedGeometry(
+  shape: DrawPositionedGeometryCacheKey,
+): DrawShapeGeometry {
+  const cacheKey = shape as object;
+  const cached = drawPositionedGeometryCache.get(cacheKey);
+  if (cached) {
+    return cached;
+  }
+
+  const geometry = createTranslatedDrawGeometry(
+    getDrawShapeLocalGeometry(shape),
+    shape.props.strokeWidth,
+    shape.x,
+    shape.y,
+    shape.props.isClosed,
+  );
+  drawPositionedGeometryCache.set(cacheKey, geometry);
+  return geometry;
+}
+
+export function getDrawShapePagePoints(shape: DrawShapeRecord): DrawShapePoint[] {
+  return getFlattenedDrawSegmentPoints(getDrawShapePageSegments(shape));
+}
+
+export function getDrawShapePageSegments(shape: DrawShapeRecord): DrawShapeSegment[] {
+  const localGeometry = getDrawShapeLocalGeometry(shape);
+  const center = getDrawShapePageCenter(shape, localGeometry);
+  return mapDrawSegmentCoordinates(
+    getDrawShapePositionedSegments(shape),
+    (point) => positionedDrawPointToPagePoint(shape, point, center),
+  );
+}
+
+export function normalizeTransformedDrawShape(
+  shape: DrawShapeRecord,
+): NormalizedDrawShape {
+  return normalizeDrawShapeFromPageSegments(
+    getDrawShapePageSegments(shape),
+    shape.props.strokeWidth,
+    shape.props.isPen ?? false,
+    shape.props.isClosed,
+  );
+}
+
+export function getDrawShapePageGeometry(
+  shape: DrawPageGeometryCacheKey,
+): DrawShapeGeometry {
+  const cacheKey = shape as object;
+  const cached = drawPageGeometryCache.get(cacheKey);
+  if (cached) {
+    return cached;
+  }
+
+  if (shape.rotation === 0 && shape.scaleX === 1 && shape.scaleY === 1) {
+    const geometry = getDrawShapePositionedGeometry(shape);
+    drawPageGeometryCache.set(cacheKey, geometry);
+    return geometry;
+  }
+
+  const localGeometry = getDrawShapeLocalGeometry(shape);
+  const center = getDrawShapePageCenter(shape, localGeometry);
+  const pageSegments = mapDrawSegmentCoordinates(
+    localGeometry.normalizedSegments,
+    (point) =>
+      positionedDrawPointToPagePoint(
+        shape,
+        new Vec(point.x + shape.x, point.y + shape.y),
+        center,
+      ),
+  );
+  const outlineVertices = localGeometry.outlineVertices.map((point) =>
+    positionedDrawPointToPagePoint(
+      shape,
+      new Vec(point.x + shape.x, point.y + shape.y),
+      center,
+    ),
+  );
+  const outlinePolygons = localGeometry.outlinePolygons.map((polygon) =>
+    polygon.map((point) =>
+      positionedDrawPointToPagePoint(
+        shape,
+        new Vec(point.x + shape.x, point.y + shape.y),
+        center,
+      ),
+    ),
+  );
+  const geometry = createDrawGeometryFromDerivedData({
+    segments: pageSegments,
+    outlineVertices,
+    outlinePolygons,
+    strokeWidth: shape.props.strokeWidth,
+    sampling: localGeometry.sampling,
+    isClosed: shape.props.isClosed,
+  });
+  drawPageGeometryCache.set(cacheKey, geometry);
+  return geometry;
+}
+
+export function resizeDrawShapeToSelectionBounds(
+  shape: DrawShapeRecord,
+  input: DrawSelectionResizeInput,
+): NormalizedDrawShape {
+  const selectionLocalSegments = mapPageDrawSegmentsToSelectionLocal(
+    getDrawShapePageSegments(shape),
+    input,
+  );
+  const resizedSelectionLocalSegments = fitDrawSegmentsToSelectionStrokeBounds({
+    segments: selectionLocalSegments,
+    strokeWidth: shape.props.strokeWidth,
+    isPen: shape.props.isPen ?? false,
+    isClosed: shape.props.isClosed,
+    targetSelectionStrokeBounds: input.targetSelectionStrokeBounds,
+  });
+  let transformedSelectionLocalSegments = resizedSelectionLocalSegments;
+  if (input.scaleX < 0) {
+    transformedSelectionLocalSegments = mirrorSelectionLocalDrawSegments(
+      transformedSelectionLocalSegments,
+      {
+        axis: "horizontal",
+        selectionMirrorBounds: input.targetSelectionStrokeBounds,
+        selectionRotation: input.selectionRotation,
+        selectionRotationCenter: input.selectionRotationCenter,
+      },
+    );
+  }
+  if (input.scaleY < 0) {
+    transformedSelectionLocalSegments = mirrorSelectionLocalDrawSegments(
+      transformedSelectionLocalSegments,
+      {
+        axis: "vertical",
+        selectionMirrorBounds: input.targetSelectionStrokeBounds,
+        selectionRotation: input.selectionRotation,
+        selectionRotationCenter: input.selectionRotationCenter,
+      },
+    );
+  }
+  const resizedPageSegments = mapSelectionLocalDrawSegmentsToPage(
+    transformedSelectionLocalSegments,
+    input,
+  );
+
+  return normalizeDrawShapeFromPageSegments(
+    resizedPageSegments,
+    shape.props.strokeWidth,
+    shape.props.isPen ?? false,
+    shape.props.isClosed,
+  );
+}
+
+export function flipDrawShapeInSelectionBounds(
+  shape: DrawShapeRecord,
+  input: DrawSelectionFlipInput,
+): NormalizedDrawShape {
+  const selectionLocalSegments = mapPageDrawSegmentsToSelectionLocal(
+    getDrawShapePageSegments(shape),
+    input,
+  );
+  const flippedSelectionLocalSegments = mirrorSelectionLocalDrawSegments(
+    selectionLocalSegments,
+    input,
+  );
+  const flippedPageSegments = mapSelectionLocalDrawSegmentsToPage(
+    flippedSelectionLocalSegments,
+    input,
+  );
+
+  return normalizeDrawShapeFromPageSegments(
+    flippedPageSegments,
+    shape.props.strokeWidth,
+    shape.props.isPen ?? false,
+    shape.props.isClosed,
+  );
+}
+
+export function resizeDrawShapeToPageBounds(
+  shape: Pick<DrawShapeRecord, "x" | "y" | "props">,
+  nextPageBounds: Box,
+): NormalizedDrawShape {
+  const positionedSegments = getDrawShapePositionedSegments(shape);
+  const currentGeometry = getDrawShapePositionedGeometry(shape);
+  const currentPointBounds = currentGeometry.pointBounds;
+  const currentStrokeBounds = currentGeometry.localBounds;
+  const targetPointBounds = getInsetBounds(nextPageBounds, {
+    left: currentPointBounds.minX - currentStrokeBounds.minX,
+    right: currentStrokeBounds.maxX - currentPointBounds.maxX,
+    top: currentPointBounds.minY - currentStrokeBounds.minY,
+    bottom: currentStrokeBounds.maxY - currentPointBounds.maxY,
+  });
+  const resizedPositionedSegments = mapDrawShapeSegmentsToBounds(
+    positionedSegments,
+    currentPointBounds,
+    targetPointBounds,
+  );
+
+  return normalizeDrawShapeFromPageSegments(
+    resizedPositionedSegments,
+    shape.props.strokeWidth,
+    shape.props.isPen ?? false,
+    shape.props.isClosed,
+  );
+}
+
+export function cloneDrawShapeSegmentsForUpdate(
+  segments: readonly DrawShapeSegment[],
+): DrawShapeSegment[] {
+  return cloneDrawSegments(segments);
+}
+
+export function getDrawShapeDiagnostics(
+  shape: DrawLocalGeometryCacheKey,
+): DrawShapeDiagnostics {
+  const geometry = getDrawShapeLocalGeometry(shape);
+
+  return {
+    ...geometry.sampling,
+    hasPath: geometry.path !== null,
+    hasSelectionPath: geometry.selectionPath !== null,
+    outlineVertexCount: geometry.outlineVertices.length,
+  };
+}