GameSentenceMiner 2.18.9__tar.gz → 2.18.11__tar.gz

{gamesentenceminer-2.18.9 → gamesentenceminer-2.18.11}/GameSentenceMiner/owocr/owocr/ocr.py

@@ -277,11 +277,12 @@ class GoogleLens:
     key = 'l'
     available = False
 
-    def __init__(self, lang='ja'):
+    def __init__(self, lang='ja', get_furigana_sens_from_file=True):
         import regex
         self.regex = get_regex(lang)
         self.initial_lang = lang
         self.punctuation_regex = regex.compile(r'[\p{P}\p{S}]')
+        self.get_furigana_sens_from_file = get_furigana_sens_from_file
         if 'betterproto' not in sys.modules:
             logger.warning('betterproto not available, Google Lens will not work!')
         else:
@@ -289,10 +290,10 @@ class GoogleLens:
             logger.info('Google Lens ready')
 
     def __call__(self, img, furigana_filter_sensitivity=0, return_coords=False):
-        if furigana_filter_sensitivity != None:
+        if self.get_furigana_sens_from_file:
             furigana_filter_sensitivity = get_furigana_filter_sensitivity()
         else:
-            furigana_filter_sensitivity = 0
+            furigana_filter_sensitivity = furigana_filter_sensitivity
         lang = get_ocr_language()
         img, is_path = input_to_pil_image(img)
         if lang != self.initial_lang:
@@ -362,6 +363,12 @@ class GoogleLens:
         text = response_dict['objects_response']['text']
         skipped = []
         previous_line = None
+        filtered_response_dict = response_dict
+        if furigana_filter_sensitivity:
+            import copy
+            filtered_response_dict = copy.deepcopy(response_dict)
+            filtered_paragraphs = []
+        
         if 'text_layout' in text:
             for paragraph in text['text_layout']['paragraphs']:
                 if previous_line:
@@ -376,25 +383,40 @@ class GoogleLens:
                     # logger.info(avg_height * 2)
                     if vertical_space > avg_height * 2:
                         res += 'BLANK_LINE\n'
+                passed_furigana_filter_lines = []
                 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
+                        passes = False
                         for word in line['words']:
                             if self.punctuation_regex.findall(word['plain_text']):
                                 res += word['plain_text'] + word['text_separator']
                                 continue
                             if line_width > furigana_filter_sensitivity and line_height > furigana_filter_sensitivity:
                                 res += word['plain_text'] + word['text_separator']
+                                passes = True
                             else:
                                 skipped.extend(word['plain_text'])
                                 continue
+                        if passes:
+                            passed_furigana_filter_lines.append(line)
                     else:
                         for word in line['words']:
                             res += word['plain_text'] + word['text_separator']
                     res += '\n'
 
+                if furigana_filter_sensitivity and passed_furigana_filter_lines:
+                    # Create a filtered paragraph with only the passing lines
+                    filtered_paragraph = paragraph.copy()
+                    filtered_paragraph['lines'] = passed_furigana_filter_lines
+                    filtered_paragraphs.append(filtered_paragraph)
+                
                 previous_line = paragraph
+            
+            if furigana_filter_sensitivity:
+                filtered_response_dict['objects_response']['text']['text_layout']['paragraphs'] = filtered_paragraphs
+            
             res += '\n'
             # logger.info(
             #     f"Skipped {len(skipped)} chars due to furigana filter sensitivity: {furigana_filter_sensitivity}")
@@ -438,7 +460,7 @@ class GoogleLens:
         #             res += '\n'
         
         if return_coords:
-            x = (True, res, response_dict)
+            x = (True, res, filtered_response_dict)
         else:
             x = (True, res)
 
@@ -869,11 +891,12 @@ class OneOCR:
     key = 'z'
     available = False
 
-    def __init__(self, config={}, lang='ja'):
+    def __init__(self, config={}, lang='ja', get_furigana_sens_from_file=True):
         import regex
         self.initial_lang = lang
         self.regex = get_regex(lang)
         self.punctuation_regex = regex.compile(r'[\p{P}\p{S}]')
+        self.get_furigana_sens_from_file = get_furigana_sens_from_file
         if sys.platform == 'win32':
             if int(platform.release()) < 10:
                 logger.warning('OneOCR is not supported on Windows older than 10!')
@@ -921,10 +944,10 @@ class OneOCR:
 
     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:
+        if self.get_furigana_sens_from_file:
             furigana_filter_sensitivity = get_furigana_filter_sensitivity()
         else:
-            furigana_filter_sensitivity = 0
+            furigana_filter_sensitivity = furigana_filter_sensitivity
         if lang != self.initial_lang:
             self.initial_lang = lang
             self.regex = get_regex(lang)
@@ -958,6 +981,7 @@ class OneOCR:
                 skipped = []
                 boxes = []
                 if furigana_filter_sensitivity > 0:
+                    passing_lines = []
                     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']
@@ -965,16 +989,20 @@ class OneOCR:
                             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']):
+                        
+                        # Check if the line passes the size filter
+                        if line_width > furigana_filter_sensitivity and line_height > furigana_filter_sensitivity:
+                            # Line passes - include all its text and add to passing_lines
+                            for char in line['words']:
                                 res += char['text']
-                                continue
-                            if line_width > furigana_filter_sensitivity and line_height > furigana_filter_sensitivity:
-                                res += char['text']
-                            else:
+                            passing_lines.append(line)
+                        else:
+                            # Line fails - only include punctuation, skip the rest
+                            for char in line['words']:
                                 skipped.extend(char for char in line['text'])
-                                continue
                         res += '\n'
+                    filtered_lines = passing_lines
+                    return_resp = {'text': res, 'text_angle': ocr_resp['text_angle'], 'lines': passing_lines}
                     # logger.info(
                     #     f"Skipped {len(skipped)} chars due to furigana filter sensitivity: {furigana_filter_sensitivity}")
                     # widths, heights = [], []
@@ -1012,6 +1040,7 @@ class OneOCR:
                     #     res += '\n'
                 else:
                     res = ocr_resp['text']
+                    return_resp = ocr_resp
                     
                 if multiple_crop_coords:
                     for line in filtered_lines:
@@ -1042,7 +1071,7 @@ class OneOCR:
         if return_one_box:
             x.append(crop_coords)
         if return_dict:
-            x.append(ocr_resp)
+            x.append(return_resp)
         if is_path:
             img.close()
         return x

{gamesentenceminer-2.18.9 → gamesentenceminer-2.18.11}/GameSentenceMiner/tools/furigana_filter_preview.py

@@ -6,9 +6,42 @@ import threading
 import regex
 
 from GameSentenceMiner import obs
-from GameSentenceMiner.util.configuration import logger
+from GameSentenceMiner.util.configuration import logger, get_overlay_config
 from GameSentenceMiner.owocr.owocr.ocr import GoogleLens, OneOCR
 
+def get_overlay_screenshot() -> Image.Image:
+    """
+    Captures a screenshot from the configured overlay monitor using mss.
+    
+    Returns:
+        A PIL Image object of the screenshot from the overlay monitor.
+    """
+    try:
+        import mss
+        overlay_config = get_overlay_config()
+        monitor_index = overlay_config.monitor_to_capture
+        
+        with mss.mss() as sct:
+            # mss.monitors[0] is all monitors combined, mss.monitors[1] is the first monitor
+            # So we need to add 1 to the monitor_index to get the correct monitor
+            monitor = sct.monitors[monitor_index + 1]
+            screenshot = sct.grab(monitor)
+            
+            # Convert to PIL Image
+            img = Image.frombytes("RGB", screenshot.size, screenshot.bgra, "raw", "BGRX")
+            logger.info(f"Screenshot captured from monitor {monitor_index + 1} ({img.width}x{img.height})")
+            return img
+            
+    except ImportError:
+        logger.error("mss library not found. Please install it to use overlay functionality.")
+        raise
+    except IndexError:
+        logger.error(f"Monitor index {monitor_index + 1} not found. Available monitors: {len(sct.monitors) - 1}")
+        raise
+    except Exception as e:
+        logger.error(f"Failed to capture overlay screenshot: {e}")
+        raise
+
 def get_ocr_results_from_image(image_obj: Image.Image) -> tuple:
     """
     This is the function where you will plug in your OCR logic.
@@ -34,7 +67,8 @@ class FuriganaFilterVisualizer:
         self.ocr1_result = None
         self.ocr2_result = None
         self.current_ocr = 1
-        self.master.title("Furigana Filter Visualizer - Lens")
+        self.title_prefix = "Furigana Filter Visualizer"
+        self.master.title(f"{self.title_prefix} - Lens")
 
         self.words_data = []
         self.lines_data = []
@@ -84,6 +118,12 @@ class FuriganaFilterVisualizer:
 
         self.punctuation_regex = regex.compile(r'[\p{P}\p{S}]')
         self.master.protocol("WM_DELETE_WINDOW", self.on_ok)
+    
+    def set_title_prefix(self, prefix: str):
+        """Set the title prefix and update the current title."""
+        self.title_prefix = prefix
+        ocr_name = "Lens" if self.current_ocr == 1 else "OneOCR"
+        self.master.title(f"{self.title_prefix} - {ocr_name}")
 
     def update_with_ocr_data(self, ocr1_result, ocr2_result):
         """Called by the background thread to populate the GUI with OCR data."""
@@ -123,10 +163,10 @@ class FuriganaFilterVisualizer:
         # 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")
+            self.master.title(f"{self.title_prefix} - Lens")
         else:
             self.swap_button.config(text="Switch to Lens")
-            self.master.title("Furigana Filter Visualizer - OneOCR")
+            self.master.title(f"{self.title_prefix} - OneOCR")
         self.pre_process_word_geometries()
         self.update_filter_visualization(self.slider.get())
 
@@ -243,17 +283,22 @@ class FuriganaFilterVisualizer:
         for words that pass the sensitivity filter.
         """
         sensitivity = float(slider_value)
-        self.slider_value_label.config(text=f"{sensitivity:.0f} px")
+        # Only update the label if it exists (GUI is fully initialized)
+        if hasattr(self, 'slider_value_label'):
+            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()
 
+        # Set color based on current OCR: green for Lens (OCR 1), blue for OneOCR (OCR 2)
+        outline_color = 'green' if self.current_ocr == 1 else 'blue'
+        
         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
+                    x1, y1, x2, y2, outline=outline_color, width=2
                 )
                 self.drawn_rects.append(rect_id)
 
@@ -289,29 +334,64 @@ def scale_down_width_height(width, height):
 
 def main():
     import sys
-    current_furigana_sensitivity = int(sys.argv[1]) if len(sys.argv) > 1 else 0
+    
+    # Parse command line arguments
+    current_furigana_sensitivity = 0
+    use_overlay = False
+    
+    if len(sys.argv) > 1:
+        # Check if any argument is "overlay" or "--overlay"
+        args = sys.argv[1:]
+        if "overlay" in args or "--overlay" in args:
+            use_overlay = True
+            # Remove overlay flags and use remaining numeric argument as sensitivity
+            numeric_args = [arg for arg in args if arg not in ["overlay", "--overlay"] and arg.isdigit()]
+            if numeric_args:
+                current_furigana_sensitivity = int(numeric_args[0])
+        else:
+            # Assume first argument is sensitivity
+            try:
+                current_furigana_sensitivity = int(args[0])
+            except ValueError:
+                logger.warning(f"Invalid sensitivity value: {args[0]}. Using default value 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')
+    if use_overlay:
+        logger.info("Using overlay mode - capturing from configured monitor...")
+        try:
+            screenshot_img = get_overlay_screenshot()
+        except Exception as e:
+            logger.error(f"Failed to get overlay screenshot: {e}")
+            return
+    else:
+        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
 
-    screenshot_img = screenshot_img.resize(scale_down_width_height(screenshot_img.width, screenshot_img.height), Image.LANCZOS)
+        logger.info("Taking OBS screenshot...")
+        screenshot_img = obs.get_screenshot_PIL(compression=90, img_format='jpg')
 
-    if not screenshot_img:
-        logger.error("Failed to get screenshot from OBS.")
-        return
+        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}).")
+    # Scale down the image for performance
+    screenshot_img = screenshot_img.resize(scale_down_width_height(screenshot_img.width, screenshot_img.height), Image.LANCZOS)
+    
+    source_type = "overlay monitor" if use_overlay else "OBS"
+    logger.info(f"Screenshot received from {source_type} ({screenshot_img.width}x{screenshot_img.height}).")
 
     root = tk.Tk()
     app = FuriganaFilterVisualizer(root, screenshot_img, current_furigana_sensitivity)
+    
+    # Update window title to reflect source
+    if use_overlay:
+        overlay_config = get_overlay_config()
+        monitor_num = overlay_config.monitor_to_capture + 1
+        app.set_title_prefix(f"Furigana Filter Visualizer - Overlay Monitor {monitor_num}")
 
     def ocr_worker():
         logger.info("Starting OCR process in background thread...")

{gamesentenceminer-2.18.9 → gamesentenceminer-2.18.11}/GameSentenceMiner/ui/config_gui.py

@@ -5,6 +5,7 @@ import os
 import subprocess
 import sys
 import time
+import re
 import tkinter as tk
 from tkinter import filedialog, messagebox, simpledialog, scrolledtext, font
 from PIL import Image, ImageTk
@@ -318,7 +319,39 @@ class ConfigApp:
         
         print(dialog.selected_path)
         return dialog.selected_path
-        
+    
+    
+    # IMPLEMENT LATER,FOR NOW JUST RUN THE FILE
+    # def show_furigana_filter_selector(self, current_sensitivity):
+    #     """
+    #     Displays a modal dialog for the user to select the furigana filter sensitivity.
+
+    #     Args:
+    #         current_sensitivity (int): The current sensitivity setting.
+    #     Returns: int: The selected sensitivity setting, or None if canceled.
+    #     """
+    #     dialog = FuriganaFilterSelectorDialog(self.window,
+    #                                           self,
+    #                                           current_sensitivity=current_sensitivity)
+    #     return dialog.selected_sensitivity
+
+    def show_minimum_character_size_selector(self, current_size):
+        """
+        Opens an external tool for selecting the minimum character size.
+
+        Args:
+            current_sensitivity (int): The current sensitivity setting.
+        Returns: int: The selected sensitivity setting, or None if canceled.
+        """
+        # Run the file directly with the current python interpreter and get stdout
+        result = subprocess.run([sys.executable, '-m', 'GameSentenceMiner.tools.furigana_filter_preview', str(current_size), 'overlay'], capture_output=True, text=True)
+        if result.returncode == 0:
+            # Parse the output for RESULT:[value]
+            match = re.search(r"RESULT:\[(\d+)\]", result.stdout)
+            if match:
+                return int(match.group(1))
+        return None
+
     def create_vars(self):
         """
         Initializes all the tkinter variables used in the configuration GUI.
@@ -462,6 +495,7 @@ class ConfigApp:
         self.periodic_value = tk.BooleanVar(value=self.settings.overlay.periodic)
         self.periodic_interval_value = tk.StringVar(value=str(self.settings.overlay.periodic_interval))
         self.scan_delay_value = tk.StringVar(value=str(self.settings.overlay.scan_delay))
+        self.overlay_minimum_character_size_value = tk.StringVar(value=str(self.settings.overlay.minimum_character_size))
         
         # Master Config Settings
         self.switch_to_default_if_not_found_value = tk.BooleanVar(value=self.master_config.switch_to_default_if_not_found)
@@ -703,6 +737,7 @@ class ConfigApp:
                 scan_delay=float(self.scan_delay_value.get()),
                 periodic=float(self.periodic_value.get()),
                 periodic_interval=float(self.periodic_interval_value.get()),
+                minimum_character_size=int(self.overlay_minimum_character_size_value.get()),
             )
             # wip=WIP(
             #     overlay_websocket_port=int(self.overlay_websocket_port_value.get()),
@@ -2387,6 +2422,19 @@ class ConfigApp:
         ttk.Entry(overlay_frame, textvariable=self.periodic_interval_value).grid(row=self.current_row, column=1, sticky='EW', pady=2)
         self.current_row += 1
 
+        # Minimum Character Size
+        minimum_character_size_i18n = overlay_i18n.get('minimum_character_size', {})
+        HoverInfoLabelWidget(overlay_frame, text=minimum_character_size_i18n.get('label', 'Minimum Character Size:'),
+                             tooltip=minimum_character_size_i18n.get('tooltip', 'Minimum size of characters to be detected.'),
+                             row=self.current_row, column=0)
+        ttk.Entry(overlay_frame, textvariable=self.overlay_minimum_character_size_value).grid(row=self.current_row, column=1, sticky='EW', pady=2)
+        # button to open minimum character size Finder
+        ttk.Button(overlay_frame, text=overlay_i18n.get('minimum_character_size_finder_button', 
+                                                        'Minimum Character Size Finder'), 
+                   command=lambda: self.open_minimum_character_size_selector(self.overlay_minimum_character_size_value.get()), bootstyle="outline").grid(row=self.current_row, column=2, padx=5, pady=2)
+
+        self.current_row += 1
+
         if self.monitors:
             # Ensure the index is valid
             monitor_index = self.settings.overlay.monitor_to_capture
@@ -2397,6 +2445,10 @@ class ConfigApp:
         
         self.add_reset_button(overlay_frame, "overlay", self.current_row, 0, self.create_overlay_tab)
 
+    def open_minimum_character_size_selector(self, size):
+        new_size = self.show_minimum_character_size_selector(size)
+        self.overlay_minimum_character_size_value.set(new_size)
+
     @new_tab
     def create_wip_tab(self):
         if self.wip_tab is None: