@yuzhouu/canvas-kit 0.1.2

package/_vendor/plugin-draw/drawShapeGeometry.ts

@@ -0,0 +1,307 @@
+import { Box, Vec } from "@land/canvas-core";
+import {
+  drawPointToVec,
+  getClosedDrawCenterlinePathFromPoints,
+  getDrawCenterlinePathFromPoints,
+  getDrawPointSamplingLimit,
+  getDrawSegmentsFromPoints,
+  getFlattenedDrawSegmentPoints,
+  getSmoothClosedSvgPathFromVecs,
+  sampleDrawPoints,
+  type DrawPointSamplingOptions,
+} from "./drawPath";
+import {
+  cloneDrawPoints,
+  cloneDrawSegment,
+  cloneDrawSegments,
+  translateDrawSegments,
+} from "./drawSegments";
+import {
+  createStrokeDerivedPoints,
+  getStrokeOutlineVertices,
+} from "./drawStrokeGeometry";
+import type { DrawShapePoint, DrawShapeSegment } from "./types";
+
+export interface DrawShapeSamplingStats {
+  rawPointCount: number;
+  sampledPointCount: number;
+  sampledPointLimit: number;
+  reduced: boolean;
+  capped: boolean;
+}
+
+export interface DrawShapeGeometry {
+  normalizedSegments: DrawShapeSegment[];
+  normalizedPoints: DrawShapePoint[];
+  pointBounds: Box;
+  path: string | null;
+  selectionPath: string | null;
+  fillPath: string | null;
+  localBounds: Box;
+  renderBounds: Box;
+  outlineVertices: Vec[];
+  outlinePolygons: Vec[][];
+  sampling: DrawShapeSamplingStats;
+}
+
+interface DrawSegmentGeometryPart {
+  normalizedSegment: DrawShapeSegment;
+  sampling: DrawShapeSamplingStats;
+}
+
+const drawSegmentGeometryCache = new WeakMap<
+  DrawShapeSegment,
+  Map<string, DrawSegmentGeometryPart>
+>();
+
+function getFallbackBounds(): Box {
+  return new Box(0, 0, 1, 1);
+}
+
+function cloneSamplingStats(
+  sampling: DrawShapeSamplingStats,
+): DrawShapeSamplingStats {
+  return { ...sampling };
+}
+
+function translateOutlineVertices(
+  points: readonly Vec[],
+  dx: number,
+  dy: number,
+): Vec[] {
+  return points.map((point) => new Vec(point.x + dx, point.y + dy));
+}
+
+function translateOutlinePolygons(
+  polygons: readonly Vec[][],
+  dx: number,
+  dy: number,
+): Vec[][] {
+  return polygons.map((polygon) => translateOutlineVertices(polygon, dx, dy));
+}
+
+function getCompoundDrawOutlinePath(polygons: readonly Vec[][]): string | null {
+  const paths = polygons
+    .map((polygon) => getSmoothClosedSvgPathFromVecs(polygon))
+    .filter((path): path is string => path !== null);
+  return paths.length > 0 ? paths.join(" ") : null;
+}
+
+export function createDrawGeometryFromDerivedData({
+  segments,
+  outlineVertices,
+  outlinePolygons,
+  strokeWidth,
+  sampling,
+  isClosed,
+}: {
+  segments: readonly DrawShapeSegment[];
+  outlineVertices: readonly Vec[];
+  outlinePolygons?: readonly Vec[][];
+  strokeWidth: number;
+  sampling: DrawShapeSamplingStats;
+  isClosed: boolean;
+}): DrawShapeGeometry {
+  const points = getFlattenedDrawSegmentPoints(segments);
+  const pointVecs = points.map(drawPointToVec);
+  const pointBounds =
+    pointVecs.length > 0 ? Box.FromPoints(pointVecs) : getFallbackBounds();
+  const localBounds =
+    outlineVertices.length > 0
+      ? Box.FromPoints([...outlineVertices])
+      : pointBounds.expand(Math.max(strokeWidth / 2, 1));
+  const fillPath =
+    isClosed && points.length >= 3
+      ? getClosedDrawCenterlinePathFromPoints(points)
+      : null;
+  const outlinePath =
+    outlinePolygons !== undefined
+      ? getCompoundDrawOutlinePath(outlinePolygons)
+      : getSmoothClosedSvgPathFromVecs(outlineVertices);
+
+  return {
+    normalizedSegments: cloneDrawSegments(segments),
+    normalizedPoints: cloneDrawPoints(points),
+    pointBounds,
+    path: outlinePath,
+    selectionPath: fillPath ?? getDrawCenterlinePathFromPoints(points),
+    fillPath,
+    localBounds,
+    renderBounds: localBounds.clone(),
+    outlineVertices: outlineVertices.map((point) => point.clone()),
+    outlinePolygons: outlinePolygons
+      ? outlinePolygons.map((polygon) => polygon.map((point) => point.clone()))
+      : [outlineVertices.map((point) => point.clone())],
+    sampling: cloneSamplingStats(sampling),
+  };
+}
+
+export function createTranslatedDrawGeometry(
+  geometry: DrawShapeGeometry,
+  strokeWidth: number,
+  dx: number,
+  dy: number,
+  isClosed: boolean,
+): DrawShapeGeometry {
+  return createDrawGeometryFromDerivedData({
+    segments: translateDrawSegments(geometry.normalizedSegments, dx, dy),
+    outlineVertices: translateOutlineVertices(geometry.outlineVertices, dx, dy),
+    outlinePolygons: translateOutlinePolygons(geometry.outlinePolygons, dx, dy),
+    strokeWidth,
+    sampling: geometry.sampling,
+    isClosed,
+  });
+}
+
+function getDrawPointSamplingOptions(
+  strokeWidth: number,
+  isPen: boolean,
+): DrawPointSamplingOptions {
+  return {
+    minPointDistance: isPen
+      ? Math.max(0.35, strokeWidth * 0.18)
+      : Math.max(0.55, strokeWidth * 0.28),
+    positionBlend: isPen ? 0.68 : 0.66,
+    pressureBlend: isPen ? 0.68 : 0.45,
+    maxPointCount: getDrawPointSamplingLimit(isPen),
+  };
+}
+
+function getDrawSegmentGeometryCacheKey({
+  strokeWidth,
+  isPen,
+}: {
+  strokeWidth: number;
+  isPen: boolean;
+}): string {
+  return [strokeWidth, isPen ? "pen" : "pointer"].join(":");
+}
+
+function getCachedDrawSegmentGeometryPart(
+  segment: DrawShapeSegment,
+  samplingOptions: DrawPointSamplingOptions,
+  strokeWidth: number,
+  isPen: boolean,
+): DrawSegmentGeometryPart {
+  const cacheKey = getDrawSegmentGeometryCacheKey({
+    strokeWidth,
+    isPen,
+  });
+  const cachedByKey = drawSegmentGeometryCache.get(segment);
+  const cached = cachedByKey?.get(cacheKey);
+  if (cached) {
+    return {
+      normalizedSegment: cloneDrawSegment(cached.normalizedSegment),
+      sampling: cloneSamplingStats(cached.sampling),
+    };
+  }
+
+  const sampled = sampleDrawPoints(segment.points, samplingOptions);
+  const part: DrawSegmentGeometryPart = {
+    normalizedSegment: { points: cloneDrawPoints(sampled.points) },
+    sampling: {
+      rawPointCount: sampled.rawPointCount,
+      sampledPointCount: sampled.sampledPointCount,
+      sampledPointLimit: sampled.maxPointCount,
+      reduced: sampled.reduced,
+      capped: sampled.capped,
+    },
+  };
+
+  const nextCachedByKey =
+    cachedByKey ?? new Map<string, DrawSegmentGeometryPart>();
+  nextCachedByKey.set(cacheKey, {
+    normalizedSegment: cloneDrawSegment(part.normalizedSegment),
+    sampling: cloneSamplingStats(part.sampling),
+  });
+  if (!cachedByKey) {
+    drawSegmentGeometryCache.set(segment, nextCachedByKey);
+  }
+
+  return part;
+}
+
+function getCombinedDrawSegmentSamplingStats(
+  samplings: readonly DrawShapeSamplingStats[],
+  sampledPointLimit: number,
+): DrawShapeSamplingStats {
+  return {
+    rawPointCount: samplings.reduce(
+      (sum, sampling) => sum + sampling.rawPointCount,
+      0,
+    ),
+    sampledPointCount: samplings.reduce(
+      (sum, sampling) => sum + sampling.sampledPointCount,
+      0,
+    ),
+    sampledPointLimit,
+    reduced: samplings.some((sampling) => sampling.reduced),
+    capped: samplings.some((sampling) => sampling.capped),
+  };
+}
+
+export function getDrawPointGeometry(
+  points: readonly DrawShapePoint[],
+  strokeWidth: number,
+  isPen = false,
+  isClosed = false,
+): DrawShapeGeometry {
+  return getDrawSegmentGeometry(
+    getDrawSegmentsFromPoints(points),
+    strokeWidth,
+    isPen,
+    isClosed,
+  );
+}
+
+export function getDrawSegmentGeometry(
+  segments: readonly DrawShapeSegment[],
+  strokeWidth: number,
+  isPen = false,
+  isClosed = false,
+): DrawShapeGeometry {
+  const samplingOptions = getDrawPointSamplingOptions(strokeWidth, isPen);
+  const normalizedSegments: DrawShapeSegment[] = [];
+  const segmentSamplings: DrawShapeSamplingStats[] = [];
+
+  const nonEmptySegments = segments.filter(
+    (segment) => segment.points.length > 0,
+  );
+  for (
+    let segmentIndex = 0;
+    segmentIndex < nonEmptySegments.length;
+    segmentIndex += 1
+  ) {
+    const segment = nonEmptySegments[segmentIndex]!;
+    const part = getCachedDrawSegmentGeometryPart(
+      segment,
+      samplingOptions,
+      strokeWidth,
+      isPen,
+    );
+    normalizedSegments.push(cloneDrawSegment(part.normalizedSegment));
+    segmentSamplings.push(cloneSamplingStats(part.sampling));
+  }
+
+  const normalizedPoints = getFlattenedDrawSegmentPoints(normalizedSegments);
+  const strokePoints = createStrokeDerivedPoints(
+    normalizedPoints,
+    strokeWidth,
+    isPen,
+    isClosed,
+  );
+  const outlineVertices = getStrokeOutlineVertices(strokePoints, isClosed);
+  const sampling = getCombinedDrawSegmentSamplingStats(
+    segmentSamplings,
+    samplingOptions.maxPointCount,
+  );
+
+  return createDrawGeometryFromDerivedData({
+    segments: normalizedSegments,
+    outlineVertices,
+    outlinePolygons: outlineVertices.length > 0 ? [outlineVertices] : [],
+    strokeWidth,
+    sampling,
+    isClosed,
+  });
+}