@stroke-stabilizer/core 0.1.3

package/README.md

@@ -0,0 +1,397 @@
+# @stroke-stabilizer/core
+
+[![npm version](https://img.shields.io/npm/v/@stroke-stabilizer/core.svg)](https://www.npmjs.com/package/@stroke-stabilizer/core)
+
+[日本語](./docs/README.ja.md)
+
+> This is part of the [stroke-stabilizer](https://github.com/usapopopooon/stroke-stabilizer) monorepo
+
+A lightweight, framework-agnostic stroke stabilization library for digital drawing applications.
+
+Reduce hand tremor and smooth pen/mouse input in real-time using a flexible filter pipeline.
+
+## Features
+
+- **[Dynamic Pipeline Pattern](https://dev.to/usapopopooon/the-dynamic-pipeline-pattern-a-mutable-method-chaining-for-real-time-processing-16e1)** - Add, remove, and update filters at runtime without rebuilding
+- **Two-layer Processing** - Real-time filters + post-processing convolution
+- **rAF Batch Processing** - Coalesce high-frequency pointer events into animation frames
+- **8 Built-in Filters** - From simple moving average to adaptive One Euro Filter
+- **Edge-preserving Smoothing** - Bilateral kernel for sharp corner preservation
+- **TypeScript First** - Full type safety with exported types
+- **Zero Dependencies** - Pure JavaScript, works anywhere
+
+## Installation
+
+```bash
+npm install @stroke-stabilizer/core
+```
+
+## Quick Start
+
+```ts
+import {
+  StabilizedPointer,
+  emaFilter,
+  oneEuroFilter,
+} from '@stroke-stabilizer/core'
+
+const pointer = new StabilizedPointer()
+  .addFilter(emaFilter({ alpha: 0.5 }))
+  .addFilter(oneEuroFilter({ minCutoff: 1.0, beta: 0.007 }))
+
+canvas.addEventListener('pointermove', (e) => {
+  const result = pointer.process({
+    x: e.clientX,
+    y: e.clientY,
+    pressure: e.pressure,
+    timestamp: e.timeStamp,
+  })
+
+  if (result) {
+    draw(result.x, result.y)
+  }
+})
+
+canvas.addEventListener('pointerup', () => {
+  pointer.reset()
+})
+```
+
+## Filters
+
+> **📖 [Detailed Filter Reference](../../docs/filters.md)** - Mathematical formulas, technical explanations, and usage recommendations
+
+### Real-time Filters
+
+| Filter                   | Description                       | Use Case                           |
+| ------------------------ | --------------------------------- | ---------------------------------- |
+| `noiseFilter`            | Rejects points too close together | Remove jitter                      |
+| `movingAverageFilter`    | Simple moving average (FIR)       | Basic smoothing                    |
+| `emaFilter`              | Exponential moving average (IIR)  | Low-latency smoothing              |
+| `kalmanFilter`           | Kalman filter                     | Noisy input smoothing              |
+| `stringFilter`           | Lazy Brush algorithm              | Delayed, smooth strokes            |
+| `oneEuroFilter`          | Adaptive lowpass filter           | Best balance of smoothness/latency |
+| `linearPredictionFilter` | Predicts next position            | Lag compensation                   |
+
+### Post-processing Kernels
+
+| Kernel            | Description               |
+| ----------------- | ------------------------- |
+| `gaussianKernel`  | Gaussian blur             |
+| `boxKernel`       | Simple average            |
+| `triangleKernel`  | Linear falloff            |
+| `bilateralKernel` | Edge-preserving smoothing |
+
+## Usage Examples
+
+### Basic Real-time Stabilization
+
+```ts
+import { StabilizedPointer, oneEuroFilter } from '@stroke-stabilizer/core'
+
+const pointer = new StabilizedPointer().addFilter(
+  oneEuroFilter({ minCutoff: 1.0, beta: 0.007 })
+)
+
+// Process each point
+const smoothed = pointer.process({ x, y, timestamp })
+```
+
+### Dynamic Filter Updates
+
+```ts
+// Add filter
+pointer.addFilter(emaFilter({ alpha: 0.3 }))
+
+// Update parameters at runtime
+pointer.updateFilter('ema', { alpha: 0.5 })
+
+// Remove filter
+pointer.removeFilter('ema')
+```
+
+### Post-processing with Bidirectional Convolution
+
+```ts
+import { StabilizedPointer, gaussianKernel } from '@stroke-stabilizer/core'
+
+const pointer = new StabilizedPointer()
+  .addFilter(oneEuroFilter({ minCutoff: 1.0, beta: 0.007 }))
+  .addPostProcess(gaussianKernel({ size: 7 }), { padding: 'reflect' })
+
+// Process points in real-time
+pointer.process(point)
+
+// After stroke ends, apply post-processing
+const finalPoints = pointer.finish()
+```
+
+### Re-applying Post-processing
+
+Use `finishWithoutReset()` to preview or re-apply post-processing with different settings without losing the buffer.
+
+```ts
+import {
+  StabilizedPointer,
+  gaussianKernel,
+  bilateralKernel,
+} from '@stroke-stabilizer/core'
+
+const pointer = new StabilizedPointer()
+
+// Process points
+pointer.process(point1)
+pointer.process(point2)
+pointer.process(point3)
+
+// Preview with gaussian kernel
+pointer.addPostProcess(gaussianKernel({ size: 5 }))
+const preview1 = pointer.finishWithoutReset()
+draw(preview1)
+
+// Change to bilateral kernel and re-apply
+pointer.removePostProcess('gaussian')
+pointer.addPostProcess(bilateralKernel({ size: 7, sigmaValue: 10 }))
+const preview2 = pointer.finishWithoutReset()
+draw(preview2)
+
+// Finalize when satisfied (resets buffer)
+const final = pointer.finish()
+```
+
+**Difference between `finishWithoutReset()` and `finish()`:**
+
+| Method                 | Post-process | Reset buffer |
+| ---------------------- | ------------ | ------------ |
+| `finishWithoutReset()` | ✅           | ❌           |
+| `finish()`             | ✅           | ✅           |
+
+### Edge-preserving Smoothing
+
+```ts
+import { smooth, bilateralKernel } from '@stroke-stabilizer/core'
+
+// Smooth while preserving sharp corners
+const smoothed = smooth(points, {
+  kernel: bilateralKernel({ size: 7, sigmaValue: 10 }),
+  padding: 'reflect',
+})
+```
+
+### Endpoint Preservation
+
+By default, `smooth()` preserves exact start and end points so the stroke reaches the actual pointer position.
+
+```ts
+import { smooth, gaussianKernel } from '@stroke-stabilizer/core'
+
+// Default: endpoints preserved (recommended)
+const smoothed = smooth(points, {
+  kernel: gaussianKernel({ size: 5 }),
+})
+
+// Disable endpoint preservation
+const smoothedAll = smooth(points, {
+  kernel: gaussianKernel({ size: 5 }),
+  preserveEndpoints: false,
+})
+```
+
+### rAF Batch Processing
+
+For high-frequency input devices (pen tablets, etc.), batch processing reduces CPU load by coalescing pointer events into animation frames.
+
+```ts
+import { StabilizedPointer, oneEuroFilter } from '@stroke-stabilizer/core'
+
+const pointer = new StabilizedPointer()
+  .addFilter(oneEuroFilter({ minCutoff: 1.0, beta: 0.007 }))
+  .enableBatching({
+    onBatch: (points) => {
+      // Called once per frame with all processed points
+      drawPoints(points)
+    },
+    onPoint: (point) => {
+      // Called for each processed point (optional)
+      updatePreview(point)
+    },
+  })
+
+canvas.addEventListener('pointermove', (e) => {
+  // Points are queued and processed on next animation frame
+  pointer.queue({
+    x: e.clientX,
+    y: e.clientY,
+    pressure: e.pressure,
+    timestamp: e.timeStamp,
+  })
+})
+
+canvas.addEventListener('pointerup', () => {
+  // Flush any pending points and apply post-processing
+  const finalPoints = pointer.finish()
+})
+```
+
+**Batch processing methods:**
+
+```ts
+// Enable/disable batching (method chaining)
+pointer.enableBatching({ onBatch, onPoint })
+pointer.disableBatching()
+
+// Queue points for batch processing
+pointer.queue(point)
+pointer.queueAll(points)
+
+// Force immediate processing
+pointer.flushBatch()
+
+// Check state
+pointer.isBatchingEnabled // boolean
+pointer.pendingCount // number of queued points
+```
+
+### Presets
+
+```ts
+import { createFromPreset } from '@stroke-stabilizer/core'
+
+// Quick setup with predefined configurations
+const pointer = createFromPreset('smooth') // Heavy smoothing
+const pointer = createFromPreset('responsive') // Low latency
+const pointer = createFromPreset('balanced') // Default balance
+```
+
+## Filter Parameters
+
+### oneEuroFilter (Recommended)
+
+```ts
+oneEuroFilter({
+  minCutoff: 1.0, // Smoothing at low speed (lower = smoother)
+  beta: 0.007, // Speed adaptation (higher = more responsive)
+  dCutoff: 1.0, // Derivative cutoff (usually 1.0)
+})
+```
+
+### emaFilter
+
+```ts
+emaFilter({
+  alpha: 0.5, // 0-1, higher = more responsive
+})
+```
+
+### kalmanFilter
+
+```ts
+kalmanFilter({
+  processNoise: 0.1, // Expected movement variance
+  measurementNoise: 0.5, // Input noise level
+})
+```
+
+### linearPredictionFilter
+
+```ts
+linearPredictionFilter({
+  historySize: 4, // Points used for prediction
+  predictionFactor: 0.5, // Prediction strength (0-1)
+  smoothing: 0.6, // Output smoothing
+})
+```
+
+### stringFilter (Lazy Brush)
+
+```ts
+stringFilter({
+  stringLength: 10, // Distance before anchor moves
+})
+```
+
+### bilateralKernel
+
+```ts
+bilateralKernel({
+  size: 7, // Kernel size (odd number)
+  sigmaValue: 10, // Edge preservation (lower = sharper edges)
+  sigmaSpace: 2, // Spatial falloff (optional)
+})
+```
+
+## API Reference
+
+### StabilizedPointer
+
+```ts
+class StabilizedPointer {
+  // Filter management
+  addFilter(filter: Filter): this
+  removeFilter(type: string): boolean
+  updateFilter<T>(type: string, params: Partial<T>): boolean
+  getFilter(type: string): Filter | undefined
+
+  // Post-processing
+  addPostProcess(kernel: Kernel, options?: { padding?: PaddingMode }): this
+  removePostProcess(type: string): boolean
+
+  // Processing
+  process(point: PointerPoint): PointerPoint | null
+  finish(): Point[] // Apply post-process and reset
+  finishWithoutReset(): Point[] // Apply post-process without reset (for preview)
+  reset(): void // Reset filters and clear buffer
+
+  // Batch processing (rAF)
+  enableBatching(config?: BatchConfig): this
+  disableBatching(): this
+  queue(point: PointerPoint): this
+  queueAll(points: PointerPoint[]): this
+  flushBatch(): PointerPoint[]
+  isBatchingEnabled: boolean
+  pendingCount: number
+}
+```
+
+### Types
+
+```ts
+interface Point {
+  x: number
+  y: number
+}
+
+interface PointerPoint extends Point {
+  pressure?: number
+  timestamp: number
+}
+
+type PaddingMode = 'reflect' | 'edge' | 'zero'
+
+interface BatchConfig {
+  onBatch?: (points: PointerPoint[]) => void
+  onPoint?: (point: PointerPoint) => void
+}
+```
+
+## Architecture
+
+```
+Input → [Real-time Filters] → process() → Output
+                                ↓
+                            [Buffer]
+                                ↓
+                      [Post-processors] → finish() → Final Output
+```
+
+**Real-time filters** run on each input point with O(1) complexity.
+**Post-processors** run once at stroke end with bidirectional convolution.
+
+## Framework Adapters
+
+- `@stroke-stabilizer/react` - React hooks
+- `@stroke-stabilizer/vue` - Vue composables
+
+## License
+
+[MIT](../../LICENSE)

package/dist/StabilizedPointer.d.ts

@@ -0,0 +1,246 @@
+import type { Filter, Point, PointerPoint } from './types';
+import type { Kernel, PaddingMode } from './kernels/types';
+/**
+ * Batch processing configuration
+ */
+export interface BatchConfig {
+    /** Callback when a batch of points is processed */
+    onBatch?: (points: PointerPoint[]) => void;
+    /** Callback for each processed point */
+    onPoint?: (point: PointerPoint) => void;
+}
+/**
+ * Dynamic Pipeline Pattern implementation
+ *
+ * A pipeline that allows adding, removing, and updating filters at runtime.
+ * Always ready to execute without requiring a .build() call.
+ *
+ * @example
+ * ```ts
+ * const pointer = new StabilizedPointer()
+ *   // Real-time layer
+ *   .addFilter(noiseFilter({ minDistance: 2 }))
+ *   .addFilter(kalmanFilter({ processNoise: 0.1 }))
+ *   // Post-processing layer
+ *   .addPostProcess(gaussianKernel({ size: 7 }))
+ *
+ * // During drawing
+ * pointer.process(point)
+ *
+ * // On completion
+ * const finalStroke = pointer.finish()
+ * ```
+ */
+export declare class StabilizedPointer {
+    private filters;
+    private postProcessors;
+    private buffer;
+    private lastRawPoint;
+    private batchConfig;
+    private pendingPoints;
+    private rafId;
+    /**
+     * Add a filter to the pipeline
+     * @returns this (for method chaining)
+     */
+    addFilter(filter: Filter): this;
+    /**
+     * Remove a filter by type
+     * @returns true if removed, false if not found
+     */
+    removeFilter(type: string): boolean;
+    /**
+     * Update parameters of a filter by type
+     * @returns true if updated, false if not found
+     */
+    updateFilter<TParams>(type: string, params: Partial<TParams>): boolean;
+    /**
+     * Get a filter by type
+     */
+    getFilter(type: string): Filter | undefined;
+    /**
+     * Get list of current filter types
+     */
+    getFilterTypes(): string[];
+    /**
+     * Check if a filter exists
+     */
+    hasFilter(type: string): boolean;
+    /**
+     * Process a point through the pipeline
+     * @returns Processed result (null if rejected by a filter)
+     */
+    process(point: PointerPoint): PointerPoint | null;
+    /**
+     * Process multiple points at once
+     * @returns Array of processed results (nulls excluded)
+     */
+    processAll(points: PointerPoint[]): PointerPoint[];
+    /**
+     * Get the processed buffer
+     */
+    getBuffer(): readonly PointerPoint[];
+    /**
+     * Clear and return the processed buffer
+     */
+    flushBuffer(): PointerPoint[];
+    /**
+     * Reset all filters and clear the buffer
+     *
+     * Call this to prepare for a new stroke without destroying the pipeline configuration.
+     * Filters are reset to their initial state and the buffer is cleared.
+     *
+     * @example
+     * ```ts
+     * // After finishing a stroke
+     * const result = pointer.finish() // automatically calls reset()
+     *
+     * // Or manually reset without finishing
+     * pointer.reset()
+     * ```
+     */
+    reset(): void;
+    /**
+     * Clear the pipeline (remove all filters)
+     */
+    clear(): void;
+    /**
+     * Get number of filters
+     */
+    get length(): number;
+    /**
+     * Add post-processor to the pipeline
+     * @returns this (for method chaining)
+     */
+    addPostProcess(kernel: Kernel, options?: {
+        padding?: PaddingMode;
+    }): this;
+    /**
+     * Remove a post-processor by type
+     * @returns true if removed, false if not found
+     */
+    removePostProcess(type: string): boolean;
+    /**
+     * Check if a post-processor exists
+     */
+    hasPostProcess(type: string): boolean;
+    /**
+     * Get list of post-processor types
+     */
+    getPostProcessTypes(): string[];
+    /**
+     * Get number of post-processors
+     */
+    get postProcessLength(): number;
+    /**
+     * Finish the stroke and return post-processed results, without resetting
+     *
+     * Use this when you want to get the final result but keep the buffer intact.
+     * Useful for previewing post-processing results or comparing different settings.
+     *
+     * @example
+     * ```ts
+     * pointer.addPostProcess(gaussianKernel({ size: 5 }))
+     * const preview1 = pointer.finishWithoutReset()
+     *
+     * // Change settings and re-apply
+     * pointer.removePostProcess('gaussian')
+     * pointer.addPostProcess(bilateralKernel({ size: 7, sigmaValue: 10 }))
+     * const preview2 = pointer.finishWithoutReset()
+     *
+     * // Finalize when done
+     * const final = pointer.finish()
+     * ```
+     */
+    finishWithoutReset(): Point[];
+    /**
+     * Track if drain has been called to avoid duplicate draining
+     */
+    private hasDrained;
+    /**
+     * Append the final raw input point to ensure stroke ends at the actual endpoint
+     *
+     * Instead of draining filters (which adds many extra points),
+     * we simply append the raw endpoint. The post-processing phase
+     * with bidirectional convolution will naturally smooth the transition.
+     */
+    private appendEndpoint;
+    /**
+     * Finish the stroke and return post-processed results
+     *
+     * This applies all post-processors to the buffer, then resets filters and clears the buffer.
+     * Use this at the end of a stroke to get the final smoothed result.
+     *
+     * @example
+     * ```ts
+     * // During drawing
+     * pointer.process(point)
+     *
+     * // On stroke end
+     * const finalStroke = pointer.finish()
+     * ```
+     */
+    finish(): Point[];
+    /**
+     * Enable requestAnimationFrame batch processing
+     *
+     * When enabled, points queued via queue() are batched and processed
+     * on the next animation frame, reducing CPU load for high-frequency
+     * pointer events.
+     *
+     * @returns this (for method chaining)
+     *
+     * @example
+     * ```ts
+     * const pointer = new StabilizedPointer()
+     *   .addFilter(noiseFilter({ minDistance: 2 }))
+     *   .enableBatching({
+     *     onBatch: (points) => drawPoints(points),
+     *     onPoint: (point) => updatePreview(point)
+     *   })
+     *
+     * canvas.onpointermove = (e) => {
+     *   pointer.queue({ x: e.clientX, y: e.clientY, timestamp: e.timeStamp })
+     * }
+     * ```
+     */
+    enableBatching(config?: BatchConfig): this;
+    /**
+     * Disable batch processing
+     * Flushes any pending points before disabling
+     * @returns this (for method chaining)
+     */
+    disableBatching(): this;
+    /**
+     * Check if batch processing is enabled
+     */
+    get isBatchingEnabled(): boolean;
+    /**
+     * Queue a point for batch processing
+     *
+     * If batching is enabled, the point is queued and processed on the next
+     * animation frame. If batching is disabled, the point is processed immediately.
+     *
+     * @returns this (for method chaining, useful for queueing multiple points)
+     */
+    queue(point: PointerPoint): this;
+    /**
+     * Queue multiple points for batch processing
+     * @returns this (for method chaining)
+     */
+    queueAll(points: PointerPoint[]): this;
+    /**
+     * Force flush pending batched points immediately
+     * @returns Array of processed points
+     */
+    flushBatch(): PointerPoint[];
+    /**
+     * Get number of pending points in the batch queue
+     */
+    get pendingCount(): number;
+    private scheduleFlush;
+    private cancelScheduledFlush;
+    private processPendingPoints;
+    private isUpdatableFilter;
+}
+//# sourceMappingURL=StabilizedPointer.d.ts.map

package/dist/StabilizedPointer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StabilizedPointer.d.ts","sourceRoot":"","sources":["../src/StabilizedPointer.ts"],"names":[],"mappings":"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"}

package/dist/filters/EmaFilter.d.ts

@@ -0,0 +1,25 @@
+import type { Filter } from '../types';
+export interface EmaFilterParams {
+    /**
+     * Smoothing coefficient (0-1)
+     * - Lower value: stronger smoothing (emphasizes past values)
+     * - Higher value: more responsive (emphasizes new values)
+     */
+    alpha: number;
+}
+/**
+ * Create an Exponential Moving Average (EMA) filter
+ *
+ * @example
+ * ```ts
+ * // Strong smoothing
+ * const pointer = new StabilizedPointer()
+ *   .addFilter(emaFilter({ alpha: 0.2 }))
+ *
+ * // Light smoothing
+ * const pointer = new StabilizedPointer()
+ *   .addFilter(emaFilter({ alpha: 0.7 }))
+ * ```
+ */
+export declare function emaFilter(params: EmaFilterParams): Filter;
+//# sourceMappingURL=EmaFilter.d.ts.map

package/dist/filters/EmaFilter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EmaFilter.d.ts","sourceRoot":"","sources":["../../src/filters/EmaFilter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAiC,MAAM,UAAU,CAAA;AAErE,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,KAAK,EAAE,MAAM,CAAA;CACd;AA6DD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,eAAe,GAAG,MAAM,CAEzD"}

package/dist/filters/KalmanFilter.d.ts

@@ -0,0 +1,21 @@
+import type { Filter } from '../types';
+export interface KalmanFilterParams {
+    /** Process noise (Q): Lower values trust prediction more */
+    processNoise: number;
+    /** Measurement noise (R): Higher values result in stronger smoothing */
+    measurementNoise: number;
+}
+/**
+ * Create a Kalman filter
+ *
+ * @example
+ * ```ts
+ * const pointer = new StabilizedPointer()
+ *   .addFilter(kalmanFilter({
+ *     processNoise: 0.1,
+ *     measurementNoise: 0.5
+ *   }))
+ * ```
+ */
+export declare function kalmanFilter(params: KalmanFilterParams): Filter;
+//# sourceMappingURL=KalmanFilter.d.ts.map

package/dist/filters/KalmanFilter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"KalmanFilter.d.ts","sourceRoot":"","sources":["../../src/filters/KalmanFilter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAiC,MAAM,UAAU,CAAA;AAErE,MAAM,WAAW,kBAAkB;IACjC,4DAA4D;IAC5D,YAAY,EAAE,MAAM,CAAA;IACpB,wEAAwE;IACxE,gBAAgB,EAAE,MAAM,CAAA;CACzB;AA4ED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,kBAAkB,GAAG,MAAM,CAE/D"}