hand-guest-control 0.1.0 → 0.3.0

package/src/HandStateManager.js

@@ -1,276 +0,0 @@
-import { HAND_STATES, LANDMARKS, DEFAULT_CONFIG } from './constants.js';
-import { HandGestureDetector } from './HandGestureDetector.js';
-
-export class HandStateManager {
-  constructor(config = {}) {
-    this.config = { ...DEFAULT_CONFIG, ...config };
-    this.gestureDetector = new HandGestureDetector(this.config);
-
-    this.initializeState();
-  }
-
-  initializeState() {
-    this.histories = {
-      centroid: new Array(this.config.maxCentroidHistorySize).fill(null),
-      landmark0: 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)
-    };
-
-    this.indices = {
-      history: 0,
-      centroid: 0,
-      open: 0,
-      pointing: 0,
-      flipping: 0,
-      closed: 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;
-  }
-
-  calculateCentroid(landmarks, now) {
-    if (!landmarks?.length) {
-      return { x: 0, y: 0 };
-    }
-
-    const landmark0 = landmarks[LANDMARKS.WRIST] || landmarks[0];
-    this.histories.landmark0[this.indices.history] = {
-      x: landmark0.x,
-      y: landmark0.y,
-      time: now
-    };
-    this.indices.history = (this.indices.history + 1) % this.config.maxHistorySize;
-
-    const validPoints = this.histories.landmark0.filter(Boolean);
-    if (!validPoints.length) {
-      return { x: landmark0.x, y: landmark0.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;
-
-    if (!this.noDetectionStartTime) {
-      this.noDetectionStartTime = now;
-    }
-
-    const noDetectionDuration = now - this.noDetectionStartTime;
-
-    if (noDetectionDuration < this.config.detectionTolerance) {
-      return { state: this.lastState || HAND_STATES.NOT_DETECTED, rotation: [0, 0, 0] };
-    }
-
-    if (noDetectionDuration >= this.config.waitingTimeout) {
-      this.lastState = HAND_STATES.WAITING;
-      if (this.config.debug) {
-        console.log(`Transitioned to WAITING after ${this.config.waitingTimeout / 1000}s`);
-      }
-      return { state: HAND_STATES.WAITING, rotation: [0, 0, 0] };
-    }
-
-    this.lastState = HAND_STATES.NOT_DETECTED;
-    if (this.config.debug) {
-      console.log(`Transitioned to NOT_DETECTED after ${this.config.detectionTolerance / 1000}s`);
-    }
-    return { state: HAND_STATES.NOT_DETECTED, rotation: [0, 0, 0] };
-  }
-
-  handleDetectionReconnection(now) {
-    const isWaitingOrNotDetected = [HAND_STATES.WAITING, HAND_STATES.NOT_DETECTED].includes(this.lastState);
-    const isReconnection = ![HAND_STATES.WAITING, HAND_STATES.NOT_DETECTED, HAND_STATES.STARTING].includes(this.lastState) &&
-      now - this.lastDetectionTime <= this.config.detectionTolerance;
-
-    if (isReconnection) {
-      if (this.config.debug) {
-        console.log(`Short reconnection (${(now - this.lastDetectionTime) / 1000}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 { state: HAND_STATES.STARTING, rotation: [0, 0, 0] };
-    }
-
-    return null;
-  }
-
-  determineHandState(distances) {
-    if (this.gestureDetector.checkSwipeNext(
-      this.histories.landmark0, distances, this.histories, this.indices,
-      this.pointingCount, this.lastActionTime
-    )) {
-      this.resetSwipeState();
-      return HAND_STATES.SWIPE_NEXT;
-    }
-
-    if (this.gestureDetector.checkSwipePrevious(
-      this.histories.landmark0, distances, this.histories, this.indices,
-      this.pointingCount, this.lastActionTime
-    )) {
-      this.resetSwipeState();
-      return HAND_STATES.SWIPE_PREVIOUS;
-    }
-
-    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.indices.history = 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];
-
-    if (newState === this.lastState || !validTransitionStates.includes(newState)) {
-      return newState;
-    }
-
-    const historyKeys = {
-      [HAND_STATES.OPEN]: 'open',
-      [HAND_STATES.POINTING]: 'pointing',
-      [HAND_STATES.CLOSED]: 'closed',
-      [HAND_STATES.FLIPPING]: 'flipping'
-    };
-
-    const historyKey = historyKeys[newState];
-    if (!historyKey) return newState;
-
-    const requiredConfidence = this.config[`min${historyKey.charAt(0).toUpperCase() + historyKey.slice(1)}Confidence`];
-    const actualConfidence = this.histories[historyKey].filter(Boolean).length;
-
-    if (actualConfidence < requiredConfidence * 0.9) {
-      return this.lastState;
-    }
-
-    return newState;
-  }
-
-  clearAllHistory() {
-    Object.values(this.histories).forEach((history) => history.fill(null));
-    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 { state: HAND_STATES.STARTING, rotation: [0, 0, 0] };
-    }
-
-    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 };
-    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);
-    newState = this.validateStateTransition(newState);
-
-    this.lastState = newState;
-
-    const rotationDisabledStates = [
-      HAND_STATES.POINTING,
-      HAND_STATES.SWIPE_NEXT,
-      HAND_STATES.SWIPE_PREVIOUS,
-      HAND_STATES.FLIPPING
-    ];
-
-    if (rotationDisabledStates.includes(newState)) {
-      rotation.fill(0);
-    }
-
-    return { state: newState, rotation };
-  }
-}

package/src/constants.js

@@ -1,52 +0,0 @@
-export const HAND_STATES = {
-  NOT_DETECTED: 'not_detected',
-  WAITING: 'waiting',
-  STARTING: 'starting',
-  OPEN: 'open',
-  CLOSED: 'closed',
-  POINTING: 'pointing',
-  FLIPPING: 'flipping',
-  SWIPE_NEXT: 'swipe_next',
-  SWIPE_PREVIOUS: 'swipe_previous'
-};
-
-export const LANDMARKS = {
-  WRIST: 0,
-  THUMB_TIP: 4,
-  INDEX_TIP: 8,
-  MIDDLE_TIP: 12,
-  RING_TIP: 16,
-  PINKY_TIP: 20
-};
-
-export const 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]
-];
-
-export const DEFAULT_CONFIG = {
-  maxHistorySize: 10,
-  maxCentroidHistorySize: 10,
-  rotationSensitivity: 4,
-  detectionTolerance: 2000,
-  startingDelay: 1000,
-  waitingTimeout: 3000,
-  minOpenConfidence: 5,
-  minPointingConfidence: 25,
-  minFlippingConfidence: 25,
-  minClosedConfidence: 5,
-  minPointingCount: 5,
-  pointingThreshold: 0.3,
-  openHandThresholds: {
-    fingerSpread: 0.2,
-    indexToMiddle: 0.15,
-    minExtendedFingers: 4,
-    maxExtendedFingers: 6,
-    middleAngle: 50
-  },
-  debug: false
-};

package/src/index.js

@@ -1,9 +0,0 @@
-export {
-  HAND_STATES,
-  LANDMARKS,
-  HAND_CONNECTIONS,
-  DEFAULT_CONFIG
-} from './constants.js';
-
-export { HandGestureDetector } from './HandGestureDetector.js';
-export { HandStateManager } from './HandStateManager.js';

package/src/mediapipe.js

@@ -1,59 +0,0 @@
-import { HandLandmarker, FilesetResolver } from '@mediapipe/tasks-vision';
-
-export const DEFAULT_MEDIAPIPE_CONFIG = {
-  wasmPath: 'https://cdn.jsdelivr.net/npm/@mediapipe/tasks-vision@0.10.0/wasm',
-  modelPath: 'https://storage.googleapis.com/mediapipe-models/hand_landmarker/hand_landmarker/float16/1/hand_landmarker.task'
-};
-
-export const DEFAULT_DETECTION_CONFIG = {
-  runningMode: 'VIDEO',
-  numHands: 1,
-  minHandDetectionConfidence: 0.6,
-  minHandPresenceConfidence: 0.6,
-  minTrackingConfidence: 0.5
-};
-
-/**
- * Create a MediaPipe HandLandmarker with GPU fallback to CPU.
- * @param {object} [options]
- * @param {string} [options.wasmPath]
- * @param {string} [options.modelPath]
- * @param {import('@mediapipe/tasks-vision').RunningMode} [options.runningMode]
- * @param {number} [options.numHands]
- * @param {number} [options.minHandDetectionConfidence]
- * @param {number} [options.minHandPresenceConfidence]
- * @param {number} [options.minTrackingConfidence]
- */
-export async function createHandLandmarker(options = {}) {
-  const config = {
-    ...DEFAULT_MEDIAPIPE_CONFIG,
-    ...DEFAULT_DETECTION_CONFIG,
-    ...options
-  };
-
-  const vision = await FilesetResolver.forVisionTasks(config.wasmPath);
-
-  const landmarkerOptions = {
-    baseOptions: {
-      modelAssetPath: config.modelPath,
-      delegate: 'GPU'
-    },
-    runningMode: config.runningMode,
-    numHands: config.numHands,
-    minHandDetectionConfidence: config.minHandDetectionConfidence,
-    minHandPresenceConfidence: config.minHandPresenceConfidence,
-    minTrackingConfidence: config.minTrackingConfidence
-  };
-
-  try {
-    return await HandLandmarker.createFromOptions(vision, landmarkerOptions);
-  } catch (gpuError) {
-    console.warn('GPU delegate failed, falling back to CPU:', gpuError);
-    return HandLandmarker.createFromOptions(vision, {
-      ...landmarkerOptions,
-      baseOptions: {
-        modelAssetPath: config.modelPath
-      }
-    });
-  }
-}