GameSentenceMiner 2.6.5__py3-none-any.whl → 2.7.0__py3-none-any.whl

GameSentenceMiner/ocr/owocr_area_selector.py

@@ -0,0 +1,275 @@
+import ctypes
+import sys
+import tkinter as tk
+from tkinter import messagebox, simpledialog
+import json
+from pathlib import Path
+import time  # Optional: for debugging timing if needed
+from PIL import Image, ImageTk
+import io
+import keyboard
+
+from GameSentenceMiner import obs, util
+
+class DynamicAreaSelector(tk.Tk):
+    def __init__(self, window_title):
+        super().__init__()
+        self.title("Dynamic Area Selector")
+        self.attributes('-fullscreen', True)
+        self.attributes("-topmost", True)  # Make the window always on top
+        self.attributes("-alpha", 0.20)
+
+        self.window_title = window_title
+        self.rects = []
+        self.start_x = None
+        self.start_y = None
+        self.current_rect_id = None
+        self.drawn_rect_ids = []
+        self.saved_rect_coords = []
+        self.excluded_rect_coords = []  # New list for excluded rectangles
+        self.drawn_excluded_rect_ids = []  # New list for excluded rect ids
+        self.image_mode = False
+        self.image_item = None
+        self.image_tk = None
+        self.canvas = None
+
+        if not self.initialize_ui():
+            self.after(0, self.destroy)
+            return
+
+        self.canvas.bind("<ButtonPress-1>", self.on_press)
+        self.canvas.bind("<B1-Motion>", self.on_drag)
+        self.canvas.bind("<ButtonRelease-1>", self.on_release)
+        self.canvas.bind("<Button-3>", self.on_right_click)  # Bind right-click
+        self.bind("<Control-s>", self.save_rects_event)
+        self.bind("<Control-z>", self.undo_last_rect)
+        self.bind("<Escape>", self.quit_app)
+        self.bind("<Control-i>", self.toggle_image_mode)
+
+        self.protocol("WM_DELETE_WINDOW", self.on_close)
+
+    def initialize_ui(self):
+        try:
+            self.canvas = tk.Canvas(self, highlightthickness=0)
+            self.canvas.pack(fill=tk.BOTH, expand=True)
+
+            self.load_and_draw_existing_rects()
+            return True
+
+        except Exception as e:
+            messagebox.showerror("Initialization Error", f"Failed: {e}")
+            print(f"Initialization error details: {e}")
+            return False
+
+    def load_and_draw_existing_rects(self):
+        if self.get_scene_ocr_config().exists():
+            try:
+                with open(self.get_scene_ocr_config(), 'r') as f:
+                    config_data = json.load(f)
+                    loaded_rects = []
+                    loaded_excluded_rects = []
+                    for r in config_data.get("rectangles", []):
+                        try:
+                            coords = tuple(map(float, r))
+                            if len(coords) == 4:
+                                loaded_rects.append(coords)
+                            else:
+                                print(f"Skipping invalid rectangle data: {r}")
+                        except (ValueError, TypeError) as coord_err:
+                            print(f"Skipping invalid coordinate data in rectangle {r}: {coord_err}")
+
+                    for r in config_data.get("excluded_rectangles", []):
+                        try:
+                            coords = tuple(map(float, r))
+                            if len(coords) == 4:
+                                loaded_excluded_rects.append(coords)
+                            else:
+                                print(f"Skipping invalid excluded rectangle data: {r}")
+                        except (ValueError, TypeError) as coord_err:
+                            print(f"Skipping invalid coordinate data in excluded rectangle {r}: {coord_err}")
+
+                    self.saved_rect_coords = loaded_rects
+                    self.excluded_rect_coords = loaded_excluded_rects
+                    for rect_id in self.drawn_rect_ids:
+                        self.canvas.delete(rect_id)
+                    for rect_id in self.drawn_excluded_rect_ids:
+                        self.canvas.delete(rect_id)
+                    self.drawn_rect_ids = []
+                    self.drawn_excluded_rect_ids = []
+
+                    for rect in self.saved_rect_coords:
+                        x1, y1, x2, y2 = rect
+                        rect_id = self.canvas.create_rectangle(x1, y1, x2, y2, outline='blue', width=2)
+                        self.drawn_rect_ids.append(rect_id)
+
+                    for rect in self.excluded_rect_coords:
+                        x1, y1, x2, y2 = rect
+                        rect_id = self.canvas.create_rectangle(x1, y1, x2, y2, outline='orange', width=2)
+                        self.drawn_excluded_rect_ids.append(rect_id)
+
+            except json.JSONDecodeError:
+                messagebox.showwarning("Config Load Warning", f"Could not parse {self.get_scene_ocr_config()}. Starting with no rectangles.")
+                self.saved_rect_coords = []
+                self.excluded_rect_coords = []
+            except FileNotFoundError:
+                self.saved_rect_coords = []
+                self.excluded_rect_coords = []
+            except Exception as e:
+                messagebox.showerror("Config Load Error", f"Error loading rectangles: {e}")
+                self.saved_rect_coords = []
+                self.excluded_rect_coords = []
+
+    def on_press(self, event):
+        if self.current_rect_id is None:
+            self.start_x = self.canvas.canvasx(event.x)
+            self.start_y = self.canvas.canvasy(event.y)
+            outline_color = 'red' if not event.state & 0x0001 else 'purple'  # check if shift is pressed
+            self.current_rect_id = self.canvas.create_rectangle(
+                self.start_x, self.start_y, self.start_x, self.start_y,
+                outline=outline_color, width=2
+            )
+
+    def on_drag(self, event):
+        if self.current_rect_id is not None:
+            cur_x = self.canvas.canvasx(event.x)
+            cur_y = self.canvas.canvasy(event.y)
+            self.canvas.coords(self.current_rect_id, self.start_x, self.start_y, cur_x, cur_y)
+
+    def on_release(self, event):
+        if self.current_rect_id is not None:
+            end_x = self.canvas.canvasx(event.x)
+            end_y = self.canvas.canvasy(event.y)
+            x1 = min(self.start_x, end_x)
+            y1 = min(self.start_y, end_y)
+            x2 = max(self.start_x, end_x)
+            y2 = max(self.start_y, end_y)
+
+            self.canvas.coords(self.current_rect_id, x1, y1, x2, y2)
+            if event.state & 0x0001:  # shift is pressed
+                self.canvas.itemconfig(self.current_rect_id, outline='orange')
+                self.excluded_rect_coords.append((x1, y1, x2, y2))
+                self.drawn_excluded_rect_ids.append(self.current_rect_id)
+            else:
+                self.canvas.itemconfig(self.current_rect_id, outline='green')
+                self.saved_rect_coords.append((x1, y1, x2, y2))
+                self.drawn_rect_ids.append(self.current_rect_id)
+
+            self.current_rect_id = None
+            self.start_x = None
+            self.start_y = None
+
+    def save_rects(self):
+        try:
+            serializable_rects = [
+                tuple(map(int, rect)) for rect in self.saved_rect_coords
+            ]
+            serializable_excluded_rects = [
+                tuple(map(int, rect)) for rect in self.excluded_rect_coords
+            ]
+            with open(self.get_scene_ocr_config(), 'w') as f:
+                json.dump({"window": self.window_title if self.window_title else "", "scene": obs.get_current_scene(), "rectangles": serializable_rects, "excluded_rectangles": serializable_excluded_rects}, f, indent=4)
+            for rect_id in self.drawn_rect_ids:
+                if self.canvas.winfo_exists():
+                    try:
+                        self.canvas.itemconfig(rect_id, outline='blue')
+                    except tk.TclError:
+                        pass
+            for rect_id in self.drawn_excluded_rect_ids:
+                if self.canvas.winfo_exists():
+                    try:
+                        self.canvas.itemconfig(rect_id, outline='orange')
+                    except tk.TclError:
+                        pass
+            print("Rectangles saved.")
+            self.on_close()
+        except Exception as e:
+            messagebox.showerror("Error", f"Failed to save rectangles: {e}")
+
+    def save_rects_event(self, event=None):
+        self.save_rects()
+
+    def undo_last_rect(self, event=None):
+        if self.saved_rect_coords and self.drawn_rect_ids:
+            self.saved_rect_coords.pop()
+            last_rect_id = self.drawn_rect_ids.pop()
+            if self.canvas.winfo_exists():
+                self.canvas.delete(last_rect_id)
+        elif self.excluded_rect_coords and self.drawn_excluded_rect_ids:
+            self.excluded_rect_coords.pop()
+            last_rect_id = self.drawn_excluded_rect_ids.pop()
+            if self.canvas.winfo_exists():
+                self.canvas.delete(last_rect_id)
+        elif self.current_rect_id is not None:
+            if self.canvas.winfo_exists():
+                self.canvas.delete(self.current_rect_id)
+            self.current_rect_id = None
+            self.start_x = None
+            self.start_y = None
+
+    def quit_app(self, event=None):
+        print("Escape pressed, closing application.")
+        self.on_close()
+
+    def on_close(self):
+        self.destroy()
+
+    def get_scene_ocr_config(self):
+        app_dir = Path.home() / "AppData" / "Roaming" / "GameSentenceMiner"
+        ocr_config_dir = app_dir / "ocr_config"
+        ocr_config_dir.mkdir(parents=True, exist_ok=True)
+        scene = util.sanitize_filename(obs.get_current_scene())
+        config_path = ocr_config_dir / f"{scene}.json"
+        return config_path
+
+    def on_right_click(self, event):
+        """Deletes the rectangle clicked with the right mouse button."""
+        item = self.canvas.find_closest(event.x, event.y)
+
+        if item:
+            if item[0] in self.drawn_rect_ids:  # Check if it's a saved rectangle
+                index = self.drawn_rect_ids.index(item[0])
+                self.canvas.delete(item[0])
+                del self.drawn_rect_ids[index]
+                del self.saved_rect_coords[index]
+            elif item[0] in self.drawn_excluded_rect_ids:
+                index = self.drawn_excluded_rect_ids.index(item[0])
+                self.canvas.delete(item[0])
+                del self.drawn_excluded_rect_ids[index]
+                del self.excluded_rect_coords[index]
+
+    def setup_hotkey(self):
+        keyboard.add_hotkey('F13', self.lift_window)  # Example hotkey
+
+    def lift_window(self):
+        self.lift()  # Bring the window to the front
+
+    def toggle_image_mode(self, event=None):
+        self.image_mode = not self.image_mode
+        if self.image_mode:
+            self.attributes("-alpha", 1.0)
+            self.load_image_from_obs()
+        else:
+            self.attributes("-alpha", 0.20)
+            if self.image_item:
+                self.canvas.delete(self.image_item)
+                self.image_item = None
+                self.image_tk = None
+
+    def load_image_from_obs(self):
+        try:
+            image_path = obs.get_screenshot()
+            image = Image.open(image_path)
+            self.image_tk = ImageTk.PhotoImage(image)
+            self.image_item = self.canvas.create_image(0, 0, anchor=tk.NW, image=self.image_tk)
+            self.canvas.tag_lower(self.image_item)
+        except Exception as e:
+            messagebox.showerror("Image Load Error", f"Failed to load image from OBS: {e}")
+
+def run_screen_picker(window_title):
+    app = DynamicAreaSelector(window_title)
+    app.mainloop()
+
+if __name__ == "__main__":
+    args = sys.argv[1:]
+    obs.connect_to_obs()
+    run_screen_picker(args[0] if len(args) > 0 else None)

GameSentenceMiner/ocr/owocr_helper.py

@@ -0,0 +1,306 @@
+# area_selector.py
+import asyncio
+import base64
+import difflib
+import logging
+import os
+import queue
+import threading
+import time
+from datetime import datetime
+from logging.handlers import RotatingFileHandler
+from tkinter import messagebox
+
+import mss
+import websockets
+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.owocr.owocr import screen_coordinate_picker, run
+from GameSentenceMiner.owocr.owocr.run import TextFiltering
+
+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)
+
+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
+
+    app_dir = Path.home() / "AppData" / "Roaming" / "GameSentenceMiner"
+    ocr_config_dir = app_dir / "ocr_config"
+    ocr_config_dir.mkdir(parents=True, exist_ok=True)
+    obs.connect_to_obs()
+    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)
+    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."""
+    app_dir = Path.home() / "AppData" / "Roaming" / "GameSentenceMiner"
+    ocr_config_dir = app_dir / "ocr_config"
+    obs.connect_to_obs()
+    scene = util.sanitize_filename(obs.get_current_scene())
+    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
+
+
+websocket_server_thread = None
+websocket_queue = queue.Queue()
+paused = False
+
+
+class WebsocketServerThread(threading.Thread):
+    def __init__(self, read):
+        super().__init__(daemon=True)
+        self._loop = None
+        self.read = read
+        self.clients = set()
+        self._event = threading.Event()
+
+    @property
+    def loop(self):
+        self._event.wait()
+        return self._loop
+
+    async def send_text_coroutine(self, message):
+        for client in self.clients:
+            await client.send(message)
+
+    async def server_handler(self, websocket):
+        self.clients.add(websocket)
+        try:
+            async for message in websocket:
+                if self.read and not paused:
+                    websocket_queue.put(message)
+                    try:
+                        await websocket.send('True')
+                    except websockets.exceptions.ConnectionClosedOK:
+                        pass
+                else:
+                    try:
+                        await websocket.send('False')
+                    except websockets.exceptions.ConnectionClosedOK:
+                        pass
+        except websockets.exceptions.ConnectionClosedError:
+            pass
+        finally:
+            self.clients.remove(websocket)
+
+    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)
+
+    def stop_server(self):
+        self.loop.call_soon_threadsafe(self._stop_event.set)
+
+    def run(self):
+        async def main():
+            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)
+            async with start_server:
+                await stop_event.wait()
+        asyncio.run(main())
+
+all_cords = None
+rectangles = None
+
+def text_callback(text, rectangle):
+    global twopassocr, ocr2, last_oneocr_results
+    if not text:
+        return
+    if not twopassocr or not ocr2:
+        websocket_server_thread.send_text(text, datetime.now())
+        return
+    with mss.mss() as sct:
+        line_time = 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]
+            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}")
+
+done = False
+
+def run_oneocr(ocr_config, i):
+    global done
+    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_only_active_windows=True if ocr_config.get("window", None) else False,
+            screen_capture_delay_secs=.25, engine=ocr1,
+            text_callback=text_callback,
+            screen_capture_exclusions=ocr_config.get('excluded_rectangles', None),
+            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]
+        twopassocr = bool(int(args[2]))
+    elif len(args) == 2:
+        ocr1 = args[0]
+        ocr2 = args[1]
+        twopassocr = True
+    elif len(args) == 1:
+        ocr1 = args[0]
+        ocr2 = None
+        twopassocr = False
+    else:
+        ocr1 = "oneocr"
+
+    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()
+    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())

GameSentenceMiner/owocr/owocr/__init__.py

@@ -0,0 +1 @@
+from owocr.ocr import *

GameSentenceMiner/owocr/owocr/__main__.py

@@ -0,0 +1,8 @@
+from .run import run
+
+def main():
+    run()
+
+
+if __name__ == '__main__':
+    main()