ok-script 0.0.81__tar.gz → 0.0.83__tar.gz

{ok-script-0.0.81 → ok-script-0.0.83}/PKG-INFO

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

{ok-script-0.0.81 → ok-script-0.0.83}/ok/alas/emulator_windows.py

@@ -467,7 +467,7 @@ class EmulatorManager(EmulatorManagerBase):
             try:
                 exe = proc.cmdline()
                 exe = exe[0]
-            except (psutil.AccessDenied, IndexError):
+            except (psutil.AccessDenied, psutil.NoSuchProcess, IndexError):
                 # psutil.AccessDenied
                 continue
 

{ok-script-0.0.81 → ok-script-0.0.83}/ok/capture/HwndWindow.py

@@ -180,22 +180,25 @@ def find_hwnd(title, exe_name, frame_width, frame_height):
     win32gui.EnumWindows(callback, None)
     biggest = None
     if len(results) > 0:
+        biggest = results[0]
         for result in results:
             from ok.capture.windows.BitBltCaptureMethod import bit_blt_test_hwnd
             if (biggest is None or (result[2] * result[3]) > biggest[2] * biggest[3]) and bit_blt_test_hwnd(result[0]):
                 biggest = result
         x_offset = 0
         y_offset = 0
-        real_width, real_height = 0, 0
-        if biggest is not None and frame_aspect_ratio != 0:
+        real_width = 0
+        real_height = 0
+        if frame_aspect_ratio != 0:
             real_width, real_height = biggest[2], biggest[3]
             matching_child = enum_child_windows(biggest, frame_aspect_ratio)
             if matching_child is not None:
                 x_offset, y_offset, real_width, real_height = matching_child
-        logger.info(f'find_hwnd {frame_width, frame_height} {biggest} {x_offset, y_offset, real_width, real_height}')
-        return biggest[6], biggest[0], biggest[1], x_offset, y_offset, real_width, real_height,
-    else:
-        return None, None, None, 0, 0, 0, 0
+            logger.info(
+                f'find_hwnd {frame_width, frame_height} {biggest} {x_offset, y_offset, real_width, real_height}')
+        return biggest[6], biggest[0], biggest[1], x_offset, y_offset, real_width, real_height
+
+    return None, None, None, 0, 0, 0, 0
 
 
 def enum_child_windows(biggest, frame_aspect_ratio):

{ok-script-0.0.81 → ok-script-0.0.83}/ok/capture/adb/DeviceManager.py

@@ -19,8 +19,9 @@ class DeviceManager:
     def __init__(self, app_config, exit_event=None):
         self._device = None
         self._adb = None
-        self.supported_ratio = parse_ratio(app_config.get(
-            'supported_screen_ratio'))
+        supported_resolution = app_config.get(
+            'supported_resolution', {})
+        self.supported_ratio = parse_ratio(supported_resolution.get('ratio'))
         self.windows_capture_config = app_config.get('windows')
         self.adb_capture_config = app_config.get('adb')
         self.debug = app_config.get('debug')
@@ -98,12 +99,12 @@ class DeviceManager:
                 pc_device["resolution"] = f"{width}x{height}"
             self.device_dict['pc'] = pc_device
 
-    def do_refresh(self, fast=False):
+    def do_refresh(self, current=False):
         self.update_pc_device()
 
-        self.refresh_emulators()
+        self.refresh_emulators(current)
 
-        self.refresh_phones()
+        self.refresh_phones(current)
 
         if self.exit_event.is_set():
             return
@@ -111,10 +112,16 @@ class DeviceManager:
 
         logger.debug(f'refresh {self.device_dict}')
 
-    def refresh_phones(self):
+    def refresh_phones(self, current=False):
+        if self.adb_capture_config is None:
+            return
         for adb_device in self.adb.iter_device():
             imei = self.adb_get_imei(adb_device)
             if imei is not None:
+                preferred = self.get_preferred_device()
+                if current and preferred is not None and preferred['imei'] != imei:
+                    logger.debug(f"refresh current only skip others {preferred['imei']} != imei")
+                    break
                 found = False
                 for device in self.device_dict.values():
                     if device.get('adb_imei') == imei:
@@ -128,13 +135,17 @@ class DeviceManager:
                                     "resolution": f'{width}x{height}'}
                     self.device_dict[imei] = phone_device
 
-    def refresh_emulators(self):
+    def refresh_emulators(self, current=False):
         if self.adb_capture_config is None:
             return
         from ok.alas.emulator_windows import EmulatorManager
         manager = EmulatorManager()
         installed_emulators = manager.all_emulator_instances
         for emulator in installed_emulators:
+            preferred = self.get_preferred_device()
+            if current and preferred is not None and preferred['imei'] != emulator.name:
+                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)
             name, hwnd, full_path, x, y, width, height = find_hwnd(None,
@@ -142,10 +153,10 @@ class DeviceManager:
             connected = adb_device is not None and name is not None
             emulator_device = {"address": emulator.serial, "device": "adb",
                                "full_path": emulator.path, "connected": connected,
+                               "imei": emulator.name,
                                "nick": name or emulator.name, "emulator": emulator}
             if adb_device is not None:
                 emulator_device["resolution"] = f"{width}x{height}"
-                emulator_device["imei"] = emulator.name
                 emulator_device["adb_imei"] = self.adb_get_imei(adb_device)
             self.device_dict[emulator.name] = emulator_device
         logger.debug(f'refresh emulators {self.device_dict}')
@@ -191,12 +202,13 @@ class DeviceManager:
             self.start()
         logger.debug(f'preferred device: {preferred}')
 
-    def adb_get_imei(self, device):
+    @staticmethod
+    def adb_get_imei(device):
         try:
             return device.shell("settings get secure android_id") or device.shell(
                 "service call iphonesubinfo 4") or device.prop.model
         except Exception as e:
-            logger.error(f"adb_get_imei error {device}", e)
+            logger.error(f"adb_get_imei error maybe offline {device}")
             return None
 
     def get_preferred_device(self):

ok-script-0.0.83/ok/color/Color.py

@@ -0,0 +1,148 @@
+import cv2
+import numpy as np
+
+from ok.feature.Box import Box
+
+black_color = {
+    'r': (0, 0),  # Red range
+    'g': (0, 0),  # Green range
+    'b': (0, 0)  # Blue range
+}
+
+white_color = {
+    'r': (255, 255),  # Red range
+    'g': (255, 255),  # Green range
+    'b': (255, 255)  # Blue range
+}
+
+
+def calculate_colorfulness(image, box=None):
+    if box is not None:
+        image = image[box.y:box.y + box.height, box.x:box.x + box.width, :3]
+    # Split the image into its respective RGB components
+    (B, G, R) = cv2.split(image.astype("float"))
+
+    # Compute rg = R - G
+    rg = np.absolute(R - G)
+
+    # Compute yb = 0.5 * (R + G) - B
+    yb = np.absolute(0.5 * (R + G) - B)
+
+    # Compute the mean and standard deviation of both rg and yb
+    (rbMean, rbStd) = (np.mean(rg), np.std(rg))
+    (ybMean, ybStd) = (np.mean(yb), np.std(yb))
+
+    # Combine the mean and standard deviation
+    stdRoot = np.sqrt((rbStd ** 2) + (ybStd ** 2))
+    meanRoot = np.sqrt((rbMean ** 2) + (ybMean ** 2))
+
+    # Derive the "colorfulness" metric
+    colorfulness = stdRoot + (0.3 * meanRoot)
+
+    return colorfulness / 100
+
+
+def get_saturation(image, box=None):
+    # Load the image
+
+    # Check if image loaded successfully
+    if image is None:
+        raise ValueError("Image not found or path is incorrect")
+
+    if box is not None:
+        if (box.x >= 0 and box.y >= 0 and
+            box.x + box.width <= image.shape[1] and  # image.shape[1] is the width of the image
+            box.y + box.height <= image.shape[
+                0]) and box.width > 0 and box.height > 0:  # image.shape[0] is the height of the image
+
+            # Extract the region of interest (ROI) using slicing
+
+            image = image[box.y:box.y + box.height, box.x:box.x + box.width, :3]
+
+    # Convert image to HSV color space
+    hsv_image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
+
+    # Extract the saturation channel
+    saturation_channel = hsv_image[:, :, 1]
+
+    # Calculate the mean saturation
+    mean_saturation = saturation_channel.mean() / 255
+
+    # If the mean saturation is above the threshold, the image is colored; otherwise, it is grayscale
+    return mean_saturation
+
+
+def find_color_rectangles(image, color_range, min_width, min_height, max_width=-1, max_height=-1, threshold=0.95,
+                          box=None):
+    if image is None:
+        raise ValueError("Image not found or path is incorrect")
+    if box is not None:
+        image = image[box.y:box.y + box.height, box.x:box.x + box.width, :3]
+
+    # Convert color range to BGR format for OpenCV
+    lower_bound = np.array([color_range['b'][0], color_range['g'][0], color_range['r'][0]], dtype="uint8")
+    upper_bound = np.array([color_range['b'][1], color_range['g'][1], color_range['r'][1]], dtype="uint8")
+
+    # Create a mask for the color range
+    mask = cv2.inRange(image, lower_bound, upper_bound)
+
+    # Find contours in the mask
+    contours, _ = cv2.findContours(mask, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
+
+    results = []
+
+    for contour in contours:
+        # Get the bounding rectangle
+        x, y, w, h = cv2.boundingRect(contour)
+
+        # Check if the rectangle meets the size criteria
+        if w >= min_width and h >= min_height and (max_height == -1 or h <= max_height) and (
+                max_width == -1 or w <= max_width):
+
+            # Extract the region of interest (ROI) from the mask
+            roi_mask = mask[y:y + h, x:x + w]
+
+            # Calculate the total number of pixels in the ROI
+            total_pixels = roi_mask.size
+
+            # Calculate the number of matching pixels (value 255)
+            matching_pixels = np.sum(roi_mask == 255)
+
+            # Check if the percentage of matching pixels is greater than or equal to 90%\
+            percent = (matching_pixels / total_pixels)
+            if percent >= threshold:
+                # Store the result
+                results.append(
+                    Box(x, y, w, h, confidence=percent)
+                )
+
+    return results
+
+
+def calculate_color_percentage(image, color_ranges, box=None):
+    # Check if the ROI is within the image bounds
+    if box is not None:
+        if (box.x >= 0 and box.y >= 0 and
+            box.x + box.width <= image.shape[1] and  # image.shape[1] is the width of the image
+            box.y + box.height <= image.shape[
+                0]) and box.width > 0 and box.height > 0:  # image.shape[0] is the height of the image
+
+            # Extract the region of interest (ROI) using slicing
+
+            image = image[box.y:box.y + box.height, box.x:box.x + box.width, :3]
+        else:
+            # Return some error value or raise an exception
+            # For example, return 0 or None
+            return 0  # or None, or raise an exception
+    else:
+        image = image[:, :, :3]
+    # Create a mask for the pixels within the desired color range
+    mask = cv2.inRange(image,
+                       (color_ranges['b'][0], color_ranges['g'][0], color_ranges['r'][0]),
+                       (color_ranges['b'][1], color_ranges['g'][1], color_ranges['r'][1]))
+
+    # Calculate the percentage of pixels within the color range
+    target_pixels = cv2.countNonZero(mask)
+    total_pixels = image.size / 3  # Divide by 3 for an RGB image
+    percentage = target_pixels / total_pixels
+    return percentage

{ok-script-0.0.81 → ok-script-0.0.83}/ok/feature/Box.py

@@ -10,14 +10,14 @@ class Box:
                  confidence: float = 1,
                  name=None, to_x: int | float = -1, to_y: int | float = -1) -> None:
         self.name = name
-        self.x = int(x)
-        self.y = int(y)
+        self.x = round(x)
+        self.y = round(y)
         if to_x != -1 and to_y != -1:
-            self.width = int(to_x - x)
-            self.height = int(to_y - y)
+            self.width = round(to_x - x)
+            self.height = round(to_y - y)
         else:
-            self.width = int(width)
-            self.height = int(height)
+            self.width = round(width)
+            self.height = round(height)
         if self.width <= 0 or self.height <= 0:
             raise ValueError(f'width and height must be greater than zero {x} {y} {width} {height} {to_x} {to_y}')
         self.confidence = confidence
@@ -265,6 +265,6 @@ def relative_box(frame_width, frame_height, x, y, to_x=1, to_y=1, width=0, heigh
         width = to_x - x
     if height == 0:
         height = to_y - y
-    return Box(int(x * frame_width), int(y * frame_height),
-               int(width * frame_width), int(height * frame_height),
+    return Box(round(x * frame_width), round(y * frame_height),
+               round(width * frame_width), round(height * frame_height),
                name=name)

{ok-script-0.0.81 → ok-script-0.0.83}/ok/feature/FeatureSet.py

@@ -145,7 +145,7 @@ class FeatureSet:
 
     def find_feature(self, mat: np.ndarray, category_name: str, horizontal_variance: float = 0,
                      vertical_variance: float = 0, threshold: float = 0, use_gray_scale: bool = False, x=-1, y=-1,
-                     to_x=-1, to_y=-1, width=-1, height=-1) -> List[Box]:
+                     to_x=-1, to_y=-1, width=-1, height=-1, box=None) -> List[Box]:
         """
         Find a feature within a given variance.
 
@@ -172,7 +172,12 @@ class FeatureSet:
             raise ValueError(f"FeatureSet: " + category_name + " not found in featureDict")
         feature = self.feature_dict[category_name]
         feature_width, feature_height = feature.width, feature.height
-        if x != -1 and y != -1:
+        if box is not None:
+            search_x1 = box.x
+            search_y1 = box.y
+            search_x2 = box.x + box.width
+            search_y2 = box.y + box.height
+        elif x != -1 and y != -1:
             frame_height, frame_width, *_ = mat.shape
             if width == -1:
                 width = to_x - x

{ok-script-0.0.81 → ok-script-0.0.83}/ok/feature/FindFeature.py

@@ -11,11 +11,9 @@ class FindFeature:
         self.executor = None
 
     def find_feature(self, feature_name, horizontal_variance=0, vertical_variance=0, threshold=0,
-                     use_gray_scale=False, x=-1, y=-1, to_x=-1, to_y=-1, width=-1, height=-1) -> List[Box]:
-        if self.executor.frame is None:
-            return list()
+                     use_gray_scale=False, x=-1, y=-1, to_x=-1, to_y=-1, width=-1, height=-1, box=None) -> List[Box]:
         return self.feature_set.find_feature(self.executor.frame, feature_name, horizontal_variance, vertical_variance,
-                                             threshold, use_gray_scale, x, y, to_x, to_y, width, height)
+                                             threshold, use_gray_scale, x, y, to_x, to_y, width, height, box=box)
 
     def get_box_by_name(self, name):
         return self.feature_set.get_box_by_name(self.executor.frame, name)
@@ -47,7 +45,8 @@ class FindFeature:
 
     def find_one(self, feature_name, horizontal_variance=0, vertical_variance=0, threshold=0,
                  use_gray_scale=False) -> Box:
-        boxes = self.find_feature(feature_name, horizontal_variance, vertical_variance, threshold, use_gray_scale=False)
+        boxes = self.find_feature(feature_name, horizontal_variance, vertical_variance, threshold,
+                                  use_gray_scale=use_gray_scale)
         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.81 → ok-script-0.0.83}/ok/gui/StartController.py

@@ -24,7 +24,7 @@ class StartController(QObject):
 
     def do_start(self, task=None):
         communicate.starting_emulator.emit(False, None, 30)
-        ok.gui.device_manager.do_refresh()
+        ok.gui.device_manager.do_refresh(True)
 
         device = ok.gui.device_manager.get_preferred_device()
 
@@ -35,7 +35,7 @@ class StartController(QObject):
                 execute(path)
                 wait_until = time.time() + 30
                 while not self.exit_event.is_set():
-                    ok.gui.device_manager.do_refresh()
+                    ok.gui.device_manager.do_refresh(True)
                     error = self.check_device_error()
                     if error is None:
                         break
@@ -73,13 +73,21 @@ class StartController(QObject):
         if not ok.gui.device_manager.capture_method.connected():
             logger.error(f'Game window is not connected {ok.gui.device_manager.capture_method}')
             return self.tr("Game window is not connected, please select the game window and capture method.")
-        supported_ratio = self.config.get(
-            'supported_screen_ratio')
-        supported, resolution = ok.gui.executor.check_frame_and_resolution(supported_ratio)
+        supported_resolution = self.config.get(
+            'supported_resolution', {})
+        supported_ratio = supported_resolution.get('ratio')
+        min_size = supported_resolution.get('min_size')
+        supported, resolution = ok.gui.executor.check_frame_and_resolution(supported_ratio, min_size)
         if not supported:
-            return self.tr(
-                "Window resolution {resolution} is not supported, the supported ratio is {supported_ratio}, check if game windows is minimized, resized or out of screen.",
-            ).format(resolution=resolution, supported_ratio=supported_ratio)
+            error = self.tr(
+                "Game resolution {resolution} is not supported").format(resolution=resolution)
+            if supported_ratio:
+                error += self.tr(', the supported ratio is {supported_ratio}').format(supported_ratio=supported_ratio)
+            if supported_ratio:
+                error += self.tr(', the supported min resolution is {min_size}').format(
+                    min_size=f'{min_size[0]}x{min_size[1]}')
+            error += self.tr(', check if game windows is minimized, resized or out of screen.')
+            return error
         if device and device['device'] == "windows" and not is_admin():
             return self.tr(
                 f"PC version requires admin privileges, Please restart this app with admin privileges!")

{ok-script-0.0.81 → ok-script-0.0.83}/ok/gui/debug/DebugTab.py

@@ -88,6 +88,7 @@ class DebugTab(Tab):
             self.task_changed(self.config.get('target_task'))
         else:
             self.tasks_combo_box.setCurrentIndex(0)
+            self.config['target_task'] = class_names[0]
 
         self.call_button = PushButton(self.tr("Call"))
         self.call_button.clicked.connect(lambda: self.handler.post(self.call))
@@ -146,8 +147,9 @@ class DebugTab(Tab):
         old_interaction = ok.gui.device_manager.interaction
         try:
             images = self.config.get("target_images")
-            ok.gui.device_manager.capture_method = ImageCaptureMethod(images)
-            ok.gui.device_manager.interaction = DoNothingInteraction(ok.gui.device_manager.capture_method)
+            if images:
+                ok.gui.device_manager.capture_method = ImageCaptureMethod(images)
+                ok.gui.device_manager.interaction = DoNothingInteraction(ok.gui.device_manager.capture_method)
             ok.gui.executor.debug_mode = True
             attr = getattr(task, func_name)
             if callable(attr):