bowling-analysis-system/src/bowling_analysis/metrics/BiasProcessor.js

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

/**
 * @module bowling_analysis/metrics/BiasProcessor
 */

const { defaultLogger } = require('../../utils/logger');
const { getTotalFrames, filterRelevantMetrics } = require('../utils/MetricsUtils');
// Using the modern BiasCalculator instead of the deprecated BiasAnalyzer
const BiasCalculator = require('../processors/BiasCalculator');
const { getConfig } = require('../utils/BiasConfigManager');
const { validateEvents } = require('../utils/EventValidator');

const logger = defaultLogger.child('BiasProcessor');

class BiasProcessor {
  constructor(options = {}) {
    this.options = {
      ...getConfig(),
      ...options
    };
    this.logger = logger;
  }

  /**
   * Process metrics with bias analysis
   */
  async process(metrics, referenceData) {
    const totalFrames = getTotalFrames(metrics);
    this.logger.debug('Processing metrics', { totalFrames });

    if (!metrics || !referenceData) {
      throw new Error('Missing required data for bias processing');
    }

    // Use the modern BiasCalculator instead of the deprecated BiasAnalyzer
    const biasCalculator = new BiasCalculator({
      debug: this.options.debug,
      logger: this.logger.child('BiasCalculator')
    });

    // Generate bias data using the modern implementation
    const biasData = await biasCalculator.calculateBias(metrics);
    if (!biasData) {
      throw new Error('Failed to generate bias data');
    }

    // Validate events
    const events = this._extractEvents(biasData);
    const validatedEvents = await validateEvents(events);

    return {
      ...biasData,
      events: validatedEvents
    };
  }

  /**
   * Extract events from bias data
   * @private
   */
  _extractEvents(biasData) {
    const events = {};

    for (const [eventType, eventData] of Object.entries(biasData.events)) {
      if (eventData && eventData.confidence >= this.options.eventConfidenceThreshold) {
        events[eventType] = {
          ...eventData,
          validated: true
        };
      }
    }

    return events;
  }
}

module.exports = BiasProcessor;