GameSentenceMiner 2.14.20__py3-none-any.whl → 2.15.0__py3-none-any.whl

GameSentenceMiner/config_gui.py

@@ -2192,6 +2192,9 @@ class ConfigApp:
                                 row=self.current_row, column=0)
         self.overlay_monitor = ttk.Combobox(overlay_frame, values=self.monitors, state="readonly")
         self.overlay_monitor.grid(row=self.current_row, column=1, sticky='EW', pady=2)
+        # disable selection for now, default to value 1
+        self.overlay_monitor.current(1)
+        self.overlay_monitor.config(state="disabled")
         self.current_row += 1
         
         if self.monitors:

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/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
@@ -483,6 +483,9 @@ def set_fit_to_screen_for_scene_items(scene_name: str):
     try:
         # 1. Get the canvas (base) resolution from OBS video settings
         video_settings = client.get_video_settings()
+        if not hasattr(video_settings, 'base_width') or not hasattr(video_settings, 'base_height'):
+            logger.debug("Video settings do not have base_width or base_height attributes, probably weird websocket error issue? Idk what causes it..")
+            return
         canvas_width = video_settings.base_width
         canvas_height = video_settings.base_height
 
@@ -499,12 +502,23 @@ def set_fit_to_screen_for_scene_items(scene_name: str):
             item_id = item['sceneItemId']
             source_name = item['sourceName']
             
+            scene_item_transform = item.get('sceneItemTransform', {})
+            
+            source_width = scene_item_transform.get('sourceWidth', None)
+            source_height = scene_item_transform.get('sourceHeight', None)
+            
             # This transform object is the equivalent of "Fit to Screen"
             fit_to_screen_transform = {
                 'boundsType': 'OBS_BOUNDS_SCALE_INNER',
                 'alignment': 5,  # 5 = Center alignment (horizontal and vertical)
                 'boundsWidth': canvas_width,
                 'boundsHeight': canvas_height,
+                'positionX': 0,
+                'positionY': 0,
+                'cropLeft': 0 if canvas_width >= source_width else (source_width - canvas_width) // 2,
+                'cropRight': 0 if canvas_width >= source_width else (source_width - canvas_width) // 2,
+                'cropTop': 0 if canvas_height >= source_height else (source_height - canvas_height) // 2,
+                'cropBottom': 0 if canvas_height >= source_height else (source_height - canvas_height) // 2,
             }
 
             try:
@@ -559,7 +573,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/ocr/gsm_ocr_config.py

@@ -83,7 +83,6 @@ class OCRConfig:
                 ]
 
     def scale_to_custom_size(self, width, height):
-        print(self.pre_scale_rectangles)
         self.rectangles = self.pre_scale_rectangles.copy()
         if self.coordinate_system and self.coordinate_system == "percentage":
             for rectangle in self.rectangles:

GameSentenceMiner/ocr/owocr_helper.py

@@ -228,7 +228,6 @@ def save_result_image(img, pre_crop_image=None):
 
 async def send_result(text, time):
     if text:
-        text = do_text_replacements(text, OCR_REPLACEMENTS_FILE)
         if get_ocr_send_to_clipboard():
             import pyperclip
             pyperclip.copy(text)

GameSentenceMiner/owocr/owocr/ocr.py

@@ -106,6 +106,7 @@ def empty_post_process(text):
 
 def post_process(text, keep_blank_lines=False):
     import jaconv
+    text = text.replace("\"", "")
     if keep_blank_lines:
         text = '\n'.join([''.join(i.split()) for i in text.splitlines()])
     else:
@@ -354,8 +355,8 @@ class GoogleLens:
         response_proto = LensOverlayServerResponse().FromString(res.content)
         response_dict = response_proto.to_dict(betterproto.Casing.SNAKE)
 
-        if os.path.exists(r"C:\Users\Beangate\GSM\Electron App\test"):
-            with open(os.path.join(r"C:\Users\Beangate\GSM\Electron App\test", 'glens_response.json'), 'w', encoding='utf-8') as f:
+        if os.path.exists(r"C:\Users\Beangate\GSM\test"):
+            with open(os.path.join(r"C:\Users\Beangate\GSM\test", 'glens_response.json'), 'w', encoding='utf-8') as f:
                 json.dump(response_dict, f, indent=4, ensure_ascii=False)
         res = ''
         text = response_dict['objects_response']['text']
@@ -377,16 +378,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 +392,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 +919,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 +939,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 +959,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 +1042,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
@@ -1432,10 +1434,10 @@ class localLLMOCR:
             self.keep_warm = config.get('keep_warm', True)
             self.custom_prompt = config.get('prompt', None)
             self.available = True
-            # if any(x in self.api_url for x in ['localhost', '127.0.0.1']):
-            #     if not self.check_connection(self.api_url):
-            #         logger.warning('Local LLM OCR API is not reachable')
-            #         return
+            if any(x in self.api_url for x in ['localhost', '127.0.0.1']):
+                if not self.check_connection(self.api_url):
+                    logger.warning('Local LLM OCR API is not reachable')
+                    return
             self.client = openai.OpenAI(
                 base_url=self.api_url.replace('/v1/chat/completions', '/v1'),
                 api_key=self.api_key
@@ -1492,7 +1494,7 @@ class localLLMOCR:
                 prompt = self.custom_prompt.strip()
             else:
                 prompt = f"""
-                Extract all {CommonLanguages.from_code(get_ocr_language()).name} Text from Image. Ignore all Furigana. Do not return any commentary, just the text in the image. If there is no text in the image, return "" (Empty String).
+                Extract all {CommonLanguages.from_code(get_ocr_language()).name} Text from Image. Ignore all Furigana. Do not return any commentary, just the text in the image. Do not Translate. If there is no text in the image, return "" (Empty String).
                 """
 
             response = self.client.chat.completions.create(

GameSentenceMiner/owocr/owocr/run.py

@@ -1,5 +1,6 @@
-from ...ocr.gsm_ocr_config import set_dpi_awareness, get_scene_ocr_config_path, OCRConfig, get_scene_ocr_config
-from ...util.electron_config import *
+from GameSentenceMiner.ocr.gsm_ocr_config import set_dpi_awareness, get_scene_ocr_config
+from GameSentenceMiner.util.electron_config import *  # noqa: F403
+from GameSentenceMiner.util.gsm_utils import do_text_replacements, OCR_REPLACEMENTS_FILE
 
 try:
     import win32gui
@@ -28,7 +29,6 @@ import signal
 import threading
 from pathlib import Path
 import queue
-import io
 import re
 import logging
 import inspect
@@ -39,23 +39,22 @@ import mss
 import asyncio
 import websockets
 import socketserver
-import queue
+import cv2
+import numpy as np
 
 from datetime import datetime, timedelta
-from PIL import Image, ImageDraw, UnidentifiedImageError
+from PIL import Image, ImageDraw
 from loguru import logger
 from desktop_notifier import DesktopNotifierSync
 import psutil
 
-import inspect
-from .ocr import *
-try:
-    from .secret import *
-except ImportError:
-    pass
+from .ocr import *  # noqa: F403
 from .config import Config
 from .screen_coordinate_picker import get_screen_selection
-from GameSentenceMiner.util.configuration import get_temporary_directory, get_config
+from GameSentenceMiner.util.configuration import get_temporary_directory
+
+from skimage.metrics import structural_similarity as ssim
+from typing import Union
 
 config = None
 last_image = None
@@ -799,8 +798,6 @@ class ScreenshotThread(threading.Thread):
             self.windows_window_tracker_instance.join()
 
 
-import cv2
-import numpy as np
     
 def apply_adaptive_threshold_filter(img):
     img = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)
@@ -865,11 +862,6 @@ def are_images_identical(img1, img2, img2_np=None):
     return (img1_np.shape == img2_np.shape) and np.array_equal(img1_np, img2_np)
 
 
-import cv2
-import numpy as np
-from skimage.metrics import structural_similarity as ssim
-from typing import Union
-
 ImageType = Union[np.ndarray, Image.Image]
 
 def _prepare_image(image: ImageType) -> np.ndarray:
@@ -1319,6 +1311,10 @@ def on_screenshot_combo():
 def on_window_minimized(minimized):
     global screencapture_window_visible
     screencapture_window_visible = not minimized
+    
+
+def do_configured_ocr_replacements(text: str) -> str:
+    return do_text_replacements(text, OCR_REPLACEMENTS_FILE)
 
 
 def process_and_write_results(img_or_path, write_to=None, last_result=None, filtering=None, notify=None, engine=None, ocr_start_time=None, furigana_filter_sensitivity=0):
@@ -1364,14 +1360,21 @@ def process_and_write_results(img_or_path, write_to=None, last_result=None, filt
     # print(engine_index)
 
     if res:
+        text = do_configured_ocr_replacements(text)
         if filtering:
             text, orig_text = filtering(text, last_result)
         if get_ocr_language() == "ja" or get_ocr_language() == "zh":
             text = post_process(text, keep_blank_lines=get_ocr_keep_newline())
-        logger.opt(ansi=True).info(
-            f'Text recognized in {end_time - start_time:0.03f}s using <{engine_color}>{engine_instance.readable_name}</{engine_color}>: {text}')
         if notify and config.get_general('notifications'):
             notifier.send(title='owocr', message='Text recognized: ' + text)
+            
+        if text and write_to is not None:
+            if check_text_is_all_menu(text, crop_coords):
+                logger.opt(ansi=True).info('Text is identified as all menu items, skipping further processing.')
+                return orig_text, ''
+            
+        logger.opt(ansi=True).info(
+    f'Text recognized in {end_time - start_time:0.03f}s using <{engine_color}>{engine_instance.readable_name}</{engine_color}>: {text}')
 
         if write_to == 'websocket':
             websocket_server_thread.send_text(text)
@@ -1395,6 +1398,83 @@ def process_and_write_results(img_or_path, write_to=None, last_result=None, filt
 
     return orig_text, text
 
+def check_text_is_all_menu(text: str, crop_coords: tuple) -> bool:
+    """
+    Checks if the recognized text consists entirely of menu items.
+    This function checks if the detected text area falls entirely within secondary rectangles (menu areas).
+
+    :param text: The recognized text from OCR.
+    :param crop_coords: Tuple containing (x, y, width, height) of the detected text area relative to the cropped image.
+    :return: True if the text is all menu items (within secondary rectangles), False otherwise.
+    """
+    if not text or not crop_coords:
+        return False
+
+    original_width = obs_screenshot_thread.width
+    original_height = obs_screenshot_thread.height
+    crop_x, crop_y, crop_w, crop_h = crop_coords
+
+    ocr_config = get_scene_ocr_config()
+    
+    if not any(rect.is_secondary for rect in ocr_config.rectangles):
+        return False
+
+    ocr_config.scale_to_custom_size(original_width, original_height)
+    if not ocr_config or not ocr_config.rectangles:
+        return False
+
+    primary_rectangles = [rect for rect in ocr_config.rectangles if not rect.is_excluded and not rect.is_secondary]
+    menu_rectangles = [rect for rect in ocr_config.rectangles if rect.is_secondary and not rect.is_excluded]
+
+    if not menu_rectangles:
+        return False
+
+    if not primary_rectangles:
+        if crop_x < 0 or crop_y < 0 or crop_x + crop_w > original_width or crop_y + crop_h > original_height:
+            return False
+        for menu_rect in menu_rectangles:
+            rect_left, rect_top, rect_width, rect_height = menu_rect.coordinates
+            rect_right = rect_left + rect_width
+            rect_bottom = rect_top + rect_height
+            if (crop_x >= rect_left and crop_y >= rect_top and
+                crop_x + crop_w <= rect_right and crop_y + crop_h <= rect_bottom):
+                return True
+        return False
+
+    primary_rectangles.sort(key=lambda r: r.coordinates[1])
+
+    if len(primary_rectangles) == 1:
+        primary_rect = primary_rectangles[0]
+        primary_left, primary_top = primary_rect.coordinates[0], primary_rect.coordinates[1]
+        original_x = crop_x + primary_left
+        original_y = crop_y + primary_top
+    else:
+        current_y_offset = 0
+        original_x = None
+        original_y = None
+        for i, primary_rect in enumerate(primary_rectangles):
+            primary_left, primary_top, primary_width, primary_height = primary_rect.coordinates
+            section_height = primary_height
+            if crop_y >= current_y_offset and crop_y < current_y_offset + section_height:
+                original_x = crop_x + primary_left
+                original_y = (crop_y - current_y_offset) + primary_top
+                break
+            current_y_offset += section_height + 50
+        if original_x is None or original_y is None:
+            return False
+
+    if original_x < 0 or original_y < 0 or original_x > original_width or original_y > original_height:
+        return False
+
+    for menu_rect in menu_rectangles:
+        rect_left, rect_top, rect_width, rect_height = menu_rect.coordinates
+        rect_right = rect_left + rect_width
+        rect_bottom = rect_top + rect_height
+        if (original_x >= rect_left and original_y >= rect_top and
+            original_x <= rect_right and original_y <= rect_bottom):
+            return True
+
+    return False
 
 def get_path_key(path):
     return path, path.lstat().st_mtime
@@ -1785,7 +1865,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/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/util/get_overlay_coords.py

@@ -94,26 +94,59 @@ class OverlayProcessor:
         except Exception as e:
             logger.error(f"Error during OCR processing: {e}", exc_info=True)
             return []
+        
+    @staticmethod
+    def get_monitor_workarea(monitor_index=0):
+        """
+        Return MSS-style dict for monitor area.
+        For primary monitor, excludes taskbar. For others, returns full monitor area.
+        monitor_index: 0 = primary monitor, 1+ = others (as in mss.monitors).
+        """
+        with mss.mss() as sct:
+            monitors = sct.monitors[1:]
+            print(monitors)
+            if is_windows() and monitor_index == 0:
+                from ctypes import wintypes
+                import ctypes
+                # Get work area for primary monitor (ignores taskbar)
+                SPI_GETWORKAREA = 0x0030
+                rect = wintypes.RECT()
+                res = ctypes.windll.user32.SystemParametersInfoW(
+                    SPI_GETWORKAREA, 0, ctypes.byref(rect), 0
+                )
+                if not res:
+                    raise ctypes.WinError()
+                
+                return {
+                    "left": rect.left,
+                    "top": rect.top,
+                    "width": rect.right - rect.left,
+                    "height": rect.bottom - rect.top,
+                }
+            elif is_windows() and monitor_index > 0:
+                # Secondary monitors: just return with a guess of how tall the taskbar is
+                taskbar_height_guess = 48  # A common taskbar height, may vary
+                mon = monitors[monitor_index]
+                return {
+                    "left": mon["left"],
+                    "top": mon["top"],
+                    "width": mon["width"],
+                    "height": mon["height"] - taskbar_height_guess
+                }
+            else:
+                # For non-Windows systems or unspecified monitors, return the monitor area as-is
+                return monitors[monitor_index] if 0 <= monitor_index < len(monitors) else monitors[0]
+
 
     def _get_full_screenshot(self) -> Tuple[Image.Image | None, int, int]:
         """Captures a screenshot of the configured monitor."""
         if not mss:
             raise RuntimeError("MSS screenshot library is not installed.")
-        
         with mss.mss() as sct:
-            monitors = sct.monitors
-            # Index 0 is the 'all monitors' virtual screen, so we skip it.
-            monitor_list = monitors[1:] if len(monitors) > 1 else [monitors[0]]
-            
-            monitor_index = self.config.overlay.monitor_to_capture
-            if monitor_index >= len(monitor_list):
-                logger.error(f"Monitor index {monitor_index} is out of bounds. Found {len(monitor_list)} monitors.")
-                return None, 0, 0
-                
-            monitor = monitor_list[monitor_index]
+            monitor = self.get_monitor_workarea(0)  # Get primary monitor work area
             sct_img = sct.grab(monitor)
             img = Image.frombytes('RGB', sct_img.size, sct_img.bgra, 'raw', 'BGRX')
-            
+                
             return img, monitor['width'], monitor['height']
 
     def _create_composite_image(
@@ -210,7 +243,8 @@ class OverlayProcessor:
             crop_x=0,
             crop_y=0,
             crop_width=composite_image.width,
-            crop_height=composite_image.height
+            crop_height=composite_image.height,
+            use_percentages=True
         )
         
         return extracted_data
@@ -223,7 +257,8 @@ class OverlayProcessor:
         crop_x: int,
         crop_y: int,
         crop_width: int,
-        crop_height: int
+        crop_height: int,
+        use_percentages: bool
     ) -> List[Dict[str, Any]]:
         """
         Parses Google Lens API response and converts normalized coordinates
@@ -244,9 +279,10 @@ class OverlayProcessor:
                     word_text = word.get("plain_text", "")
                     line_text_parts.append(word_text)
                     
-                    word_box = self._convert_box_to_pixels_v2(
+                    word_box = self._convert_box_to_overlay_coords(
                         word["geometry"]["bounding_box"],
-                        crop_x, crop_y, crop_width, crop_height
+                        crop_x, crop_y, crop_width, crop_height,
+                        use_percentage=use_percentages
                     )
                     
                     word_list.append({
@@ -258,9 +294,9 @@ class OverlayProcessor:
                     continue
                 
                 full_line_text = "".join(line_text_parts)
-                line_box = self._convert_box_to_pixels_v2(
+                line_box = self._convert_box_to_overlay_coords(
                     line["geometry"]["bounding_box"],
-                    crop_x, crop_y, crop_width, crop_height
+                    crop_x, crop_y, crop_width, crop_height, use_percentage=use_percentages
                 )
 
                 results.append({
@@ -270,36 +306,45 @@ class OverlayProcessor:
                 })
         return results
 
-    def _convert_box_to_pixels_v2(
+    def _convert_box_to_overlay_coords(
         self,
         bbox_data: Dict[str, float],
         crop_x: int,
         crop_y: int,
         crop_width: int,
-        crop_height: int
+        crop_height: int,
+        use_percentage: bool
     ) -> Dict[str, float]:
         """
         Simplified conversion: scales normalized bbox to pixel coordinates within
         the cropped region, then offsets by the crop position. Ignores rotation.
+        If use_percentage is True, returns coordinates as percentages of the crop dimensions.
         """
         cx, cy = bbox_data['center_x'], bbox_data['center_y']
         w, h = bbox_data['width'], bbox_data['height']
 
-        # Scale normalized coordinates to pixel coordinates relative to the crop area
-        box_width_px = w * crop_width
-        box_height_px = h * crop_height
-        
-        # Calculate center within the cropped area and then add the crop offset
-        center_x_px = (cx * crop_width) + crop_x
-        center_y_px = (cy * crop_height) + crop_y
+        if use_percentage:
+            # Return coordinates as percentages of the crop dimensions
+            box_width = w
+            box_height = h
+            center_x = cx
+            center_y = cy
+        else:
+            # Scale normalized coordinates to pixel coordinates relative to the crop area
+            box_width = w * crop_width
+            box_height = h * crop_height
+
+            # Calculate center within the cropped area and then add the crop offset
+            center_x = (cx * crop_width) + crop_x
+            center_y = (cy * crop_height) + crop_y
 
         # Calculate corners (unrotated)
-        half_w_px, half_h_px = box_width_px / 2, box_height_px / 2
+        half_w, half_h = box_width / 2, box_height / 2
         return {
-            "x1": center_x_px - half_w_px, "y1": center_y_px - half_h_px,
-            "x2": center_x_px + half_w_px, "y2": center_y_px - half_h_px,
-            "x3": center_x_px + half_w_px, "y3": center_y_px + half_h_px,
-            "x4": center_x_px - half_w_px, "y4": center_y_px + half_h_px,
+            "x1": center_x - half_w, "y1": center_y - half_h,
+            "x2": center_x + half_w, "y2": center_y - half_h,
+            "x3": center_x + half_w, "y3": center_y + half_h,
+            "x4": center_x - half_w, "y4": center_y + half_h,
         }
 
 async def main_test_screenshot():
@@ -334,22 +379,10 @@ async def main_run_ocr():
     """
     Main function to demonstrate running the full OCR process.
     """
-    processor = OverlayProcessor()
-    results, _ = await processor.find_box_for_sentence()
-    if results:
-        import json
-        print("OCR process completed successfully.")
-        # print(json.dumps(results, indent=2, ensure_ascii=False))
-        # Find first result with some text
-        for result in results:
-            if result.get("text"):
-                print(f"Found line: '{result['text']}'")
-                print(f"  - Line BBox: {result['bounding_rect']}")
-                if result.get("words"):
-                    print(f"  - First word: '{result['words'][0]['text']}' BBox: {result['words'][0]['bounding_rect']}")
-                break
-    else:
-        print("OCR process did not find any text.")
+    overlay_processor = OverlayProcessor()
+    while True:
+        await overlay_processor.find_box_and_send_to_overlay('')
+        await asyncio.sleep(10)
 
 
 if __name__ == '__main__':

GameSentenceMiner/vad.py

@@ -173,7 +173,7 @@ class WhisperVADProcessor(VADProcessor):
 
     def _detect_voice_activity(self, input_audio):
         from stable_whisper import WhisperResult
-        # Convert the audio to 16kHz mono 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)
 
@@ -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\NEKOPARAvol.1_2025-08-18-16-42-32-020.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.20.dist-info → gamesentenceminer-2.15.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GameSentenceMiner
-Version: 2.14.20
+Version: 2.15.0
 Summary: A tool for mining sentences from games. Update: Overlay?
 Author-email: Beangate <bpwhelan95@gmail.com>
 License: MIT License
@@ -57,7 +57,7 @@ An application designed to assist with language learning through games.
 
 Short Demo (Watch this first): https://www.youtube.com/watch?v=FeFBL7py6HY
 
-Installation: https://youtu.be/h5ksXallc-o
+Installation: https://www.youtube.com/watch?v=sVL9omRbGc4
 
 Discord: https://discord.gg/yP8Qse6bb8
 

{gamesentenceminer-2.14.20.dist-info → gamesentenceminer-2.15.0.dist-info}/RECORD

@@ -1,10 +1,10 @@
 GameSentenceMiner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/anki.py,sha256=4Tq6OGjfN-5tYorYRWiih7FZjSKMG6amrLv6DFKkFQc,25344
-GameSentenceMiner/config_gui.py,sha256=SDZ4TEkdhvXxOM_pEG1LABt12M1QkKjMHcQX7bG0OAs,139519
+GameSentenceMiner/config_gui.py,sha256=Ynr7P0xkhqeOiO-7aiM9OzB3aTLs5JSlEsia5cHyyd4,139669
 GameSentenceMiner/gametext.py,sha256=fgBgLchezpauWELE9Y5G3kVCLfAneD0X4lJFoI3FYbs,10351
-GameSentenceMiner/gsm.py,sha256=0ycEa5PaDo7bU9xsiGt-XyYaERSYiiYJgGpVRLeFZis,31275
-GameSentenceMiner/obs.py,sha256=7A84DnzO14s98JZ7DIlENuLNGzvf7t7VEKggIrqbeW8,23519
-GameSentenceMiner/vad.py,sha256=IV34ZSrhJWdzlyDi1T8U8S-76mzFnwAX77NjRKbBxLA,19137
+GameSentenceMiner/gsm.py,sha256=4mJn5v4WKqKAJEtph5e0v4YPVDOpvFN1ylV2vQvf_Dg,31913
+GameSentenceMiner/obs.py,sha256=U7ooVhf3k0vx-T8noSLVQirgCbS27fNnuZmpfM6alnc,24580
+GameSentenceMiner/vad.py,sha256=YCn4ZIc6_Q3IGOr5QNMiheVT3Ma5nisn8-V8xD53Mw4,19236
 GameSentenceMiner/ai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/ai/ai_prompting.py,sha256=41xdBzE88Jlt12A0D-T_cMfLO5j6MSxfniOptpwNZm0,24068
 GameSentenceMiner/assets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -19,20 +19,21 @@ GameSentenceMiner/locales/en_us.json,sha256=FAnvsCfsFzWyxYKZKh8HKHsAahi3Oa4wGVek
 GameSentenceMiner/locales/ja_jp.json,sha256=-v0ng0psD88-C4XjYazJL0Rn0gwQU7b2VYspvdatDO4,28326
 GameSentenceMiner/locales/zh_cn.json,sha256=X5nw6tsu7ACaZIuSUDSUUjG8qPUwmqyG3TKcPbWSIYw,24654
 GameSentenceMiner/ocr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-GameSentenceMiner/ocr/gsm_ocr_config.py,sha256=QyBarjb6Wjt-oyor1sIT9hG-KrGdi6wODLyCrHXun6E,6008
+GameSentenceMiner/ocr/gsm_ocr_config.py,sha256=DfcR3bHTu26JJerLzqfW_KpdgUBSrRV4hqSy_LYclps,5967
 GameSentenceMiner/ocr/ocrconfig.py,sha256=_tY8mjnzHMJrLS8E5pHqYXZjMuLoGKYgJwdhYgN-ny4,6466
 GameSentenceMiner/ocr/owocr_area_selector.py,sha256=Rm1_nuZotJhfOfoJ_3mesh9udtOBjYqKhnAvSief6fo,29181
-GameSentenceMiner/ocr/owocr_helper.py,sha256=vquG3O1-2LdAuSt9yQ5hFzCv2E5rDnfqw7eaY33zsYM,28502
+GameSentenceMiner/ocr/owocr_helper.py,sha256=8aIpAHSPPByox5qcU4SX-_ECDgQZVEwrXdj4A8AQZ6U,28437
 GameSentenceMiner/ocr/ss_picker.py,sha256=0IhxUdaKruFpZyBL-8SpxWg7bPrlGpy3lhTcMMZ5rwo,5224
 GameSentenceMiner/owocr/owocr/__init__.py,sha256=87hfN5u_PbL_onLfMACbc0F5j4KyIK9lKnRCj6oZgR0,49
 GameSentenceMiner/owocr/owocr/__main__.py,sha256=XQaqZY99EKoCpU-gWQjNbTs7Kg17HvBVE7JY8LqIE0o,157
 GameSentenceMiner/owocr/owocr/config.py,sha256=qM7kISHdUhuygGXOxmgU6Ef2nwBShrZtdqu4InDCViE,8103
 GameSentenceMiner/owocr/owocr/lens_betterproto.py,sha256=oNoISsPilVVRBBPVDtb4-roJtAhp8ZAuFTci3TGXtMc,39141
-GameSentenceMiner/owocr/owocr/ocr.py,sha256=23zm_LUuCDH05Q_RxAYf-LcVnlzFe2v_x-fDntm91mQ,71008
-GameSentenceMiner/owocr/owocr/run.py,sha256=tCuqq9SbKuUU7mEHaCX6ffyneL46jyNr-vTpAQlPMhw,76123
+GameSentenceMiner/owocr/owocr/ocr.py,sha256=rJKmB8xtSVrayq8XcZ4JKBULyPKDqfJDGKgLjICbUX8,71021
+GameSentenceMiner/owocr/owocr/run.py,sha256=xbBpyFCVfITZDztsRLT8_sX6BGf1o5LxOPxE9zUWfQc,79975
 GameSentenceMiner/owocr/owocr/screen_coordinate_picker.py,sha256=Na6XStbQBtpQUSdbN3QhEswtKuU1JjReFk_K8t5ezQE,3395
 GameSentenceMiner/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/tools/audio_offset_selector.py,sha256=8Stk3BP-XVIuzRv9nl9Eqd2D-1yD3JrgU-CamBywJmY,8542
+GameSentenceMiner/tools/furigana_filter_preview.py,sha256=BXv7FChPEJW_VeG5XYt6suAsMKVArsjr3cEduE9KhYg,13642
 GameSentenceMiner/tools/ss_selector.py,sha256=cbjMxiKOCuOfbRvLR_PCRlykBrGtm1LXd6u5czPqkmc,4793
 GameSentenceMiner/tools/window_transparency.py,sha256=GtbxbmZg0-UYPXhfHff-7IKZyY2DKe4B9GdyovfmpeM,8166
 GameSentenceMiner/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -40,7 +41,7 @@ GameSentenceMiner/util/configuration.py,sha256=JVwaqvfrUrOUiA0kZcznDsCo9hJkJqBpV
 GameSentenceMiner/util/db.py,sha256=2bO0rD4i8A1hhsRBER-wgZy9IK17ibRbI8DHxdKvYsI,16598
 GameSentenceMiner/util/electron_config.py,sha256=KfeJToeFFVw0IR5MKa-gBzpzaGrU-lyJbR9z-sDEHYU,8767
 GameSentenceMiner/util/ffmpeg.py,sha256=jA-cFtCmdCWrUSPpdtFSLr-GSoqs4qNUzW20v4HPHf0,28715
-GameSentenceMiner/util/get_overlay_coords.py,sha256=VtrT25DOjqMgo-eRFRMovuq6LUnoY8GrpbkfDsvgSjM,13855
+GameSentenceMiner/util/get_overlay_coords.py,sha256=bSvBSvLFmABogPp-quXcQrN-meWvl5NRB6gFEluoNNg,15142
 GameSentenceMiner/util/gsm_utils.py,sha256=Piwv88Q9av2LBeN7M6QDi0Mp0_R2lNbkcI6ekK5hd2o,11851
 GameSentenceMiner/util/model.py,sha256=R-_RYTYLSDNgBoVTPuPBcIHeOznIqi_vBzQ7VQ20WYk,6727
 GameSentenceMiner/util/notification.py,sha256=YBhf_mSo_i3cjBz-pmeTPx3wchKiG9BK2VBdZSa2prQ,4597
@@ -71,9 +72,9 @@ GameSentenceMiner/web/templates/index.html,sha256=LqXZx7-NE42pXSpHNZ3To680rD-vt9
 GameSentenceMiner/web/templates/text_replacements.html,sha256=tV5c8mCaWSt_vKuUpbdbLAzXZ3ATZeDvQ9PnnAfqY0M,8598
 GameSentenceMiner/web/templates/utility.html,sha256=3flZinKNqUJ7pvrZk6xu__v67z44rXnaK7UTZ303R-8,16946
 GameSentenceMiner/wip/__init___.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gamesentenceminer-2.14.20.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-gamesentenceminer-2.14.20.dist-info/METADATA,sha256=RbMHKhKfxzfRgnSWWb1HQrocVu45fa2AHXdYXxAwdnk,7303
-gamesentenceminer-2.14.20.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-gamesentenceminer-2.14.20.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
-gamesentenceminer-2.14.20.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
-gamesentenceminer-2.14.20.dist-info/RECORD,,
+gamesentenceminer-2.15.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+gamesentenceminer-2.15.0.dist-info/METADATA,sha256=Fd7VWnRI-2fkihajfxLaGnHXWOF2h7couT11IqrsJoc,7317
+gamesentenceminer-2.15.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+gamesentenceminer-2.15.0.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
+gamesentenceminer-2.15.0.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
+gamesentenceminer-2.15.0.dist-info/RECORD,,