Upload 3 files

app.py

@@ -0,0 +1,479 @@
+
+import tkinter as tk
+from tkinter import filedialog, messagebox
+from PIL import Image, ImageTk
+import cv2
+import os
+from datetime import datetime
+import traceback
+import re
+import time
+from scenedetect import open_video, SceneManager
+from scenedetect.detectors import ContentDetector
+from ffpyplayer.player import MediaPlayer
+from tkinterdnd2 import DND_FILES, TkinterDnD
+
+class App(TkinterDnD.Tk):
+    def __init__(self):
+        TkinterDnD.Tk.__init__(self)
+        self.title("MVシーン抽出ツール")
+        self.geometry("1240x800")
+        self.base_dir = os.path.dirname(os.path.abspath(__file__))
+        
+        # Video and Playback State
+        self.video_path = None
+        self.cap = None
+        self.fps = 0
+        self.total_frames = 0
+        self.is_playing = False
+        self.after_id = None
+        self.audio_player = None
+
+        # Scene Extraction State
+        self.thumbnail_widgets = []
+        self.selected_thumbnail_index = None
+        self.extracted_frames = []
+        self.checked_vars = []
+        self.scene_threshold = 27 # Default threshold
+        self.min_scene_len = 15 # Default minimum scene length
+        self.luma_only = tk.BooleanVar(value=False) # Default to considering color
+
+        # --- Main Layout ---
+        main_frame = tk.Frame(self)
+        main_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
+
+        left_frame = tk.Frame(main_frame)
+        left_frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
+        left_frame.pack_propagate(False) # Prevent resizing
+
+        right_frame = tk.Frame(main_frame, width=720)
+        right_frame.pack(side=tk.RIGHT, fill=tk.Y, padx=(10, 0))
+
+        # --- Left Frame: Video Preview and Controls ---
+        self.video_frame = tk.Frame(left_frame)
+        self.video_frame.pack(fill=tk.BOTH, expand=True)
+        self.video_frame.pack_propagate(False)
+
+        self.video_preview_label = tk.Label(self.video_frame, text="動画プレビュー", bg="black", fg="white")
+        self.video_preview_label.pack(fill=tk.BOTH, expand=True)
+        self.video_preview_label.drop_target_register(DND_FILES)
+        self.video_preview_label.dnd_bind('<<Drop>>', self._on_drop)
+
+        # Playback Controls
+        playback_frame = tk.Frame(left_frame)
+        playback_frame.pack(fill=tk.X, pady=5)
+        self.play_btn = tk.Button(playback_frame, text="▶ 再生", command=self.toggle_play, state=tk.DISABLED)
+        self.play_btn.pack(side=tk.LEFT, padx=5)
+        self.seek_bar = tk.Scale(playback_frame, from_=0, to=100, orient=tk.HORIZONTAL, showvalue=False, state=tk.DISABLED)
+        self.seek_bar.bind("<ButtonRelease-1>", self.on_seek_release)
+        self.seek_bar.pack(fill=tk.X, expand=True, padx=5)
+        self.time_label = tk.Label(playback_frame, text="00:00 / 00:00")
+        self.time_label.pack(side=tk.RIGHT, padx=5)
+
+        # Main Controls
+        main_control_frame = tk.Frame(left_frame)
+        main_control_frame.pack(fill=tk.X, pady=5)
+        self.select_video_btn = tk.Button(main_control_frame, text="動画を選択", command=self.select_video)
+        self.select_video_btn.pack(side=tk.LEFT, padx=5)
+        self.detect_scenes_btn = tk.Button(main_control_frame, text="シーンを検出", command=self.detect_scenes, state=tk.DISABLED)
+        self.detect_scenes_btn.pack(side=tk.LEFT, padx=5)
+
+        # Scene Sensitivity Control
+        scene_control_frame = tk.Frame(left_frame)
+        scene_control_frame.pack(fill=tk.X, pady=5)
+        self.threshold_label = tk.Label(scene_control_frame, text=f"感度: {self.scene_threshold}")
+        self.threshold_label.pack(side=tk.LEFT, padx=5)
+        self.threshold_scale = tk.Scale(scene_control_frame, from_=1, to=100, orient=tk.HORIZONTAL,
+                                        command=self._update_threshold_label, showvalue=False, length=200) # Fixed length
+        self.threshold_scale.set(self.scene_threshold)
+        self.threshold_scale.pack(side=tk.LEFT, padx=5)
+
+        # Minimum Scene Length Control
+        self.min_scene_len_label = tk.Label(scene_control_frame, text=f"最小シーン長: {self.min_scene_len}")
+        self.min_scene_len_label.pack(side=tk.LEFT, padx=5)
+        self.min_scene_len_scale = tk.Scale(scene_control_frame, from_=1, to=100, orient=tk.HORIZONTAL,
+                                            command=self._update_min_scene_len_label, showvalue=False, length=200) # Fixed length
+        self.min_scene_len_scale.set(self.min_scene_len)
+        self.min_scene_len_scale.pack(side=tk.LEFT, padx=5)
+
+        # Luma Only Control
+        self.luma_only_check = tk.Checkbutton(scene_control_frame, text="輝度のみ", variable=self.luma_only)
+        self.luma_only_check.pack(side=tk.LEFT, padx=5)
+
+        # --- Right Frame: Extracted Frames ---
+        right_header_frame = tk.Frame(right_frame)
+        right_header_frame.grid(row=0, column=0, columnspan=2, sticky=tk.EW)
+        frames_header_label = tk.Label(right_header_frame, text="抽出したフレ��ム")
+        frames_header_label.pack(side=tk.LEFT, expand=True)
+
+        # New control frame for buttons
+        right_control_frame = tk.Frame(right_frame)
+        right_control_frame.grid(row=1, column=0, columnspan=2, sticky=tk.EW, pady=5)
+        self.check_all_btn = tk.Button(right_control_frame, text="すべて選択/解除", command=self.toggle_check_all, state=tk.DISABLED)
+        self.check_all_btn.pack(side=tk.LEFT, fill=tk.X, expand=True, padx=5)
+        self.save_frame_btn = tk.Button(right_control_frame, text="チェックした画像を保存", command=self.save_checked_frames, state=tk.DISABLED)
+        self.save_frame_btn.pack(side=tk.RIGHT, fill=tk.X, expand=True, padx=5)
+
+        self.frames_canvas = tk.Canvas(right_frame, borderwidth=2, relief="sunken")
+        self.frames_canvas.grid(row=2, column=0, sticky=tk.NSEW)
+        self.frames_scrollbar = tk.Scrollbar(right_frame, orient="vertical", command=self.frames_canvas.yview)
+        self.frames_scrollbar.grid(row=2, column=1, sticky=tk.NS)
+        self.scrollable_frame = tk.Frame(self.frames_canvas)
+        self.scrollable_frame.bind("<Configure>", lambda e: self.frames_canvas.configure(scrollregion=self.frames_canvas.bbox("all")))
+        self.frames_canvas.create_window((0, 0), window=self.scrollable_frame, anchor="nw")
+        self.frames_canvas.configure(yscrollcommand=self.frames_scrollbar.set)
+
+        # Configure row and column weights for right_frame to make frames_canvas expand
+        right_frame.grid_rowconfigure(2, weight=1)
+        right_frame.grid_columnconfigure(0, weight=1)
+        
+        # --- Bottom Frame: Status and Warning ---
+        bottom_frame = tk.Frame(self, height=30)
+        bottom_frame.pack(side=tk.BOTTOM, fill=tk.X, padx=10, pady=(0, 5))
+        warning_label = tk.Label(bottom_frame, text="注意: Soraで生成された動画は、著作権やウォーターマークの対象となる場合があります。", fg="gray")
+        warning_label.pack(side=tk.LEFT)
+
+        self.protocol("WM_DELETE_WINDOW", self.on_closing)
+
+    def select_video(self):
+        file_path = filedialog.askopenfilename(title="動画ファイルを選択", filetypes=(("MP4 ファイル", "*.mp4"), ("すべてのファイル", "*.*")))
+        if not file_path:
+            return
+        self.select_video_from_path(os.path.abspath(file_path))
+
+    def select_video_from_path(self, path):
+        if self.is_playing:
+            self.toggle_play()
+        if self.cap is not None:
+            self.cap.release()
+        if self.audio_player is not None:
+            self.audio_player.close_player()
+
+        self.video_path = path
+        os.chdir(self.base_dir)
+        
+        self.cap = cv2.VideoCapture(self.video_path)
+        if not self.cap.isOpened():
+            messagebox.showerror("エラー", "動画ファイルを開けませんでした。")
+            self.cap = None
+            return
+
+        try:
+            self.audio_player = MediaPlayer(self.video_path)
+            self.audio_player.set_pause(True)
+        except Exception as e:
+            messagebox.showwarning("警告", f"音声ファイルの読み込みに失敗しました: {e}")
+            self.audio_player = None
+
+        self.fps = self.cap.get(cv2.CAP_PROP_FPS)
+        self.total_frames = int(self.cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        
+        # Reset and setup UI
+        self.detect_scenes_btn.config(state=tk.NORMAL)
+        self.play_btn.config(state=tk.NORMAL)
+        self.seek_bar.config(state=tk.NORMAL, to=self.total_frames - 1)
+        self.seek_bar.set(0)
+        self._update_time_label()
+        self.save_frame_btn.config(state=tk.DISABLED)
+        self.check_all_btn.config(state=tk.DISABLED)
+        self.selected_thumbnail_index = None
+        self.extracted_frames.clear()
+        self.checked_vars.clear()
+        for widget in self.thumbnail_widgets:
+            widget.destroy()
+        self.thumbnail_widgets.clear()
+
+        ret, frame = self.cap.read()
+        if ret:
+            self._display_main_preview(frame)
+
+    def _on_drop(self, event):
+        file_path = event.data
+        if file_path.startswith('{') and file_path.endswith('}'):
+            file_path = file_path[1:-1] # Remove curly braces
+
+        if os.path.isfile(file_path):
+            self.select_video_from_path(os.path.abspath(file_path))
+        else:
+            messagebox.showwarning("警告", "無効なファイルがドロップされました。")
+
+    def on_closing(self):
+        if self.is_playing:
+            self.toggle_play()
+        if self.cap is not None:
+            self.cap.release()
+        if self.audio_player is not None:
+            self.audio_player.close_player()
+        self.destroy()
+
+    def _display_main_preview(self, frame):
+        preview_width = self.video_frame.winfo_width()
+        preview_height = self.video_frame.winfo_height()
+        if preview_width < 50 or preview_height < 50: preview_width, preview_height = 640, 360 # Default if not yet rendered
+
+        h, w, _ = frame.shape
+        aspect_ratio = w / h
+        if w > preview_width or h > preview_height:
+            if (preview_width / aspect_ratio) <= preview_height: new_w, new_h = preview_width, int(preview_width / aspect_ratio)
+            else: new_h, new_w = preview_height, int(preview_height * aspect_ratio)
+            frame = cv2.resize(frame, (new_w, new_h), interpolation=cv2.INTER_AREA)
+
+        img_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        img_pil = Image.fromarray(img_rgb)
+        img_tk = ImageTk.PhotoImage(image=img_pil)
+        self.video_preview_label.config(image=img_tk, text="")
+        self.video_preview_label.image = img_tk
+
+    def toggle_play(self):
+        self.is_playing = not self.is_playing
+        if self.is_playing:
+            self.play_btn.config(text="❚❚ 一時停止")
+            if self.audio_player:
+                self.audio_player.set_pause(False)
+            self.play_video()
+        else:
+            self.play_btn.config(text="▶ 再生")
+            if self.audio_player:
+                self.audio_player.set_pause(True)
+            if self.after_id:
+                self.after_cancel(self.after_id)
+                self.after_id = None
+
+    def play_video(self):
+        if not self.is_playing or self.cap is None:
+            return
+
+        start_time = time.time()
+        
+        # Audio synchronization
+        if self.audio_player:
+            audio_pts = self.audio_player.get_pts()
+            if audio_pts is not None:
+                # Calculate target frame based on audio PTS
+                target_frame_num = int(audio_pts * self.fps)
+                current_video_frame = int(self.cap.get(cv2.CAP_PROP_POS_FRAMES))
+                
+                # Only seek if the video is significantly out of sync
+                if abs(target_frame_num - current_video_frame) > self.fps / 2: # If more than half a second off
+                    self.cap.set(cv2.CAP_PROP_POS_FRAMES, target_frame_num)
+
+        ret, frame = self.cap.read()
+        if ret:
+            current_frame = int(self.cap.get(cv2.CAP_PROP_POS_FRAMES))
+            self._display_main_preview(frame)
+            self.seek_bar.set(current_frame)
+            self._update_time_label(current_frame)
+            end_time = time.time()
+            elapsed_time_ms = (end_time - start_time) * 1000
+            ideal_delay_ms = 1000 / self.fps
+            delay_ms = max(1, int(ideal_delay_ms - elapsed_time_ms))
+            self.after_id = self.after(delay_ms, self.play_video)
+        else:
+            self.toggle_play()
+
+    def on_seek_release(self, event):
+        if self.cap is None:
+            return
+        
+        was_playing = self.is_playing
+        if was_playing:
+            # Manually pause video and audio
+            self.is_playing = False
+            self.play_btn.config(text="▶ 再生")
+            if self.audio_player:
+                self.audio_player.set_pause(True)
+            if self.after_id:
+                self.after_cancel(self.after_id)
+                self.after_id = None
+
+        frame_num = self.seek_bar.get()
+        
+        # Calculate target time in milliseconds
+        target_frame_num = self.seek_bar.get()
+        current_frame_num = int(self.cap.get(cv2.CAP_PROP_POS_FRAMES))
+
+        # If seeking backward or to the very beginning, re-initialize and fast-forward
+        if target_frame_num < current_frame_num or target_frame_num == 0:
+            # Close existing players
+            if self.cap is not None:
+                self.cap.release()
+            if self.audio_player is not None:
+                self.audio_player.close_player()
+            
+            # Re-initialize players
+            self.cap = cv2.VideoCapture(self.video_path)
+            if not self.cap.isOpened():
+                messagebox.showerror("エラー", "動画ファイルを開けませんでした。")
+                self.cap = None
+                return
+
+            try:
+                self.audio_player = MediaPlayer(self.video_path)
+                self.audio_player.set_pause(True) # Start paused
+            except Exception as e:
+                messagebox.showwarning("警告", f"音声ファイルの読み込みに失敗しました: {e}")
+                self.audio_player = None
+
+            # Fast-forward to target_frame_num
+            for _ in range(target_frame_num):
+                ret, frame = self.cap.read()
+                if not ret:
+                    break
+
+            # After fast-forwarding video, seek audio player to the correct position
+            if self.audio_player:
+                try:
+                    self.audio_player.seek(target_frame_num / self.fps)
+                except Exception as e:
+                    print(f"Error seeking audio during fast-forward: {e}")
+                    messagebox.showwarning("警告", f"早送り中の音声シーク中にエラーが発生しました: {e}")
+        else:
+            # For forward seeking, use direct seek (current reliable method)
+            target_time_ms = (target_frame_num / self.fps) * 1000
+            self.cap.set(cv2.CAP_PROP_POS_MSEC, target_time_ms)
+            if self.audio_player:
+                try:
+                    self.audio_player.seek(target_frame_num / self.fps)
+                except Exception as e:
+                    print(f"Error seeking audio: {e}")
+                    messagebox.showwarning("警告", f"音声シーク中にエラーが発生しました: {e}")
+
+        # Read and display the frame at the target position
+        ret, frame = self.cap.read()
+        if ret:
+            self._display_main_preview(frame)
+            self._update_time_label(target_frame_num) # Update time label with target frame
+        else:
+            messagebox.showwarning("警告", "シーク後にフレームを読み込めませんでした。")
+            if was_playing:
+                self.is_playing = False
+                self.play_btn.config(text="▶ 再生")
+                if self.audio_player:
+                    self.audio_player.set_pause(True)
+                if self.after_id:
+                    self.after_cancel(self.after_id)
+                    self.after_id = None
+            return
+        
+        if was_playing:
+            # Manually resume video and audio
+            self.is_playing = True
+            self.play_btn.config(text="❚❚ 一時停止")
+            if self.audio_player:
+                self.audio_player.set_pause(False)
+            self.play_video()
+
+    def _update_time_label(self, current_frame=0):
+        if self.total_frames > 0 and self.fps > 0:
+            current_time = datetime.utcfromtimestamp(current_frame / self.fps).strftime('%M:%S')
+            total_time = datetime.utcfromtimestamp(self.total_frames / self.fps).strftime('%M:%S')
+            self.time_label.config(text=f"{current_time} / {total_time}")
+
+    def _update_threshold_label(self, value):
+        self.scene_threshold = int(value)
+        self.threshold_label.config(text=f"感度: {self.scene_threshold}")
+
+    def _update_min_scene_len_label(self, value):
+        self.min_scene_len = int(value)
+        self.min_scene_len_label.config(text=f"最小シーン長: {self.min_scene_len}")
+
+    def detect_scenes(self):
+        if not self.video_path: messagebox.showwarning("警告", "最初に動画を選択してください。"); return
+        if self.is_playing: self.toggle_play()
+
+        self.config(cursor="watch"); self.update_idletasks()
+        self.save_frame_btn.config(state=tk.DISABLED); self.check_all_btn.config(state=tk.DISABLED)
+        self.selected_thumbnail_index = None; self.extracted_frames.clear(); self.checked_vars.clear()
+        for widget in self.thumbnail_widgets: widget.destroy()
+        self.thumbnail_widgets.clear()
+
+        try:
+            video_stream = open_video(self.video_path)
+            scene_manager = SceneManager()
+            scene_manager.add_detector(ContentDetector(threshold=self.scene_threshold,
+                                                       min_scene_len=self.min_scene_len,
+                                                       luma_only=self.luma_only.get()))
+            scene_manager.detect_scenes(video=video_stream, show_progress=False)
+            scene_list = scene_manager.get_scene_list()
+
+            self.cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
+            ret, first_frame = self.cap.read()
+            if ret: self.extracted_frames.append(first_frame)
+
+            if scene_list:
+                for scene in scene_list:
+                    start_frame_num = scene[0].get_frames()
+                    if start_frame_num > 0:
+                        self.cap.set(cv2.CAP_PROP_POS_FRAMES, start_frame_num)
+                        ret, frame = self.cap.read()
+                        if ret and not any((frame == ef).all() for ef in self.extracted_frames):
+                            self.extracted_frames.append(frame)
+
+            if not self.extracted_frames: messagebox.showinfo("情報", "ユニークなフレームを抽出できませんでした。"); return
+
+            self._display_thumbnails()
+            if self.extracted_frames: self.save_frame_btn.config(state=tk.NORMAL); self.check_all_btn.config(state=tk.NORMAL)
+
+        except Exception as e: messagebox.showerror("シーン検出エラー", f"エラーが発生しました: {e}\n\nトレースバック:\n{traceback.format_exc()}")
+        finally: self.config(cursor="")
+
+    def _display_thumbnails(self):
+        num_columns = 3; thumb_width = 120
+        for i, frame in enumerate(self.extracted_frames):
+            row, col = divmod(i, num_columns)
+            h, w, _ = frame.shape; aspect_ratio = w / h; new_h = int(thumb_width / aspect_ratio)
+            thumb = cv2.resize(frame, (thumb_width, new_h), interpolation=cv2.INTER_AREA)
+            img_rgb = cv2.cvtColor(thumb, cv2.COLOR_BGR2RGB)
+            img_pil = Image.fromarray(img_rgb)
+            img_tk = ImageTk.PhotoImage(image=img_pil)
+            thumb_frame = tk.Frame(self.scrollable_frame, bd=2, relief="solid", borderwidth=1, bg="gray")
+            thumb_frame.grid(row=row, column=col, padx=5, pady=5)
+            thumb_label = tk.Label(thumb_frame, image=img_tk); thumb_label.pack()
+            check_var = tk.BooleanVar(value=False); check_button = tk.Checkbutton(thumb_frame, variable=check_var); check_button.pack()
+            thumb_label.bind("<Button-1>", lambda e, index=i: self._on_thumbnail_click(index))
+            self.thumbnail_widgets.append(thumb_frame); thumb_frame.image = img_tk; self.checked_vars.append(check_var)
+
+    def toggle_check_all(self):
+        new_state = any(not var.get() for var in self.checked_vars)
+        for var in self.checked_vars: var.set(new_state)
+
+    def _on_thumbnail_click(self, index):
+        if self.is_playing: self.toggle_play()
+        if self.selected_thumbnail_index is not None: self.thumbnail_widgets[self.selected_thumbnail_index].config(bg="gray", borderwidth=1)
+        self.selected_thumbnail_index = index
+        self.thumbnail_widgets[index].config(bg="dodgerblue", borderwidth=2)
+        selected_frame = self.extracted_frames[index]
+        self._display_main_preview(selected_frame)
+
+    def save_checked_frames(self):
+        if self.is_playing: self.toggle_play()
+        checked_indices = [i for i, var in enumerate(self.checked_vars) if var.get()]
+        if not checked_indices: messagebox.showwarning("警告", "保存するフレームにチェックを入れてください。"); return
+
+        output_dir = os.path.join(self.base_dir, "output"); os.makedirs(output_dir, exist_ok=True)
+        base_name = os.path.splitext(os.path.basename(self.video_path))[0]
+        safe_base_name = re.sub(r'[\\/:*?"<>|]', '_', base_name)
+        timestamp = datetime.now().strftime("%Y%m%d%H%M%S")
+        
+        saved_count = 0; failed_files = []
+        try:
+            for i, frame_index in enumerate(checked_indices):
+                file_name = f"{safe_base_name}_{timestamp}_{i+1:03d}.png"
+                file_path = os.path.abspath(os.path.join(output_dir, file_name))
+                frame_to_save = self.extracted_frames[frame_index]
+                result, encoded_image = cv2.imencode('.png', frame_to_save)
+                if result:
+                    try:
+                        with open(file_path, 'wb') as f: f.write(encoded_image)
+                        if os.path.exists(file_path): saved_count += 1
+                        else: failed_files.append(file_name + " (書き込み後ファイル未検出)")
+                    except IOError as e: failed_files.append(file_name + f" (IOエラー: {e})")
+                else: failed_files.append(file_name + " (エンコード失敗)")
+            
+            if saved_count > 0: messagebox.showinfo("成功", f"{saved_count} フレームの保存に成功しました。\n場所: {output_dir}")
+            if failed_files: messagebox.showerror("保存エラー", f"以下のファイルの保存に失敗しました:\n{', '.join(failed_files)}")
+        except Exception as e: messagebox.showerror("エラー", f"保存中にエラーが発生しました: {e}")
+
+if __name__ == "__main__":
+    app = App()
+    app.mainloop()

requirements.txt

@@ -0,0 +1,5 @@
+opencv-python-headless
+Pillow
+scenedetect[opencv]
+ffpyplayer
+tkinterdnd2

start_venv.bat

@@ -0,0 +1,4 @@
+@echo off
+
+set CUDA_VISIBLE_DEVICES=0
+call .venv\Scripts\activate && python app.py