ok-script 0.0.85__tar.gz → 0.0.87__tar.gz

{ok-script-0.0.85 → ok-script-0.0.87}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ok-script
-Version: 0.0.85
+Version: 0.0.87
 Summary: Automation with Computer Vision for Python
 Home-page: https://github.com/ok-oldking/ok-script
 Author: ok-oldking

{ok-script-0.0.85 → ok-script-0.0.87}/ok/OK.py

@@ -97,7 +97,7 @@ class OK:
         if template_matching is not None:
             coco_feature_json = self.config.get('template_matching').get('coco_feature_json')
             from ok.feature.FeatureSet import FeatureSet
-            self.feature_set = FeatureSet(coco_feature_json,
+            self.feature_set = FeatureSet(self.debug, coco_feature_json,
                                           default_horizontal_variance=template_matching.get(
                                               'default_horizontal_variance', 0),
                                           default_vertical_variance=template_matching.get('default_vertical_variance',

{ok-script-0.0.85 → ok-script-0.0.87}/ok/capture/HwndWindow.py

@@ -160,6 +160,8 @@ def find_hwnd(title, exe_name, frame_width, frame_height, player_id=-1):
                 elif not re.search(title, text):
                     return True
             name, full_path, cmdline = get_exe_by_hwnd(hwnd)
+            if not name:
+                return True
             x, y, border, title_height, width, height, scaling, ext_left_bounds, ext_top_bounds = get_window_bounds(
                 hwnd)
             ret = (hwnd, full_path, width, height, x, y, text)
@@ -246,8 +248,11 @@ def get_exe_by_hwnd(hwnd):
     _, pid = win32process.GetWindowThreadProcessId(hwnd)
 
     # Get the process name and executable path
-    process = psutil.Process(pid)
-    return process.name(), process.exe(), process.cmdline()
+    if pid > 0:
+        process = psutil.Process(pid)
+        return process.name(), process.exe(), process.cmdline()
+    else:
+        return None, None, None
 
 
 if __name__ == '__main__':

{ok-script-0.0.85 → ok-script-0.0.87}/ok/capture/adb/DeviceManager.py

@@ -1,4 +1,4 @@
-from adbutils import AdbTimeout
+from adbutils import AdbTimeout, AdbError
 
 from ok.alas.platform_windows import get_emulator_exe
 from ok.capture.HwndWindow import HwndWindow, find_hwnd
@@ -53,27 +53,25 @@ class DeviceManager:
             logger.debug(f'connect adb')
         return self._adb
 
-    def adb_connect(self, addr):
+    def adb_connect(self, addr, try_connect=True):
         try:
-            for info in self.adb.list():
+            for device in self.adb.device_list():
                 if self.exit_event.is_set():
                     logger.error(f"adb_connect exit_event is set")
                     return None
-                if info.serial == addr:
-                    if info.state == 'offline':
+                if device.serial == addr:
+                    if device.info['state'] == 'offline':
                         logger.debug(f'adb_connect offline disconnect first {addr}')
                         self.adb.disconnect(addr)
                     else:
                         logger.debug(f'adb_connect already connected {addr}')
-                        return self.adb.device(addr)
-            self.adb.connect(addr, timeout=5)
-            device = self.adb.device(addr)
-            logger.debug(f'adb_connect {addr} device {device}')
-            return device
+                        return device
+            if try_connect:
+                self.adb.connect(addr, timeout=5)
+                logger.debug(f'adb_connect {addr}')
+                return self.adb_connect(addr, try_connect=False)
         except AdbTimeout as e:
             logger.error(f"adb connect error try kill server {addr}", e)
-            # self.adb.server_kill()
-            # self._adb = None
         except Exception as e:
             logger.error(f"adb connect error return none {addr}", e)
 
@@ -145,7 +143,7 @@ class DeviceManager:
                 logger.debug(f"refresh current only skip others {preferred['imei']} != {emulator.name}")
                 break
             adb_device = self.adb_connect(emulator.serial)
-            width, height = self.get_resolution(adb_device)
+            width, height = self.get_resolution(adb_device) if adb_device is not None else 0, 0
             name, hwnd, full_path, x, y, width, height = find_hwnd(None,
                                                                    emulator.path, width, height, emulator.player_id)
             connected = adb_device is not None and name is not None
@@ -339,12 +337,13 @@ class DeviceManager:
         if device is not None:
             try:
                 return device.shell(*args, **kwargs)
+            except AdbError as e:
+                logger.debug(f'shell adb error {args} {e}')
             except Exception as e:
                 addr = self.get_preferred_device()['address']
                 self.refresh_emulators()
                 new_addr = self.get_preferred_device()['address']
                 logger.error(f"shell_wrapper error occurred, try refresh_emulators {addr} {new_addr}", e)
-                return None
         else:
             raise Exception('Device is none')
 

ok-script-0.0.87/ok/capture/adb/WindowsCaptureFactory.py

@@ -0,0 +1,42 @@
+from ok.logging.Logger import get_logger
+
+logger = get_logger(__name__)
+
+
+def update_capture_method(config, capture_method, hwnd, require_bg=False, use_bit_blt_only=False):
+    try:
+        if config.get('can_bit_blt'):
+            logger.debug(
+                f"try BitBlt method {config} {hwnd} current_type:{type(capture_method)}")
+            from ok.capture.windows.BitBltCaptureMethod import BitBltCaptureMethod
+            target_method = BitBltCaptureMethod
+            capture_method = get_capture(capture_method, target_method, hwnd)
+            if capture_method.test_exclusive_full_screen():
+                return capture_method
+            else:
+                logger.info("test_exclusive_full_screen failed, can't use BitBlt")
+        if use_bit_blt_only:
+            return None
+        from ok.capture.windows.WindowsGraphicsCaptureMethod import windows_graphics_available
+        if windows_graphics_available():
+            from ok.capture.windows.WindowsGraphicsCaptureMethod import WindowsGraphicsCaptureMethod
+            target_method = WindowsGraphicsCaptureMethod
+            capture_method = get_capture(capture_method, target_method, hwnd)
+            return capture_method
+
+        if not require_bg:
+            from ok.capture.windows.DesktopDuplicationCaptureMethod import DesktopDuplicationCaptureMethod
+            target_method = DesktopDuplicationCaptureMethod
+            capture_method = get_capture(capture_method, target_method, hwnd)
+            return capture_method
+    except Exception as e:
+        logger.error(f'update_capture_method exception, return None: ', e)
+
+
+def get_capture(capture_method, target_method, hwnd):
+    if not isinstance(capture_method, target_method):
+        if capture_method is not None:
+            capture_method.close()
+        capture_method = target_method(hwnd)
+    capture_method.hwnd_window = hwnd
+    return capture_method

{ok-script-0.0.85 → ok-script-0.0.87}/ok/capture/windows/WindowsGraphicsCaptureMethod.py

@@ -23,7 +23,7 @@ logger = get_logger(__name__)
 class WindowsGraphicsCaptureMethod(BaseWindowsCaptureMethod):
     name = "Windows Graphics Capture"
     description = "fast, most compatible, capped at 60fps"
-    last_frame = None
+    last_dx_frame = None
     last_frame_time = 0
     frame_pool = None
     item = None
@@ -38,67 +38,71 @@ class WindowsGraphicsCaptureMethod(BaseWindowsCaptureMethod):
 
     def frame_arrived_callback(self, x, y):
         try:
-            frame = self.frame_pool.TryGetNextFrame()
+            self.last_frame_time = time.time()
+            self.last_dx_frame = self.frame_pool.TryGetNextFrame()
         except Exception as e:
             logger.error(f"TryGetNextFrame error {e}")
             self.close()
             return
+
+    def convert_dx_frame(self):
+        frame = self.last_dx_frame
         if not frame:
+            return None
+
+        need_reset_framepool = False
+        if frame.ContentSize.Width != self.last_size.Width or frame.ContentSize.Height != self.last_size.Height:
+            need_reset_framepool = True
+            self.last_size = frame.ContentSize
+
+        if need_reset_framepool:
+            logger.info('need_reset_framepool')
+            self.reset_framepool(frame.ContentSize)
             return
-        self.last_frame_time = time.time()
-        img = None
-        with frame:
-            need_reset_framepool = False
-            need_reset_device = False
-            if frame.ContentSize.Width != self.last_size.Width or frame.ContentSize.Height != self.last_size.Height:
-                need_reset_framepool = True
-                self.last_size = frame.ContentSize
+        need_reset_device = False
 
-            if need_reset_framepool:
-                self.reset_framepool(frame.ContentSize)
-                return
-            tex = None
+        tex = None
 
-            cputex = None
-            try:
-                from ok.rotypes.Windows.Graphics.DirectX.Direct3D11 import IDirect3DDxgiInterfaceAccess
-                from ok.rotypes.roapi import GetActivationFactory
-                tex = frame.Surface.astype(IDirect3DDxgiInterfaceAccess).GetInterface(
-                    d3d11.ID3D11Texture2D.GUID).astype(d3d11.ID3D11Texture2D)
-                desc = tex.GetDesc()
-                desc2 = d3d11.D3D11_TEXTURE2D_DESC()
-                desc2.Width = desc.Width
-                desc2.Height = desc.Height
-                desc2.MipLevels = desc.MipLevels
-                desc2.ArraySize = desc.ArraySize
-                desc2.Format = desc.Format
-                desc2.SampleDesc = desc.SampleDesc
-                desc2.Usage = d3d11.D3D11_USAGE_STAGING
-                desc2.CPUAccessFlags = d3d11.D3D11_CPU_ACCESS_READ
-                desc2.BindFlags = 0
-                desc2.MiscFlags = 0
-                cputex = self.dxdevice.CreateTexture2D(ctypes.byref(desc2), None)
-                self.immediatedc.CopyResource(cputex, tex)
-                mapinfo = self.immediatedc.Map(cputex, 0, d3d11.D3D11_MAP_READ, 0)
-                img = np.ctypeslib.as_array(ctypes.cast(mapinfo.pData, PBYTE),
-                                            (desc.Height, mapinfo.RowPitch // 4, 4))[
-                      :, :desc.Width].copy()
-                self.immediatedc.Unmap(cputex, 0)
-            except OSError as e:
-                if e.winerror == d3d11.DXGI_ERROR_DEVICE_REMOVED or e.winerror == d3d11.DXGI_ERROR_DEVICE_RESET:
-                    need_reset_framepool = True
-                    need_reset_device = True
-                else:
-                    raise
-            finally:
-                if tex is not None:
-                    tex.Release()
-                if cputex is not None:
-                    cputex.Release()
-            if need_reset_framepool:
-                self.reset_framepool(frame.ContentSize, need_reset_device)
-                return self.get_frame()
-        self.last_frame = img
+        cputex = None
+        try:
+            from ok.rotypes.Windows.Graphics.DirectX.Direct3D11 import IDirect3DDxgiInterfaceAccess
+            from ok.rotypes.roapi import GetActivationFactory
+            tex = frame.Surface.astype(IDirect3DDxgiInterfaceAccess).GetInterface(
+                d3d11.ID3D11Texture2D.GUID).astype(d3d11.ID3D11Texture2D)
+            desc = tex.GetDesc()
+            desc2 = d3d11.D3D11_TEXTURE2D_DESC()
+            desc2.Width = desc.Width
+            desc2.Height = desc.Height
+            desc2.MipLevels = desc.MipLevels
+            desc2.ArraySize = desc.ArraySize
+            desc2.Format = desc.Format
+            desc2.SampleDesc = desc.SampleDesc
+            desc2.Usage = d3d11.D3D11_USAGE_STAGING
+            desc2.CPUAccessFlags = d3d11.D3D11_CPU_ACCESS_READ
+            desc2.BindFlags = 0
+            desc2.MiscFlags = 0
+            cputex = self.dxdevice.CreateTexture2D(ctypes.byref(desc2), None)
+            self.immediatedc.CopyResource(cputex, tex)
+            mapinfo = self.immediatedc.Map(cputex, 0, d3d11.D3D11_MAP_READ, 0)
+            img = np.ctypeslib.as_array(ctypes.cast(mapinfo.pData, PBYTE),
+                                        (desc.Height, mapinfo.RowPitch // 4, 4))[
+                  :, :desc.Width].copy()
+            self.immediatedc.Unmap(cputex, 0)
+            return img
+        except OSError as e:
+            if e.winerror == d3d11.DXGI_ERROR_DEVICE_REMOVED or e.winerror == d3d11.DXGI_ERROR_DEVICE_RESET:
+                need_reset_framepool = True
+                need_reset_device = True
+            else:
+                raise e
+        finally:
+            if tex is not None:
+                tex.Release()
+            if cputex is not None:
+                cputex.Release()
+        if need_reset_framepool:
+            self.reset_framepool(frame.ContentSize, need_reset_device)
+            return self.get_frame()
 
     @property
     def hwnd_window(self):
@@ -139,7 +143,7 @@ class WindowsGraphicsCaptureMethod(BaseWindowsCaptureMethod):
                 self.evtoken = item.add_Closed(delegate)
                 self.frame_pool = Direct3D11CaptureFramePool.CreateFreeThreaded(self.rtdevice,
                                                                                 DirectXPixelFormat.B8G8R8A8UIntNormalized,
-                                                                                1, item.Size)
+                                                                                2, item.Size)
                 self.session = self.frame_pool.CreateCaptureSession(item)
                 pool = self.frame_pool
                 pool.add_FrameArrived(
@@ -193,10 +197,11 @@ class WindowsGraphicsCaptureMethod(BaseWindowsCaptureMethod):
     @override
     def do_get_frame(self):
         if self.start_or_stop():
-            frame = self.last_frame
-            self.last_frame = None
+            frame = self.convert_dx_frame()
+            if frame is None:
+                return
+            self.last_dx_frame = None
             latency = time.time() - self.last_frame_time
-            self.last_frame_time = time.time()
 
             frame = self.crop_image(frame)
 
@@ -209,14 +214,16 @@ class WindowsGraphicsCaptureMethod(BaseWindowsCaptureMethod):
                 logger.warning(f"latency too large return None frame: {latency}")
                 return None
             else:
+                # logger.debug(f'frame latency: {latency}')
                 return frame
 
     def reset_framepool(self, size, reset_device=False):
+        logger.info(f'reset_framepool')
         from ok.rotypes.Windows.Graphics.DirectX import DirectXPixelFormat
         if reset_device:
             self.create_device()
         self.frame_pool.Recreate(self.rtdevice,
-                                 DirectXPixelFormat.B8G8R8A8UIntNormalized, 1, size)
+                                 DirectXPixelFormat.B8G8R8A8UIntNormalized, 2, size)
 
     def crop_image(self, frame):
         if frame is not None:

{ok-script-0.0.85 → ok-script-0.0.87}/ok/config/Config.py

@@ -78,8 +78,10 @@ class Config(dict):
 
     def __setitem__(self, key, value):
         if self.validate(key, value):
+            old_value = self.get(key)
             super().__setitem__(key, value)
-            self.save_file()
+            if old_value != value:
+                self.save_file()
 
     def __getitem__(self, key):
         try:

ok-script-0.0.87/ok/feature/CompressCoco.py

@@ -0,0 +1,57 @@
+import json
+import os
+import sys
+
+import cv2
+from PIL import Image
+
+
+def compress_coco(coco_json) -> None:
+    coco_folder = os.path.dirname(coco_json)
+
+    image_dict = {}
+    with open(coco_json, 'r') as file:
+        data = json.load(file)
+
+        image_map = {image['id']: image['file_name'] for image in data['images']}
+        category_map = {category['id']: category['name'] for category in data['categories']}
+
+        for annotation in data['annotations']:
+            image_id = annotation['image_id']
+            category_id = annotation['category_id']
+            bbox = annotation['bbox']
+
+            # Load and scale the image
+            image_path = str(os.path.join(coco_folder, image_map[image_id]))
+            image = cv2.imread(image_path)
+            original_height, original_width = image.shape[:2]
+            if image is None:
+                print(f'Could not read image {image_path}')
+                continue
+            x, y, w, h = bbox
+            # Crop the image to the bounding box
+            image = image[round(y):round(y + h), round(x):round(x + w), :3]
+
+            image_features = image_dict.get(image_path, [])
+            image_features.append((round(x), round(y), image, original_width, original_height))
+            image_dict[image_path] = image_features
+
+        # Loop through the image_dict and write all the image_feature associated with it in a new PNG
+        for image_path, features in image_dict.items():
+            background = None
+            for feature in features:
+                x, y, image, original_width, original_height = feature
+                # Create a white background
+                if not background:
+                    background = Image.new('RGBA', (original_width, original_height), (255, 255, 255, 255))
+                # Convert the OpenCV image (numpy array) to a PIL image
+                image = Image.fromarray(cv2.cvtColor(image, cv2.COLOR_BGR2RGBA))
+                # Paste the image onto the background
+                background.paste(image, (x, y), image)
+                # Save the image with compression level 9
+            background.save(image_path, 'PNG', optimize=True, compress_level=9)
+
+
+if __name__ == '__main__':
+    json_file = sys.argv[1]
+    compress_coco(json_file)

{ok-script-0.0.85 → ok-script-0.0.87}/ok/feature/FeatureSet.py

@@ -1,6 +1,7 @@
 import json
 import os
 import sys
+import threading
 from typing import Dict
 from typing import List
 
@@ -21,7 +22,7 @@ class FeatureSet:
     feature_dict: Dict[str, Feature] = {}
     box_dict: Dict[str, Box] = {}
 
-    def __init__(self, coco_json: str, default_horizontal_variance=0,
+    def __init__(self, debug, coco_json: str, default_horizontal_variance=0,
                  default_vertical_variance=0, default_threshold=0.95) -> None:
         """
         Initialize the FeatureSet by loading images and annotations from a COCO dataset.
@@ -33,6 +34,7 @@ class FeatureSet:
         """
         self.coco_json = resource_path(coco_json)
         self.coco_folder = os.path.dirname(self.coco_json)
+        self.debug = debug
 
         logger.debug(f'Loading features from {self.coco_json}')
 
@@ -44,6 +46,7 @@ class FeatureSet:
         self.default_threshold = default_threshold
         self.default_horizontal_variance = default_horizontal_variance
         self.default_vertical_variance = default_vertical_variance
+        self.lock = threading.Lock()
 
     def check_size(self, frame):
         height, width = frame.shape[:2]
@@ -52,6 +55,8 @@ class FeatureSet:
             self.width = width
             self.height = height
             self.process_data()
+        elif not self.feature_dict:
+            self.process_data()
 
     def process_data(self) -> None:
         """
@@ -61,49 +66,60 @@ class FeatureSet:
             width (int): Target width for scaling images.
             height (int): Target height for scaling images.
         """
-        self.feature_dict.clear()
-        self.box_dict.clear()
-        with open(self.coco_json, 'r') as file:
-            data = json.load(file)
-
-        # Create a map from image ID to file name
-        image_map = {image['id']: image['file_name'] for image in data['images']}
-
-        # Create a map from category ID to category name
-        category_map = {category['id']: category['name'] for category in data['categories']}
-
-        for annotation in data['annotations']:
-            image_id = annotation['image_id']
-            category_id = annotation['category_id']
-            bbox = annotation['bbox']
-
-            # Load and scale the image
-            image_path = str(os.path.join(self.coco_folder, image_map[image_id]))
-            image = cv2.imread(image_path)
-            _, original_width = image.shape[:2]
-            if image is None:
-                logger.error(f'Could not read image {image_path}')
-                continue
-            x, y, w, h = bbox
-            if self.width != image.shape[1] or self.height != image.shape[0]:
-                scale_x, scale_y = self.width / image.shape[1], self.height / image.shape[0]
-                logger.debug(f'scaling images {scale_x}, {scale_y}')
-                image = cv2.resize(image, (self.width, self.height))
-                # Calculate the scaled bounding box
-                x, y, w, h = x * scale_x, y * scale_y, w * scale_x, h * scale_y
-
-            # Crop the image to the bounding box
-            image = image[int(y):int(y + h), int(x):int(x + w), :3]
-
-            # Store in featureDict using the category name
-            category_name = category_map[category_id]
-            logger.debug(
-                f"loaded {category_name} resized width {self.width} / original_width:{original_width},scale_x:{self.width / original_width}")
-            if category_name in self.feature_dict:
-                raise ValueError(f"Multiple boxes found for category {category_name}")
-            if not category_name.startswith('box_'):
-                self.feature_dict[category_name] = Feature(image, x, y, w, h)
-            self.box_dict[category_name] = Box(x, y, w, h, name=category_name)
+        with self.lock:
+            if self.debug:
+                folder_size = sum(os.path.getsize(os.path.join(dirpath, filename))
+                                  for dirpath, dirnames, filenames in os.walk(self.coco_folder)
+                                  for filename in filenames)
+                # Convert size to MB
+                folder_size_mb = folder_size / (1024 * 1024)
+                if folder_size_mb > 5:
+                    from ok.feature.CompressCoco import compress_coco
+                    logger.info(f'template folder greater than 5MB try to compress the COCO dataset')
+                    compress_coco(self.coco_json)
+            self.feature_dict.clear()
+            self.box_dict.clear()
+            with open(self.coco_json, 'r') as file:
+                data = json.load(file)
+
+            # Create a map from image ID to file name
+            image_map = {image['id']: image['file_name'] for image in data['images']}
+
+            # Create a map from category ID to category name
+            category_map = {category['id']: category['name'] for category in data['categories']}
+
+            for annotation in data['annotations']:
+                image_id = annotation['image_id']
+                category_id = annotation['category_id']
+                bbox = annotation['bbox']
+
+                # Load and scale the image
+                image_path = str(os.path.join(self.coco_folder, image_map[image_id]))
+                image = cv2.imread(image_path)
+                _, original_width = image.shape[:2]
+                if image is None:
+                    logger.error(f'Could not read image {image_path}')
+                    continue
+                x, y, w, h = bbox
+                if self.width != image.shape[1] or self.height != image.shape[0]:
+                    scale_x, scale_y = self.width / image.shape[1], self.height / image.shape[0]
+                    logger.debug(f'scaling images {scale_x}, {scale_y}')
+                    image = cv2.resize(image, (self.width, self.height))
+                    # Calculate the scaled bounding box
+                    x, y, w, h = x * scale_x, y * scale_y, w * scale_x, h * scale_y
+
+                # Crop the image to the bounding box
+                image = image[round(y):round(y + h), round(x):round(x + w), :3]
+
+                # Store in featureDict using the category name
+                category_name = category_map[category_id]
+                logger.debug(
+                    f"loaded {category_name} resized width {self.width} / original_width:{original_width},scale_x:{self.width / original_width}")
+                if category_name in self.feature_dict:
+                    raise ValueError(f"Multiple boxes found for category {category_name}")
+                if not category_name.startswith('box_'):
+                    self.feature_dict[category_name] = Feature(image, x, y, w, h)
+                self.box_dict[category_name] = Box(x, y, w, h, name=category_name)
 
     def get_box_by_name(self, mat, category_name: str) -> Box:
         self.check_size(mat)
@@ -130,7 +146,6 @@ class FeatureSet:
 
             # Save the image
             cv2.imwrite(file_path, image.mat)
-            print(f"Saved {file_path}")
 
     def find_one(self, mat: np.ndarray, category_name: str, horizontal_variance: float = 0,
                  vertical_variance: float = 0,
@@ -183,16 +198,16 @@ class FeatureSet:
                 width = to_x - x
             if height == -1:
                 height = to_y - y
-            search_x1 = int(x * frame_width)
-            search_y1 = int(y * frame_height)
-            search_x2 = int((x + width) * frame_width)
-            search_y2 = int((y + height) * frame_height)
+            search_x1 = round(x * frame_width)
+            search_y1 = round(y * frame_height)
+            search_x2 = round((x + width) * frame_width)
+            search_y2 = round((y + height) * frame_height)
         else:
             # Define search area using variance
-            search_x1 = max(0, int(feature.x - self.width * horizontal_variance))
-            search_y1 = max(0, int(feature.y - self.height * vertical_variance))
-            search_x2 = min(self.width, int(feature.x + feature_width + self.width * horizontal_variance))
-            search_y2 = min(self.height, int(feature.y + feature_height + self.height * vertical_variance))
+            search_x1 = max(0, round(feature.x - self.width * horizontal_variance))
+            search_y1 = max(0, round(feature.y - self.height * vertical_variance))
+            search_x2 = min(self.width, round(feature.x + feature_width + self.width * horizontal_variance))
+            search_y2 = min(self.height, round(feature.y + feature_height + self.height * vertical_variance))
 
         search_area = mat[search_y1:search_y2, search_x1:search_x2, :3]
         # Crop the search area from the image

{ok-script-0.0.85 → ok-script-0.0.87}/ok/feature/FindFeature.py

@@ -44,9 +44,9 @@ class FindFeature:
         return False
 
     def find_one(self, feature_name, horizontal_variance=0, vertical_variance=0, threshold=0,
-                 use_gray_scale=False) -> Box:
+                 use_gray_scale=False, box=None) -> Box:
         boxes = self.find_feature(feature_name, horizontal_variance, vertical_variance, threshold,
-                                  use_gray_scale=use_gray_scale)
+                                  use_gray_scale=use_gray_scale, box=box)
         if len(boxes) > 0:
             if len(boxes) > 1:
                 print(f"find_one:found {feature_name} too many {len(boxes)}", file=sys.stderr)

{ok-script-0.0.85 → ok-script-0.0.87}/ok/gui/App.py

@@ -13,6 +13,7 @@ from ok.gui.Communicate import communicate
 from ok.gui.MainWindow import MainWindow
 from ok.gui.MessageWindow import MessageWindow
 from ok.gui.StartController import StartController
+from ok.gui.debug.LogWindow import LogWindow
 from ok.gui.i18n.path import i18n_path
 from ok.gui.overlay.OverlayWindow import OverlayWindow
 from ok.logging.Logger import get_logger
@@ -47,6 +48,7 @@ class App:
         self.loading_window = None
         self.overlay_window = None
         self.main_window = None
+        self.log_window = None
         self.exit_event = exit_event
         self.icon = QIcon(self.config.get('gui_icon') or ":/icon/icon.ico")
         if self.config.get('analytics'):
@@ -109,6 +111,10 @@ class App:
         self.main_window.show()
         self.main_window.raise_()
         self.main_window.activateWindow()
+        if self.config.get('debug'):
+            self.log_window = LogWindow(self.config)
+            self.log_window.show()
+            logger.debug('showing log_window')
 
     def size_relative_to_screen(self, width, height):
         screen = self.app.primaryScreen()

{ok-script-0.0.85 → ok-script-0.0.87}/ok/gui/MainWindow.py

@@ -43,10 +43,7 @@ class MainWindow(MSFluentWindow):
             if self.first_tab is None:
                 self.first_tab = self.trigger_tab
             self.addSubInterface(self.trigger_tab, FluentIcon.ROBOT, self.tr('Triggers'))
-        # if debug:
-        #     debug_tab = DebugTab()
-        #     self.addSubInterface(debug_tab, FluentIcon.COMMAND_PROMPT, self.tr('Debug'))
-        # ... Add other tabs similarly
+
         self.addSubInterface(self.start_tab, FluentIcon.PLAY, self.tr('Capture'))
 
         if debug:
@@ -77,8 +74,8 @@ class MainWindow(MSFluentWindow):
         self.tray.setContextMenu(menu)
         self.tray.show()
 
-        if ok.gui.device_manager.get_preferred_device() is not None and self.onetime_tab is not None:
-            self.switchTo(self.onetime_tab)
+        if ok.gui.device_manager.config.get("preferred") is None or self.onetime_tab is None:
+            self.switchTo(self.start_tab)
 
         communicate.capture_error.connect(self.capture_error)
         communicate.notification.connect(self.show_notification)

{ok-script-0.0.85 → ok-script-0.0.87}/ok/gui/debug/DebugTab.py

@@ -49,9 +49,6 @@ class DebugTab(Tab):
         capture_button.clicked.connect(lambda: self.handler.post(self.capture))
         layout.addWidget(capture_button)
 
-        # self.shortcut = QShortcut(QKeySequence("Ctrl+Alt+S"), self)
-        # self.shortcut.activated.connect(lambda: self.handler.post(self.capture))
-
         ocr_button = PushButton("OCR")
         ocr_button.clicked.connect(lambda: self.handler.post(self.ocr))
         layout.addWidget(ocr_button)