@nice2dev/ui-3d 1.3.14 → 1.3.16

package/dist/esm/dance/DanceScoreEngine.js

@@ -1,227 +1,218 @@
-import { useRef, useState, useCallback } from 'react';
-
-/**
- * DanceScoreEngine — Compares detected poses against reference choreography
- *
- * Calculates real-time dance accuracy by comparing camera-detected Pose3DFrames
- * against a reference sequence (from choreography DSL or recorded poses).
- */
-// ── Default config ──────────────────────────────────────────────
+import { useRef, useState, useCallback } from "react";
 const DEFAULT_CONFIG = {
-    keypointWeights: {},
-    perfectThreshold: 0.05,
-    goodThreshold: 0.12,
-    okThreshold: 0.25,
-    timingWindowSec: 0.15,
-    minConfidence: 0.4,
+  keypointWeights: {},
+  perfectThreshold: 0.05,
+  goodThreshold: 0.12,
+  okThreshold: 0.25,
+  timingWindowSec: 0.15,
+  minConfidence: 0.4
 };
-// ── DanceScoreEngine ────────────────────────────────────────────
 class DanceScoreEngine {
-    constructor(config = {}) {
-        this.reference = [];
-        this.frameScores = [];
-        this.lastMatchedRef = -1;
-        this.combo = 0;
-        this.maxCombo = 0;
-        this.config = { ...DEFAULT_CONFIG, ...config };
-    }
-    /** Load a reference choreography sequence */
-    loadReference(sequence) {
-        this.reference = sequence.frames;
-        this.reset();
-    }
-    /** Load reference from raw frames */
-    loadReferenceFrames(frames) {
-        this.reference = frames;
-        this.reset();
-    }
-    /** Reset scoring state for a new session */
-    reset() {
-        this.frameScores = [];
-        this.lastMatchedRef = -1;
-        this.combo = 0;
-        this.maxCombo = 0;
-    }
-    /** Score a single detected frame against the reference */
-    scoreFrame(detected) {
-        const refIndex = this.findClosestRefFrame(detected.timestamp_sec);
-        const refFrame = this.reference[refIndex];
-        const detectedPerson = detected.persons[0];
-        const refPerson = refFrame === null || refFrame === void 0 ? void 0 : refFrame.persons[0];
-        if (!detectedPerson || !refPerson) {
-            const missFrame = {
-                frameIndex: detected.frame_index,
-                timestamp: detected.timestamp_sec,
-                overallScore: 0,
-                rating: 'miss',
-                keypointScores: [],
-                matchedRefIndex: refIndex,
-            };
-            this.recordMiss();
-            this.frameScores.push(missFrame);
-            return missFrame;
-        }
-        const keypointScores = this.compareKeypoints(detectedPerson, refPerson);
-        const totalWeight = keypointScores.reduce((s, k) => s + k.weight, 0);
-        const weightedScore = totalWeight > 0
-            ? keypointScores.reduce((s, k) => s + k.weight * (1 - Math.min(k.distance / this.config.okThreshold, 1)), 0) / totalWeight
-            : 0;
-        const rating = this.rateScore(weightedScore);
-        if (rating !== 'miss') {
-            this.combo++;
-            this.maxCombo = Math.max(this.maxCombo, this.combo);
-        }
-        else {
-            this.combo = 0;
-        }
-        const frameScore = {
-            frameIndex: detected.frame_index,
-            timestamp: detected.timestamp_sec,
-            overallScore: Math.round(weightedScore * 100),
-            rating,
-            keypointScores,
-            matchedRefIndex: refIndex,
-        };
-        this.frameScores.push(frameScore);
-        this.lastMatchedRef = refIndex;
-        return frameScore;
-    }
-    /** Get the final session result */
-    getResult() {
-        const counts = { perfect: 0, good: 0, ok: 0, miss: 0 };
-        let totalScore = 0;
-        for (const fs of this.frameScores) {
-            counts[fs.rating]++;
-            totalScore += fs.overallScore;
-        }
-        const maxScore = this.frameScores.length * 100;
-        const percentage = maxScore > 0 ? (totalScore / maxScore) * 100 : 0;
-        return {
-            totalScore,
-            maxScore,
-            percentage: Math.round(percentage * 10) / 10,
-            grade: this.percentageToGrade(percentage),
-            perfectCount: counts.perfect,
-            goodCount: counts.good,
-            okCount: counts.ok,
-            missCount: counts.miss,
-            frameScores: this.frameScores,
-            combo: this.combo,
-            maxCombo: this.maxCombo,
-        };
-    }
-    // ── Private ─────────────────────────────────────────────────────
-    findClosestRefFrame(timestamp) {
-        let best = 0;
-        let bestDist = Infinity;
-        const start = Math.max(0, this.lastMatchedRef);
-        for (let i = start; i < this.reference.length; i++) {
-            const dist = Math.abs(this.reference[i].timestamp_sec - timestamp);
-            if (dist < bestDist) {
-                bestDist = dist;
-                best = i;
-            }
-            if (this.reference[i].timestamp_sec > timestamp + this.config.timingWindowSec) {
-                break;
-            }
-        }
-        return best;
-    }
-    compareKeypoints(detected, reference) {
-        var _a, _b;
-        const scores = [];
-        const refMap = new Map(reference.keypoints.map((kp) => [kp.name, kp]));
-        for (const dkp of detected.keypoints) {
-            if (((_a = dkp.confidence) !== null && _a !== void 0 ? _a : 0) < this.config.minConfidence) {
-                continue;
-            }
-            const rkp = refMap.get(dkp.name);
-            if (!rkp) {
-                continue;
-            }
-            const distance = this.keypointDistance(dkp, rkp);
-            const weight = (_b = this.config.keypointWeights[dkp.name]) !== null && _b !== void 0 ? _b : 1;
-            const rating = this.rateDistance(distance);
-            scores.push({ name: dkp.name, distance, rating, weight });
-        }
-        return scores;
-    }
-    keypointDistance(a, b) {
-        const dx = a.x - b.x, dy = a.y - b.y, dz = a.z - b.z;
-        return Math.sqrt(dx * dx + dy * dy + dz * dz);
-    }
-    rateDistance(distance) {
-        if (distance <= this.config.perfectThreshold) {
-            return 'perfect';
-        }
-        if (distance <= this.config.goodThreshold) {
-            return 'good';
-        }
-        if (distance <= this.config.okThreshold) {
-            return 'ok';
-        }
-        return 'miss';
-    }
-    rateScore(normalizedScore) {
-        if (normalizedScore >= 0.9) {
-            return 'perfect';
-        }
-        if (normalizedScore >= 0.7) {
-            return 'good';
-        }
-        if (normalizedScore >= 0.4) {
-            return 'ok';
-        }
-        return 'miss';
-    }
-    recordMiss() {
-        this.combo = 0;
-    }
-    percentageToGrade(pct) {
-        if (pct >= 95) {
-            return 'S';
-        }
-        if (pct >= 85) {
-            return 'A';
-        }
-        if (pct >= 70) {
-            return 'B';
-        }
-        if (pct >= 55) {
-            return 'C';
-        }
-        if (pct >= 40) {
-            return 'D';
-        }
-        return 'F';
+  constructor(config = {}) {
+    this.reference = [];
+    this.frameScores = [];
+    this.lastMatchedRef = -1;
+    this.combo = 0;
+    this.maxCombo = 0;
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  /** Load a reference choreography sequence */
+  loadReference(sequence) {
+    this.reference = sequence.frames;
+    this.reset();
+  }
+  /** Load reference from raw frames */
+  loadReferenceFrames(frames) {
+    this.reference = frames;
+    this.reset();
+  }
+  /** Reset scoring state for a new session */
+  reset() {
+    this.frameScores = [];
+    this.lastMatchedRef = -1;
+    this.combo = 0;
+    this.maxCombo = 0;
+  }
+  /** Score a single detected frame against the reference */
+  scoreFrame(detected) {
+    const refIndex = this.findClosestRefFrame(detected.timestamp_sec);
+    const refFrame = this.reference[refIndex];
+    const detectedPerson = detected.persons[0];
+    const refPerson = refFrame?.persons[0];
+    if (!detectedPerson || !refPerson) {
+      const missFrame = {
+        frameIndex: detected.frame_index,
+        timestamp: detected.timestamp_sec,
+        overallScore: 0,
+        rating: "miss",
+        keypointScores: [],
+        matchedRefIndex: refIndex
+      };
+      this.recordMiss();
+      this.frameScores.push(missFrame);
+      return missFrame;
     }
+    const keypointScores = this.compareKeypoints(detectedPerson, refPerson);
+    const totalWeight = keypointScores.reduce((s, k) => s + k.weight, 0);
+    const weightedScore = totalWeight > 0 ? keypointScores.reduce(
+      (s, k) => s + k.weight * (1 - Math.min(k.distance / this.config.okThreshold, 1)),
+      0
+    ) / totalWeight : 0;
+    const rating = this.rateScore(weightedScore);
+    if (rating !== "miss") {
+      this.combo++;
+      this.maxCombo = Math.max(this.maxCombo, this.combo);
+    } else {
+      this.combo = 0;
+    }
+    const frameScore = {
+      frameIndex: detected.frame_index,
+      timestamp: detected.timestamp_sec,
+      overallScore: Math.round(weightedScore * 100),
+      rating,
+      keypointScores,
+      matchedRefIndex: refIndex
+    };
+    this.frameScores.push(frameScore);
+    this.lastMatchedRef = refIndex;
+    return frameScore;
+  }
+  /** Get the final session result */
+  getResult() {
+    const counts = { perfect: 0, good: 0, ok: 0, miss: 0 };
+    let totalScore = 0;
+    for (const fs of this.frameScores) {
+      counts[fs.rating]++;
+      totalScore += fs.overallScore;
+    }
+    const maxScore = this.frameScores.length * 100;
+    const percentage = maxScore > 0 ? totalScore / maxScore * 100 : 0;
+    return {
+      totalScore,
+      maxScore,
+      percentage: Math.round(percentage * 10) / 10,
+      grade: this.percentageToGrade(percentage),
+      perfectCount: counts.perfect,
+      goodCount: counts.good,
+      okCount: counts.ok,
+      missCount: counts.miss,
+      frameScores: this.frameScores,
+      combo: this.combo,
+      maxCombo: this.maxCombo
+    };
+  }
+  // ── Private ─────────────────────────────────────────────────────
+  findClosestRefFrame(timestamp) {
+    let best = 0;
+    let bestDist = Infinity;
+    const start = Math.max(0, this.lastMatchedRef);
+    for (let i = start; i < this.reference.length; i++) {
+      const dist = Math.abs(this.reference[i].timestamp_sec - timestamp);
+      if (dist < bestDist) {
+        bestDist = dist;
+        best = i;
+      }
+      if (this.reference[i].timestamp_sec > timestamp + this.config.timingWindowSec) {
+        break;
+      }
+    }
+    return best;
+  }
+  compareKeypoints(detected, reference) {
+    const scores = [];
+    const refMap = new Map(reference.keypoints.map((kp) => [kp.name, kp]));
+    for (const dkp of detected.keypoints) {
+      if ((dkp.confidence ?? 0) < this.config.minConfidence) {
+        continue;
+      }
+      const rkp = refMap.get(dkp.name);
+      if (!rkp) {
+        continue;
+      }
+      const distance = this.keypointDistance(dkp, rkp);
+      const weight = this.config.keypointWeights[dkp.name] ?? 1;
+      const rating = this.rateDistance(distance);
+      scores.push({ name: dkp.name, distance, rating, weight });
+    }
+    return scores;
+  }
+  keypointDistance(a, b) {
+    const dx = a.x - b.x, dy = a.y - b.y, dz = a.z - b.z;
+    return Math.sqrt(dx * dx + dy * dy + dz * dz);
+  }
+  rateDistance(distance) {
+    if (distance <= this.config.perfectThreshold) {
+      return "perfect";
+    }
+    if (distance <= this.config.goodThreshold) {
+      return "good";
+    }
+    if (distance <= this.config.okThreshold) {
+      return "ok";
+    }
+    return "miss";
+  }
+  rateScore(normalizedScore) {
+    if (normalizedScore >= 0.9) {
+      return "perfect";
+    }
+    if (normalizedScore >= 0.7) {
+      return "good";
+    }
+    if (normalizedScore >= 0.4) {
+      return "ok";
+    }
+    return "miss";
+  }
+  recordMiss() {
+    this.combo = 0;
+  }
+  percentageToGrade(pct) {
+    if (pct >= 95) {
+      return "S";
+    }
+    if (pct >= 85) {
+      return "A";
+    }
+    if (pct >= 70) {
+      return "B";
+    }
+    if (pct >= 55) {
+      return "C";
+    }
+    if (pct >= 40) {
+      return "D";
+    }
+    return "F";
+  }
 }
-// ── React hook ──────────────────────────────────────────────────
 function useDanceScore(config) {
-    const engineRef = useRef(new DanceScoreEngine(config));
-    const [lastScore, setLastScore] = useState(null);
-    const [result, setResult] = useState(null);
-    const loadReference = useCallback((seq) => {
-        engineRef.current.loadReference(seq);
-        setLastScore(null);
-        setResult(null);
-    }, []);
-    const scoreFrame = useCallback((frame) => {
-        const score = engineRef.current.scoreFrame(frame);
-        setLastScore(score);
-        return score;
-    }, []);
-    const finish = useCallback(() => {
-        const r = engineRef.current.getResult();
-        setResult(r);
-        return r;
-    }, []);
-    const reset = useCallback(() => {
-        engineRef.current.reset();
-        setLastScore(null);
-        setResult(null);
-    }, []);
-    return { loadReference, scoreFrame, finish, reset, lastScore, result };
+  const engineRef = useRef(new DanceScoreEngine(config));
+  const [lastScore, setLastScore] = useState(null);
+  const [result, setResult] = useState(null);
+  const loadReference = useCallback((seq) => {
+    engineRef.current.loadReference(seq);
+    setLastScore(null);
+    setResult(null);
+  }, []);
+  const scoreFrame = useCallback((frame) => {
+    const score = engineRef.current.scoreFrame(frame);
+    setLastScore(score);
+    return score;
+  }, []);
+  const finish = useCallback(() => {
+    const r = engineRef.current.getResult();
+    setResult(r);
+    return r;
+  }, []);
+  const reset = useCallback(() => {
+    engineRef.current.reset();
+    setLastScore(null);
+    setResult(null);
+  }, []);
+  return { loadReference, scoreFrame, finish, reset, lastScore, result };
 }
-
-export { DanceScoreEngine, useDanceScore };
+export {
+  DanceScoreEngine,
+  useDanceScore
+};