@reftrixmcp/mcp-server 0.1.8 → 0.2.0

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

@@ -1,1060 +0,0 @@
-"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