@reftrixmcp/mcp-server 0.1.7

package/dist/services/motion/visual-category-classifier.js

@@ -0,0 +1,1060 @@
+"use strict";
+// SPDX-FileCopyrightText: 2026 TKMD and Reftrix Contributors
+// SPDX-License-Identifier: AGPL-3.0-only
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VisualCategoryClassifier = void 0;
+/**
+ * Visual Category Classifier
+ *
+ * フレーム差分解析結果から視覚的な動きのカテゴリを分類するサービス
+ *
+ * カテゴリ:
+ * - fade: フェードイン/アウト（opacity変化が主、位置変化なし）
+ * - slide: スライド（一方向の移動が主、水平or垂直）
+ * - scale: スケール（サイズ変化が主、中心からの拡大/縮小）
+ * - rotate: 回転（回転変化が主）
+ * - parallax: パララックス（複数レイヤーの異なる速度移動）
+ * - reveal: 出現/消滅（要素の出現/消滅、クリッピング）
+ * - morph: モーフィング（形状の変形）
+ * - complex: 複合（複数カテゴリの組み合わせ）
+ * - static: 静的（変化なし）
+ * - unknown: 不明（分類不能）
+ *
+ * @module @reftrixmcp/mcp-server/services/motion/visual-category-classifier
+ */
+const logger_1 = require("../../utils/logger");
+// =============================================================================
+// 定数
+// =============================================================================
+const DEFAULT_CONFIG = {
+    fade_threshold: 0.1,
+    slide_consistency_threshold: 0.85,
+    scale_threshold: 0.15,
+    parallax_speed_diff_threshold: 0.3,
+    complex_category_threshold: 0.4,
+    min_confidence_threshold: 0.3,
+};
+// セキュリティ制限
+const MAX_FRAMES = 1000;
+// =============================================================================
+// ヘルパー関数
+// =============================================================================
+/**
+ * 角度を度からラジアンに変換
+ */
+function degToRad(degrees) {
+    return (degrees * Math.PI) / 180;
+}
+/**
+ * ラジアンから角度に変換
+ */
+function radToDeg(radians) {
+    return (radians * 180) / Math.PI;
+}
+/**
+ * 数値がNaNやInfinityでないことを確認
+ */
+function isValidNumber(value) {
+    return typeof value === "number" && !Number.isNaN(value) && Number.isFinite(value);
+}
+/**
+ * 数値を安全にクランプ
+ */
+function clamp(value, min, max) {
+    if (!isValidNumber(value))
+        return min;
+    return Math.max(min, Math.min(max, value));
+}
+/**
+ * 配列の平均を計算
+ */
+function average(values) {
+    if (values.length === 0)
+        return 0;
+    const sum = values.reduce((acc, v) => acc + (isValidNumber(v) ? v : 0), 0);
+    return sum / values.length;
+}
+/**
+ * 配列の分散を計算
+ */
+function variance(values) {
+    if (values.length <= 1)
+        return 0;
+    const avg = average(values);
+    const squareDiffs = values.map((v) => {
+        const val = isValidNumber(v) ? v : 0;
+        return Math.pow(val - avg, 2);
+    });
+    return average(squareDiffs);
+}
+/**
+ * dx, dy から角度（度）を計算
+ */
+function calculateAngle(dx, dy) {
+    if (!isValidNumber(dx) || !isValidNumber(dy))
+        return 0;
+    const radians = Math.atan2(dy, dx);
+    let degrees = radToDeg(radians);
+    if (degrees < 0)
+        degrees += 360;
+    return degrees;
+}
+// =============================================================================
+// Visual Category Classifier クラス
+// =============================================================================
+/**
+ * Visual Category Classifier
+ *
+ * フレーム差分解析結果から視覚的な動きのカテゴリを分類するクラス
+ */
+class VisualCategoryClassifier {
+    config;
+    constructor(config) {
+        this.config = {
+            ...DEFAULT_CONFIG,
+            ...config,
+        };
+        logger_1.logger.debug("[VisualCategoryClassifier] Initialized with config:", this.config);
+    }
+    /**
+     * フレーム分析結果から動きカテゴリを分類
+     */
+    classify(input) {
+        const startTime = performance.now();
+        // 入力検証
+        const frames = this.validateAndLimitFrames(input.frames);
+        // 空またはほぼ空のフレーム配列の場合は static を返す
+        if (frames.length === 0) {
+            return this.createStaticResult(startTime);
+        }
+        // 単一フレームの場合
+        if (frames.length === 1) {
+            return this.createStaticResult(startTime);
+        }
+        // メトリクスを計算
+        const metrics = this.calculateMetrics(frames);
+        // 各カテゴリのスコアを計算
+        const scores = this.calculateCategoryScores(frames, metrics);
+        // 最適なカテゴリを選択
+        const result = this.selectBestCategory(scores, metrics, frames, startTime);
+        logger_1.logger.debug("[VisualCategoryClassifier] Classification result:", {
+            category: result.primary_category,
+            confidence: result.confidence,
+            processing_time_ms: result.processing_time_ms,
+        });
+        return result;
+    }
+    /**
+     * フレーム配列を直接受け取って分類
+     */
+    classifyFrameSequence(frames) {
+        const input = {
+            frames,
+            summary: {
+                avgDiffPercentage: average(frames.map((f) => f.diffPercentage)),
+                maxDiffPercentage: Math.max(...frames.map((f) => f.diffPercentage), 0),
+                totalFrames: frames.length,
+            },
+        };
+        return this.classify(input);
+    }
+    // ===========================================================================
+    // プライベートメソッド
+    // ===========================================================================
+    /**
+     * フレーム配列を検証し、制限内に収める
+     */
+    validateAndLimitFrames(frames) {
+        if (!Array.isArray(frames)) {
+            return [];
+        }
+        // 最大フレーム数制限
+        const limitedFrames = frames.slice(0, MAX_FRAMES);
+        // 数値検証
+        return limitedFrames.map((frame) => ({
+            ...frame,
+            diffPercentage: isValidNumber(frame.diffPercentage) ? frame.diffPercentage : 0,
+            changedPixels: isValidNumber(frame.changedPixels) ? frame.changedPixels : 0,
+            totalPixels: isValidNumber(frame.totalPixels) ? Math.max(frame.totalPixels, 1) : 1,
+            motionVectors: (frame.motionVectors ?? []).filter((v) => isValidNumber(v.dx) && isValidNumber(v.dy) && isValidNumber(v.magnitude)),
+        }));
+    }
+    /**
+     * static結果を生成
+     */
+    createStaticResult(startTime) {
+        return {
+            primary_category: "static",
+            confidence: 0.95,
+            metrics: {
+                movement_intensity: 0,
+                affected_area_ratio: 0,
+            },
+            processing_time_ms: performance.now() - startTime,
+        };
+    }
+    /**
+     * メトリクスを計算
+     */
+    calculateMetrics(frames) {
+        // 影響領域比率を計算
+        const affected_area_ratio = this.calculateAffectedAreaRatio(frames);
+        // 移動強度を計算
+        const movement_intensity = this.calculateMovementIntensity(frames);
+        // 主要な方向を計算（モーションベクトルがある場合）
+        const dominant_direction = this.calculateDominantDirection(frames);
+        // 速度分散を計算
+        const velocity_variance = this.calculateVelocityVariance(frames);
+        // exactOptionalPropertyTypesに対応するため、undefinedのプロパティは省略
+        const metrics = {
+            movement_intensity,
+            affected_area_ratio,
+        };
+        if (dominant_direction !== undefined) {
+            metrics.dominant_direction = dominant_direction;
+        }
+        if (velocity_variance !== undefined) {
+            metrics.velocity_variance = velocity_variance;
+        }
+        return metrics;
+    }
+    /**
+     * 影響領域比率を計算
+     *
+     * 標準的なWeb画面サイズ（1000x1000 = 1,000,000ピクセル）を基準として
+     * 影響領域の比率を計算する。
+     */
+    calculateAffectedAreaRatio(frames) {
+        // 標準画面サイズ（1000x1000）
+        const STANDARD_AREA = 1000000;
+        const ratios = [];
+        for (const frame of frames) {
+            if (frame.boundingBox) {
+                const boxArea = frame.boundingBox.width * frame.boundingBox.height;
+                // 標準サイズに対する比率を計算
+                // 浮動小数点精度の問題を避けるため、小数点6桁で丸める
+                const ratio = Math.round((boxArea / STANDARD_AREA) * 1000000) / 1000000;
+                ratios.push(clamp(ratio, 0, 1));
+            }
+            else if (frame.diffPercentage > 0) {
+                // boundingBoxがない場合はdiffPercentageから推定
+                ratios.push(clamp(frame.diffPercentage, 0, 1));
+            }
+        }
+        if (ratios.length === 0)
+            return 0;
+        // 平均値も同様に丸める
+        const avg = average(ratios);
+        return Math.round(avg * 1000000) / 1000000;
+    }
+    /**
+     * 移動強度を計算
+     */
+    calculateMovementIntensity(frames) {
+        const magnitudes = [];
+        for (const frame of frames) {
+            if (frame.motionVectors && frame.motionVectors.length > 0) {
+                const avgMag = average(frame.motionVectors.map((v) => v.magnitude));
+                magnitudes.push(avgMag);
+            }
+        }
+        if (magnitudes.length === 0) {
+            // モーションベクトルがない場合はdiffPercentageから推定
+            const avgDiff = average(frames.map((f) => f.diffPercentage));
+            return clamp(avgDiff * 2, 0, 1);
+        }
+        // 正規化（最大速度30px/frameを基準）
+        const avgMag = average(magnitudes);
+        return clamp(avgMag / 30, 0, 1);
+    }
+    /**
+     * 主要な方向を計算
+     */
+    calculateDominantDirection(frames) {
+        const angles = [];
+        const weights = [];
+        for (const frame of frames) {
+            if (frame.motionVectors && frame.motionVectors.length > 0) {
+                for (const vector of frame.motionVectors) {
+                    if (vector.magnitude > 0.1) {
+                        const angle = calculateAngle(vector.dx, vector.dy);
+                        angles.push(angle);
+                        weights.push(vector.magnitude);
+                    }
+                }
+            }
+        }
+        if (angles.length === 0)
+            return undefined;
+        // 重み付き平均を計算（角度の循環性を考慮）
+        let sinSum = 0;
+        let cosSum = 0;
+        let totalWeight = 0;
+        for (let i = 0; i < angles.length; i++) {
+            const angle = angles[i];
+            const w = weights[i];
+            if (angle === undefined || w === undefined)
+                continue;
+            const rad = degToRad(angle);
+            sinSum += Math.sin(rad) * w;
+            cosSum += Math.cos(rad) * w;
+            totalWeight += w;
+        }
+        if (totalWeight === 0)
+            return undefined;
+        const avgRad = Math.atan2(sinSum / totalWeight, cosSum / totalWeight);
+        let avgDeg = radToDeg(avgRad);
+        if (avgDeg < 0)
+            avgDeg += 360;
+        return avgDeg;
+    }
+    /**
+     * 速度分散を計算
+     */
+    calculateVelocityVariance(frames) {
+        const speeds = [];
+        for (const frame of frames) {
+            if (frame.motionVectors && frame.motionVectors.length > 0) {
+                const avgSpeed = average(frame.motionVectors.map((v) => v.magnitude));
+                speeds.push(avgSpeed);
+            }
+        }
+        if (speeds.length <= 1)
+            return 0;
+        // 正規化された分散を計算
+        const v = variance(speeds);
+        const maxSpeed = Math.max(...speeds);
+        if (maxSpeed === 0)
+            return 0;
+        return clamp(v / (maxSpeed * maxSpeed), 0, 1);
+    }
+    /**
+     * 各カテゴリのスコアを計算
+     */
+    calculateCategoryScores(frames, metrics) {
+        const scores = new Map();
+        // static検出
+        scores.set("static", this.calculateStaticScore(frames));
+        // fade検出
+        scores.set("fade", this.calculateFadeScore(frames, metrics));
+        // slide検出
+        scores.set("slide", this.calculateSlideScore(frames, metrics));
+        // scale検出
+        scores.set("scale", this.calculateScaleScore(frames));
+        // parallax検出
+        scores.set("parallax", this.calculateParallaxScore(frames));
+        // complex検出（後で調整）
+        scores.set("complex", 0);
+        // rotate, reveal, morph は高度な検出が必要なため基本スコア0
+        scores.set("rotate", 0);
+        scores.set("reveal", 0);
+        scores.set("morph", 0);
+        return scores;
+    }
+    /**
+     * static スコアを計算
+     */
+    calculateStaticScore(frames) {
+        const avgDiff = average(frames.map((f) => f.diffPercentage));
+        // 変化がほとんどない場合は static
+        if (avgDiff < 0.01) {
+            return 0.95;
+        }
+        else if (avgDiff < 0.02) {
+            return 0.7;
+        }
+        else if (avgDiff < 0.03) {
+            return 0.4;
+        }
+        return 0;
+    }
+    /**
+     * fade スコアを計算
+     */
+    calculateFadeScore(frames, _metrics) {
+        // フェードの特徴:
+        // 1. モーションベクトルがないか、非常に小さい
+        // 2. diffPercentageが徐々に変化（単調増加/減少）
+        // 3. 変化率が閾値以上
+        // モーションベクトルのチェック（存在・強度）
+        let totalMotionMagnitude = 0;
+        let motionVectorCount = 0;
+        for (const frame of frames) {
+            if (frame.motionVectors) {
+                for (const v of frame.motionVectors) {
+                    totalMotionMagnitude += v.magnitude;
+                    motionVectorCount++;
+                }
+            }
+        }
+        const avgMotionMagnitude = motionVectorCount > 0 ? totalMotionMagnitude / motionVectorCount : 0;
+        // モーションベクトルがある場合はfade可能性を下げる
+        // ただし、複合パターン判定のためにペナルティを調整
+        let motionPenalty = 0;
+        if (avgMotionMagnitude > 8) {
+            motionPenalty = 0.4; // 非常に大きなモーションはfadeではない
+        }
+        else if (avgMotionMagnitude > 5) {
+            motionPenalty = 0.25; // 大きなモーション
+        }
+        else if (avgMotionMagnitude > 2) {
+            motionPenalty = 0.15; // 中程度のモーション
+        }
+        else if (motionVectorCount > 0 && avgMotionMagnitude > 0.5) {
+            motionPenalty = 0.1; // 小さなモーション
+        }
+        // diffPercentageの変化パターンをチェック
+        const diffs = frames.map((f) => f.diffPercentage);
+        const isMonotonic = this.isMonotonicSequence(diffs);
+        // 変化の幅を計算（フェードは最初と最後で大きな差がある）
+        const diffRange = Math.max(...diffs) - Math.min(...diffs);
+        const hasSignificantChange = diffRange > 0.1; // 10%以上の変化が必要
+        // scaleパターンとの区別: サイズ変化がある場合はfadeの可能性を下げる
+        const hasSizeChange = this.detectSizeChange(frames);
+        if (hasSizeChange) {
+            // サイズ変化がある場合、diffPercentageの変化はスケールの結果である可能性が高い
+            return 0.25;
+        }
+        // 平均変化率を計算
+        const avgDiff = average(diffs);
+        // 閾値との比率によってスコアを微調整
+        const thresholdRatio = avgDiff / this.config.fade_threshold;
+        // 基本スコア
+        let baseScore = 0.3;
+        // フェードには変化の幅が必要（一定値ならフェードではない）
+        if (!hasSignificantChange) {
+            return 0.2;
+        }
+        // fade_thresholdは平均変化率の閾値として使用
+        // avgDiff < threshold の場合、fadeスコアを大幅に下げる
+        if (thresholdRatio < 0.5) {
+            // 閾値の半分未満: フェードの可能性が非常に低い
+            return 0.25;
+        }
+        if (isMonotonic && thresholdRatio > 1.0) {
+            // 単調変化かつ閾値以上：典型的なフェード
+            baseScore = 0.9;
+        }
+        else if (isMonotonic && thresholdRatio > 0.5) {
+            // 単調変化だが閾値の50%以上：弱いフェード
+            baseScore = 0.6 + thresholdRatio * 0.2;
+        }
+        else if (thresholdRatio > 1.5) {
+            // 閾値の1.5倍以上の変化率（単調でない場合）
+            baseScore = 0.7;
+        }
+        else if (thresholdRatio > 1.0) {
+            // 閾値以上だが単調ではない
+            baseScore = 0.55;
+        }
+        else {
+            // 閾値未満
+            baseScore = 0.35;
+        }
+        return clamp(baseScore - motionPenalty, 0, 1);
+    }
+    /**
+     * slide スコアを計算
+     */
+    calculateSlideScore(frames, _metrics) {
+        // スライドの特徴:
+        // 1. 一貫した方向のモーションベクトル
+        // 2. boundingBoxが一方向に移動
+        const hasVectors = frames.some((f) => f.motionVectors && f.motionVectors.length > 0);
+        if (!hasVectors) {
+            // boundingBoxの移動をチェック
+            return this.calculateSlideScoreFromBoundingBox(frames);
+        }
+        // モーションベクトルの一貫性をチェック
+        const consistency = this.calculateDirectionConsistency(frames);
+        if (consistency > this.config.slide_consistency_threshold) {
+            return 0.9;
+        }
+        else if (consistency > 0.7) {
+            return 0.75;
+        }
+        else if (consistency > 0.5) {
+            return 0.5;
+        }
+        return 0.2;
+    }
+    /**
+     * boundingBoxからスライドスコアを計算
+     */
+    calculateSlideScoreFromBoundingBox(frames) {
+        const positions = [];
+        for (const frame of frames) {
+            if (frame.boundingBox) {
+                positions.push({
+                    x: frame.boundingBox.x + frame.boundingBox.width / 2,
+                    y: frame.boundingBox.y + frame.boundingBox.height / 2,
+                });
+            }
+        }
+        if (positions.length < 2)
+            return 0;
+        // 位置の変化を計算
+        const deltas = [];
+        for (let i = 1; i < positions.length; i++) {
+            const current = positions[i];
+            const prev = positions[i - 1];
+            if (!current || !prev)
+                continue;
+            deltas.push({
+                dx: current.x - prev.x,
+                dy: current.y - prev.y,
+            });
+        }
+        // 移動距離の合計を計算
+        const totalDistance = deltas.reduce((sum, d) => sum + Math.sqrt(d.dx * d.dx + d.dy * d.dy), 0);
+        // 移動がほとんどない場合はスライドではない
+        if (totalDistance < 5) {
+            return 0.1;
+        }
+        // 方向の一貫性をチェック
+        const angles = deltas.map((d) => calculateAngle(d.dx, d.dy));
+        const angleVariance = variance(angles);
+        // 角度の分散が小さければスライドの可能性が高い
+        if (angleVariance < 100) {
+            return 0.8;
+        }
+        else if (angleVariance < 500) {
+            return 0.5;
+        }
+        return 0.2;
+    }
+    /**
+     * 方向の一貫性を計算
+     */
+    calculateDirectionConsistency(frames) {
+        const angles = [];
+        for (const frame of frames) {
+            if (frame.motionVectors && frame.motionVectors.length > 0) {
+                // 最も大きいベクトルの角度を使用
+                const mainVector = frame.motionVectors.reduce((max, v) => v.magnitude > max.magnitude ? v : max);
+                if (mainVector.magnitude > 0.1) {
+                    angles.push(calculateAngle(mainVector.dx, mainVector.dy));
+                }
+            }
+        }
+        if (angles.length < 2)
+            return 0;
+        // 角度の標準偏差を計算（循環性を考慮）
+        const sinSum = angles.reduce((sum, a) => sum + Math.sin(degToRad(a)), 0);
+        const cosSum = angles.reduce((sum, a) => sum + Math.cos(degToRad(a)), 0);
+        const meanSin = sinSum / angles.length;
+        const meanCos = cosSum / angles.length;
+        const r = Math.sqrt(meanSin * meanSin + meanCos * meanCos);
+        return r; // r=1 で完全に一貫、r=0 でランダム
+    }
+    /**
+     * scale スコアを計算
+     */
+    calculateScaleScore(frames) {
+        // スケールの特徴:
+        // 1. boundingBoxのサイズが一貫して変化
+        // 2. 中心位置は大きく変わらない
+        // 3. モーションベクトルが放射状パターン
+        const sizes = [];
+        const centers = [];
+        for (const frame of frames) {
+            if (frame.boundingBox) {
+                const size = frame.boundingBox.width * frame.boundingBox.height;
+                sizes.push(size);
+                centers.push({
+                    x: frame.boundingBox.x + frame.boundingBox.width / 2,
+                    y: frame.boundingBox.y + frame.boundingBox.height / 2,
+                });
+            }
+        }
+        if (sizes.length < 2)
+            return 0;
+        // サイズ変化率を計算
+        const firstSize = sizes[0] ?? 1;
+        const lastSize = sizes[sizes.length - 1] ?? 1;
+        const sizeRatio = lastSize / firstSize;
+        // サイズ変化がほぼない場合はscaleではない
+        if (sizeRatio > 0.95 && sizeRatio < 1.05) {
+            return 0.1;
+        }
+        // サイズの変化を確認（単調増加/減少）
+        const isMonotonic = this.isMonotonicSequence(sizes);
+        if (!isMonotonic) {
+            return 0.2;
+        }
+        // サイズ変化が顕著かチェック（1.5倍以上または0.67倍以下）
+        const significantSizeChange = sizeRatio > 1.5 || sizeRatio < 0.67;
+        // 中心位置の変化を確認
+        const centerVarianceX = variance(centers.map((c) => c.x));
+        const centerVarianceY = variance(centers.map((c) => c.y));
+        const centerStable = centerVarianceX < 100 && centerVarianceY < 100;
+        // アスペクト比変更の場合、一方向のみ変化することを許容
+        const centerSemiStable = (centerVarianceX < 500 && centerVarianceY < 100) ||
+            (centerVarianceX < 100 && centerVarianceY < 500);
+        // 放射状モーションベクトルをチェック
+        const hasRadialMotion = this.hasRadialMotionPattern(frames);
+        if (significantSizeChange && centerStable) {
+            return 0.92; // 高いスコア
+        }
+        // アスペクト比変更の場合（一方向のみ中心移動）
+        if (significantSizeChange && centerSemiStable) {
+            return 0.88;
+        }
+        if (hasRadialMotion && centerStable) {
+            return 0.85;
+        }
+        // サイズ変化がある程度あるがcenterStable
+        if (centerStable && (sizeRatio > 1.1 || sizeRatio < 0.9)) {
+            return 0.75;
+        }
+        // サイズ変化が非常に大きい場合（4倍以上または0.25倍以下）は確実にスケール
+        // slideの最大スコア0.9より高くする
+        if (sizeRatio > 4 || sizeRatio < 0.25) {
+            return 0.95;
+        }
+        // サイズ変化が大きい場合（2.5倍以上または0.4倍以下）は中心移動があってもscaleの可能性
+        if (sizeRatio > 2.5 || sizeRatio < 0.4) {
+            return 0.85;
+        }
+        return 0.4;
+    }
+    /**
+     * 放射状のモーションパターンをチェック
+     */
+    hasRadialMotionPattern(frames) {
+        for (const frame of frames) {
+            if (frame.motionVectors && frame.motionVectors.length >= 2) {
+                // 複数のベクトルの角度を取得
+                const angles = frame.motionVectors
+                    .filter((v) => v.magnitude > 0.1)
+                    .map((v) => calculateAngle(v.dx, v.dy));
+                if (angles.length >= 2) {
+                    // 角度が異なる方向を向いている（放射状）かチェック
+                    const angleSet = new Set(angles.map((a) => Math.round(a / 45) * 45));
+                    if (angleSet.size >= 2) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * parallax スコアを計算
+     */
+    calculateParallaxScore(frames) {
+        // パララックスの特徴:
+        // 1. 複数のモーションベクトルが異なる速度を持つ
+        // 2. 同じ方向だが異なるmagnitude
+        // 3. 複数フレームで一貫してこのパターンが見られる
+        let parallaxFrameCount = 0;
+        let sameDirectionCount = 0;
+        for (const frame of frames) {
+            if (frame.motionVectors && frame.motionVectors.length >= 2) {
+                const validVectors = frame.motionVectors.filter((v) => v.magnitude > 0.5);
+                if (validVectors.length < 2)
+                    continue;
+                const magnitudes = validVectors.map((v) => v.magnitude).sort((a, b) => a - b);
+                const angles = validVectors.map((v) => calculateAngle(v.dx, v.dy));
+                // 速度差を確認
+                const minMag = magnitudes[0] ?? 0;
+                const maxMag = magnitudes[magnitudes.length - 1] ?? 0;
+                if (maxMag > 0 && minMag > 0) {
+                    const ratio = minMag / maxMag;
+                    if (ratio < 0.7 && ratio > 0.1) {
+                        parallaxFrameCount++;
+                        // 方向の一貫性をチェック
+                        const avgAngle = average(angles);
+                        const angleDeviation = angles.map((a) => Math.abs(a - avgAngle)).reduce((a, b) => a + b, 0) / angles.length;
+                        if (angleDeviation < 30) {
+                            sameDirectionCount++;
+                        }
+                    }
+                }
+            }
+        }
+        // 複数フレームでパララックスパターンが検出されたら高スコア
+        if (parallaxFrameCount >= frames.length * 0.5 && sameDirectionCount >= frames.length * 0.3) {
+            return 0.92;
+        }
+        if (parallaxFrameCount >= frames.length * 0.3) {
+            return 0.85;
+        }
+        if (parallaxFrameCount > 0) {
+            return 0.6;
+        }
+        return 0.1;
+    }
+    /**
+     * 単調増加/減少シーケンスかチェック
+     */
+    isMonotonicSequence(values) {
+        if (values.length < 2)
+            return true;
+        let increasing = true;
+        let decreasing = true;
+        for (let i = 1; i < values.length; i++) {
+            const current = values[i];
+            const prev = values[i - 1];
+            if (current === undefined || prev === undefined)
+                continue;
+            if (current < prev - 0.001) {
+                increasing = false;
+            }
+            if (current > prev + 0.001) {
+                decreasing = false;
+            }
+        }
+        return increasing || decreasing;
+    }
+    /**
+     * サイズ変化を検出（scaleパターンの特徴）
+     */
+    detectSizeChange(frames) {
+        const sizes = [];
+        const centers = [];
+        for (const frame of frames) {
+            if (frame.boundingBox) {
+                const size = frame.boundingBox.width * frame.boundingBox.height;
+                sizes.push(size);
+                centers.push({
+                    x: frame.boundingBox.x + frame.boundingBox.width / 2,
+                    y: frame.boundingBox.y + frame.boundingBox.height / 2,
+                });
+            }
+        }
+        if (sizes.length < 2)
+            return false;
+        // サイズ変化率を計算
+        const firstSize = sizes[0] ?? 1;
+        const lastSize = sizes[sizes.length - 1] ?? 1;
+        const sizeRatio = lastSize / firstSize;
+        // 中心位置の安定性をチェック（アスペクト比変更時も許容）
+        const centerVarianceX = variance(centers.map((c) => c.x));
+        const centerVarianceY = variance(centers.map((c) => c.y));
+        // 中心変動が大きい場合でも、サイズ変化が顕著なら許容
+        const centerStable = centerVarianceX < 500 && centerVarianceY < 500;
+        // サイズが1.3倍以上または0.77倍以下で、中心がある程度安定している場合はscaleの特徴
+        const significantSizeChange = sizeRatio > 1.3 || sizeRatio < 0.77;
+        return significantSizeChange && centerStable;
+    }
+    /**
+     * 最適なカテゴリを選択
+     */
+    selectBestCategory(scores, metrics, frames, startTime) {
+        // スコアをソート
+        const sortedScores = Array.from(scores.entries()).sort((a, b) => b[1] - a[1]);
+        const first = sortedScores[0] ?? ["unknown", 0];
+        const [bestCategory, bestScore] = first;
+        const second = sortedScores.length > 1
+            ? (sortedScores[1] ?? ["unknown", 0])
+            : ["unknown", 0];
+        const [secondCategory, secondScore] = second;
+        // 有効なカテゴリの数をカウント（static, unknown以外で閾値を超えているもの）
+        const significantScores = sortedScores.filter(([cat, score]) => score > this.config.complex_category_threshold && cat !== "static" && cat !== "unknown");
+        // 複合カテゴリの判定
+        // fade + slide の特別なケースをチェック
+        const fadeScore = scores.get("fade") ?? 0;
+        const slideScore = scores.get("slide") ?? 0;
+        // fade + slide の複合パターンの条件:
+        // - fadeとslide両方が0.5以上
+        // - diffPercentageが単調変化している（fade特性）
+        // - モーションベクトルが一貫している（slide特性）
+        const diffs = frames.map((f) => f.diffPercentage);
+        const isMonotonicDiff = this.isMonotonicSequence(diffs);
+        // scaleスコアが非常に高い場合はfade+slideの複合とは判定しない
+        const scaleScore = scores.get("scale") ?? 0;
+        const isFadeSlideComplex = fadeScore >= 0.5 &&
+            slideScore >= 0.5 &&
+            isMonotonicDiff &&
+            fadeScore + slideScore > 1.3 &&
+            scaleScore < 0.9; // scaleが明確に高い場合は除外
+        // 一般的な複合パターンの条件:
+        // - 2つ以上の有効なカテゴリがあり、両方が0.6以上
+        // - スコア差が0.15未満（非常に競合）
+        // - 最高スコアが0.9未満（0.9以上なら明確な勝者がいる）
+        const isGeneralComplex = significantScores.length >= 2 &&
+            secondScore >= 0.6 &&
+            bestScore - secondScore < 0.15 &&
+            bestScore < 0.9 &&
+            bestCategory !== "static" &&
+            secondCategory !== "static";
+        const isComplex = isFadeSlideComplex || isGeneralComplex;
+        if (isComplex) {
+            return this.createComplexResult(sortedScores, metrics, frames, startTime);
+        }
+        // ノイズ/不一貫性によるペナルティを計算
+        const noisePenalty = this.calculateNoisePenalty(frames);
+        const adjustedConfidence = clamp(bestScore - noisePenalty, 0, 1);
+        // 調整後の信頼度が閾値未満の場合は unknown
+        if (adjustedConfidence < this.config.min_confidence_threshold) {
+            return {
+                primary_category: "unknown",
+                confidence: adjustedConfidence,
+                metrics,
+                processing_time_ms: performance.now() - startTime,
+            };
+        }
+        // 詳細を生成
+        const details = this.generateDetails(bestCategory, frames, metrics);
+        const result = {
+            primary_category: bestCategory,
+            confidence: adjustedConfidence,
+            metrics,
+            processing_time_ms: performance.now() - startTime,
+        };
+        if (details) {
+            result.details = details;
+        }
+        return result;
+    }
+    /**
+     * ノイズ/不一貫性によるペナルティを計算
+     */
+    calculateNoisePenalty(frames) {
+        // モーションベクトルの方向の分散をチェック
+        const angles = [];
+        for (const frame of frames) {
+            if (frame.motionVectors) {
+                for (const v of frame.motionVectors) {
+                    if (v.magnitude > 0.5) {
+                        angles.push(calculateAngle(v.dx, v.dy));
+                    }
+                }
+            }
+        }
+        if (angles.length < 3)
+            return 0;
+        // 角度の循環分散を計算
+        const sinSum = angles.reduce((sum, a) => sum + Math.sin(degToRad(a)), 0);
+        const cosSum = angles.reduce((sum, a) => sum + Math.cos(degToRad(a)), 0);
+        const r = Math.sqrt(Math.pow(sinSum / angles.length, 2) + Math.pow(cosSum / angles.length, 2));
+        // r=1 で完全に一貫、r=0 でランダム
+        // 一貫性が低い（r < 0.5）場合にペナルティを適用
+        if (r < 0.3) {
+            return 0.5; // 大きなペナルティ（ランダムノイズに近い）
+        }
+        else if (r < 0.5) {
+            return 0.3; // 中程度のペナルティ
+        }
+        else if (r < 0.7) {
+            return 0.1; // 小さなペナルティ
+        }
+        return 0;
+    }
+    /**
+     * complex結果を生成
+     */
+    createComplexResult(sortedScores, metrics, _frames, startTime) {
+        const significantCategories = sortedScores.filter(([cat, score]) => score > this.config.complex_category_threshold && cat !== "static" && cat !== "unknown");
+        // 重みを正規化
+        const totalWeight = significantCategories.reduce((sum, [, score]) => sum + score, 0);
+        const secondary_categories = significantCategories.map(([category, score]) => ({
+            category,
+            weight: totalWeight > 0 ? score / totalWeight : 0,
+        }));
+        // 平均信頼度
+        const avgConfidence = average(significantCategories.map(([, score]) => score));
+        return {
+            primary_category: "complex",
+            confidence: clamp(avgConfidence, 0, 1),
+            secondary_categories,
+            metrics,
+            processing_time_ms: performance.now() - startTime,
+        };
+    }
+    /**
+     * カテゴリ詳細を生成
+     */
+    generateDetails(category, frames, metrics) {
+        switch (category) {
+            case "fade":
+                return this.generateFadeDetails(frames);
+            case "slide":
+                return this.generateSlideDetails(frames, metrics);
+            case "scale":
+                return this.generateScaleDetails(frames);
+            case "parallax":
+                return this.generateParallaxDetails(frames);
+            default:
+                return undefined;
+        }
+    }
+    /**
+     * フェード詳細を生成
+     */
+    generateFadeDetails(frames) {
+        const diffs = frames.map((f) => f.diffPercentage);
+        const firstDiff = diffs[0] || 0;
+        const lastDiff = diffs[diffs.length - 1] || 0;
+        // フェードイン: 変化が減少（最初が大きい）
+        // フェードアウト: 変化が増加（最後が大きい）
+        const type = firstDiff > lastDiff ? "in" : "out";
+        // opacity推定（diffPercentageから）
+        const start_opacity = type === "in" ? 0 : 1;
+        const end_opacity = type === "in" ? 1 : 0;
+        return {
+            fade: {
+                type,
+                start_opacity,
+                end_opacity,
+                duration_frames: frames.length,
+            },
+        };
+    }
+    /**
+     * スライド詳細を生成
+     */
+    generateSlideDetails(frames, metrics) {
+        // 方向を判定
+        let angle = metrics.dominant_direction ?? 0;
+        let direction;
+        // 角度から方向を決定
+        const normalizedAngle = angle % 360;
+        if ((normalizedAngle >= 0 && normalizedAngle < 22.5) ||
+            (normalizedAngle >= 337.5 && normalizedAngle < 360) ||
+            (normalizedAngle >= 157.5 && normalizedAngle < 202.5)) {
+            direction = "horizontal";
+            // 正確な角度を設定
+            angle = normalizedAngle < 90 || normalizedAngle > 270 ? 0 : 180;
+        }
+        else if ((normalizedAngle >= 67.5 && normalizedAngle < 112.5) ||
+            (normalizedAngle >= 247.5 && normalizedAngle < 292.5)) {
+            direction = "vertical";
+            // 正確な角度を設定
+            angle = normalizedAngle < 180 ? 90 : 270;
+        }
+        else {
+            direction = "diagonal";
+        }
+        // 移動距離を計算
+        const distance = this.calculateTotalDistance(frames);
+        return {
+            slide: {
+                direction,
+                distance_px: distance,
+                angle_degrees: Math.round(angle),
+            },
+        };
+    }
+    /**
+     * 総移動距離を計算
+     */
+    calculateTotalDistance(frames) {
+        let totalDistance = 0;
+        // モーションベクトルから計算
+        for (const frame of frames) {
+            if (frame.motionVectors && frame.motionVectors.length > 0) {
+                const mainVector = frame.motionVectors.reduce((max, v) => v.magnitude > max.magnitude ? v : max);
+                totalDistance += mainVector.magnitude;
+            }
+        }
+        if (totalDistance > 0) {
+            return Math.round(totalDistance);
+        }
+        // boundingBoxから計算
+        const positions = [];
+        for (const frame of frames) {
+            if (frame.boundingBox) {
+                positions.push({
+                    x: frame.boundingBox.x,
+                    y: frame.boundingBox.y,
+                });
+            }
+        }
+        if (positions.length >= 2) {
+            const first = positions[0];
+            const last = positions[positions.length - 1];
+            if (first !== undefined && last !== undefined) {
+                return Math.round(Math.sqrt(Math.pow(last.x - first.x, 2) + Math.pow(last.y - first.y, 2)));
+            }
+        }
+        return 0;
+    }
+    /**
+     * スケール詳細を生成
+     */
+    generateScaleDetails(frames) {
+        const sizes = [];
+        for (const frame of frames) {
+            if (frame.boundingBox) {
+                sizes.push({
+                    width: frame.boundingBox.width,
+                    height: frame.boundingBox.height,
+                });
+            }
+        }
+        if (sizes.length < 2) {
+            return {
+                scale: {
+                    type: "expand",
+                    start_scale: 1,
+                    end_scale: 1,
+                    aspect_ratio_maintained: true,
+                },
+            };
+        }
+        const firstSize = sizes[0];
+        const lastSize = sizes[sizes.length - 1];
+        // Early return if sizes are undefined (TypeScript safety)
+        if (firstSize === undefined || lastSize === undefined) {
+            return {
+                scale: {
+                    type: "expand",
+                    start_scale: 1,
+                    end_scale: 1,
+                    aspect_ratio_maintained: true,
+                },
+            };
+        }
+        const firstArea = firstSize.width * firstSize.height;
+        const lastArea = lastSize.width * lastSize.height;
+        const type = lastArea > firstArea ? "expand" : "shrink";
+        // 基準を100として、スケール比率を計算
+        const startScale = 1;
+        const endScale = lastArea > 0 ? Math.sqrt(lastArea / firstArea) : 1;
+        // アスペクト比の維持をチェック
+        const firstRatio = firstSize.width / firstSize.height;
+        const lastRatio = lastSize.width / lastSize.height;
+        const aspect_ratio_maintained = Math.abs(firstRatio - lastRatio) < 0.1;
+        return {
+            scale: {
+                type,
+                start_scale: startScale,
+                end_scale: endScale,
+                aspect_ratio_maintained,
+            },
+        };
+    }
+    /**
+     * パララックス詳細を生成
+     */
+    generateParallaxDetails(frames) {
+        const layerSpeeds = [];
+        for (const frame of frames) {
+            if (frame.motionVectors && frame.motionVectors.length >= 2) {
+                for (const vector of frame.motionVectors) {
+                    if (!layerSpeeds.includes(vector.magnitude)) {
+                        layerSpeeds.push(vector.magnitude);
+                    }
+                }
+            }
+        }
+        // 重複を除去してソート
+        const uniqueSpeeds = [...new Set(layerSpeeds)].sort((a, b) => a - b);
+        const maxSpeed = Math.max(...uniqueSpeeds, 1);
+        const speed_ratios = uniqueSpeeds.map((s) => s / maxSpeed);
+        const layer_count = speed_ratios.length;
+        const depth_order = Array.from({ length: layer_count }, (_, i) => i);
+        return {
+            parallax: {
+                layer_count,
+                speed_ratios,
+                depth_order,
+            },
+        };
+    }
+}
+exports.VisualCategoryClassifier = VisualCategoryClassifier;
+exports.default = VisualCategoryClassifier;
+//# sourceMappingURL=visual-category-classifier.js.map