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 'brush.dart';
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,
  BrushProfile? brush,
}) {
  if (pfPoints.isEmpty) return const <Offset>[];
  return pf.getStroke(
    pfPoints,
    options: brush != null
        // Brush-driven path: every geometry knob (thinning / streamline /
        // smoothing / caps / taper / simulatePressure) comes from the
        // BrushProfile so each brush renders distinctly. Pressure was already
        // pre-warped by the brush's gamma at CAPTURE (PressureCurve), so the
        // pre-warp is baked into pfPoints — perfect_freehand stays linear here.
        // simulatePressure is forced true only when the device gave us NO real
        // pressure, so velocity-thinning still kicks in for mice/trackpads.
        ? _optionsFromBrush(brush,
            size: size,
            isComplete: isComplete,
            hasRealPressure: hasRealPressure)
        : 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,
          ),
  );
}

/// Build perfect_freehand [pf.StrokeOptions] from a [BrushProfile] (spec §4).
///
/// Geometry only: [BrushProfile.opacity] / [BrushProfile.blendMultiply] are
/// consumed by the painters' [paintForEditorStroke] / `paintForStroke` (via
/// [resolveStrokePaint]), NOT here — this stays a pure outline recipe.
pf.StrokeOptions _optionsFromBrush(
  BrushProfile brush, {
  required double size,
  required bool isComplete,
  required bool hasRealPressure,
}) {
  return pf.StrokeOptions(
    size: size,
    thinning: brush.pfThinning,
    smoothing: brush.pfSmoothing,
    streamline: brush.pfStreamline,
    // Honor REAL pressure (already gamma-pre-warped at capture). Only fall back
    // to velocity simulation when the device reported no usable pressure.
    simulatePressure: brush.simulatePressure || !hasRealPressure,
    start: pf.StrokeEndOptions.start(
      cap: brush.capStart,
      taperEnabled: brush.taper,
    ),
    end: pf.StrokeEndOptions.end(
      cap: brush.capEnd,
      taperEnabled: brush.taper,
    ),
    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();

  // Resolve the brush so each stroke renders with its own geometry. The
  // pressure pre-warp ([BrushProfile.pressureGamma]) was already applied at
  // capture, so it is baked into the points here.
  final brush = brushProfileFor(stroke.brush);

  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,
    brush: brush,
  );

  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;
}

/// Mean point pressure (`pressure ?? 0.5`) of an [EditorStroke], for the
/// per-stroke opacity resolution (spec §3/§4 tie ballpoint/pencil opacity to
/// pressure).
double _avgPressure(EditorStroke stroke) {
  if (stroke.points.isEmpty) return 0.5;
  var sum = 0.0;
  for (final p in stroke.points) {
    sum += p.pressure ?? 0.5;
  }
  return sum / stroke.points.length;
}

/// THE single fill [Paint] for an [EditorStroke], with the brush's resolved
/// opacity (multiplied into the color's alpha) and blend mode applied — closes
/// TODO(brush-opacity). Shared by the committed [Picture] and live painters so
/// the EditorStroke render path composites exactly like the PenStroke one.
///
/// The stroke is drawn as ONE fill polygon, so a highlighter's own self-overlap
/// never darkens; cross-stroke overlap darkens via [BlendMode.multiply]
/// (marker build-up). TODO(brush-texture): pencil paper grain still deferred.
Paint paintForEditorStroke(EditorStroke stroke) {
  final resolved = resolveStrokePaint(
    stroke.brush,
    stroke.color,
    pressureAvg: _avgPressure(stroke),
  );
  return Paint()
    ..color = resolved.color
    ..blendMode = resolved.blendMode
    ..style = PaintingStyle.fill
    ..isAntiAlias = true;
}