@yuzhouu/canvas-kit 0.1.2 → 0.1.4

package/_vendor/plugin-draw/drawShapeGeometry.ts

@@ -1,307 +0,0 @@
-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,
-  });
-}