hand-guest-control 0.1.0 → 0.3.0

package/dist/index.js

@@ -0,0 +1,819 @@
+// src/constants.ts
+var HAND_STATES = {
+  NOT_DETECTED: "not_detected",
+  WAITING: "waiting",
+  STARTING: "starting",
+  OPEN: "open",
+  CLOSED: "closed",
+  POINTING: "pointing",
+  FLIPPING: "flipping",
+  THUMB_UP: "thumb_up",
+  SWIPE_NEXT: "swipe_next",
+  SWIPE_PREVIOUS: "swipe_previous",
+  PALM_LEFT: "palm_left",
+  PALM_RIGHT: "palm_right",
+  PALM_UP: "palm_up",
+  PALM_DOWN: "palm_down"
+};
+var GESTURE_ACTIONS = {
+  NONE: "none",
+  SWIPE_LEFT: "swipe_left",
+  SWIPE_RIGHT: "swipe_right",
+  ZOOM_IN: "zoom_in",
+  ZOOM_OUT: "zoom_out",
+  ROTATE_LEFT: "rotate_left",
+  ROTATE_RIGHT: "rotate_right",
+  ROTATE_UP: "rotate_up",
+  ROTATE_DOWN: "rotate_down",
+  OK: "ok",
+  CUSTOM: "custom"
+};
+var LANDMARKS = {
+  WRIST: 0,
+  THUMB_TIP: 4,
+  INDEX_TIP: 8,
+  MIDDLE_TIP: 12,
+  RING_TIP: 16,
+  PINKY_TIP: 20
+};
+var HAND_CONNECTIONS = [
+  [0, 1],
+  [1, 2],
+  [2, 3],
+  [3, 4],
+  [0, 5],
+  [5, 6],
+  [6, 7],
+  [7, 8],
+  [0, 9],
+  [9, 10],
+  [10, 11],
+  [11, 12],
+  [0, 13],
+  [13, 14],
+  [14, 15],
+  [15, 16],
+  [0, 17],
+  [17, 18],
+  [18, 19],
+  [19, 20],
+  [5, 9],
+  [9, 13],
+  [13, 17]
+];
+var DEFAULT_ACTION_MAP = {
+  [HAND_STATES.SWIPE_PREVIOUS]: GESTURE_ACTIONS.SWIPE_LEFT,
+  [HAND_STATES.SWIPE_NEXT]: GESTURE_ACTIONS.SWIPE_RIGHT,
+  [HAND_STATES.OPEN]: GESTURE_ACTIONS.ZOOM_OUT,
+  [HAND_STATES.CLOSED]: GESTURE_ACTIONS.ZOOM_IN,
+  [HAND_STATES.THUMB_UP]: GESTURE_ACTIONS.OK,
+  [HAND_STATES.PALM_LEFT]: GESTURE_ACTIONS.ROTATE_LEFT,
+  [HAND_STATES.PALM_RIGHT]: GESTURE_ACTIONS.ROTATE_RIGHT,
+  [HAND_STATES.PALM_UP]: GESTURE_ACTIONS.ROTATE_UP,
+  [HAND_STATES.PALM_DOWN]: GESTURE_ACTIONS.ROTATE_DOWN,
+  [HAND_STATES.FLIPPING]: GESTURE_ACTIONS.CUSTOM
+};
+var DEFAULT_CONFIG = {
+  maxHistorySize: 10,
+  maxCentroidHistorySize: 10,
+  rotationSensitivity: 4,
+  detectionTolerance: 2e3,
+  startingDelay: 1e3,
+  waitingTimeout: 3e3,
+  minOpenConfidence: 5,
+  minPointingConfidence: 25,
+  minFlippingConfidence: 25,
+  minClosedConfidence: 5,
+  minThumbUpConfidence: 15,
+  minPointingCount: 5,
+  pointingThreshold: 0.3,
+  swipeSource: "index",
+  swipeMinRange: 0.03,
+  swipeCooldownMs: 2e3,
+  swipeMinHistory: 6,
+  palmDirectionThreshold: 0.025,
+  palmDirectionMinFrames: 6,
+  rotationActionThreshold: 0.5,
+  enableContinuousRotation: true,
+  mapActions: true,
+  actionMap: null,
+  openHandThresholds: {
+    fingerSpread: 0.2,
+    indexToMiddle: 0.15,
+    minExtendedFingers: 4,
+    maxExtendedFingers: 6,
+    middleAngle: 50
+  },
+  thumbUpThresholds: {
+    minThumbExtension: 0.9,
+    maxOtherFingersRatio: 0.8
+  },
+  debug: false
+};
+
+// src/HandGestureDetector.ts
+var HandGestureDetector = class _HandGestureDetector {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  static getDistance(p1, p2) {
+    const dx = p1.x - p2.x;
+    const dy = p1.y - p2.y;
+    return Math.sqrt(dx * dx + dy * dy);
+  }
+  static getAngle(p1, p2, p3) {
+    const v1x = p2.x - p1.x;
+    const v1y = p2.y - p1.y;
+    const v2x = p3.x - p2.x;
+    const v2y = p3.y - p2.y;
+    const dot = v1x * v2x + v1y * v2y;
+    const det = v1x * v2y - v1y * v2x;
+    let angle = Math.atan2(det, dot) * 180 / Math.PI;
+    return angle < 0 ? angle + 360 : angle;
+  }
+  computeDistances(landmarks) {
+    const wrist = landmarks[LANDMARKS.WRIST];
+    const tips = [
+      LANDMARKS.THUMB_TIP,
+      LANDMARKS.INDEX_TIP,
+      LANDMARKS.MIDDLE_TIP,
+      LANDMARKS.RING_TIP,
+      LANDMARKS.PINKY_TIP
+    ];
+    const fingerNames = ["Thumb", "Index", "Middle", "Ring", "Pinky"];
+    const adjacentNames = ["thumbToIndex", "indexToMiddle", "middleToRing", "ringToPinky"];
+    const distances = {};
+    tips.forEach((tip, i) => {
+      const palmKey = `palmTo${fingerNames[i]}`;
+      distances[palmKey] = _HandGestureDetector.getDistance(wrist, landmarks[tip]);
+      if (i > 0) {
+        distances[adjacentNames[i - 1]] = _HandGestureDetector.getDistance(
+          landmarks[tips[i - 1]],
+          landmarks[tip]
+        );
+      }
+    });
+    return distances;
+  }
+  getNormalizedFingerLengths(distances) {
+    const handSize = (distances.palmToThumb + distances.palmToMiddle) / 2 || 0.15;
+    return {
+      thumb: distances.palmToThumb / handSize,
+      index: distances.palmToIndex / handSize,
+      middle: distances.palmToMiddle / handSize,
+      ring: distances.palmToRing / handSize,
+      pinky: distances.palmToPinky / handSize,
+      thumbToIndex: distances.thumbToIndex / handSize
+    };
+  }
+  getTimedEntries(history) {
+    return history.filter((entry) => entry !== null).sort((a, b) => a.time - b.time || (a.seq ?? 0) - (b.seq ?? 0));
+  }
+  getDirectionDelta(first, last) {
+    return {
+      dx: last.x - first.x,
+      dy: last.y - first.y
+    };
+  }
+  checkOpenHand(distances, histories, indices) {
+    const normalized = this.getNormalizedFingerLengths(distances);
+    if (this.config.debug) {
+      console.log(`Hand state check (open): thumb=${normalized.thumb.toFixed(2)}, index=${normalized.index.toFixed(2)}, middle=${normalized.middle.toFixed(2)}, ring=${normalized.ring.toFixed(2)}, pinky=${normalized.pinky.toFixed(2)}, thumbToIndex=${normalized.thumbToIndex.toFixed(2)}`);
+    }
+    const fingers = ["index", "middle", "ring", "pinky"];
+    const extended = fingers.filter((finger) => normalized[finger] > normalized.thumb).length;
+    const isCandidate = extended >= this.config.openHandThresholds.minExtendedFingers;
+    histories.open[indices.open] = isCandidate;
+    indices.open = (indices.open + 1) % this.config.minOpenConfidence;
+    return histories.open.filter(Boolean).length >= Math.ceil(this.config.minOpenConfidence * 0.7);
+  }
+  checkClosedHand(distances, histories, indices) {
+    const normalized = this.getNormalizedFingerLengths(distances);
+    if (this.config.debug) {
+      console.log(`Hand state check (closed): thumb=${normalized.thumb.toFixed(2)}, index=${normalized.index.toFixed(2)}, middle=${normalized.middle.toFixed(2)}, ring=${normalized.ring.toFixed(2)}, pinky=${normalized.pinky.toFixed(2)}, thumbToIndex=${normalized.thumbToIndex.toFixed(2)}`);
+    }
+    const fingers = ["index", "middle", "ring", "pinky"];
+    const closedFingers = fingers.filter((finger) => normalized[finger] < normalized.thumb).length;
+    const isCandidate = closedFingers >= this.config.openHandThresholds.minExtendedFingers;
+    histories.closed[indices.closed] = isCandidate;
+    indices.closed = (indices.closed + 1) % this.config.minClosedConfidence;
+    return histories.closed.filter(Boolean).length >= Math.ceil(this.config.minClosedConfidence * 0.7);
+  }
+  isPointing(distances, histories, indices) {
+    const handSize = distances.palmToIndex || 0.15;
+    const normalized = {
+      index: distances.palmToIndex / handSize,
+      middle: distances.palmToMiddle / handSize,
+      ring: distances.palmToRing / handSize,
+      pinky: distances.palmToPinky / handSize,
+      thumb: distances.palmToThumb / handSize
+    };
+    const otherFingers = [normalized.middle, normalized.ring, normalized.pinky, normalized.thumb];
+    const isIndexExtended = 0.5 > Math.max(...otherFingers) && normalized.thumb < 0.7;
+    histories.pointing[indices.pointing] = isIndexExtended;
+    indices.pointing = (indices.pointing + 1) % this.config.minPointingConfidence;
+    return histories.pointing.filter(Boolean).length >= Math.ceil(this.config.minPointingConfidence * 0.9);
+  }
+  isThumbUp(distances, landmarks, histories, indices) {
+    const normalized = this.getNormalizedFingerLengths(distances);
+    const { minThumbExtension, maxOtherFingersRatio } = this.config.thumbUpThresholds;
+    const thumbTip = landmarks[LANDMARKS.THUMB_TIP];
+    const wrist = landmarks[LANDMARKS.WRIST];
+    const othersClosed = ["index", "middle", "ring", "pinky"].every((finger) => normalized[finger] < normalized.thumb * maxOtherFingersRatio);
+    const thumbExtended = normalized.thumb >= minThumbExtension;
+    const thumbAboveWrist = thumbTip.y < wrist.y;
+    const isCandidate = thumbExtended && othersClosed && thumbAboveWrist;
+    histories.thumbUp[indices.thumbUp] = isCandidate;
+    indices.thumbUp = (indices.thumbUp + 1) % this.config.minThumbUpConfidence;
+    return histories.thumbUp.filter(Boolean).length >= Math.ceil(this.config.minThumbUpConfidence * 0.8);
+  }
+  isFlipping(distances, histories, indices) {
+    const handSize = distances.palmToIndex || 0.15;
+    const normalized = {
+      index: distances.palmToIndex / handSize,
+      middle: distances.palmToMiddle / handSize,
+      ring: distances.palmToRing / handSize,
+      pinky: distances.palmToPinky / handSize,
+      thumb: distances.palmToThumb / handSize
+    };
+    if (this.config.debug) {
+      console.log(`Hand state check (flip): index=${normalized.index.toFixed(2)}, middle=${normalized.middle.toFixed(2)}, ring=${normalized.ring.toFixed(2)}, pinky=${normalized.pinky.toFixed(2)}, thumb=${normalized.thumb.toFixed(2)}`);
+    }
+    const isFlippingGesture = normalized.middle > 0.8 && Math.max(normalized.ring, normalized.pinky, normalized.thumb) < 0.5;
+    histories.flipping[indices.flipping] = isFlippingGesture;
+    indices.flipping = (indices.flipping + 1) % this.config.minFlippingConfidence;
+    return histories.flipping.filter(Boolean).length >= Math.ceil(this.config.minFlippingConfidence * 0.9);
+  }
+  getSwipeHistory(histories) {
+    return this.config.swipeSource === "index" ? histories.indexTip : histories.landmark0;
+  }
+  checkSwipeNext(swipeHistory, distances, histories, indices, pointingCount, lastActionTime) {
+    if (!this.isPointing(distances, histories, indices) || this.getTimedEntries(swipeHistory).length < this.config.swipeMinHistory || pointingCount < this.config.minPointingCount || Date.now() - lastActionTime < this.config.swipeCooldownMs) {
+      return false;
+    }
+    const entries = this.getTimedEntries(swipeHistory);
+    const xPositions = entries.map((e) => e.x);
+    const xRange = Math.max(...xPositions) - Math.min(...xPositions);
+    const firstX = entries[0].x;
+    const lastX = entries[entries.length - 1].x;
+    return xRange > this.config.swipeMinRange && lastX - firstX > this.config.swipeMinRange;
+  }
+  checkSwipePrevious(swipeHistory, distances, histories, indices, pointingCount, lastActionTime) {
+    if (!this.isPointing(distances, histories, indices) || this.getTimedEntries(swipeHistory).length < this.config.swipeMinHistory || pointingCount < this.config.minPointingCount || Date.now() - lastActionTime < this.config.swipeCooldownMs) {
+      return false;
+    }
+    const entries = this.getTimedEntries(swipeHistory);
+    const xPositions = entries.map((e) => e.x);
+    const xRange = Math.max(...xPositions) - Math.min(...xPositions);
+    const firstX = entries[0].x;
+    const lastX = entries[entries.length - 1].x;
+    return xRange > this.config.swipeMinRange && firstX - lastX > this.config.swipeMinRange;
+  }
+  detectPalmDirection(centroidHistory) {
+    const entries = this.getTimedEntries(centroidHistory);
+    if (entries.length < this.config.palmDirectionMinFrames) {
+      return null;
+    }
+    const { dx, dy } = this.getDirectionDelta(entries[0], entries[entries.length - 1]);
+    const threshold = this.config.palmDirectionThreshold;
+    if (Math.abs(dx) >= Math.abs(dy) && Math.abs(dx) > threshold) {
+      return dx > 0 ? HAND_STATES.PALM_RIGHT : HAND_STATES.PALM_LEFT;
+    }
+    if (Math.abs(dy) > threshold) {
+      return dy > 0 ? HAND_STATES.PALM_DOWN : HAND_STATES.PALM_UP;
+    }
+    return null;
+  }
+};
+
+// src/ActionMapper.ts
+function resolveRotationAction(rotation, threshold = 0.5) {
+  const [vertical, horizontal] = rotation;
+  const absVertical = Math.abs(vertical);
+  const absHorizontal = Math.abs(horizontal);
+  if (absVertical < threshold && absHorizontal < threshold) {
+    return null;
+  }
+  if (absHorizontal >= absVertical) {
+    return horizontal > 0 ? GESTURE_ACTIONS.ROTATE_RIGHT : GESTURE_ACTIONS.ROTATE_LEFT;
+  }
+  return vertical > 0 ? GESTURE_ACTIONS.ROTATE_DOWN : GESTURE_ACTIONS.ROTATE_UP;
+}
+var ActionMapper = class {
+  actionMap;
+  rotationThreshold;
+  enableContinuousRotation;
+  constructor(config = {}) {
+    this.actionMap = {
+      ...DEFAULT_ACTION_MAP,
+      ...config.actionMap ?? {}
+    };
+    this.rotationThreshold = config.rotationActionThreshold ?? 0.5;
+    this.enableContinuousRotation = config.enableContinuousRotation ?? true;
+  }
+  map(result) {
+    const base = {
+      ...result,
+      gesture: result.gesture ?? result.state
+    };
+    const actions = [];
+    const add = (action) => {
+      if (action && action !== GESTURE_ACTIONS.NONE && !actions.includes(action)) {
+        actions.push(action);
+      }
+    };
+    add(this.actionMap[base.state]);
+    if (base.palmDirection) {
+      add(this.actionMap[base.palmDirection]);
+    }
+    const rotationStates = [HAND_STATES.OPEN, HAND_STATES.CLOSED];
+    if (this.enableContinuousRotation && rotationStates.includes(base.state) && !base.palmDirection) {
+      add(resolveRotationAction(base.rotation, this.rotationThreshold));
+    }
+    return {
+      ...base,
+      actions,
+      primaryAction: actions[0] ?? GESTURE_ACTIONS.NONE
+    };
+  }
+};
+function mapGestureToAction(result, actionMap = DEFAULT_ACTION_MAP, options = {}) {
+  const mapper = new ActionMapper({
+    actionMap,
+    rotationActionThreshold: options.rotationActionThreshold,
+    enableContinuousRotation: options.enableContinuousRotation
+  });
+  return mapper.map(result);
+}
+
+// src/validate.ts
+var ConfigValidationError = class extends Error {
+  issues;
+  constructor(issues) {
+    super(`Invalid hand-guest-control config: ${issues.join("; ")}`);
+    this.name = "ConfigValidationError";
+    this.issues = issues;
+  }
+};
+function isPositiveInt(value, field, issues) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+    issues.push(`${field} must be a positive integer`);
+  }
+}
+function isPositiveNumber(value, field, issues) {
+  if (typeof value !== "number" || Number.isNaN(value) || value <= 0) {
+    issues.push(`${field} must be a positive number`);
+  }
+}
+function isNonNegativeInt(value, field, issues) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    issues.push(`${field} must be a non-negative integer`);
+  }
+}
+function isRatio(value, field, issues) {
+  if (typeof value !== "number" || Number.isNaN(value) || value < 0 || value > 1) {
+    issues.push(`${field} must be between 0 and 1`);
+  }
+}
+function isSwipeSource(value, issues) {
+  if (value !== "index" && value !== "wrist") {
+    issues.push(`swipeSource must be "index" or "wrist"`);
+  }
+}
+function validateHandConfig(config) {
+  const issues = [];
+  if (config.maxHistorySize !== void 0) isPositiveInt(config.maxHistorySize, "maxHistorySize", issues);
+  if (config.maxCentroidHistorySize !== void 0) {
+    isPositiveInt(config.maxCentroidHistorySize, "maxCentroidHistorySize", issues);
+  }
+  if (config.rotationSensitivity !== void 0) {
+    isPositiveNumber(config.rotationSensitivity, "rotationSensitivity", issues);
+  }
+  if (config.detectionTolerance !== void 0) {
+    isPositiveInt(config.detectionTolerance, "detectionTolerance", issues);
+  }
+  if (config.startingDelay !== void 0) isPositiveInt(config.startingDelay, "startingDelay", issues);
+  if (config.waitingTimeout !== void 0) isPositiveInt(config.waitingTimeout, "waitingTimeout", issues);
+  if (config.minOpenConfidence !== void 0) isPositiveInt(config.minOpenConfidence, "minOpenConfidence", issues);
+  if (config.minPointingConfidence !== void 0) {
+    isPositiveInt(config.minPointingConfidence, "minPointingConfidence", issues);
+  }
+  if (config.minFlippingConfidence !== void 0) {
+    isPositiveInt(config.minFlippingConfidence, "minFlippingConfidence", issues);
+  }
+  if (config.minClosedConfidence !== void 0) {
+    isPositiveInt(config.minClosedConfidence, "minClosedConfidence", issues);
+  }
+  if (config.minThumbUpConfidence !== void 0) {
+    isPositiveInt(config.minThumbUpConfidence, "minThumbUpConfidence", issues);
+  }
+  if (config.minPointingCount !== void 0) isPositiveInt(config.minPointingCount, "minPointingCount", issues);
+  if (config.pointingThreshold !== void 0) isRatio(config.pointingThreshold, "pointingThreshold", issues);
+  if (config.swipeSource !== void 0) isSwipeSource(config.swipeSource, issues);
+  if (config.swipeMinRange !== void 0) isPositiveNumber(config.swipeMinRange, "swipeMinRange", issues);
+  if (config.swipeCooldownMs !== void 0) isNonNegativeInt(config.swipeCooldownMs, "swipeCooldownMs", issues);
+  if (config.swipeMinHistory !== void 0) isPositiveInt(config.swipeMinHistory, "swipeMinHistory", issues);
+  if (config.palmDirectionThreshold !== void 0) {
+    isPositiveNumber(config.palmDirectionThreshold, "palmDirectionThreshold", issues);
+  }
+  if (config.palmDirectionMinFrames !== void 0) {
+    isPositiveInt(config.palmDirectionMinFrames, "palmDirectionMinFrames", issues);
+  }
+  if (config.rotationActionThreshold !== void 0) {
+    isPositiveNumber(config.rotationActionThreshold, "rotationActionThreshold", issues);
+  }
+  if (config.mapActions !== void 0 && typeof config.mapActions !== "boolean") {
+    issues.push("mapActions must be a boolean");
+  }
+  if (config.debug !== void 0 && typeof config.debug !== "boolean") {
+    issues.push("debug must be a boolean");
+  }
+  if (config.enableContinuousRotation !== void 0 && typeof config.enableContinuousRotation !== "boolean") {
+    issues.push("enableContinuousRotation must be a boolean");
+  }
+  if (config.openHandThresholds) {
+    const t = config.openHandThresholds;
+    if (t.minExtendedFingers !== void 0 && (!Number.isInteger(t.minExtendedFingers) || t.minExtendedFingers < 1)) {
+      issues.push("openHandThresholds.minExtendedFingers must be >= 1");
+    }
+  }
+  if (config.thumbUpThresholds) {
+    const t = config.thumbUpThresholds;
+    if (t.minThumbExtension !== void 0) {
+      isPositiveNumber(t.minThumbExtension, "thumbUpThresholds.minThumbExtension", issues);
+    }
+    if (t.maxOtherFingersRatio !== void 0) {
+      isPositiveNumber(t.maxOtherFingersRatio, "thumbUpThresholds.maxOtherFingersRatio", issues);
+    }
+  }
+  if (issues.length > 0) {
+    throw new ConfigValidationError(issues);
+  }
+}
+function mergeHandConfig(config = {}) {
+  validateHandConfig(config);
+  return {
+    ...DEFAULT_CONFIG,
+    ...config,
+    openHandThresholds: {
+      ...DEFAULT_CONFIG.openHandThresholds,
+      ...config.openHandThresholds ?? {}
+    },
+    thumbUpThresholds: {
+      ...DEFAULT_CONFIG.thumbUpThresholds,
+      ...config.thumbUpThresholds ?? {}
+    },
+    actionMap: config.actionMap ?? DEFAULT_CONFIG.actionMap
+  };
+}
+
+// src/HandStateManager.ts
+var CONFIDENCE_BY_HISTORY = {
+  open: "minOpenConfidence",
+  pointing: "minPointingConfidence",
+  closed: "minClosedConfidence",
+  flipping: "minFlippingConfidence",
+  thumbUp: "minThumbUpConfidence"
+};
+var HISTORY_KEY_BY_STATE = {
+  [HAND_STATES.OPEN]: "open",
+  [HAND_STATES.POINTING]: "pointing",
+  [HAND_STATES.CLOSED]: "closed",
+  [HAND_STATES.FLIPPING]: "flipping",
+  [HAND_STATES.THUMB_UP]: "thumbUp"
+};
+var ROTATION_DISABLED_STATES = [
+  HAND_STATES.POINTING,
+  HAND_STATES.SWIPE_NEXT,
+  HAND_STATES.SWIPE_PREVIOUS,
+  HAND_STATES.FLIPPING,
+  HAND_STATES.THUMB_UP
+];
+var PALM_DIRECTION_STATES = [
+  HAND_STATES.OPEN,
+  HAND_STATES.CLOSED
+];
+var HandStateManager = class {
+  config;
+  gestureDetector;
+  actionMapper;
+  histories;
+  indices;
+  prevLandmark0 = null;
+  lastActionTime = 0;
+  pointingCount = 0;
+  flippingCount = 0;
+  detectionPausedUntil = 0;
+  noDetectionStartTime = 0;
+  lastDetectionTime = 0;
+  lastState = null;
+  lastPalmDirection = null;
+  frameSeq = 0;
+  constructor(config = {}) {
+    this.config = mergeHandConfig(config);
+    this.gestureDetector = new HandGestureDetector(this.config);
+    this.actionMapper = new ActionMapper({
+      actionMap: this.config.actionMap ?? void 0,
+      rotationActionThreshold: this.config.rotationActionThreshold,
+      enableContinuousRotation: this.config.enableContinuousRotation
+    });
+    this.initializeState();
+  }
+  initializeState() {
+    this.histories = {
+      centroid: new Array(this.config.maxCentroidHistorySize).fill(null),
+      landmark0: new Array(this.config.maxHistorySize).fill(null),
+      indexTip: new Array(this.config.maxHistorySize).fill(null),
+      open: new Array(this.config.minOpenConfidence).fill(false),
+      pointing: new Array(this.config.minPointingConfidence).fill(false),
+      flipping: new Array(this.config.minFlippingConfidence).fill(false),
+      closed: new Array(this.config.minClosedConfidence).fill(false),
+      thumbUp: new Array(this.config.minThumbUpConfidence).fill(false)
+    };
+    this.indices = {
+      history: 0,
+      indexTip: 0,
+      centroid: 0,
+      open: 0,
+      pointing: 0,
+      flipping: 0,
+      closed: 0,
+      thumbUp: 0
+    };
+    this.resetTrackingState();
+  }
+  resetTrackingState() {
+    this.prevLandmark0 = null;
+    this.lastActionTime = 0;
+    this.pointingCount = 0;
+    this.flippingCount = 0;
+    this.detectionPausedUntil = 0;
+    this.noDetectionStartTime = 0;
+    this.lastDetectionTime = 0;
+    this.lastState = null;
+    this.lastPalmDirection = null;
+    this.frameSeq = 0;
+  }
+  buildResult(state, rotation = [0, 0, 0], palmDirection = null) {
+    const result = {
+      state,
+      gesture: state,
+      rotation,
+      palmDirection
+    };
+    if (!this.config.mapActions) {
+      return {
+        ...result,
+        actions: [],
+        primaryAction: GESTURE_ACTIONS.NONE
+      };
+    }
+    return this.actionMapper.map(result);
+  }
+  calculateCentroid(landmarks, now) {
+    if (!landmarks?.length) {
+      return { x: 0, y: 0 };
+    }
+    const wrist = landmarks[LANDMARKS.WRIST] ?? landmarks[0];
+    const indexTip = landmarks[LANDMARKS.INDEX_TIP];
+    this.frameSeq += 1;
+    const pointMeta = { time: now, seq: this.frameSeq };
+    this.histories.landmark0[this.indices.history] = {
+      x: wrist.x,
+      y: wrist.y,
+      ...pointMeta
+    };
+    this.indices.history = (this.indices.history + 1) % this.config.maxHistorySize;
+    if (indexTip) {
+      this.histories.indexTip[this.indices.indexTip] = {
+        x: indexTip.x,
+        y: indexTip.y,
+        ...pointMeta
+      };
+      this.indices.indexTip = (this.indices.indexTip + 1) % this.config.maxHistorySize;
+    }
+    const validPoints = this.histories.landmark0.filter((p) => p !== null);
+    if (!validPoints.length) {
+      return { x: wrist.x, y: wrist.y };
+    }
+    const sum = validPoints.reduce(
+      (acc, p) => ({ x: acc.x + p.x, y: acc.y + p.y }),
+      { x: 0, y: 0 }
+    );
+    return {
+      x: sum.x / validPoints.length,
+      y: sum.y / validPoints.length
+    };
+  }
+  getRotation(landmarks, centroid) {
+    if (!landmarks[LANDMARKS.MIDDLE_TIP]) {
+      return [0, 0, 0];
+    }
+    const handSize = HandGestureDetector.getDistance(
+      landmarks[LANDMARKS.WRIST],
+      landmarks[LANDMARKS.THUMB_TIP]
+    ) || 0.15;
+    const scaleFactor = 0.15 / handSize;
+    const delta = this.prevLandmark0 ? {
+      x: (centroid.x - this.prevLandmark0.x) * scaleFactor,
+      y: (centroid.y - this.prevLandmark0.y) * scaleFactor
+    } : { x: 0, y: 0 };
+    this.prevLandmark0 = { x: centroid.x, y: centroid.y };
+    return [
+      delta.y * this.config.rotationSensitivity,
+      delta.x * this.config.rotationSensitivity,
+      0
+    ];
+  }
+  handleNoDetection(now) {
+    this.pointingCount = 0;
+    this.flippingCount = 0;
+    this.lastPalmDirection = null;
+    if (!this.noDetectionStartTime) {
+      this.noDetectionStartTime = now;
+    }
+    const noDetectionDuration = now - this.noDetectionStartTime;
+    if (noDetectionDuration < this.config.detectionTolerance) {
+      return this.buildResult(this.lastState ?? HAND_STATES.NOT_DETECTED);
+    }
+    if (noDetectionDuration >= this.config.waitingTimeout) {
+      this.lastState = HAND_STATES.WAITING;
+      if (this.config.debug) {
+        console.log(`Transitioned to WAITING after ${this.config.waitingTimeout / 1e3}s`);
+      }
+      return this.buildResult(HAND_STATES.WAITING);
+    }
+    this.lastState = HAND_STATES.NOT_DETECTED;
+    if (this.config.debug) {
+      console.log(`Transitioned to NOT_DETECTED after ${this.config.detectionTolerance / 1e3}s`);
+    }
+    return this.buildResult(HAND_STATES.NOT_DETECTED);
+  }
+  handleDetectionReconnection(now) {
+    const isWaitingOrNotDetected = this.lastState === HAND_STATES.WAITING || this.lastState === HAND_STATES.NOT_DETECTED;
+    const isReconnection = this.lastState !== HAND_STATES.WAITING && this.lastState !== HAND_STATES.NOT_DETECTED && this.lastState !== HAND_STATES.STARTING && now - this.lastDetectionTime <= this.config.detectionTolerance;
+    if (isReconnection) {
+      if (this.config.debug) {
+        console.log(
+          `Short reconnection (${(now - this.lastDetectionTime) / 1e3}s), continuing with last state: ${this.lastState}`
+        );
+      }
+    } else if (isWaitingOrNotDetected) {
+      this.detectionPausedUntil = now + this.config.startingDelay;
+      this.noDetectionStartTime = 0;
+      this.lastState = HAND_STATES.STARTING;
+      return this.buildResult(HAND_STATES.STARTING);
+    }
+    return null;
+  }
+  determineHandState(distances, landmarks) {
+    const swipeHistory = this.gestureDetector.getSwipeHistory(this.histories);
+    if (this.gestureDetector.checkSwipeNext(
+      swipeHistory,
+      distances,
+      this.histories,
+      this.indices,
+      this.pointingCount,
+      this.lastActionTime
+    )) {
+      this.resetSwipeState();
+      return HAND_STATES.SWIPE_NEXT;
+    }
+    if (this.gestureDetector.checkSwipePrevious(
+      swipeHistory,
+      distances,
+      this.histories,
+      this.indices,
+      this.pointingCount,
+      this.lastActionTime
+    )) {
+      this.resetSwipeState();
+      return HAND_STATES.SWIPE_PREVIOUS;
+    }
+    if (this.gestureDetector.isThumbUp(distances, landmarks, this.histories, this.indices)) {
+      return HAND_STATES.THUMB_UP;
+    }
+    if (this.gestureDetector.isFlipping(distances, this.histories, this.indices)) {
+      return HAND_STATES.FLIPPING;
+    }
+    if (this.gestureDetector.checkClosedHand(distances, this.histories, this.indices)) {
+      return HAND_STATES.CLOSED;
+    }
+    if (this.gestureDetector.checkOpenHand(distances, this.histories, this.indices)) {
+      return HAND_STATES.OPEN;
+    }
+    if (this.gestureDetector.isPointing(distances, this.histories, this.indices)) {
+      return HAND_STATES.POINTING;
+    }
+    return HAND_STATES.CLOSED;
+  }
+  resetSwipeState() {
+    this.histories.landmark0.fill(null);
+    this.histories.indexTip.fill(null);
+    this.indices.history = 0;
+    this.indices.indexTip = 0;
+    this.lastActionTime = Date.now();
+    this.pointingCount = 0;
+    this.flippingCount = 0;
+  }
+  validateStateTransition(newState) {
+    const validTransitionStates = [
+      HAND_STATES.OPEN,
+      HAND_STATES.POINTING,
+      HAND_STATES.CLOSED,
+      HAND_STATES.FLIPPING,
+      HAND_STATES.THUMB_UP
+    ];
+    if (newState === this.lastState || !validTransitionStates.includes(newState)) {
+      return newState;
+    }
+    const historyKey = HISTORY_KEY_BY_STATE[newState];
+    if (!historyKey) {
+      return newState;
+    }
+    const confidenceKey = CONFIDENCE_BY_HISTORY[historyKey];
+    const requiredConfidence = this.config[confidenceKey];
+    const actualConfidence = this.histories[historyKey].filter(Boolean).length;
+    if (actualConfidence < requiredConfidence * 0.9) {
+      return this.lastState ?? newState;
+    }
+    return newState;
+  }
+  clearAllHistory() {
+    this.histories.centroid.fill(null);
+    this.histories.landmark0.fill(null);
+    this.histories.indexTip.fill(null);
+    this.histories.open.fill(false);
+    this.histories.pointing.fill(false);
+    this.histories.flipping.fill(false);
+    this.histories.closed.fill(false);
+    this.histories.thumbUp.fill(false);
+    Object.keys(this.indices).forEach((key) => {
+      this.indices[key] = 0;
+    });
+    this.resetTrackingState();
+  }
+  processLandmarks(landmarks) {
+    const now = Date.now();
+    if (this.detectionPausedUntil > now) {
+      if (this.config.debug) {
+        console.log(`In STARTING state until ${new Date(this.detectionPausedUntil).toLocaleTimeString()}`);
+      }
+      return this.buildResult(HAND_STATES.STARTING);
+    }
+    if (!landmarks?.[LANDMARKS.PINKY_TIP]) {
+      return this.handleNoDetection(now);
+    }
+    this.lastDetectionTime = now;
+    const reconnectionResult = this.handleDetectionReconnection(now);
+    if (reconnectionResult) {
+      return reconnectionResult;
+    }
+    this.noDetectionStartTime = 0;
+    this.detectionPausedUntil = 0;
+    const distances = this.gestureDetector.computeDistances(landmarks);
+    const centroid = this.calculateCentroid(landmarks, now);
+    this.histories.centroid[this.indices.centroid] = {
+      x: centroid.x,
+      y: centroid.y,
+      time: now,
+      seq: this.frameSeq
+    };
+    this.indices.centroid = (this.indices.centroid + 1) % this.config.maxCentroidHistorySize;
+    const rotation = this.getRotation(landmarks, centroid);
+    this.pointingCount += this.gestureDetector.isPointing(distances, this.histories, this.indices) ? 1 : 0;
+    this.flippingCount += this.gestureDetector.isFlipping(distances, this.histories, this.indices) ? 1 : 0;
+    let newState = this.determineHandState(distances, landmarks);
+    newState = this.validateStateTransition(newState);
+    let palmDirection = null;
+    if (PALM_DIRECTION_STATES.includes(newState)) {
+      palmDirection = this.gestureDetector.detectPalmDirection(this.histories.centroid);
+      this.lastPalmDirection = palmDirection;
+    } else {
+      this.lastPalmDirection = null;
+    }
+    this.lastState = newState;
+    if (ROTATION_DISABLED_STATES.includes(newState)) {
+      rotation.fill(0);
+    }
+    return this.buildResult(newState, rotation, palmDirection);
+  }
+};
+export {
+  ActionMapper,
+  ConfigValidationError,
+  DEFAULT_ACTION_MAP,
+  DEFAULT_CONFIG,
+  GESTURE_ACTIONS,
+  HAND_CONNECTIONS,
+  HAND_STATES,
+  HandGestureDetector,
+  HandStateManager,
+  LANDMARKS,
+  mapGestureToAction,
+  mergeHandConfig,
+  resolveRotationAction,
+  validateHandConfig
+};
+//# sourceMappingURL=index.js.map