BadNote/lib/editor/engine/stroke_geometry.dart

// lib/editor/engine/stroke_geometry.dart
//
// Single source of stroke outline geometry for both screen render and export.
// The recipe is lifted verbatim from the proven live
// `ink_painters.buildStrokePath` (lib/editor/canvas/ink_painters.dart): points
// are scaled from normalized page coords to pixels, perfect_freehand produces
// the outline, and a closed fill Path is built. Keeping ONE implementation here
// kills the hairline-export divergence (R7).

import 'dart:ui';

import 'package:perfect_freehand/perfect_freehand.dart' as pf;

import 'stroke_model.dart';

/// Canonical default for perfect_freehand's `thinning` (how strongly pressure
/// modulates stroke width). The SINGLE source of truth shared by the on-screen
/// painter ([buildStrokeOutline] here and `ink_painters.buildStrokePath`) and
/// the PDF export path, so screen and export can never diverge. `0.85` =
/// pressure visibly sweeps width; preserves the existing feel + export golden.
/// Overridable per-stroke via [PenConfig.pressureSensitivity].
const double kDefaultPenThinning = 0.85;

/// perfect_freehand input-smoothing parameters, shared (single source of truth)
/// by the on-screen painter and the export path so the two can never diverge
/// (guarded by the screen==export parity test). [kPenStreamline] lowers the
/// per-point lag from freehand's 0.5 default to 0.32: at 0.5 a quick flick lags
/// so far behind the pen that a short fast stroke collapsed toward its start and
/// rendered as a dot ("写字识别成单击") and the pen felt sluggish; 0.32 tracks the
/// real path closely (crisper, lower-latency feel) while still damping digitizer
/// jitter. [kPenSmoothing] keeps freehand's 0.5 corner rounding.
const double kPenStreamline = 0.32;
const double kPenSmoothing = 0.5;

/// THE single perfect_freehand outline recipe — the raw outline points for a
/// stroke. Both the on-screen painter ([buildStrokeOutline] / the live
/// `ink_painters.buildStrokePath`) and the PDF export
/// (`pdf_service._buildFreehandPdfPath`) call THIS, so the `StrokeOptions`
/// (thinning / smoothing / streamline / simulatePressure) live in exactly one
/// place and screen↔export can never drift again (R7 — the hairline-export bug
/// was pdf_service hardcoding its own `thinning: 0.7, streamline: 0.5`).
///
/// Callers supply already-pixel-scaled [pfPoints] (because the two stroke
/// models scale differently) plus the per-stroke flags. Returns the closed
/// outline as `List<Offset>` (perfect_freehand 2.x); empty when freehand
/// produces nothing.
List<Offset> freehandOutlinePoints({
  required List<pf.PointVector> pfPoints,
  required double size,
  required bool isHighlighter,
  required bool hasRealPressure,
  required bool isComplete,
  double thinning = kDefaultPenThinning,
}) {
  if (pfPoints.isEmpty) return const <Offset>[];
  return pf.getStroke(
    pfPoints,
    options: pf.StrokeOptions(
      size: size,
      // Highlighter keeps a constant width (no thinning); pen uses the
      // configurable [thinning] so Surface-Pen pressure changes width.
      thinning: isHighlighter ? 0.0 : thinning,
      smoothing: kPenSmoothing,
      streamline: kPenStreamline,
      // Real stylus pressure -> don't simulate; no pressure -> let freehand
      // fake it based on velocity (highlighter never simulates). perfect_freehand
      // 2.x honors real pressure when simulatePressure is false.
      simulatePressure: !hasRealPressure && !isHighlighter,
      isComplete: isComplete,
    ),
  );
}

/// Builds a closed, fillable outline [Path] for one [stroke], scaled into the
/// pixel space of [pageSize] (which maps normalized [0,1] coords to pixels).
///
/// [isComplete] should be false for the in-progress live stroke so freehand
/// tapers the trailing end correctly, and true for committed strokes.
///
/// [thinning] is perfect_freehand's pressure→width response (see
/// [kDefaultPenThinning]); highlighter always forces `0.0` (constant width).
///
/// Returns an empty [Path] when the stroke has no points (or freehand produces
/// no outline).
Path buildStrokeOutline(
  EditorStroke stroke,
  Size pageSize, {
  required bool isComplete,
  double thinning = kDefaultPenThinning,
}) {
  final path = Path();
  if (stroke.points.isEmpty) return path;

  final pfPoints = stroke.points
      .map(
        (p) => pf.PointVector(
          p.x * pageSize.width,
          p.y * pageSize.height,
          p.pressure ?? 0.5,
        ),
      )
      .toList();

  final outline = freehandOutlinePoints(
    pfPoints: pfPoints,
    size: stroke.width * pageSize.width,
    isHighlighter: stroke.tool == EditorTool.highlighter,
    hasRealPressure: stroke.points.any((p) => p.pressure != null),
    isComplete: isComplete,
    thinning: thinning,
  );

  if (outline.isEmpty) return path;
  path.moveTo(outline.first.dx, outline.first.dy);
  for (var i = 1; i < outline.length; i++) {
    path.lineTo(outline[i].dx, outline[i].dy);
  }
  path.close();
  return path;
}