@stroke-stabilizer/core 0.1.3

package/dist/index.js

@@ -0,0 +1,1086 @@
+function isAdaptiveKernel(kernel) {
+  return "computeWeights" in kernel && typeof kernel.computeWeights === "function";
+}
+function applyPadding(points, halfSize, mode) {
+  if (points.length === 0) return [];
+  const padded = [];
+  for (let i = halfSize; i > 0; i--) {
+    switch (mode) {
+      case "reflect":
+        padded.push(points[Math.min(i, points.length - 1)]);
+        break;
+      case "edge":
+        padded.push(points[0]);
+        break;
+      case "zero":
+        padded.push({ x: 0, y: 0 });
+        break;
+    }
+  }
+  padded.push(...points);
+  for (let i = 1; i <= halfSize; i++) {
+    switch (mode) {
+      case "reflect":
+        padded.push(points[Math.max(0, points.length - 1 - i)]);
+        break;
+      case "edge":
+        padded.push(points[points.length - 1]);
+        break;
+      case "zero":
+        padded.push({ x: 0, y: 0 });
+        break;
+    }
+  }
+  return padded;
+}
+function smooth(points, options) {
+  const { kernel, padding = "reflect", preserveEndpoints = true } = options;
+  if (points.length === 0) return [];
+  const originalStart = points[0];
+  const originalEnd = points[points.length - 1];
+  let result;
+  if (isAdaptiveKernel(kernel)) {
+    const halfSize = Math.floor(kernel.size / 2);
+    const padded = applyPadding(points, halfSize, padding);
+    result = [];
+    for (let i = 0; i < points.length; i++) {
+      const centerIdx = i + halfSize;
+      const center = padded[centerIdx];
+      const neighbors = [];
+      for (let k = 0; k < kernel.size; k++) {
+        neighbors.push(padded[i + k]);
+      }
+      const weights = kernel.computeWeights(center, neighbors);
+      let sumX = 0;
+      let sumY = 0;
+      for (let k = 0; k < weights.length; k++) {
+        sumX += neighbors[k].x * weights[k];
+        sumY += neighbors[k].y * weights[k];
+      }
+      result.push({ x: sumX, y: sumY });
+    }
+  } else {
+    const fixedKernel = kernel;
+    const { weights } = fixedKernel;
+    if (weights.length <= 1) return [...points];
+    const halfSize = Math.floor(weights.length / 2);
+    const padded = applyPadding(points, halfSize, padding);
+    result = [];
+    for (let i = 0; i < points.length; i++) {
+      let sumX = 0;
+      let sumY = 0;
+      for (let k = 0; k < weights.length; k++) {
+        const point = padded[i + k];
+        sumX += point.x * weights[k];
+        sumY += point.y * weights[k];
+      }
+      result.push({ x: sumX, y: sumY });
+    }
+  }
+  if (preserveEndpoints && result.length > 0) {
+    result[0] = { ...originalStart };
+    if (result.length > 1) {
+      result[result.length - 1] = { ...originalEnd };
+    }
+  }
+  return result;
+}
+class StabilizedPointer {
+  constructor() {
+    this.filters = [];
+    this.postProcessors = [];
+    this.buffer = [];
+    this.lastRawPoint = null;
+    this.batchConfig = null;
+    this.pendingPoints = [];
+    this.rafId = null;
+    this.hasDrained = false;
+  }
+  /**
+   * Add a filter to the pipeline
+   * @returns this (for method chaining)
+   */
+  addFilter(filter) {
+    this.filters.push(filter);
+    return this;
+  }
+  /**
+   * Remove a filter by type
+   * @returns true if removed, false if not found
+   */
+  removeFilter(type) {
+    const index = this.filters.findIndex((f) => f.type === type);
+    if (index === -1) return false;
+    this.filters.splice(index, 1);
+    return true;
+  }
+  /**
+   * Update parameters of a filter by type
+   * @returns true if updated, false if not found
+   */
+  updateFilter(type, params) {
+    const filter = this.filters.find((f) => f.type === type);
+    if (!filter) return false;
+    if (this.isUpdatableFilter(filter)) {
+      filter.updateParams(params);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Get a filter by type
+   */
+  getFilter(type) {
+    return this.filters.find((f) => f.type === type);
+  }
+  /**
+   * Get list of current filter types
+   */
+  getFilterTypes() {
+    return this.filters.map((f) => f.type);
+  }
+  /**
+   * Check if a filter exists
+   */
+  hasFilter(type) {
+    return this.filters.some((f) => f.type === type);
+  }
+  /**
+   * Process a point through the pipeline
+   * @returns Processed result (null if rejected by a filter)
+   */
+  process(point) {
+    this.lastRawPoint = point;
+    let current = point;
+    for (const filter of this.filters) {
+      if (current === null) break;
+      current = filter.process(current);
+    }
+    if (current !== null) {
+      this.buffer.push(current);
+    }
+    return current;
+  }
+  /**
+   * Process multiple points at once
+   * @returns Array of processed results (nulls excluded)
+   */
+  processAll(points) {
+    const results = [];
+    for (const point of points) {
+      const result = this.process(point);
+      if (result !== null) {
+        results.push(result);
+      }
+    }
+    return results;
+  }
+  /**
+   * Get the processed buffer
+   */
+  getBuffer() {
+    return this.buffer;
+  }
+  /**
+   * Clear and return the processed buffer
+   */
+  flushBuffer() {
+    const flushed = [...this.buffer];
+    this.buffer = [];
+    return flushed;
+  }
+  /**
+   * 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() {
+    for (const filter of this.filters) {
+      filter.reset();
+    }
+    this.buffer = [];
+    this.lastRawPoint = null;
+    this.hasDrained = false;
+  }
+  /**
+   * Clear the pipeline (remove all filters)
+   */
+  clear() {
+    this.filters = [];
+    this.postProcessors = [];
+    this.buffer = [];
+  }
+  /**
+   * Get number of filters
+   */
+  get length() {
+    return this.filters.length;
+  }
+  // ========================================
+  // Post-processing layer
+  // ========================================
+  /**
+   * Add post-processor to the pipeline
+   * @returns this (for method chaining)
+   */
+  addPostProcess(kernel, options = {}) {
+    this.postProcessors.push({
+      kernel,
+      padding: options.padding ?? "reflect"
+    });
+    return this;
+  }
+  /**
+   * Remove a post-processor by type
+   * @returns true if removed, false if not found
+   */
+  removePostProcess(type) {
+    const index = this.postProcessors.findIndex((p) => p.kernel.type === type);
+    if (index === -1) return false;
+    this.postProcessors.splice(index, 1);
+    return true;
+  }
+  /**
+   * Check if a post-processor exists
+   */
+  hasPostProcess(type) {
+    return this.postProcessors.some((p) => p.kernel.type === type);
+  }
+  /**
+   * Get list of post-processor types
+   */
+  getPostProcessTypes() {
+    return this.postProcessors.map((p) => p.kernel.type);
+  }
+  /**
+   * Get number of post-processors
+   */
+  get postProcessLength() {
+    return this.postProcessors.length;
+  }
+  /**
+   * 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() {
+    if (this.batchConfig) {
+      this.flushBatch();
+    }
+    this.appendEndpoint();
+    let points = [...this.buffer];
+    for (const processor of this.postProcessors) {
+      points = smooth(points, {
+        kernel: processor.kernel,
+        padding: processor.padding
+      });
+    }
+    return points;
+  }
+  /**
+   * 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.
+   */
+  appendEndpoint() {
+    if (this.hasDrained) {
+      return;
+    }
+    if (this.lastRawPoint === null || this.buffer.length === 0) {
+      return;
+    }
+    this.hasDrained = true;
+    const target = this.lastRawPoint;
+    const lastBufferPoint = this.buffer[this.buffer.length - 1];
+    const dx = target.x - lastBufferPoint.x;
+    const dy = target.y - lastBufferPoint.y;
+    const distance = Math.sqrt(dx * dx + dy * dy);
+    if (distance < 1) {
+      return;
+    }
+    this.buffer.push({
+      x: target.x,
+      y: target.y,
+      pressure: target.pressure ?? 1,
+      timestamp: target.timestamp + 8
+    });
+  }
+  /**
+   * 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() {
+    const points = this.finishWithoutReset();
+    this.reset();
+    return points;
+  }
+  // ========================================
+  // Batch processing layer (rAF)
+  // ========================================
+  /**
+   * 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 = {}) {
+    this.batchConfig = config;
+    return this;
+  }
+  /**
+   * Disable batch processing
+   * Flushes any pending points before disabling
+   * @returns this (for method chaining)
+   */
+  disableBatching() {
+    this.flushBatch();
+    this.batchConfig = null;
+    return this;
+  }
+  /**
+   * Check if batch processing is enabled
+   */
+  get isBatchingEnabled() {
+    return this.batchConfig !== null;
+  }
+  /**
+   * 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) {
+    if (this.batchConfig) {
+      this.pendingPoints.push(point);
+      this.scheduleFlush();
+    } else {
+      this.process(point);
+    }
+    return this;
+  }
+  /**
+   * Queue multiple points for batch processing
+   * @returns this (for method chaining)
+   */
+  queueAll(points) {
+    if (this.batchConfig) {
+      this.pendingPoints.push(...points);
+      this.scheduleFlush();
+    } else {
+      this.processAll(points);
+    }
+    return this;
+  }
+  /**
+   * Force flush pending batched points immediately
+   * @returns Array of processed points
+   */
+  flushBatch() {
+    this.cancelScheduledFlush();
+    return this.processPendingPoints();
+  }
+  /**
+   * Get number of pending points in the batch queue
+   */
+  get pendingCount() {
+    return this.pendingPoints.length;
+  }
+  // ----------------------------------------
+  // Private batch processing methods
+  // ----------------------------------------
+  scheduleFlush() {
+    if (this.rafId !== null) return;
+    if (typeof requestAnimationFrame !== "undefined") {
+      this.rafId = requestAnimationFrame(() => {
+        this.rafId = null;
+        this.processPendingPoints();
+      });
+    } else {
+      this.rafId = setTimeout(() => {
+        this.rafId = null;
+        this.processPendingPoints();
+      }, 16);
+    }
+  }
+  cancelScheduledFlush() {
+    if (this.rafId === null) return;
+    if (typeof cancelAnimationFrame !== "undefined") {
+      cancelAnimationFrame(this.rafId);
+    } else {
+      clearTimeout(this.rafId);
+    }
+    this.rafId = null;
+  }
+  processPendingPoints() {
+    var _a, _b, _c, _d;
+    if (this.pendingPoints.length === 0) return [];
+    const points = this.pendingPoints;
+    this.pendingPoints = [];
+    const results = [];
+    for (const point of points) {
+      const result = this.process(point);
+      if (result !== null) {
+        results.push(result);
+        (_b = (_a = this.batchConfig) == null ? void 0 : _a.onPoint) == null ? void 0 : _b.call(_a, result);
+      }
+    }
+    if (results.length > 0) {
+      (_d = (_c = this.batchConfig) == null ? void 0 : _c.onBatch) == null ? void 0 : _d.call(_c, results);
+    }
+    return results;
+  }
+  isUpdatableFilter(filter) {
+    return "updateParams" in filter && typeof filter.updateParams === "function";
+  }
+}
+const FILTER_TYPE$6 = "noise";
+class NoiseFilterImpl {
+  constructor(params) {
+    this.type = FILTER_TYPE$6;
+    this.lastPoint = null;
+    this.params = { ...params };
+  }
+  process(point) {
+    if (this.lastPoint === null) {
+      this.lastPoint = point;
+      return point;
+    }
+    const dx = point.x - this.lastPoint.x;
+    const dy = point.y - this.lastPoint.y;
+    const distance = Math.sqrt(dx * dx + dy * dy);
+    if (distance < this.params.minDistance) {
+      return null;
+    }
+    this.lastPoint = point;
+    return point;
+  }
+  updateParams(params) {
+    this.params = { ...this.params, ...params };
+  }
+  reset() {
+    this.lastPoint = null;
+  }
+}
+function noiseFilter(params) {
+  return new NoiseFilterImpl(params);
+}
+const FILTER_TYPE$5 = "kalman";
+class KalmanFilterImpl {
+  constructor(params) {
+    this.type = FILTER_TYPE$5;
+    this.state = null;
+    this.params = { ...params };
+  }
+  process(point) {
+    if (this.state === null) {
+      this.state = {
+        x: point.x,
+        y: point.y,
+        p: 1,
+        lastTimestamp: point.timestamp
+      };
+      return point;
+    }
+    const { processNoise: Q, measurementNoise: R } = this.params;
+    const predictedX = this.state.x;
+    const predictedY = this.state.y;
+    const predictedP = this.state.p + Q;
+    const K = predictedP / (predictedP + R);
+    const newX = predictedX + K * (point.x - predictedX);
+    const newY = predictedY + K * (point.y - predictedY);
+    const newP = (1 - K) * predictedP;
+    this.state = {
+      x: newX,
+      y: newY,
+      p: newP,
+      lastTimestamp: point.timestamp
+    };
+    return {
+      x: newX,
+      y: newY,
+      pressure: point.pressure,
+      timestamp: point.timestamp
+    };
+  }
+  updateParams(params) {
+    this.params = { ...this.params, ...params };
+  }
+  reset() {
+    this.state = null;
+  }
+}
+function kalmanFilter(params) {
+  return new KalmanFilterImpl(params);
+}
+const FILTER_TYPE$4 = "movingAverage";
+class MovingAverageFilterImpl {
+  constructor(params) {
+    this.type = FILTER_TYPE$4;
+    this.window = [];
+    this.params = { ...params };
+  }
+  process(point) {
+    this.window.push(point);
+    while (this.window.length > this.params.windowSize) {
+      this.window.shift();
+    }
+    let sumX = 0;
+    let sumY = 0;
+    let sumPressure = 0;
+    let pressureCount = 0;
+    for (const p of this.window) {
+      sumX += p.x;
+      sumY += p.y;
+      if (p.pressure !== void 0) {
+        sumPressure += p.pressure;
+        pressureCount++;
+      }
+    }
+    const avgX = sumX / this.window.length;
+    const avgY = sumY / this.window.length;
+    const avgPressure = pressureCount > 0 ? sumPressure / pressureCount : void 0;
+    return {
+      x: avgX,
+      y: avgY,
+      pressure: avgPressure,
+      timestamp: point.timestamp
+    };
+  }
+  updateParams(params) {
+    this.params = { ...this.params, ...params };
+    while (this.window.length > this.params.windowSize) {
+      this.window.shift();
+    }
+  }
+  reset() {
+    this.window = [];
+  }
+}
+function movingAverageFilter(params) {
+  return new MovingAverageFilterImpl(params);
+}
+const FILTER_TYPE$3 = "string";
+class StringFilterImpl {
+  constructor(params) {
+    this.type = FILTER_TYPE$3;
+    this.anchorPoint = null;
+    this.params = { ...params };
+  }
+  process(point) {
+    if (this.anchorPoint === null) {
+      this.anchorPoint = point;
+      return point;
+    }
+    const dx = point.x - this.anchorPoint.x;
+    const dy = point.y - this.anchorPoint.y;
+    const distance = Math.sqrt(dx * dx + dy * dy);
+    if (distance <= this.params.stringLength) {
+      return {
+        ...this.anchorPoint,
+        pressure: point.pressure,
+        timestamp: point.timestamp
+      };
+    }
+    const ratio = (distance - this.params.stringLength) / distance;
+    const newX = this.anchorPoint.x + dx * ratio;
+    const newY = this.anchorPoint.y + dy * ratio;
+    this.anchorPoint = {
+      x: newX,
+      y: newY,
+      pressure: point.pressure,
+      timestamp: point.timestamp
+    };
+    return this.anchorPoint;
+  }
+  updateParams(params) {
+    this.params = { ...this.params, ...params };
+  }
+  reset() {
+    this.anchorPoint = null;
+  }
+}
+function stringFilter(params) {
+  return new StringFilterImpl(params);
+}
+const FILTER_TYPE$2 = "ema";
+class EmaFilterImpl {
+  constructor(params) {
+    this.type = FILTER_TYPE$2;
+    this.lastPoint = null;
+    this.params = { ...params };
+  }
+  process(point) {
+    if (this.lastPoint === null) {
+      this.lastPoint = point;
+      return point;
+    }
+    const { alpha } = this.params;
+    const newX = alpha * point.x + (1 - alpha) * this.lastPoint.x;
+    const newY = alpha * point.y + (1 - alpha) * this.lastPoint.y;
+    let newPressure;
+    if (point.pressure !== void 0 && this.lastPoint.pressure !== void 0) {
+      newPressure = alpha * point.pressure + (1 - alpha) * this.lastPoint.pressure;
+    } else {
+      newPressure = point.pressure;
+    }
+    this.lastPoint = {
+      x: newX,
+      y: newY,
+      pressure: newPressure,
+      timestamp: point.timestamp
+    };
+    return this.lastPoint;
+  }
+  updateParams(params) {
+    this.params = { ...this.params, ...params };
+  }
+  reset() {
+    this.lastPoint = null;
+  }
+}
+function emaFilter(params) {
+  return new EmaFilterImpl(params);
+}
+const FILTER_TYPE$1 = "oneEuro";
+class LowPassFilter {
+  constructor() {
+    this.y = null;
+    this.alpha = 1;
+  }
+  setAlpha(alpha) {
+    this.alpha = Math.max(0, Math.min(1, alpha));
+  }
+  filter(value) {
+    if (this.y === null) {
+      this.y = value;
+    } else {
+      this.y = this.alpha * value + (1 - this.alpha) * this.y;
+    }
+    return this.y;
+  }
+  reset() {
+    this.y = null;
+  }
+  lastValue() {
+    return this.y;
+  }
+}
+class OneEuroFilterImpl {
+  constructor(params) {
+    this.type = FILTER_TYPE$1;
+    this.xFilter = new LowPassFilter();
+    this.yFilter = new LowPassFilter();
+    this.dxFilter = new LowPassFilter();
+    this.dyFilter = new LowPassFilter();
+    this.pressureFilter = new LowPassFilter();
+    this.lastTimestamp = null;
+    this.params = {
+      dCutoff: 1,
+      ...params
+    };
+  }
+  process(point) {
+    let rate = 60;
+    if (this.lastTimestamp !== null) {
+      const dt = (point.timestamp - this.lastTimestamp) / 1e3;
+      if (dt > 0) {
+        rate = 1 / dt;
+      }
+    }
+    this.lastTimestamp = point.timestamp;
+    const { minCutoff, beta, dCutoff } = this.params;
+    const newX = this.filterAxis(
+      point.x,
+      this.xFilter,
+      this.dxFilter,
+      rate,
+      minCutoff,
+      beta,
+      dCutoff
+    );
+    const newY = this.filterAxis(
+      point.y,
+      this.yFilter,
+      this.dyFilter,
+      rate,
+      minCutoff,
+      beta,
+      dCutoff
+    );
+    let newPressure;
+    if (point.pressure !== void 0) {
+      const alpha = this.computeAlpha(minCutoff, rate);
+      this.pressureFilter.setAlpha(alpha);
+      newPressure = this.pressureFilter.filter(point.pressure);
+    }
+    return {
+      x: newX,
+      y: newY,
+      pressure: newPressure,
+      timestamp: point.timestamp
+    };
+  }
+  filterAxis(value, valueFilter, derivFilter, rate, minCutoff, beta, dCutoff) {
+    const prevValue = valueFilter.lastValue();
+    let dValue = 0;
+    if (prevValue !== null) {
+      dValue = (value - prevValue) * rate;
+    }
+    const dAlpha = this.computeAlpha(dCutoff, rate);
+    derivFilter.setAlpha(dAlpha);
+    const filteredDValue = derivFilter.filter(dValue);
+    const cutoff = minCutoff + beta * Math.abs(filteredDValue);
+    const alpha = this.computeAlpha(cutoff, rate);
+    valueFilter.setAlpha(alpha);
+    return valueFilter.filter(value);
+  }
+  computeAlpha(cutoff, rate) {
+    const tau = 1 / (2 * Math.PI * cutoff);
+    const te = 1 / rate;
+    return 1 / (1 + tau / te);
+  }
+  updateParams(params) {
+    this.params = { ...this.params, ...params };
+  }
+  reset() {
+    this.xFilter.reset();
+    this.yFilter.reset();
+    this.dxFilter.reset();
+    this.dyFilter.reset();
+    this.pressureFilter.reset();
+    this.lastTimestamp = null;
+  }
+}
+function oneEuroFilter(params) {
+  return new OneEuroFilterImpl(params);
+}
+const FILTER_TYPE = "linearPrediction";
+class LinearPredictionFilterImpl {
+  constructor(params) {
+    this.type = FILTER_TYPE;
+    this.history = [];
+    this.lastOutput = null;
+    this.params = {
+      smoothing: 0.6,
+      ...params
+    };
+  }
+  process(point) {
+    this.history.push(point);
+    while (this.history.length > this.params.historySize + 1) {
+      this.history.shift();
+    }
+    if (this.history.length === 1) {
+      this.lastOutput = point;
+      return point;
+    }
+    const { velocity, acceleration } = this.estimateMotion();
+    const dt = this.history.length >= 2 ? (this.history[this.history.length - 1].timestamp - this.history[this.history.length - 2].timestamp) / 1e3 : 1 / 60;
+    const { predictionFactor } = this.params;
+    const predictedX = point.x + velocity.x * dt * predictionFactor + 0.5 * acceleration.x * dt * dt * predictionFactor;
+    const predictedY = point.y + velocity.y * dt * predictionFactor + 0.5 * acceleration.y * dt * dt * predictionFactor;
+    let outputX = predictedX;
+    let outputY = predictedY;
+    let outputPressure = point.pressure;
+    if (this.lastOutput !== null && this.params.smoothing !== void 0) {
+      const s = this.params.smoothing;
+      outputX = s * predictedX + (1 - s) * this.lastOutput.x;
+      outputY = s * predictedY + (1 - s) * this.lastOutput.y;
+      if (point.pressure !== void 0 && this.lastOutput.pressure !== void 0) {
+        outputPressure = s * point.pressure + (1 - s) * this.lastOutput.pressure;
+      }
+    }
+    this.lastOutput = {
+      x: outputX,
+      y: outputY,
+      pressure: outputPressure,
+      timestamp: point.timestamp
+    };
+    return this.lastOutput;
+  }
+  /**
+   * Estimate velocity and acceleration using least squares
+   */
+  estimateMotion() {
+    const n = this.history.length;
+    if (n < 2) {
+      return {
+        velocity: { x: 0, y: 0 },
+        acceleration: { x: 0, y: 0 }
+      };
+    }
+    const t0 = this.history[0].timestamp;
+    const times = this.history.map((p) => (p.timestamp - t0) / 1e3);
+    const xs = this.history.map((p) => p.x);
+    const ys = this.history.map((p) => p.y);
+    if (n === 2) {
+      const dt = times[1] - times[0];
+      if (dt <= 0) {
+        return { velocity: { x: 0, y: 0 }, acceleration: { x: 0, y: 0 } };
+      }
+      return {
+        velocity: {
+          x: (xs[1] - xs[0]) / dt,
+          y: (ys[1] - ys[0]) / dt
+        },
+        acceleration: { x: 0, y: 0 }
+      };
+    }
+    const fitX = this.polynomialFit(times, xs);
+    const fitY = this.polynomialFit(times, ys);
+    const lastT = times[times.length - 1];
+    return {
+      velocity: {
+        x: fitX.b + 2 * fitX.c * lastT,
+        y: fitY.b + 2 * fitY.c * lastT
+      },
+      acceleration: {
+        x: 2 * fitX.c,
+        y: 2 * fitY.c
+      }
+    };
+  }
+  /**
+   * Quadratic polynomial least squares fitting
+   * y = a + b*x + c*x^2
+   */
+  polynomialFit(x, y) {
+    const n = x.length;
+    let sumX = 0, sumX2 = 0, sumX3 = 0, sumX4 = 0;
+    let sumY = 0, sumXY = 0, sumX2Y = 0;
+    for (let i = 0; i < n; i++) {
+      const xi = x[i];
+      const yi = y[i];
+      const xi2 = xi * xi;
+      sumX += xi;
+      sumX2 += xi2;
+      sumX3 += xi2 * xi;
+      sumX4 += xi2 * xi2;
+      sumY += yi;
+      sumXY += xi * yi;
+      sumX2Y += xi2 * yi;
+    }
+    const det = n * (sumX2 * sumX4 - sumX3 * sumX3) - sumX * (sumX * sumX4 - sumX3 * sumX2) + sumX2 * (sumX * sumX3 - sumX2 * sumX2);
+    if (Math.abs(det) < 1e-10) {
+      const avgX = sumX / n;
+      const avgY = sumY / n;
+      let num = 0, den = 0;
+      for (let i = 0; i < n; i++) {
+        num += (x[i] - avgX) * (y[i] - avgY);
+        den += (x[i] - avgX) * (x[i] - avgX);
+      }
+      const b2 = den > 0 ? num / den : 0;
+      const a2 = avgY - b2 * avgX;
+      return { a: a2, b: b2, c: 0 };
+    }
+    const a = (sumY * (sumX2 * sumX4 - sumX3 * sumX3) - sumX * (sumXY * sumX4 - sumX3 * sumX2Y) + sumX2 * (sumXY * sumX3 - sumX2 * sumX2Y)) / det;
+    const b = (n * (sumXY * sumX4 - sumX3 * sumX2Y) - sumY * (sumX * sumX4 - sumX3 * sumX2) + sumX2 * (sumX * sumX2Y - sumXY * sumX2)) / det;
+    const c = (n * (sumX2 * sumX2Y - sumXY * sumX3) - sumX * (sumX * sumX2Y - sumXY * sumX2) + sumY * (sumX * sumX3 - sumX2 * sumX2)) / det;
+    return { a, b, c };
+  }
+  updateParams(params) {
+    this.params = { ...this.params, ...params };
+  }
+  reset() {
+    this.history = [];
+    this.lastOutput = null;
+  }
+}
+function linearPredictionFilter(params) {
+  return new LinearPredictionFilterImpl(params);
+}
+function createStabilizedPointer(level) {
+  const clampedLevel = Math.max(0, Math.min(100, level));
+  const pointer = new StabilizedPointer();
+  if (clampedLevel === 0) {
+    return pointer;
+  }
+  const minDistance = 1 + clampedLevel / 100 * 2;
+  pointer.addFilter(noiseFilter({ minDistance }));
+  if (clampedLevel >= 21) {
+    const processNoise = 0.12 - clampedLevel / 100 * 0.08;
+    const measurementNoise = 0.4 + clampedLevel / 100 * 0.6;
+    pointer.addFilter(kalmanFilter({ processNoise, measurementNoise }));
+  }
+  if (clampedLevel >= 41) {
+    const windowSize = clampedLevel >= 61 ? 7 : 5;
+    pointer.addFilter(movingAverageFilter({ windowSize }));
+  }
+  if (clampedLevel >= 61) {
+    const stringLength = clampedLevel >= 81 ? 15 : 8;
+    pointer.addFilter(stringFilter({ stringLength }));
+  }
+  return pointer;
+}
+const presetLevels = {
+  none: 0,
+  light: 20,
+  medium: 50,
+  heavy: 75,
+  extreme: 100
+};
+function createFromPreset(preset) {
+  return createStabilizedPointer(presetLevels[preset]);
+}
+function gaussianKernel(params) {
+  const { size } = params;
+  const sigma = params.sigma ?? size / 3;
+  const actualSize = size % 2 === 0 ? size + 1 : size;
+  const halfSize = Math.floor(actualSize / 2);
+  const weights = [];
+  let sum = 0;
+  for (let i = 0; i < actualSize; i++) {
+    const x = i - halfSize;
+    const weight = Math.exp(-(x * x) / (2 * sigma * sigma));
+    weights.push(weight);
+    sum += weight;
+  }
+  for (let i = 0; i < weights.length; i++) {
+    weights[i] /= sum;
+  }
+  return {
+    type: "gaussian",
+    weights
+  };
+}
+function boxKernel(params) {
+  const { size } = params;
+  const actualSize = size % 2 === 0 ? size + 1 : size;
+  const weight = 1 / actualSize;
+  const weights = Array(actualSize).fill(weight);
+  return {
+    type: "box",
+    weights
+  };
+}
+function triangleKernel(params) {
+  const { size } = params;
+  const actualSize = size % 2 === 0 ? size + 1 : size;
+  const halfSize = Math.floor(actualSize / 2);
+  const weights = [];
+  let sum = 0;
+  for (let i = 0; i < actualSize; i++) {
+    const weight = halfSize + 1 - Math.abs(i - halfSize);
+    weights.push(weight);
+    sum += weight;
+  }
+  for (let i = 0; i < weights.length; i++) {
+    weights[i] /= sum;
+  }
+  return {
+    type: "triangle",
+    weights
+  };
+}
+function bilateralKernel(params) {
+  const { size, sigmaValue } = params;
+  const actualSize = size % 2 === 0 ? size + 1 : size;
+  const sigmaSpace = params.sigmaSpace ?? actualSize / 3;
+  const halfSize = Math.floor(actualSize / 2);
+  const spatialWeights = [];
+  for (let i = 0; i < actualSize; i++) {
+    const d = i - halfSize;
+    spatialWeights.push(Math.exp(-(d * d) / (2 * sigmaSpace * sigmaSpace)));
+  }
+  return {
+    type: "bilateral",
+    size: actualSize,
+    sigmaSpace,
+    sigmaValue,
+    computeWeights(center, neighbors) {
+      const weights = [];
+      let sum = 0;
+      for (let i = 0; i < neighbors.length; i++) {
+        const dx = neighbors[i].x - center.x;
+        const dy = neighbors[i].y - center.y;
+        const valueDiff = dx * dx + dy * dy;
+        const valueWeight = Math.exp(-valueDiff / (2 * sigmaValue * sigmaValue));
+        const weight = spatialWeights[i] * valueWeight;
+        weights.push(weight);
+        sum += weight;
+      }
+      if (sum > 0) {
+        for (let i = 0; i < weights.length; i++) {
+          weights[i] /= sum;
+        }
+      }
+      return weights;
+    }
+  };
+}
+export {
+  StabilizedPointer,
+  bilateralKernel,
+  boxKernel,
+  createFromPreset,
+  createStabilizedPointer,
+  emaFilter,
+  gaussianKernel,
+  isAdaptiveKernel,
+  kalmanFilter,
+  linearPredictionFilter,
+  movingAverageFilter,
+  noiseFilter,
+  oneEuroFilter,
+  smooth,
+  stringFilter,
+  triangleKernel
+};
+//# sourceMappingURL=index.js.map