GameSentenceMiner 2.7.8__py3-none-any.whl → 2.7.10__py3-none-any.whl

GameSentenceMiner/ocr/owocr_helper.py

@@ -1,7 +1,6 @@
-# area_selector.py
 import asyncio
-import base64
 import difflib
+import json
 import logging
 import os
 import queue
@@ -9,52 +8,62 @@ import threading
 import time
 from datetime import datetime
 from logging.handlers import RotatingFileHandler
+from pathlib import Path
 from tkinter import messagebox
 
 import mss
 import websockets
+from rapidfuzz import fuzz
 from PIL import Image, ImageDraw
-import json
-from pathlib import Path
 
 from GameSentenceMiner import obs, util
 from GameSentenceMiner.configuration import get_config, get_app_directory
-from GameSentenceMiner.gametext import get_line_history
+from GameSentenceMiner.electron_config import get_ocr_scan_rate, get_requires_open_window
+from GameSentenceMiner.ocr.gsm_ocr_config import OCRConfig, Rectangle
 from GameSentenceMiner.owocr.owocr import screen_coordinate_picker, run
 from GameSentenceMiner.owocr.owocr.run import TextFiltering
-from GameSentenceMiner.electron_config import store, get_ocr_scan_rate, get_requires_open_window
+
+from dataclasses import dataclass
+from typing import List, Optional
 
 CONFIG_FILE = Path("ocr_config.json")
 DEFAULT_IMAGE_PATH = r"C:\Users\Beangate\Pictures\msedge_acbl8GL7Ax.jpg"  # CHANGE THIS
-
 logger = logging.getLogger("GSM_OCR")
 logger.setLevel(logging.DEBUG)
-
 # Create a file handler for logging
 log_file = os.path.join(get_app_directory(), "logs", "ocr_log.txt")
 os.makedirs(os.path.join(get_app_directory(), "logs"), exist_ok=True)
-
 file_handler = RotatingFileHandler(log_file, maxBytes=1024 * 1024, backupCount=5, encoding='utf-8')
 file_handler.setLevel(logging.DEBUG)
-
 # Create a formatter and set it for the handler
 formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
 file_handler.setFormatter(formatter)
-
 # Add the handler to the logger
 logger.addHandler(file_handler)
 
+console_handler = logging.StreamHandler()
+console_handler.setLevel(logging.INFO)
+console_handler.setFormatter(formatter)
+logger.addHandler(console_handler)
+
+
 def get_new_game_cords():
     """Allows multiple coordinate selections."""
     coords_list = []
-    while True:
-        cords = screen_coordinate_picker.get_screen_selection()
-        coords_list.append({"coordinates": cords})
-        if messagebox.askyesno("Add Another Region", "Do you want to add another region?"):
-            continue
-        else:
-            break
-
+    with mss.mss() as sct:
+        monitors = sct.monitors
+        monitor_map = {i: mon for i, mon in enumerate(monitors)}
+        while True:
+            selected_monitor_index, cords = screen_coordinate_picker.get_screen_selection_with_monitor(monitor_map)
+            selected_monitor = monitor_map[selected_monitor_index]
+            coords_list.append({"monitor": {"left": selected_monitor["left"], "top": selected_monitor["top"],
+                                            "width": selected_monitor["width"], "height": selected_monitor["height"],
+                                            "index": selected_monitor_index}, "coordinates": cords,
+                                "is_excluded": False})
+            if messagebox.askyesno("Add Another Region", "Do you want to add another region?"):
+                continue
+            else:
+                break
     app_dir = Path.home() / "AppData" / "Roaming" / "GameSentenceMiner"
     ocr_config_dir = app_dir / "ocr_config"
     ocr_config_dir.mkdir(parents=True, exist_ok=True)
@@ -62,13 +71,13 @@ def get_new_game_cords():
     scene = util.sanitize_filename(obs.get_current_scene())
     config_path = ocr_config_dir / f"{scene}.json"
     with open(config_path, 'w') as f:
-        json.dump(coords_list, f, indent=4)
+        json.dump({"scene": scene, "window": None, "rectangles": coords_list}, f, indent=4)
     print(f"Saved OCR config to {config_path}")
     return coords_list
 
 
-def get_ocr_config():
-    """Loads multiple screen capture areas from the corresponding JSON file."""
+def get_ocr_config() -> OCRConfig:
+    """Loads and updates screen capture areas from the corresponding JSON file."""
     app_dir = Path.home() / "AppData" / "Roaming" / "GameSentenceMiner"
     ocr_config_dir = app_dir / "ocr_config"
     obs.connect_to_obs()
@@ -76,14 +85,58 @@ def get_ocr_config():
     config_path = ocr_config_dir / f"{scene}.json"
     if not config_path.exists():
         raise Exception(f"No config file found at {config_path}.")
-
-    if not config_path.exists():
-        print("Config Screen picker failed to make file. Please run again.")
-        return
-
-    with open(config_path, 'r') as f:
-        coords_list = json.load(f)
-        return coords_list
+    try:
+        with open(config_path, 'r', encoding="utf-8") as f:
+            config_data = json.load(f)
+        if "rectangles" in config_data and isinstance(config_data["rectangles"], list) and all(
+                isinstance(item, list) and len(item) == 4 for item in config_data["rectangles"]):
+            # Old config format, convert to new
+            new_rectangles = []
+            with mss.mss() as sct:
+                monitors = sct.monitors
+                default_monitor = monitors[1] if len(monitors) > 1 else monitors[0]
+                for rect in config_data["rectangles"]:
+                    new_rectangles.append({
+                        "monitor": {
+                            "left": default_monitor["left"],
+                            "top": default_monitor["top"],
+                            "width": default_monitor["width"],
+                            "height": default_monitor["height"],
+                            "index": 0  # Assuming single monitor for old config
+                        },
+                        "coordinates": rect,
+                        "is_excluded": False
+                    })
+                for rect in config_data['excluded_rectangles']:
+                    new_rectangles.append({
+                        "monitor": {
+                            "left": default_monitor["left"],
+                            "top": default_monitor["top"],
+                            "width": default_monitor["width"],
+                            "height": default_monitor["height"],
+                            "index": 0  # Assuming single monitor for old config
+                        },
+                        "coordinates": rect,
+                        "is_excluded": True
+                    })
+            new_config_data = {"scene": config_data.get("scene", scene), "window": config_data.get("window", None),
+                               "rectangles": new_rectangles}
+            with open(config_path, 'w', encoding="utf-8") as f:
+                json.dump(new_config_data, f, indent=4)
+            return OCRConfig.from_dict(new_config_data)
+        elif "rectangles" in config_data and isinstance(config_data["rectangles"], list) and all(
+                isinstance(item, dict) and "coordinates" in item for item in config_data["rectangles"]):
+            logger.info("Loading new OCR config format.")
+            logger.info(config_data)
+            return OCRConfig.from_dict(config_data)
+        else:
+            raise Exception(f"Invalid config format in {config_path}.")
+    except json.JSONDecodeError:
+        print("Error decoding JSON. Please check your config file.")
+        return None
+    except Exception as e:
+        print(f"Error loading config: {e}")
+        return None
 
 
 websocket_server_thread = None
@@ -130,7 +183,8 @@ class WebsocketServerThread(threading.Thread):
 
     def send_text(self, text, line_time: datetime):
         if text:
-            return asyncio.run_coroutine_threadsafe(self.send_text_coroutine(json.dumps({"sentence": text, "time": line_time.isoformat()})), self.loop)
+            return asyncio.run_coroutine_threadsafe(
+                self.send_text_coroutine(json.dumps({"sentence": text, "time": line_time.isoformat()})), self.loop)
 
     def stop_server(self):
         self.loop.call_soon_threadsafe(self._stop_event.set)
@@ -140,129 +194,119 @@ class WebsocketServerThread(threading.Thread):
             self._loop = asyncio.get_running_loop()
             self._stop_event = stop_event = asyncio.Event()
             self._event.set()
-            self.server = start_server = websockets.serve(self.server_handler, get_config().general.websocket_uri.split(":")[0], get_config().general.websocket_uri.split(":")[1], max_size=1000000000)
+            self.server = start_server = websockets.serve(self.server_handler,
+                                                          get_config().general.websocket_uri.split(":")[0],
+                                                          get_config().general.websocket_uri.split(":")[1],
+                                                          max_size=1000000000)
             async with start_server:
                 await stop_event.wait()
+
         asyncio.run(main())
 
+
 all_cords = None
 rectangles = None
 
-def text_callback(text, rectangle, time):
-    global twopassocr, ocr2, last_oneocr_results
+def do_second_ocr(ocr1_text, rectangle_index, time, img):
+    global twopassocr, ocr2, last_ocr1_results, last_ocr2_results
+    last_result = ([], -1)
+
+    previous_ocr1_text = last_ocr1_results[rectangle_index]
+    if fuzz.ratio(previous_ocr1_text, ocr1_text) >= 80:
+        logger.info("Seems like the same text, not doing 2nd pass")
+    last_ocr1_results[rectangle_index] = ocr1_text
+    try:
+        orig_text, text = run.process_and_write_results(img, None, None, last_result, TextFiltering(),
+                                                        engine=ocr2)
+        previous_ocr2_text = last_ocr2_results[rectangle_index]
+        if fuzz.ratio(previous_ocr2_text, text) >= 80:
+            logger.info("Seems like the same text from previous ocr2 result, not sending")
+            return
+        last_ocr2_results[rectangle_index] = text
+        if get_config().advanced.ocr_sends_to_clipboard:
+            import pyperclip
+            pyperclip.copy(text)
+        websocket_server_thread.send_text(text, time)
+    except json.JSONDecodeError:
+        print("Invalid JSON received.")
+    except Exception as e:
+        logger.exception(e)
+        print(f"Error processing message: {e}")
+
+
+last_oneocr_results_to_check = {}  # Store last OCR result for each rectangle
+last_oneocr_times = {}    # Store last OCR time for each rectangle
+text_stable_start_times = {} # Store the start time when text becomes stable for each rectangle
+TEXT_APPEARENCE_DELAY = get_ocr_scan_rate() * 1000 + 500  # Adjust as needed
+
+def text_callback(text, rectangle_index, time, img=None):
+    global twopassocr, ocr2, last_oneocr_results_to_check, last_oneocr_times, text_stable_start_times
+
+    current_time = time if time else datetime.now()
+
+    previous_text = last_oneocr_results_to_check.get(rectangle_index, "")
+
     if not text:
+        if previous_text:
+            if rectangle_index in text_stable_start_times:
+                stable_time = text_stable_start_times[rectangle_index]
+                if twopassocr:
+                    do_second_ocr(previous_text, rectangle_index, time, img)
+                else:
+                    previous_ocr1_text = last_ocr1_results[rectangle_index]
+                    if fuzz.ratio(previous_ocr1_text, text) >= 80:
+                        logger.info("Seems like the same text, not sending")
+                    last_ocr1_results[rectangle_index] = text
+                    websocket_server_thread.send_text(previous_text, stable_time)
+                del text_stable_start_times[rectangle_index]
+            del last_oneocr_results_to_check[rectangle_index]
         return
-    if not twopassocr or not ocr2:
-        websocket_server_thread.send_text(text, time if time else datetime.now())
+
+    if rectangle_index not in last_oneocr_results_to_check:
+        last_oneocr_results_to_check[rectangle_index] = text
+        last_oneocr_times[rectangle_index] = current_time
+        text_stable_start_times[rectangle_index] = current_time
         return
-    with mss.mss() as sct:
-        line_time = time if time else datetime.now()
-        logger.info(f"Received message: {text}, ATTEMPTING LENS OCR")
-        if rectangles:
-            cords = rectangles[rectangle]
-            i = rectangle
-        else:
-            i = 0
-            mon = sct.monitors
-            cords = [mon[1]['left'], mon[1]['top'], mon[1]['width'], mon[1]['height']]
-        similarity = difflib.SequenceMatcher(None, last_oneocr_results[i], text).ratio()
-        if similarity > .8:
-            return
-        logger.debug(f"Similarity for region {i}: {similarity}")
-        last_oneocr_results[i] = text
-        last_result = ([], -1)
-        try:
-            sct_params = {'left': cords[0], 'top': cords[1], 'width': cords[2], 'height': cords[3]}
-            sct_img = sct.grab(sct_params)
-            img = Image.frombytes('RGB', sct_img.size, sct_img.bgra, 'raw', 'BGRX')
-            img = img.convert("RGBA")
-            draw = ImageDraw.Draw(img)
-            for exclusion in ocr_config.get("excluded_rectangles", []):
-                left, top, right, bottom = exclusion
-                draw.rectangle((left, top, right, bottom), fill=(0, 0, 0, 0))
-                # draw.rectangle((left, top, right, bottom), fill=(0,0,0))
-            orig_text, text = run.process_and_write_results(img, None, None, last_result, TextFiltering(),
-                                                            engine=ocr2)
-            if ":gsm_prefix:" in text:
-                text = text.split(":gsm_prefix:")[1]
-            if get_config().advanced.ocr_sends_to_clipboard:
-                import pyperclip
-                pyperclip.copy(text)
-            websocket_server_thread.send_text(text, line_time)
-        except json.JSONDecodeError:
-            print("Invalid JSON received.")
-        except Exception as e:
-            logger.exception(e)
-            print(f"Error processing message: {e}")
+
+    stable = text_stable_start_times.get(rectangle_index)
+
+    if stable:
+        time_since_stable_ms = int((current_time - stable).total_seconds() * 1000)
+
+        if time_since_stable_ms >= TEXT_APPEARENCE_DELAY:
+            last_oneocr_results_to_check[rectangle_index] = text
+            last_oneocr_times[rectangle_index] = current_time
+    else:
+        last_oneocr_results_to_check[rectangle_index] = text
+        last_oneocr_times[rectangle_index] = current_time
 
 done = False
 
-def run_oneocr(ocr_config, i):
+
+def run_oneocr(ocr_config: OCRConfig, i):
     global done
+    rect_config = ocr_config.rectangles[i]
+    coords = rect_config.coordinates
+    monitor_config = rect_config.monitor
+    exclusions = (rect.coordinates for rect in list(filter(lambda x: x.is_excluded, ocr_config.rectangles)))
+    screen_area = ",".join(str(c) for c in coords)
     run.run(read_from="screencapture", write_to="callback",
-            screen_capture_area=",".join(str(c) for c in ocr_config['rectangles'][i]) if ocr_config['rectangles'] else 'screen_1',
-            screen_capture_window=ocr_config.get("window", None),
+            screen_capture_area=screen_area,
+            # screen_capture_monitor=monitor_config['index'],
+            screen_capture_window=ocr_config.window,
             screen_capture_only_active_windows=get_requires_open_window(),
             screen_capture_delay_secs=get_ocr_scan_rate(), engine=ocr1,
             text_callback=text_callback,
-            screen_capture_exclusions=ocr_config.get('excluded_rectangles', None),
+            screen_capture_exclusions=exclusions,
             rectangle=i)
     done = True
 
 
-# async def websocket_client():
-#     uri = "ws://localhost:7331"  # Replace with your hosted websocket address
-#     print("Connecting to WebSocket...")
-#     async with websockets.connect(uri) as websocket:
-#         print("Connected to WebSocket.")
-#
-#         try:
-#             while True:
-#                 message = await websocket.recv()
-#                 if not message:
-#                     continue
-#                 line_time = datetime.now()
-#                 get_line_history().add_secondary_line(message)
-#                 print(f"Received message: {message}, ATTEMPTING LENS OCR")
-#                 if ":gsm_prefix:" in message:
-#                     i = int(message.split(":gsm_prefix:")[0])
-#                 cords = all_cords[i] if i else all_cords[0]
-#                 similarity = difflib.SequenceMatcher(None, last_oneocr_results[i], message).ratio()
-#                 if similarity > .8:
-#                     continue
-#                 print(f"Similarity for region {i}: {similarity}")
-#                 last_oneocr_results[i] = message
-#                 last_result = ([], -1)
-#                 try:
-#                     sct_params = {'top': cords[1], 'left': cords[0], 'width': cords[2], 'height': cords[3]}
-#                     with mss.mss() as sct:
-#                         sct_img = sct.grab(sct_params)
-#                     img = Image.frombytes('RGB', sct_img.size, sct_img.bgra, 'raw', 'BGRX')
-#                     draw = ImageDraw.Draw(img)
-#                     for exclusion in ocr_config.get("excluded_rectangles", []):
-#                         exclusion = tuple(exclusion)
-#                         draw.rectangle(exclusion, fill="black")
-#                     orig_text, text = run.process_and_write_results(img, "results.txt", None, last_result, TextFiltering(), engine="glens")
-#                     if ":gsm_prefix:" in text:
-#                         text = text.split(":gsm_prefix:")[1]
-#                     websocket_server_thread.send_text(text, line_time)
-#                 except json.JSONDecodeError:
-#                     print("Invalid JSON received.")
-#                 except Exception as e:
-#                     logger.exception(e)
-#                     print(f"Error processing message: {e}")
-#         except websockets.exceptions.ConnectionClosed:
-#             print("WebSocket connection closed.")
-#         except Exception as e:
-#             print(f"WebSocket error: {e}")
-
-
 if __name__ == "__main__":
     global ocr1, ocr2, twopassocr
     import sys
 
     args = sys.argv[1:]
-
     if len(args) == 3:
         ocr1 = args[0]
         ocr2 = args[1]
@@ -277,34 +321,35 @@ if __name__ == "__main__":
         twopassocr = False
     else:
         ocr1 = "oneocr"
-
+        ocr2 = "glens"
+        twopassocr = True
     logger.info(f"Received arguments: ocr1={ocr1}, ocr2={ocr2}, twopassocr={twopassocr}")
     global ocr_config
-    ocr_config = get_ocr_config()
-    rectangles = ocr_config['rectangles']
-    last_oneocr_results = [""] * len(rectangles) if rectangles else [""]
-    oneocr_threads = []
-    run.init_config(False)
-    if rectangles:
-        for i, rectangle in enumerate(rectangles):
-            thread = threading.Thread(target=run_oneocr, args=(ocr_config,i,), daemon=True)
-            oneocr_threads.append(thread)
-            thread.start()
+    ocr_config: OCRConfig = get_ocr_config()
+    if ocr_config and ocr_config.rectangles:
+        rectangles = ocr_config.rectangles
+        last_ocr1_results = [""] * len(rectangles) if rectangles else [""]
+        last_ocr2_results = [""] * len(rectangles) if rectangles else [""]
+        oneocr_threads = []
+        run.init_config(False)
+        if rectangles:
+            for i, rectangle in enumerate(rectangles):
+                thread = threading.Thread(target=run_oneocr, args=(ocr_config, i,), daemon=True)
+                oneocr_threads.append(thread)
+                thread.start()
+        else:
+            single_ocr_thread = threading.Thread(target=run_oneocr, args=(ocr_config, 0,), daemon=True)
+            oneocr_threads.append(single_ocr_thread)
+            single_ocr_thread.start()
+        websocket_server_thread = WebsocketServerThread(read=True)
+        websocket_server_thread.start()
+        try:
+            while not done:
+                time.sleep(1)
+        except KeyboardInterrupt as e:
+            pass
+        for thread in oneocr_threads:
+            thread.join()
+        # asyncio.run(websocket_client())
     else:
-        single_ocr_thread = threading.Thread(target=run_oneocr, args=(ocr_config, 0,), daemon=True)
-        oneocr_threads.append(single_ocr_thread)
-        single_ocr_thread.start()
-
-    websocket_server_thread = WebsocketServerThread(read=True)
-    websocket_server_thread.start()
-
-    try:
-        while not done:
-            time.sleep(1)
-    except KeyboardInterrupt as e:
-        pass
-
-    for thread in oneocr_threads:
-        thread.join()
-
-    # asyncio.run(websocket_client())
+        print("Failed to load OCR configuration. Please check the logs.")

GameSentenceMiner/owocr/owocr/run.py

@@ -571,7 +571,7 @@ def process_and_write_results(img_or_path, write_to, notifications, last_result,
         elif write_to == 'clipboard':
             pyperclipfix.copy(text)
         elif write_to == "callback":
-            txt_callback(text, rectangle, start_time)
+            txt_callback(text, rectangle, start_time, img_or_path)
         elif write_to:
             with Path(write_to).open('a', encoding='utf-8') as f:
                 f.write(text + '\n')
@@ -1026,6 +1026,7 @@ def run(read_from=None,
                     else:
                         try:
                             coord_left, coord_top, right, bottom = win32gui.GetWindowRect(window_handle)
+
                             coord_width = right - coord_left
                             coord_height = bottom - coord_top
 
@@ -1045,12 +1046,18 @@ def run(read_from=None,
                             on_window_closed(False)
                             break
 
-                        rand = random.randint(1, 10)
+                        # rand = random.randint(1, 10)
 
                         img = Image.frombuffer('RGB', (bmpinfo['bmWidth'], bmpinfo['bmHeight']), bmpstr, 'raw', 'BGRX', 0, 1)
 
+                        # if rand == 1:
+                        #     img.show()
+
                         if custom_left:
-                            img = img.crop((custom_left, custom_top, custom_width, custom_height))
+                            img = img.crop((custom_left, custom_top, custom_left + custom_width, custom_top + custom_height))
+
+                        # if rand == 1:
+                        #     img.show()
 
                         win32gui.DeleteObject(save_bitmap.GetHandle())
                         save_dc.DeleteDC()
@@ -1064,8 +1071,8 @@ def run(read_from=None,
                     img = img.convert("RGBA")
                     draw = ImageDraw.Draw(img)
                     for exclusion in screen_capture_exclusions:
-                        left, top, right, bottom = exclusion
-                        draw.rectangle((left, top, right, bottom), fill=(0, 0, 0, 0))
+                        left, top, width, height = exclusion
+                        draw.rectangle((left, top, left + width, top + height), fill=(0, 0, 0, 0))
                         # draw.rectangle((left, top, right, bottom), fill=(0, 0, 0))
                 # img.save(os.path.join(get_temporary_directory(), 'screencapture.png'), 'png')
                 res, _ = process_and_write_results(img, write_to, notifications, last_result, filtering, rectangle=rectangle, start_time=start_time)

GameSentenceMiner/owocr/owocr/screen_coordinate_picker.py

@@ -55,12 +55,12 @@ class ScreenSelector:
         def on_release(event):
             nonlocal start_x, start_y
             end_x, end_y = event.x, event.y
-            
-            x1 = min(start_x, end_x) 
-            y1 = min(start_y, end_y) 
-            x2 = max(start_x, end_x) 
-            y2 = max(start_y, end_y) 
-            
+
+            x1 = min(start_x, end_x)
+            y1 = min(start_y, end_y)
+            x2 = max(start_x, end_x)
+            y2 = max(start_y, end_y)
+
             self.on_select(monitor, (x1, y1, x2 - x1, y2 - y1))
 
         canvas.bind('<ButtonPress-1>', on_click)
@@ -90,11 +90,19 @@ def get_screen_selection():
     with Manager() as manager:
         res = manager.dict()
         process = Process(target=run_screen_selector, args=(res,))
-        
-        process.start()    
+
+        process.start()
         process.join()
 
         if 'monitor' in res and 'coordinates' in res:
             return res.copy()
         else:
             return False
+
+if __name__ == "__main__":
+    selection = get_screen_selection()
+    if selection:
+        print(f"Selected monitor: {selection['monitor']}")
+        print(f"Selected coordinates: {selection['coordinates']}")
+    else:
+        print("No selection made or process was interrupted.")