bowling-analysis-system/src/bowling_analysis/processors/PhaseOneProcessor.js

A comprehensive system for analyzing bowling techniques using video processing and metrics calculation

/**
 * @module bowling_analysis/processors/PhaseOneProcessor
 * @description Process Phase One metrics focusing on pure biomechanical measurements
 */

class PhaseOneProcessor {
  /**
   * Process Phase One metrics
   * @param {Object} data - Input data including keypoints
   * @returns {Object} Phase One metrics
   */
  async processPhaseOne(data) {
    if (!data || !data.keypoints) {
      throw new Error('Invalid input data: missing keypoints');
    }

    const metrics = {
      biomechanics: {
        angles: this._calculateJointAngles(data.keypoints),
        balance: this._calculateBalanceMetrics(data.keypoints),
        posture: this._calculatePosturalMetrics(data.keypoints),
        coordination: this._calculateCoordinationMetrics(data.keypoints),
        segments: {
          lower: this._analyzeLowerBodySegments(data.keypoints),
          trunk: this._analyzeTrunkSegments(data.keypoints),
          upper: this._analyzeUpperBodySegments(data.keypoints)
        }
      },
      metadata: {
        generatedAt: new Date().toISOString(),
        version: systemConfig.version
      }
    };

    return metrics;
  }

  /**
   * Calculate joint angles
   * @param {Object} keypoints - Keypoint data
   * @returns {Object} Joint angles
   * @private
   */
  _calculateJointAngles(keypoints) {
    return {
      shoulder: this._calculateShoulderAngles(keypoints),
      elbow: this._calculateElbowAngles(keypoints),
      wrist: this._calculateWristAngles(keypoints),
      hip: this._calculateHipAngles(keypoints),
      knee: this._calculateKneeAngles(keypoints),
      ankle: this._calculateAnkleAngles(keypoints),
      spine: this._calculateSpineAngles(keypoints)
    };
  }

  /**
   * Calculate balance metrics
   * @param {Object} keypoints - Keypoint data
   * @returns {Object} Balance metrics
   * @private
   */
  _calculateBalanceMetrics(keypoints) {
    return {
      centerOfMass: this._calculateCenterOfMass(keypoints),
      weightDistribution: this._calculateWeightDistribution(keypoints),
      stabilityIndices: this._calculateStabilityIndices(keypoints),
      balanceRatios: this._calculateBalanceRatios(keypoints)
    };
  }

  /**
   * Calculate postural metrics
   * @param {Object} keypoints - Keypoint data
   * @returns {Object} Postural metrics
   * @private
   */
  _calculatePosturalMetrics(keypoints) {
    return {
      spinalAlignment: this._calculateSpinalAlignment(keypoints),
      shoulderAlignment: this._calculateShoulderAlignment(keypoints),
      hipAlignment: this._calculateHipAlignment(keypoints),
      headPosition: this._calculateHeadPosition(keypoints),
      trunkRotation: this._calculateTrunkRotation(keypoints)
    };
  }

  /**
   * Calculate coordination metrics
   * @param {Object} keypoints - Keypoint data
   * @returns {Object} Coordination metrics
   * @private
   */
  _calculateCoordinationMetrics(keypoints) {
    return {
      limbSynchronization: this._calculateLimbSynchronization(keypoints),
      crossBodyCoordination: this._calculateCrossBodyCoordination(keypoints),
      segmentalTiming: this._calculateSegmentalTiming(keypoints),
      movementSymmetry: this._calculateMovementSymmetry(keypoints)
    };
  }

  /**
   * Analyze lower body segments
   * @param {Object} keypoints - Keypoint data
   * @returns {Object} Lower body analysis
   * @private
   */
  _analyzeLowerBodySegments(keypoints) {
    return {
      footwork: this._analyzeFootwork(keypoints),
      legDrive: this._analyzeLegDrive(keypoints),
      hipRotation: this._analyzeHipRotation(keypoints),
      kneeAction: this._analyzeKneeAction(keypoints)
    };
  }

  /**
   * Analyze trunk segments
   * @param {Object} keypoints - Keypoint data
   * @returns {Object} Trunk analysis
   * @private
   */
  _analyzeTrunkSegments(keypoints) {
    return {
      spinalRotation: this._analyzeSpinalRotation(keypoints),
      corePower: this._analyzeCorePower(keypoints),
      trunkStability: this._analyzeTrunkStability(keypoints),
      shoulderGirdle: this._analyzeShoulderGirdle(keypoints)
    };
  }

  /**
   * Analyze upper body segments
   * @param {Object} keypoints - Keypoint data
   * @returns {Object} Upper body analysis
   * @private
   */
  _analyzeUpperBodySegments(keypoints) {
    return {
      armAction: this._analyzeArmAction(keypoints),
      wristPosition: this._analyzeWristPosition(keypoints),
      shoulderRotation: this._analyzeShoulderRotation(keypoints),
      handPath: this._analyzeHandPath(keypoints)
    };
  }
}

module.exports = PhaseOneProcessor;