GameSentenceMiner 2.14.19__tar.gz → 2.14.21__tar.gz

{gamesentenceminer-2.14.19 → gamesentenceminer-2.14.21}/GameSentenceMiner/gsm.py

@@ -123,8 +123,6 @@ if is_windows():
 procs_to_close = []
 settings_window: config_gui.ConfigApp = None
 obs_paused = False
-icon: Icon
-menu: Menu
 root = None
 warnings.simplefilter("ignore", DeprecationWarning)
 
@@ -401,83 +399,94 @@ def open_log():
     logger.info("Log opened.")
 
 
-def exit_program(passed_icon, item):
-    """Exit the application."""
-    if not passed_icon:
-        passed_icon = icon
-    logger.info("Exiting...")
-    passed_icon.stop()
-    cleanup()
+def open_multimine(icon, item):
+    texthooking_page.open_texthooker()
 
 
-def play_pause(icon, item):
-    global obs_paused, menu
-    obs.toggle_replay_buffer()
-    update_icon()
+def exit_program(passed_icon, item):
+        """Exit the application."""
+        if not passed_icon:
+            passed_icon = icon
+        logger.info("Exiting...")
+        passed_icon.stop()
+        cleanup()
 
+class GSMTray(threading.Thread):
+    def __init__(self):
+        super().__init__()
+        self.daemon = True
+        self.menu = None
+        self.icon = None
+
+    def run(self):
+        self.run_tray()
+
+
+    def run_tray(self):
+        self.profile_menu = Menu(
+            *[MenuItem(("Active: " if profile == get_master_config().current_profile else "") + profile, self.switch_profile) for
+            profile in
+            get_master_config().get_all_profile_names()]
+        )
+
+        menu = Menu(
+            MenuItem("Open Settings", open_settings, default=True),
+            MenuItem("Open Texthooker", texthooking_page.open_texthooker),
+            MenuItem("Open Log", open_log),
+            MenuItem("Toggle Replay Buffer", self.play_pause),
+            MenuItem("Restart OBS", restart_obs),
+            MenuItem("Switch Profile", self.profile_menu),
+            MenuItem("Exit", exit_program)
+        )
+
+        self.icon = Icon("TrayApp", create_image(), "GameSentenceMiner", menu)
+        self.icon.run()
+
+    def update_icon(self, profile=None):
+        global menu, icon
+        # Recreate the menu with the updated button text
+        profile_menu = Menu(
+            *[MenuItem(("Active: " if profile == get_master_config().current_profile else "") + profile, self.switch_profile) for
+            profile in
+            get_master_config().get_all_profile_names()]
+        )
+
+        menu = Menu(
+            MenuItem("Open Settings", open_settings, default=True),
+            MenuItem("Open Multi-Mine GUI", open_multimine),
+            MenuItem("Open Log", open_log),
+            MenuItem("Toggle Replay Buffer", self.play_pause),
+            MenuItem("Restart OBS", restart_obs),
+            MenuItem("Switch Profile", profile_menu),
+            MenuItem("Exit", exit_program)
+        )
+
+        self.icon.menu = menu
+        self.icon.update_menu()
+
+    def switch_profile(self, icon, item):
+        if "Active:" in item.text:
+            logger.error("You cannot switch to the currently active profile!")
+            return
+        logger.info(f"Switching to profile: {item.text}")
+        prev_config = get_config()
+        get_master_config().current_profile = item.text
+        switch_profile_and_save(item.text)
+        settings_window.reload_settings()
+        self.update_icon()
+        if get_config().restart_required(prev_config):
+            send_restart_signal()
 
-def open_multimine(icon, item):
-    texthooking_page.open_texthooker()
+    def play_pause(self, icon, item):
+        global obs_paused, menu
+        obs.toggle_replay_buffer()
+        self.update_icon()
 
+    def stop(self):
+        if self.icon:
+            self.icon.stop()
 
-def update_icon(profile=None):
-    global menu, icon
-    # Recreate the menu with the updated button text
-    profile_menu = Menu(
-        *[MenuItem(("Active: " if profile == get_master_config().current_profile else "") + profile, switch_profile) for
-          profile in
-          get_master_config().get_all_profile_names()]
-    )
-
-    menu = Menu(
-        MenuItem("Open Settings", open_settings, default=True),
-        MenuItem("Open Multi-Mine GUI", open_multimine),
-        MenuItem("Open Log", open_log),
-        MenuItem("Toggle Replay Buffer", play_pause),
-        MenuItem("Restart OBS", restart_obs),
-        MenuItem("Switch Profile", profile_menu),
-        MenuItem("Exit", exit_program)
-    )
-
-    icon.menu = menu
-    icon.update_menu()
-
-
-def switch_profile(icon, item):
-    if "Active:" in item.text:
-        logger.error("You cannot switch to the currently active profile!")
-        return
-    logger.info(f"Switching to profile: {item.text}")
-    prev_config = get_config()
-    get_master_config().current_profile = item.text
-    switch_profile_and_save(item.text)
-    settings_window.reload_settings()
-    update_icon()
-    if get_config().restart_required(prev_config):
-        send_restart_signal()
-
-
-def run_tray():
-    global menu, icon
-
-    profile_menu = Menu(
-        *[MenuItem(("Active: " if profile == get_master_config().current_profile else "") + profile, switch_profile) for
-          profile in
-          get_master_config().get_all_profile_names()]
-    )
-
-    menu = Menu(
-        MenuItem("Open Settings", open_settings, default=True),
-        MenuItem("Open Texthooker", texthooking_page.open_texthooker),
-        MenuItem("Open Log", open_log),
-        MenuItem("Toggle Replay Buffer", play_pause),
-        MenuItem("Restart OBS", restart_obs),
-        MenuItem("Switch Profile", profile_menu),
-        MenuItem("Exit", exit_program)
-    )
-
-    icon = Icon("TrayApp", create_image(), "GameSentenceMiner", menu)
-    icon.run()
+gsm_tray = GSMTray()
 
 
 # def close_obs():
@@ -551,8 +560,8 @@ def cleanup():
                 proc.kill()
                 logger.error(f"Error terminating process {proc}: {e}")
 
-        if icon:
-            icon.stop()
+        if gsm_tray:
+            gsm_tray.stop()
 
         for video in gsm_state.videos_to_remove:
             try:
@@ -608,7 +617,7 @@ def initialize(reloading=False):
 
 
 def initialize_async():
-    tasks = [connect_websocket, run_tray]
+    tasks = [connect_websocket]
     threads = []
     tasks.append(anki.start_monitoring_anki)
     for task in tasks:
@@ -633,11 +642,12 @@ def handle_websocket_message(message: Message):
             case FunctionName.OPEN_LOG:
                 open_log()
             case FunctionName.TOGGLE_REPLAY_BUFFER:
-                play_pause(None, None)
+                obs.toggle_replay_buffer()
             case FunctionName.RESTART_OBS:
                 restart_obs()
             case FunctionName.EXIT:
-                exit_program(None, None)
+                cleanup()
+                sys.exit(0)
             case FunctionName.CONNECT:
                 logger.debug("Electron WSS connected")
             case _:
@@ -671,7 +681,7 @@ async def register_scene_switcher_callback():
         all_configured_scenes = [
             config.scenes for config in get_master_config().configs.values()]
         print(all_configured_scenes)
-        matching_configs = [name.strip() for name, config in config_instance.configs.items(
+        matching_configs = [name.strip() for name, config in get_master_config().configs.items(
         ) if scene.strip() in config.scenes]
         switch_to = None
 
@@ -692,7 +702,7 @@ async def register_scene_switcher_callback():
             get_master_config().current_profile = switch_to
             switch_profile_and_save(switch_to)
             settings_window.reload_settings()
-            update_icon()
+            gsm_tray.update_icon()
 
     await obs.register_scene_change_callback(scene_switcher_callback)
 
@@ -763,7 +773,8 @@ async def async_main(reloading=False):
         try:
             if get_config().general.open_config_on_startup:
                 root.after(50, settings_window.show)
-            settings_window.add_save_hook(update_icon)
+            root.after(50, gsm_tray.start)
+            settings_window.add_save_hook(gsm_tray.update_icon)
             settings_window.on_exit = exit_program
             root.mainloop()
         except KeyboardInterrupt:

{gamesentenceminer-2.14.19 → gamesentenceminer-2.14.21}/GameSentenceMiner/obs.py

@@ -1,16 +1,17 @@
 import asyncio
+import json
 import os.path
 import subprocess
 import threading
 import time
-from pprint import pprint
+import logging
 
 import psutil
 
 import obsws_python as obs
 
 from GameSentenceMiner.util import configuration
-from GameSentenceMiner.util.configuration import *
+from GameSentenceMiner.util.configuration import get_app_directory, get_config, get_master_config, is_windows, save_full_config, reload_config, logger, gsm_status, gsm_state
 from GameSentenceMiner.util.gsm_utils import sanitize_filename, make_unique_file_name
 import tkinter as tk
 from tkinter import messagebox
@@ -54,7 +55,7 @@ class OBSConnectionManager(threading.Thread):
                         if gsm_status.obs_connected and not replay_buffer_status and not self.said_no_to_replay_buffer:
                             try:
                                 self.check_output()
-                            except Exception as e:
+                            except Exception:
                                 pass
                 except Exception as e:
                     logger.error(f"Error when running Extra Utils in OBS Health Check, Keeping ConnectionManager Alive: {e}")
@@ -251,7 +252,6 @@ def connect_to_obs_sync(retry=2, check_output=True):
                 logger.error(f"Failed to connect to OBS WebSocket: {e}")
                 client = None
                 event_client = None
-                connecting = False
                 break
             time.sleep(1)
             retry -= 1
@@ -559,7 +559,6 @@ def main():
     disconnect_from_obs()
 
 if __name__ == '__main__':
-    from mss import mss
     logging.basicConfig(level=logging.INFO)
     connect_to_obs_sync()
     set_fit_to_screen_for_scene_items(get_current_scene())

{gamesentenceminer-2.14.19 → gamesentenceminer-2.14.21}/GameSentenceMiner/owocr/owocr/ocr.py

@@ -377,16 +377,13 @@ class GoogleLens:
                         res += 'BLANK_LINE'
                 for line in paragraph['lines']:
                     if furigana_filter_sensitivity:
+                        line_width = line['geometry']['bounding_box']['width'] * img.width
+                        line_height = line['geometry']['bounding_box']['height'] * img.height
                         for word in line['words']:
                             if self.punctuation_regex.findall(word['plain_text']):
                                 res += word['plain_text'] + word['text_separator']
                                 continue
-                            if 'geometry' not in word:
-                                res += word['plain_text'] + word['text_separator']
-                                continue
-                            word_width = word['geometry']['bounding_box']['width'] * img.width
-                            word_height = word['geometry']['bounding_box']['height'] * img.height
-                            if word_width > furigana_filter_sensitivity and word_height > furigana_filter_sensitivity:
+                            if line_width > furigana_filter_sensitivity and line_height > furigana_filter_sensitivity:
                                 res += word['plain_text'] + word['text_separator']
                             else:
                                 skipped.extend(word['plain_text'])
@@ -394,7 +391,8 @@ class GoogleLens:
                     else:
                         for word in line['words']:
                             res += word['plain_text'] + word['text_separator']
-                            
+                    res += '\n'
+
                 previous_line = paragraph
             res += '\n'
             # logger.info(
@@ -920,7 +918,7 @@ class OneOCR:
             self.regex = re.compile(
             r'[a-zA-Z\u00C0-\u00FF\u0100-\u017F\u0180-\u024F\u0250-\u02AF\u1D00-\u1D7F\u1D80-\u1DBF\u1E00-\u1EFF\u2C60-\u2C7F\uA720-\uA7FF\uAB30-\uAB6F]')
 
-    def __call__(self, img, furigana_filter_sensitivity=0, return_coords=False, multiple_crop_coords=False, return_one_box=True):
+    def __call__(self, img, furigana_filter_sensitivity=0, return_coords=False, multiple_crop_coords=False, return_one_box=True, return_dict=False):
         lang = get_ocr_language()
         if furigana_filter_sensitivity != None:
             furigana_filter_sensitivity = get_furigana_filter_sensitivity()
@@ -940,6 +938,7 @@ class OneOCR:
             return (False, 'Invalid image provided')
         crop_coords = None
         crop_coords_list = []
+        ocr_resp = ''
         if sys.platform == 'win32':
             try:
                 ocr_resp = self.model.recognize_pil(img)
@@ -959,17 +958,17 @@ class OneOCR:
                 boxes = []
                 if furigana_filter_sensitivity > 0:
                     for line in filtered_lines:
+                        line_x1, line_x2, line_x3, line_x4 = line['bounding_rect']['x1'], line['bounding_rect']['x2'], \
+                            line['bounding_rect']['x3'], line['bounding_rect']['x4']
+                        line_y1, line_y2, line_y3, line_y4 = line['bounding_rect']['y1'], line['bounding_rect']['y2'], \
+                            line['bounding_rect']['y3'], line['bounding_rect']['y4']
+                        line_width = max(line_x2 - line_x1, line_x3 - line_x4)
+                        line_height = max(line_y3 - line_y1, line_y4 - line_y2)
                         for char in line['words']:
                             if self.punctuation_regex.findall(char['text']):
                                 res += char['text']
                                 continue
-                            x1, x2, x3, x4 = char['bounding_rect']['x1'], char['bounding_rect']['x2'], \
-                            char['bounding_rect']['x3'], char['bounding_rect']['x4']
-                            y1, y2, y3, y4 = char['bounding_rect']['y1'], char['bounding_rect']['y2'], \
-                                char['bounding_rect']['y3'], char['bounding_rect']['y4']
-                            width = max(x2 - x1, x3 - x4)
-                            height = max(y3 - y1, y4 - y2)
-                            if width > furigana_filter_sensitivity and height > furigana_filter_sensitivity:
+                            if line_width > furigana_filter_sensitivity and line_height > furigana_filter_sensitivity:
                                 res += char['text']
                             else:
                                 skipped.extend(char for char in line['text'])
@@ -1042,6 +1041,8 @@ class OneOCR:
             x.append(crop_coords_list)
         if return_one_box:
             x.append(crop_coords)
+        if return_dict:
+            x.append(ocr_resp)
         if is_path:
             img.close()
         return x

{gamesentenceminer-2.14.19 → gamesentenceminer-2.14.21}/GameSentenceMiner/owocr/owocr/run.py

@@ -1785,7 +1785,7 @@ def run(read_from=None,
                     continue
 
                 res, text = process_and_write_results(img, write_to, last_result, filtering, notify,
-                                                   ocr_start_time=ocr_start_time, furigana_filter_sensitivity=get_ocr_furigana_filter_sensitivity())
+                                                   ocr_start_time=ocr_start_time, furigana_filter_sensitivity=None if get_ocr_two_pass_ocr() else get_furigana_filter_sensitivity())
                 if not text and not previous_text and time.time() - last_result_time > 10:
                     sleep_time_to_add += .005
                     logger.info(f"No text detected again, sleeping.")

gamesentenceminer-2.14.21/GameSentenceMiner/tools/furigana_filter_preview.py

@@ -0,0 +1,330 @@
+import tkinter as tk
+from tkinter import ttk
+from PIL import Image, ImageTk
+import threading
+
+import regex
+
+from GameSentenceMiner import obs
+from GameSentenceMiner.util.configuration import logger
+from GameSentenceMiner.owocr.owocr.ocr import GoogleLens, OneOCR
+
+def get_ocr_results_from_image(image_obj: Image.Image) -> tuple:
+    """
+    This is the function where you will plug in your OCR logic.
+
+    Args:
+        image_obj: A PIL Image object of the screenshot (used by your actual OCR call).
+
+    Returns:
+        A tuple containing the OCR results from both engines.
+    """
+    lens = GoogleLens()
+    oneocr = OneOCR()
+    oneocr_res = oneocr(image_obj, return_dict=True)
+    res = lens(image_obj, return_coords=True)
+    
+    return res[2], oneocr_res[3]
+
+
+class FuriganaFilterVisualizer:
+    def __init__(self, master, image: Image.Image, current_furigana_sensitivity: int = 0):
+        self.master = master
+        self.image = image
+        self.ocr1_result = None
+        self.ocr2_result = None
+        self.current_ocr = 1
+        self.master.title("Furigana Filter Visualizer - Lens")
+
+        self.words_data = []
+        self.lines_data = []
+        self.drawn_rects = []
+
+        main_frame = tk.Frame(master)
+        main_frame.pack(fill=tk.BOTH, expand=True)
+
+        self.photo_image = ImageTk.PhotoImage(self.image)
+        self.canvas = tk.Canvas(main_frame, width=self.image.width, height=self.image.height)
+        self.canvas.pack(side=tk.TOP, fill=tk.BOTH, expand=True)
+        self.canvas.create_image(0, 0, image=self.photo_image, anchor=tk.NW)
+
+        self.loading_bg = self.canvas.create_rectangle(
+            self.image.width/2 - 100, self.image.height/2 - 25,
+            self.image.width/2 + 100, self.image.height/2 + 25,
+            fill="black", outline="white", width=2
+        )
+        self.loading_text = self.canvas.create_text(
+            self.image.width / 2, self.image.height / 2,
+            text="Loading OCR data...", fill="white", font=("Helvetica", 16)
+        )
+
+        self.control_frame = tk.Frame(main_frame, padx=10, pady=10)
+        self.control_frame.pack(side=tk.BOTTOM, fill=tk.X)
+
+        ttk.Label(self.control_frame, text="Furigana Filter Sensitivity:").pack(side=tk.LEFT, padx=(0, 10))
+
+        self.slider = ttk.Scale(
+            self.control_frame, from_=0, to=100, orient=tk.HORIZONTAL, command=self.update_filter_visualization
+        )
+        self.slider.set(current_furigana_sensitivity)
+        self.slider.pack(side=tk.LEFT, fill=tk.X, expand=True)
+
+        self.slider_value_label = ttk.Label(self.control_frame, text=f"{self.slider.get():.0f} px", width=6)
+        self.slider_value_label.pack(side=tk.LEFT, padx=(10, 0))
+        
+        self.swap_button = ttk.Button(self.control_frame, text="Switch to OneOCR", command=self.swap_ocr)
+        self.swap_button.pack(side=tk.LEFT, padx=(10, 0))
+            
+        self.ok_button = ttk.Button(self.control_frame, text="OK", command=self.on_ok)
+        self.ok_button.pack(side=tk.LEFT, padx=(10, 0))
+        
+        self.slider.config(state=tk.DISABLED)
+        self.swap_button.config(state=tk.DISABLED)
+        self.ok_button.config(state=tk.DISABLED)
+
+        self.punctuation_regex = regex.compile(r'[\p{P}\p{S}]')
+        self.master.protocol("WM_DELETE_WINDOW", self.on_ok)
+
+    def update_with_ocr_data(self, ocr1_result, ocr2_result):
+        """Called by the background thread to populate the GUI with OCR data."""
+        self.ocr1_result = ocr1_result
+        self.ocr2_result = ocr2_result
+
+        # Remove loading message
+        self.canvas.delete(self.loading_bg)
+        self.canvas.delete(self.loading_text)
+
+        if not self.ocr1_result:
+            logger.error("OCR processing failed or returned no data.")
+            self.canvas.create_text(
+                self.image.width / 2, self.image.height / 2,
+                text="OCR Failed!", fill="red", font=("Helvetica", 16)
+            )
+            # Still enable OK button to allow closing
+            self.ok_button.config(state=tk.NORMAL)
+            return
+
+        # Enable controls
+        self.slider.config(state=tk.NORMAL)
+        self.ok_button.config(state=tk.NORMAL)
+        if self.ocr2_result:
+            self.swap_button.config(state=tk.NORMAL)
+        
+        # Process and display initial data
+        self.pre_process_word_geometries()
+        self.update_filter_visualization(self.slider.get())
+
+    def on_ok(self):
+        print(f"RESULT:[{self.slider.get():.0f}]")
+        self.master.destroy()
+
+    def swap_ocr(self):
+        self.current_ocr = 2 if self.current_ocr == 1 else 1
+        # Change to oneocr or lens, in title too
+        if self.current_ocr == 1:
+            self.swap_button.config(text="Switch to OneOCR")
+            self.master.title("Furigana Filter Visualizer - Lens")
+        else:
+            self.swap_button.config(text="Switch to Lens")
+            self.master.title("Furigana Filter Visualizer - OneOCR")
+        self.pre_process_word_geometries()
+        self.update_filter_visualization(self.slider.get())
+
+    def pre_process_word_geometries(self):
+        """
+        Parses the OCR result structure (supports both original and new JSON formats),
+        calculates absolute pixel values, and stores them for high-performance updates.
+        """
+        img_w, img_h = self.image.size
+        logger.info(f"Processing word geometries for image size {img_w}x{img_h}...")
+
+        # Select the current OCR result
+        ocr_result = self.ocr1_result if self.current_ocr == 1 else self.ocr2_result
+        if not ocr_result:
+            return
+        self.words_data.clear()
+        self.lines_data.clear()
+
+        # Try to detect the format: oneocr has 'lines' as a top-level key
+        if 'lines' in ocr_result:
+            for line in ocr_result.get('lines', []):
+                for word in line.get('words', []):
+                    try:
+                        bbox = word['bounding_rect']
+                        x1 = bbox['x1']
+                        y1 = bbox['y1']
+                        x2 = bbox['x3']
+                        y2 = bbox['y3']
+                        px_w = abs(x2 - x1)
+                        px_h = abs(y2 - y1)
+                        self.words_data.append({
+                            'text': word.get('text', ''),
+                            'px_w': px_w,
+                            'px_h': px_h,
+                            'coords': (x1, y1, x2, y2)
+                        })
+                    except Exception as e:
+                        logger.warning(f"Skipping malformed word data (new format): {e}. Data: {word}")
+                        continue
+                try:
+                    bbox = line['bounding_rect']
+                    x1 = bbox['x1']
+                    y1 = bbox['y1']
+                    x2 = bbox['x3']
+                    y2 = bbox['y3']
+                    px_w = abs(x2 - x1)
+                    px_h = abs(y2 - y1)
+                    self.lines_data.append({
+                        'text': line.get('text', ''),
+                        'px_w': px_w,
+                        'px_h': px_h,
+                        'coords': (x1, y1, x2, y2)
+                    })
+                except Exception as e:
+                    logger.warning(f"Skipping malformed line data (new format): {e}. Data: {line}")
+                    continue
+        else:
+            # Lens format (nested paragraphs/lines/words)
+            text_layout = ocr_result.get('objects_response', {}).get('text', {}).get('text_layout', {})
+            if not text_layout:
+                logger.error("Could not find 'text_layout' in the OCR response.")
+                return
+            for paragraph in text_layout.get('paragraphs', []):
+                for line in paragraph.get('lines', []):
+                    for word in line.get('words', []):
+                        try:
+                            bbox_pct = word['geometry']['bounding_box']
+                            width_pct = bbox_pct['width']
+                            height_pct = bbox_pct['height']
+                            top_left_x_pct = bbox_pct['center_x'] - (width_pct / 2)
+                            top_left_y_pct = bbox_pct['center_y'] - (height_pct / 2)
+                            px_w = width_pct * img_w
+                            px_h = height_pct * img_h
+                            x1 = top_left_x_pct * img_w
+                            y1 = top_left_y_pct * img_h
+                            x2 = x1 + px_w
+                            y2 = y1 + px_h
+                            self.words_data.append({
+                                'text': word.get('plain_text', ''),
+                                'px_w': px_w,
+                                'px_h': px_h,
+                                'coords': (x1, y1, x2, y2)
+                            })
+                        except (KeyError, TypeError) as e:
+                            logger.warning(f"Skipping malformed word data (orig format): {e}. Data: {word}")
+                            continue
+                    try:
+                        line_bbox = line['geometry']['bounding_box']
+                        width_pct = line_bbox['width']
+                        height_pct = line_bbox['height']
+                        top_left_x_pct = line_bbox['center_x'] - (width_pct / 2)
+                        top_left_y_pct = line_bbox['center_y'] - (height_pct / 2)
+                        px_w = width_pct * img_w
+                        px_h = height_pct * img_h
+                        x1 = top_left_x_pct * img_w
+                        y1 = top_left_y_pct * img_h
+                        x2 = x1 + px_w
+                        y2 = y1 + px_h
+                        self.lines_data.append({
+                            'text': ''.join([w.get('plain_text', '') for w in line.get('words', [])]),
+                            'px_w': px_w,
+                            'px_h': px_h,
+                            'coords': (x1, y1, x2, y2)
+                        })
+                    except (KeyError, TypeError) as e:
+                        logger.warning(f"Skipping malformed line data (orig format): {e}. Data: {line}")
+                        continue
+        logger.info(f"Successfully pre-processed {len(self.lines_data)} lines.")
+        
+
+    def update_filter_visualization(self, slider_value):
+        """
+        Called on every slider move. Clears old rectangles and draws new ones
+        for words that pass the sensitivity filter.
+        """
+        sensitivity = float(slider_value)
+        self.slider_value_label.config(text=f"{sensitivity:.0f} px")
+
+        for rect_id in self.drawn_rects:
+            self.canvas.delete(rect_id)
+        self.drawn_rects.clear()
+
+        for line_data in self.lines_data:
+            if line_data['px_w'] > sensitivity and line_data['px_h'] > sensitivity:
+                x1, y1, x2, y2 = line_data['coords']
+                rect_id = self.canvas.create_rectangle(
+                    x1, y1, x2, y2, outline='blue', width=2
+                )
+                self.drawn_rects.append(rect_id)
+
+def scale_down_width_height(width, height):
+        if width == 0 or height == 0:
+            return width, height
+        aspect_ratio = width / height
+        if aspect_ratio > 2.66:
+            # Ultra-wide (32:9) - use 1920x540
+            return 1920, 540
+        elif aspect_ratio > 2.33:
+            # 21:9 - use 1920x800
+            return 1920, 800
+        elif aspect_ratio > 1.77:
+            # 16:9 - use 1280x720
+            return 1280, 720
+        elif aspect_ratio > 1.6:
+            # 16:10 - use 1280x800
+            return 1280, 800
+        elif aspect_ratio > 1.33:
+            # 4:3 - use 960x720
+            return 960, 720
+        elif aspect_ratio > 1.25:
+            # 5:4 - use 900x720
+            return 900, 720
+        elif aspect_ratio > 1.5:
+            # 3:2 - use 1080x720
+            return 1080, 720
+        else:
+            # Default/fallback - use original resolution
+            print(f"Unrecognized aspect ratio {aspect_ratio}. Using original resolution.")
+            return width, height
+
+def main():
+    import sys
+    current_furigana_sensitivity = int(sys.argv[1]) if len(sys.argv) > 1 else 0
+
+    """Main execution function."""
+    try:
+        logger.info("Connecting to OBS...")
+        obs.connect_to_obs_sync()
+    except Exception as e:
+        logger.error(f"Failed to connect to OBS. Please ensure OBS is running and the WebSocket server is enabled. Error: {e}")
+        return
+
+    logger.info("Taking OBS screenshot...")
+    screenshot_img = obs.get_screenshot_PIL(compression=90, img_format='jpg')
+
+    screenshot_img = screenshot_img.resize(scale_down_width_height(screenshot_img.width, screenshot_img.height), Image.LANCZOS)
+
+    if not screenshot_img:
+        logger.error("Failed to get screenshot from OBS.")
+        return
+
+    logger.info(f"Screenshot received ({screenshot_img.width}x{screenshot_img.height}).")
+
+    root = tk.Tk()
+    app = FuriganaFilterVisualizer(root, screenshot_img, current_furigana_sensitivity)
+
+    def ocr_worker():
+        logger.info("Starting OCR process in background thread...")
+        try:
+            ocr1_data, ocr2_data = get_ocr_results_from_image(screenshot_img)
+            root.after(0, app.update_with_ocr_data, ocr1_data, ocr2_data)
+        except Exception as e:
+            logger.error(f"Error in OCR background thread: {e}")
+            root.after(0, app.update_with_ocr_data, None, None)
+
+    threading.Thread(target=ocr_worker, daemon=True).start()
+
+    root.mainloop()
+
+if __name__ == "__main__":
+    main()

{gamesentenceminer-2.14.19 → gamesentenceminer-2.14.21}/GameSentenceMiner/vad.py

@@ -150,9 +150,9 @@ class SileroVADProcessor(VADProcessor):
 
     def _detect_voice_activity(self, input_audio):
         from silero_vad import read_audio, get_speech_timestamps
-        # temp_wav = tempfile.NamedTemporaryFile(dir=configuration.get_temporary_directory(), suffix='.wav').name
-        # ffmpeg.convert_audio_to_wav(input_audio, temp_wav)
-        wav = read_audio(input_audio)
+        temp_wav = tempfile.NamedTemporaryFile(dir=configuration.get_temporary_directory(), suffix='.wav').name
+        ffmpeg.convert_audio_to_wav(input_audio, temp_wav)
+        wav = read_audio(temp_wav)
         speech_timestamps = get_speech_timestamps(wav, self.vad_model, return_seconds=True, threshold=0.2)
         logger.debug(speech_timestamps)
         return speech_timestamps
@@ -173,15 +173,15 @@ class WhisperVADProcessor(VADProcessor):
 
     def _detect_voice_activity(self, input_audio):
         from stable_whisper import WhisperResult
-        # Convert the audio to 16kHz mono WAV
-        # temp_wav = tempfile.NamedTemporaryFile(dir=configuration.get_temporary_directory(), suffix='.wav').name
-        # ffmpeg.convert_audio_to_wav(input_audio, temp_wav)
+        # Convert the audio to 16kHz mono WAV, evidence https://discord.com/channels/1286409772383342664/1286518821913362445/1407017127529152533
+        temp_wav = tempfile.NamedTemporaryFile(dir=configuration.get_temporary_directory(), suffix='.wav').name
+        ffmpeg.convert_audio_to_wav(input_audio, temp_wav)
 
         logger.info('transcribing audio...')
 
         # Transcribe the audio using Whisper
         with warnings.catch_warnings():
-            result: WhisperResult = self.vad_model.transcribe(input_audio, vad=True, language=get_config().vad.language,
+            result: WhisperResult = self.vad_model.transcribe(temp_wav, vad=True, language=get_config().vad.language,
                                                              temperature=0.0)
         voice_activity = []
 
@@ -376,7 +376,7 @@ vad_processor = VADSystem()
 # Test cases for all VADProcessors
 def test_vad_processors():
     logger.setLevel(logging.DEBUG)
-    test_audio = r"C:\Users\Beangate\GSM\GameSentenceMiner\GameSentenceMiner\test\tmpso7v0265.opus"
+    test_audio = r"C:\Users\Beangate\GSM\GameSentenceMiner\GameSentenceMiner\test\NEKOPARAvol.1_2025-08-18-17-20-43-614.opus"
     output_dir = r"C:\Users\Beangate\GSM\GameSentenceMiner\GameSentenceMiner\test\output"
     os.makedirs(output_dir, exist_ok=True)
     processors = [

{gamesentenceminer-2.14.19 → gamesentenceminer-2.14.21}/GameSentenceMiner.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GameSentenceMiner
-Version: 2.14.19
+Version: 2.14.21
 Summary: A tool for mining sentences from games. Update: Overlay?
 Author-email: Beangate <bpwhelan95@gmail.com>
 License: MIT License

{gamesentenceminer-2.14.19 → gamesentenceminer-2.14.21}/GameSentenceMiner.egg-info/SOURCES.txt

@@ -42,6 +42,7 @@ GameSentenceMiner/owocr/owocr/run.py
 GameSentenceMiner/owocr/owocr/screen_coordinate_picker.py
 GameSentenceMiner/tools/__init__.py
 GameSentenceMiner/tools/audio_offset_selector.py
+GameSentenceMiner/tools/furigana_filter_preview.py
 GameSentenceMiner/tools/ss_selector.py
 GameSentenceMiner/tools/window_transparency.py
 GameSentenceMiner/util/__init__.py

{gamesentenceminer-2.14.19 → gamesentenceminer-2.14.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GameSentenceMiner
-Version: 2.14.19
+Version: 2.14.21
 Summary: A tool for mining sentences from games. Update: Overlay?
 Author-email: Beangate <bpwhelan95@gmail.com>
 License: MIT License

{gamesentenceminer-2.14.19 → gamesentenceminer-2.14.21}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "GameSentenceMiner"
-version = "2.14.19"
+version = "2.14.21"
 description = "A tool for mining sentences from games. Update: Overlay?"
 readme = "README.md"
 requires-python = ">=3.10"