✨ 動画フレーム結合のコアモジュール実装

- VideoProcessorクラス: SSIM技術による高精度フレーム類似度計算
- FrameBridgeクラス: 2つの動画の最適接続点検出と結合機能
- BatchProcessorクラス: 複数動画の順次結合・ペア結合処理
- 設定管理とパッケージ初期化ファイルを追加

src/frame_bridge/__init__.py

@@ -0,0 +1,20 @@
+"""
+Frame Bridge - AI-powered video frame bridging application
+2つの動画を最適なフレームで自動結合するAIアプリケーション
+"""
+
+__version__ = "1.0.0"
+__author__ = "Sunwood AI Labs"
+__email__ = "[email protected]"
+
+from .video_processor import VideoProcessor, FrameBridge
+from .batch_processor import BatchProcessor
+
+__all__ = [
+    "VideoProcessor",
+    "FrameBridge", 
+    "BatchProcessor",
+    "__version__",
+    "__author__",
+    "__email__"
+]

src/frame_bridge/batch_processor.py

@@ -0,0 +1,311 @@
+"""
+Frame Bridge - Batch Processing Module
+フォルダ内の動画ファイルを順次結合するバッチ処理モジュール
+"""
+
+import os
+import glob
+import logging
+from pathlib import Path
+from typing import List, Tuple, Optional
+from .video_processor import FrameBridge
+
+# ログ設定
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class BatchProcessor:
+    """バッチ処理を行うクラス"""
+    
+    def __init__(self, output_dir: str = "output", exclude_edge_frames: bool = True):
+        """
+        初期化
+        
+        Args:
+            output_dir: 出力ディレクトリ
+            exclude_edge_frames: 最初と最後のフレームを除外するかどうか
+        """
+        self.frame_bridge = FrameBridge(exclude_edge_frames=exclude_edge_frames)
+        self.output_dir = Path(output_dir)
+        self.output_dir.mkdir(exist_ok=True)
+        self.exclude_edge_frames = exclude_edge_frames
+        
+        # サポートする動画形式
+        self.supported_formats = ['.mp4', '.avi', '.mov', '.mkv', '.wmv', '.flv', '.webm']
+    
+    def get_video_files(self, input_dir: str) -> List[str]:
+        """
+        指定ディレクトリから動画ファイルを取得し、名前順にソート
+        
+        Args:
+            input_dir: 入力ディレクトリ
+            
+        Returns:
+            ソートされた動画ファイルのリスト
+        """
+        input_path = Path(input_dir)
+        if not input_path.exists():
+            logger.error(f"入力ディレクトリが存在しません: {input_dir}")
+            return []
+        
+        video_files = []
+        for ext in self.supported_formats:
+            pattern = str(input_path / f"*{ext}")
+            video_files.extend(glob.glob(pattern))
+        
+        # ファイル名でソート（自然順序）
+        video_files.sort(key=lambda x: os.path.basename(x).lower())
+        
+        logger.info(f"検出された動画ファイル数: {len(video_files)}")
+        for i, file in enumerate(video_files):
+            logger.info(f"  {i+1}. {os.path.basename(file)}")
+        
+        return video_files
+    
+    def process_sequential_merge(self, input_dir: str, output_filename: str = "merged_sequence.mp4") -> Tuple[bool, str, List[dict]]:
+        """
+        フォルダ内の動画を順次結合
+        
+        Args:
+            input_dir: 入力ディレクトリ
+            output_filename: 出力ファイル名
+            
+        Returns:
+            Tuple[成功フラグ, 最終出力パス, 処理結果リスト]
+        """
+        video_files = self.get_video_files(input_dir)
+        
+        if len(video_files) < 2:
+            return False, "", [{"error": "結合には最低2つの動画ファイルが必要です"}]
+        
+        results = []
+        current_video = video_files[0]
+        
+        logger.info(f"順次結合処理開始: {len(video_files)}個のファイル")
+        
+        for i in range(1, len(video_files)):
+            next_video = video_files[i]
+            
+            logger.info(f"結合 {i}/{len(video_files)-1}: {os.path.basename(current_video)} + {os.path.basename(next_video)}")
+            
+            # 中間出力ファイル名
+            if i == len(video_files) - 1:
+                # 最後の結合は最終ファイル名
+                temp_output = self.output_dir / output_filename
+            else:
+                # 中間ファイル
+                temp_output = self.output_dir / f"temp_merge_{i}.mp4"
+            
+            # 結合処理
+            result_text, output_path, frame1_path, frame2_path, similarity = self.frame_bridge.process_video_bridge(
+                current_video, next_video
+            )
+            
+            if output_path and os.path.exists(output_path):
+                # 結果を指定の場所に移動
+                import shutil
+                shutil.move(output_path, str(temp_output))
+                
+                result_info = {
+                    "step": i,
+                    "video1": os.path.basename(current_video),
+                    "video2": os.path.basename(next_video),
+                    "similarity": similarity,
+                    "output": str(temp_output),
+                    "success": True
+                }
+                
+                # 次のループでは結合結果を使用
+                current_video = str(temp_output)
+                
+                logger.info(f"結合完了 {i}/{len(video_files)-1}: 類似度 {similarity:.3f}")
+            else:
+                result_info = {
+                    "step": i,
+                    "video1": os.path.basename(current_video),
+                    "video2": os.path.basename(next_video),
+                    "error": result_text,
+                    "success": False
+                }
+                logger.error(f"結合失敗 {i}/{len(video_files)-1}: {result_text}")
+            
+            results.append(result_info)
+            
+            # 中間ファイルのクリーンアップ（最後以外）
+            if i > 1 and i < len(video_files) - 1:
+                prev_temp = self.output_dir / f"temp_merge_{i-1}.mp4"
+                if prev_temp.exists():
+                    prev_temp.unlink()
+        
+        final_output = self.output_dir / output_filename
+        success = final_output.exists()
+        
+        if success:
+            logger.info(f"全結合処理完了: {final_output}")
+            logger.info(f"最終ファイルサイズ: {final_output.stat().st_size / (1024*1024):.1f} MB")
+        
+        return success, str(final_output), results
+    
+    def process_pairwise_merge(self, input_dir: str) -> Tuple[bool, List[str], List[dict]]:
+        """
+        フォルダ内の動画をペアワイズで結合
+        
+        Args:
+            input_dir: 入力ディレクトリ
+            
+        Returns:
+            Tuple[成功フラグ, 出力ファイルリスト, 処理結果リスト]
+        """
+        video_files = self.get_video_files(input_dir)
+        
+        if len(video_files) < 2:
+            return False, [], [{"error": "結合には最低2つの動画ファイルが必要です"}]
+        
+        results = []
+        output_files = []
+        
+        logger.info(f"ペアワイズ結合処理開始: {len(video_files)}個のファイル")
+        
+        # ペアごとに処理
+        for i in range(0, len(video_files) - 1, 2):
+            video1 = video_files[i]
+            video2 = video_files[i + 1] if i + 1 < len(video_files) else None
+            
+            if video2 is None:
+                # 奇数個の場合、最後のファイルはそのままコピー
+                import shutil
+                output_name = f"single_{os.path.basename(video1)}"
+                output_path = self.output_dir / output_name
+                shutil.copy2(video1, output_path)
+                output_files.append(str(output_path))
+                
+                results.append({
+                    "pair": i // 2 + 1,
+                    "video1": os.path.basename(video1),
+                    "video2": None,
+                    "action": "copied",
+                    "output": str(output_path),
+                    "success": True
+                })
+                continue
+            
+            logger.info(f"ペア {i//2 + 1}: {os.path.basename(video1)} + {os.path.basename(video2)}")
+            
+            # 出力ファイル名
+            output_name = f"merged_pair_{i//2 + 1}_{os.path.basename(video1).split('.')[0]}_{os.path.basename(video2).split('.')[0]}.mp4"
+            output_path = self.output_dir / output_name
+            
+            # 結合処理
+            result_text, temp_output, frame1_path, frame2_path, similarity = self.frame_bridge.process_video_bridge(
+                video1, video2
+            )
+            
+            if temp_output and os.path.exists(temp_output):
+                # 結果を指定の場所に移動
+                import shutil
+                shutil.move(temp_output, str(output_path))
+                output_files.append(str(output_path))
+                
+                result_info = {
+                    "pair": i // 2 + 1,
+                    "video1": os.path.basename(video1),
+                    "video2": os.path.basename(video2),
+                    "similarity": similarity,
+                    "output": str(output_path),
+                    "success": True
+                }
+                
+                logger.info(f"ペア結合完了 {i//2 + 1}: 類似度 {similarity:.3f}")
+            else:
+                result_info = {
+                    "pair": i // 2 + 1,
+                    "video1": os.path.basename(video1),
+                    "video2": os.path.basename(video2),
+                    "error": result_text,
+                    "success": False
+                }
+                logger.error(f"ペア結合失敗 {i//2 + 1}: {result_text}")
+            
+            results.append(result_info)
+        
+        success = len(output_files) > 0
+        logger.info(f"ペアワイズ結合完了: {len(output_files)}個のファイル出力")
+        
+        return success, output_files, results
+    
+    def generate_report(self, results: List[dict], output_path: str = None) -> str:
+        """
+        処理結果のレポートを生成
+        
+        Args:
+            results: 処理結果リスト
+            output_path: レポート出力パス
+            
+        Returns:
+            レポート文字列
+        """
+        report_lines = [
+            "🎬 Frame Bridge - バッチ処理レポート",
+            "=" * 60,
+            f"📅 処理日時: {__import__('datetime').datetime.now().strftime('%Y-%m-%d %H:%M:%S')}",
+            f"📊 総処理数: {len(results)}",
+            ""
+        ]
+        
+        success_count = sum(1 for r in results if r.get('success', False))
+        report_lines.extend([
+            f"✅ 成功: {success_count}",
+            f"❌ 失敗: {len(results) - success_count}",
+            ""
+        ])
+        
+        # 詳細結果
+        for i, result in enumerate(results, 1):
+            if result.get('success', False):
+                if 'similarity' in result:
+                    quality = self._evaluate_quality(result['similarity'])
+                    report_lines.extend([
+                        f"📋 処理 {i}: ✅ 成功",
+                        f"   📹 動画1: {result.get('video1', 'N/A')}",
+                        f"   📹 動画2: {result.get('video2', 'N/A')}",
+                        f"   📈 類似度: {result['similarity']:.3f} ({quality})",
+                        f"   📁 出力: {os.path.basename(result.get('output', 'N/A'))}",
+                        ""
+                    ])
+                else:
+                    report_lines.extend([
+                        f"📋 処理 {i}: ✅ {result.get('action', '処理完了')}",
+                        f"   📹 ファイル: {result.get('video1', 'N/A')}",
+                        f"   📁 出力: {os.path.basename(result.get('output', 'N/A'))}",
+                        ""
+                    ])
+            else:
+                report_lines.extend([
+                    f"📋 処理 {i}: ❌ 失敗",
+                    f"   📹 動画1: {result.get('video1', 'N/A')}",
+                    f"   📹 動画2: {result.get('video2', 'N/A')}",
+                    f"   ⚠️ エラー: {result.get('error', '不明なエラー')}",
+                    ""
+                ])
+        
+        report_text = "\n".join(report_lines)
+        
+        # ファイルに保存
+        if output_path:
+            with open(output_path, 'w', encoding='utf-8') as f:
+                f.write(report_text)
+            logger.info(f"レポート保存: {output_path}")
+        
+        return report_text
+    
+    def _evaluate_quality(self, similarity: float) -> str:
+        """類似度から品質を評価"""
+        if similarity > 0.8:
+            return "優秀"
+        elif similarity > 0.6:
+            return "良好"
+        elif similarity > 0.4:
+            return "普通"
+        else:
+            return "要確認"

src/frame_bridge/config.py

@@ -0,0 +1,46 @@
+"""
+Frame Bridge - Configuration Module
+設定管理モジュール
+"""
+
+from dataclasses import dataclass
+from typing import List
+
+
+@dataclass
+class VideoProcessorConfig:
+    """VideoProcessor設定クラス"""
+    similarity_threshold: float = 0.3
+    exclude_edge_frames: bool = True
+    num_frames_video1: int = 30  # 動画1から抽出するフレーム数
+    num_frames_video2: int = 10  # 動画2から抽出するフレーム数
+    comparison_frames: int = 3   # 動画2の比較対象フレーム数
+
+
+@dataclass
+class BatchProcessorConfig:
+    """BatchProcessor設定クラス"""
+    output_dir: str = "output"
+    exclude_edge_frames: bool = True
+    supported_formats: List[str] = None
+    
+    def __post_init__(self):
+        if self.supported_formats is None:
+            self.supported_formats = ['.mp4', '.avi', '.mov', '.mkv', '.wmv', '.flv', '.webm']
+
+
+@dataclass
+class AppConfig:
+    """アプリケーション全体設定クラス"""
+    video_processor: VideoProcessorConfig = None
+    batch_processor: BatchProcessorConfig = None
+    
+    def __post_init__(self):
+        if self.video_processor is None:
+            self.video_processor = VideoProcessorConfig()
+        if self.batch_processor is None:
+            self.batch_processor = BatchProcessorConfig()
+
+
+# デフォルト設定
+DEFAULT_CONFIG = AppConfig()

src/frame_bridge/video_processor.py

@@ -0,0 +1,399 @@
+"""
+Frame Bridge - Video Processing Module
+2つの動画を最適なフレームで結合するための処理モジュール
+"""
+
+import cv2
+import numpy as np
+from PIL import Image
+import tempfile
+import os
+from skimage.metrics import structural_similarity as ssim
+from typing import Tuple, List, Optional, Union
+import logging
+
+# ログ設定
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class VideoProcessor:
+    """動画処理を行うメインクラス"""
+    
+    def __init__(self, similarity_threshold: float = 0.3, exclude_edge_frames: bool = True):
+        """
+        初期化
+        
+        Args:
+            similarity_threshold: フレーム類似度の閾値
+            exclude_edge_frames: 最初と最後のフレームを除外するかどうか
+        """
+        self.similarity_threshold = similarity_threshold
+        self.exclude_edge_frames = exclude_edge_frames
+        
+    def extract_frames(self, video_path: str, num_frames: int = 20) -> Tuple[Optional[List], Optional[str]]:
+        """
+        動画からフレームを抽出する
+        
+        Args:
+            video_path: 動画ファイルのパス
+            num_frames: 抽出するフレーム数
+            
+        Returns:
+            Tuple[フレームリスト, エラーメッセージ]
+        """
+        try:
+            cap = cv2.VideoCapture(video_path)
+            if not cap.isOpened():
+                return None, f"動画ファイルを開けませんでした: {video_path}"
+            
+            total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+            if total_frames == 0:
+                return None, "動画にフレームが見つかりませんでした"
+            
+            logger.info(f"動画 {video_path}: 総フレーム数 {total_frames}")
+            
+            frames = []
+            # 最初と最後のフレームを含む等間隔でフレームを抽出
+            frame_indices = np.linspace(0, total_frames-1, num_frames, dtype=int)
+            
+            for frame_idx in frame_indices:
+                cap.set(cv2.CAP_PROP_POS_FRAMES, frame_idx)
+                ret, frame = cap.read()
+                if ret:
+                    # BGR to RGB変換
+                    frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                    frames.append((frame_idx, frame_rgb))
+            
+            cap.release()
+            logger.info(f"フレーム抽出完了: {len(frames)}フレーム")
+            return frames, None
+            
+        except Exception as e:
+            logger.error(f"フレーム抽出エラー: {e}")
+            return None, f"フレーム抽出エラー: {str(e)}"
+
+    def calculate_frame_similarity(self, frame1: np.ndarray, frame2: np.ndarray) -> float:
+        """
+        2つのフレーム間の類似度を計算する
+        
+        Args:
+            frame1: 比較フレーム1
+            frame2: 比較フレーム2
+            
+        Returns:
+            類似度スコア (0.0-1.0)
+        """
+        try:
+            # グレースケールに変換
+            gray1 = cv2.cvtColor(frame1, cv2.COLOR_RGB2GRAY)
+            gray2 = cv2.cvtColor(frame2, cv2.COLOR_RGB2GRAY)
+            
+            # 同じサイズにリサイズ
+            h, w = min(gray1.shape[0], gray2.shape[0]), min(gray1.shape[1], gray2.shape[1])
+            gray1 = cv2.resize(gray1, (w, h))
+            gray2 = cv2.resize(gray2, (w, h))
+            
+            # SSIM（構造的類似性指標）を計算
+            similarity = ssim(gray1, gray2)
+            return max(0.0, similarity)  # 負の値を0にクリップ
+            
+        except Exception as e:
+            logger.error(f"類似度計算エラー: {e}")
+            return 0.0
+
+    def find_best_connection_frames(self, video1_path: str, video2_path: str) -> Tuple[Optional[np.ndarray], Optional[np.ndarray], float, Optional[str], Tuple[int, int]]:
+        """
+        2つの動画の最適な接続フレームを見つける
+        動画2の最初のフレームと動画1の全フレームから最も類似したフレームを探索
+        
+        Args:
+            video1_path: 動画1のパス
+            video2_path: 動画2のパス
+            
+        Returns:
+            Tuple[最適フレーム1, 最適フレーム2, 類似度, エラーメッセージ, フレームインデックス]
+        """
+        try:
+            # 各動画からフレームを抽出
+            frames1, error1 = self.extract_frames(video1_path, 30)  # より多くのフレームを抽出
+            if error1:
+                return None, None, 0.0, error1, (0, 0)
+            
+            frames2, error2 = self.extract_frames(video2_path, 10)  # 動画2は少なめでOK
+            if error2:
+                return None, None, 0.0, error2, (0, 0)
+            
+            # エッジフレーム除外オプションの適用
+            if self.exclude_edge_frames:
+                # 最初と最後のフレームを除外
+                frames1_filtered = frames1[1:-1] if len(frames1) > 2 else frames1
+                frames2_filtered = frames2[1:-1] if len(frames2) > 2 else frames2
+                logger.info(f"エッジフレーム除外: 動画1 {len(frames1)} → {len(frames1_filtered)}フレーム, 動画2 {len(frames2)} → {len(frames2_filtered)}フレーム")
+            else:
+                frames1_filtered = frames1
+                frames2_filtered = frames2
+                logger.info("エッジフレーム除外: 無効")
+            
+            # 動画2の最初の数フレームを基準にする（より高精度な探索）
+            video2_start_frames = frames2_filtered[:3]  # 動画2の最初の3フレーム（エッジ除外後）
+            
+            best_similarity = -1
+            best_frame1 = None
+            best_frame2 = None
+            best_indices = (0, 0)
+            
+            logger.info(f"フレーム類似度分析開始: 動画2の最初の{len(video2_start_frames)}フレームと動画1の{len(frames1_filtered)}フレームを比較...")
+            
+            # 動画2の各開始フレームについて、動画1の全フレームと比較
+            for j, (idx2, frame2) in enumerate(video2_start_frames):
+                logger.info(f"動画2のフレーム[{idx2}]との比較開始...")
+                
+                for i, (idx1, frame1) in enumerate(frames1_filtered):
+                    similarity = self.calculate_frame_similarity(frame1, frame2)
+                    logger.info(f"  動画1[{idx1}] vs 動画2[{idx2}]: 類似度 {similarity:.3f}")
+                    
+                    if similarity > best_similarity:
+                        best_similarity = similarity
+                        best_frame1 = frame1
+                        best_frame2 = frame2
+                        best_indices = (idx1, idx2)
+                        logger.info(f"  🌟 新しい最高類似度: {similarity:.3f} (動画1[{idx1}] → 動画2[{idx2}])")
+            
+            logger.info(f"最適接続点検出完了: 類似度 {best_similarity:.3f}")
+            logger.info(f"最適結合点: 動画1のフレーム[{best_indices[0]}] → 動画2のフレーム[{best_indices[1]}]")
+            
+            return best_frame1, best_frame2, best_similarity, None, best_indices
+            
+        except Exception as e:
+            logger.error(f"フレーム比較エラー: {e}")
+            return None, None, 0.0, f"フレーム比較エラー: {str(e)}", (0, 0)
+
+    def create_merged_video(self, video1_path: str, video2_path: str, cut_frame1: int, cut_frame2: int, output_path: str) -> Tuple[bool, Optional[str]]:
+        """
+        2つの動画を指定されたフレームで結合する
+        
+        Args:
+            video1_path: 動画1のパス
+            video2_path: 動画2のパス
+            cut_frame1: 動画1のカットフレーム
+            cut_frame2: 動画2のカットフレーム
+            output_path: 出力パス
+            
+        Returns:
+            Tuple[成功フラグ, エラーメッセージ]
+        """
+        try:
+            # 動画1を読み込み
+            cap1 = cv2.VideoCapture(video1_path)
+            if not cap1.isOpened():
+                return False, "動画1を開けませんでした"
+            
+            # 動画2を読み込み
+            cap2 = cv2.VideoCapture(video2_path)
+            if not cap2.isOpened():
+                cap1.release()
+                return False, "動画2を開けませんでした"
+            
+            # 動画の情報を取得
+            fps1 = cap1.get(cv2.CAP_PROP_FPS)
+            width1 = int(cap1.get(cv2.CAP_PROP_FRAME_WIDTH))
+            height1 = int(cap1.get(cv2.CAP_PROP_FRAME_HEIGHT))
+            
+            logger.info(f"動画1情報: {width1}x{height1}, {fps1}fps")
+            
+            # 出力動画の設定（最初の動画の設定を使用）
+            fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+            out = cv2.VideoWriter(output_path, fourcc, fps1, (width1, height1))
+            
+            # 動画1の最初からcut_frame1まで
+            frame_count = 0
+            while frame_count <= cut_frame1:
+                ret, frame = cap1.read()
+                if not ret:
+                    break
+                out.write(frame)
+                frame_count += 1
+            
+            logger.info(f"動画1から {frame_count} フレームを結合")
+            
+            # 動画2のcut_frame2から最後まで
+            cap2.set(cv2.CAP_PROP_POS_FRAMES, cut_frame2)
+            frame_count2 = 0
+            while True:
+                ret, frame = cap2.read()
+                if not ret:
+                    break
+                # サイズを動画1に合わせる
+                if frame.shape[:2] != (height1, width1):
+                    frame = cv2.resize(frame, (width1, height1))
+                out.write(frame)
+                frame_count2 += 1
+            
+            logger.info(f"動画2から {frame_count2} フレームを結合")
+            
+            # リソースを解放
+            cap1.release()
+            cap2.release()
+            out.release()
+            
+            logger.info(f"動画結合完了: {output_path}")
+            return True, None
+            
+        except Exception as e:
+            logger.error(f"動画結合エラー: {e}")
+            return False, f"動画結合エラー: {str(e)}"
+
+    def save_frame_as_image(self, frame: np.ndarray, filename: str) -> Optional[str]:
+        """
+        フレームを画像として保存する
+        
+        Args:
+            frame: 保存するフレーム
+            filename: ファイル名
+            
+        Returns:
+            保存されたファイルのパス
+        """
+        try:
+            temp_dir = tempfile.gettempdir()
+            file_path = os.path.join(temp_dir, filename)
+            
+            # PIL Imageに変換して保存
+            pil_image = Image.fromarray(frame)
+            pil_image.save(file_path)
+            
+            logger.info(f"フレーム画像保存: {file_path}")
+            return file_path
+            
+        except Exception as e:
+            logger.error(f"画像保存エラー: {e}")
+            return None
+
+    def analyze_video_details(self, video_path: str) -> str:
+        """
+        動画の詳細情報を分析する
+        
+        Args:
+            video_path: 動画ファイルのパス
+            
+        Returns:
+            動画情報の文字列
+        """
+        try:
+            cap = cv2.VideoCapture(video_path)
+            if not cap.isOpened():
+                return "動画を開けませんでした"
+            
+            fps = cap.get(cv2.CAP_PROP_FPS)
+            frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+            width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+            height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+            duration = frame_count / fps if fps > 0 else 0
+            
+            cap.release()
+            
+            return f"""📹 動画情報:
+• 解像度: {width} x {height}
+• フレームレート: {fps:.2f} FPS
+• 総フレーム数: {frame_count}
+• 再生時間: {duration:.2f} 秒
+• ファイルサイズ: {os.path.getsize(video_path) / (1024*1024):.1f} MB"""
+            
+        except Exception as e:
+            logger.error(f"動画分析エラー: {e}")
+            return f"動画分析エラー: {str(e)}"
+
+
+class FrameBridge:
+    """Frame Bridge メインクラス"""
+    
+    def __init__(self, exclude_edge_frames: bool = True):
+        """
+        初期化
+        
+        Args:
+            exclude_edge_frames: 最初と最後のフレームを除外するかどうか
+        """
+        self.processor = VideoProcessor(exclude_edge_frames=exclude_edge_frames)
+    
+    def process_video_bridge(self, video1_path: str, video2_path: str) -> Tuple[str, Optional[str], Optional[str], Optional[str], float]:
+        """
+        2つの動画を分析して最適な結合点を見つけ、結合する
+        
+        Args:
+            video1_path: 動画1のパス
+            video2_path: 動画2のパス
+            
+        Returns:
+            Tuple[結果テキスト, 結合動画パス, フレーム1パス, フレーム2パス, 類似度]
+        """
+        if not video1_path or not video2_path:
+            return "2つの動画ファイルが必要です。", None, None, None, 0.0
+        
+        if not os.path.exists(video1_path) or not os.path.exists(video2_path):
+            return "指定された動画ファイルが見つかりません。", None, None, None, 0.0
+        
+        try:
+            logger.info("動画分析開始...")
+            
+            # 最適な接続フレームを見つける
+            frame1, frame2, similarity, error, indices = self.processor.find_best_connection_frames(video1_path, video2_path)
+            
+            if error:
+                return f"エラー: {error}", None, None, None, 0.0
+            
+            logger.info("最適な接続点を検出しました")
+            
+            # フレームを画像として保存
+            frame1_path = self.processor.save_frame_as_image(frame1, "connection_frame1.png")
+            frame2_path = self.processor.save_frame_as_image(frame2, "connection_frame2.png")
+            
+            logger.info("動画結合開始...")
+            
+            # 結合動画を作成
+            temp_dir = tempfile.gettempdir()
+            output_path = os.path.join(temp_dir, "merged_video.mp4")
+            
+            # 最適なフレームで結合
+            success, merge_error = self.processor.create_merged_video(
+                video1_path, video2_path, indices[0], indices[1], output_path
+            )
+            
+            if not success:
+                return f"動画結合���ラー: {merge_error}", None, None, None, similarity
+            
+            # 品質評価
+            quality = self._evaluate_quality(similarity)
+            
+            result_text = f"""🎬 動画結合完了！
+
+📊 分析結果:
+• フレーム類似度: {similarity:.3f}
+• 接続品質: {quality}
+• 結合フレーム: 動画1[{indices[0]}] → 動画2[{indices[1]}]
+
+💡 結合情報:
+• 動画1の最適な終了フレームを検出
+• 動画2の最適な開始フレームを検出
+• スムーズな接続を実現
+
+📁 出力ファイル: {os.path.basename(output_path)}"""
+            
+            logger.info("処理完了")
+            return result_text, output_path, frame1_path, frame2_path, similarity
+            
+        except Exception as e:
+            logger.error(f"処理エラー: {e}")
+            return f"処理エラー: {str(e)}", None, None, None, 0.0
+    
+    def _evaluate_quality(self, similarity: float) -> str:
+        """類似度から品質を評価"""
+        if similarity > 0.8:
+            return "優秀 🌟"
+        elif similarity > 0.6:
+            return "良好 ✅"
+        elif similarity > 0.4:
+            return "普通 ⚡"
+        else:
+            return "要確認 ⚠️"