GameSentenceMiner 2.14.20__tar.gz → 2.15.0__tar.gz

{gamesentenceminer-2.14.20 → gamesentenceminer-2.15.0}/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-2.14.20 → gamesentenceminer-2.15.0}/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.20 → gamesentenceminer-2.15.0}/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-2.14.20 → gamesentenceminer-2.15.0}/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-2.14.20 → gamesentenceminer-2.15.0}/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-2.14.20 → gamesentenceminer-2.15.0}/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-2.14.20 → gamesentenceminer-2.15.0}/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.")