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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ok-script
-Version: 0.0.82
+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.82 → 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.82 → 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.82 → ok-script-0.0.83}/ok/capture/adb/DeviceManager.py

@@ -99,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
@@ -112,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:
@@ -129,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,
@@ -192,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.82 → 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.82 → 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.82 → 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.82 → 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

{ok-script-0.0.82 → 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):

{ok-script-0.0.82 → ok-script-0.0.83}/ok/interaction/BaseInteraction.py

@@ -14,6 +14,12 @@ class BaseInteraction:
     def send_key(self, key, down_time=0.02):
         pass
 
+    def send_key_down(self, key):
+        pass
+    
+    def send_key_up(self, key):
+        pass
+
     def move(self, x, y):
         pass
 

{ok-script-0.0.82 → ok-script-0.0.83}/ok/interaction/Win32Interaction.py

@@ -22,10 +22,23 @@ class Win32Interaction(BaseInteraction):
 
     def send_key(self, key, down_time=0.02):
         if not self.capture.clickable():
+            logger.error(f"can't click on {key}, because capture is not clickable")
             return
-        pydirectinput.keyDown(key)
+        pydirectinput.keyDown(str(key))
         time.sleep(down_time)
-        pydirectinput.keyUp(key)
+        pydirectinput.keyUp(str(key))
+
+    def send_key_down(self, key):
+        if not self.capture.clickable():
+            logger.error(f"can't click on {key}, because capture is not clickable")
+            return
+        pydirectinput.keyDown(str(key))
+
+    def send_key_up(self, key):
+        if not self.capture.clickable():
+            logger.error(f"can't click on {key}, because capture is not clickable")
+            return
+        pydirectinput.keyUp(str(key))
 
     def move(self, x, y):
         if not self.capture.clickable():
@@ -82,6 +95,22 @@ class Win32Interaction(BaseInteraction):
         if current_x != -1 and current_y != -1:
             pydirectinput.moveTo(current_x, current_y)
 
+    def mouse_down(self, x=-1, y=-1, name=None):
+        if not self.capture.clickable():
+            logger.info(f"window in background, not clickable")
+            return
+        if x != -1 and y != -1:
+            x, y = self.capture.get_abs_cords(x, y)
+            logger.info(f"left_click {x, y}")
+            pydirectinput.moveTo(x, y)
+        pydirectinput.mouseDown()
+
+    def mouse_up(self):
+        if not self.capture.clickable():
+            logger.info(f"window in background, not clickable")
+            return
+        pydirectinput.mouseUp()
+
     def should_capture(self):
         return self.capture.clickable()
 

{ok-script-0.0.82 → ok-script-0.0.83}/ok/ocr/OCR.py

@@ -44,12 +44,9 @@ class OCR:
                     box.name = str(match)
 
             image, scale_factor = resize_image(image, original_height, target_height)
-            try:
-                result, _ = self.executor.ocr(image, use_det=True, use_cls=False, use_rec=True)
-            except Exception as e:
-                logger.error('ocr_error sleep and retry once', e)
-                time.sleep(3)
-                result, _ = self.executor.ocr(image, use_det=True, use_cls=False, use_rec=True)
+
+            result, _ = self.executor.ocr(image, use_det=True, use_cls=False, use_rec=True)
+
             detected_boxes = []
             ocr_boxes = None
             # Process the results and create Box objects

{ok-script-0.0.82 → ok-script-0.0.83}/ok/task/ExecutorOperation.py

@@ -34,12 +34,27 @@ class ExecutorOperation:
     def is_scene(self, the_scene):
         return isinstance(self.executor.current_scene, the_scene)
 
-    def click(self, x, y, move_back=False, name=None):
+    def click(self, x=-1, y=-1, move_back=False, name=None):
         frame = self.executor.nullable_frame()
         communicate.emit_draw_box("click", [Box(max(0, x - 10), max(0, y - 10), 20, 20, name="click")], "green", frame)
         self.executor.reset_scene()
         self.executor.interaction.click(x, y, move_back, name=name)
 
+    def mouse_down(self, x=-1, y=-1, name=None):
+        frame = self.executor.nullable_frame()
+        communicate.emit_draw_box("mouse_down", [Box(max(0, x - 10), max(0, y - 10), 20, 20, name="click")], "green",
+                                  frame)
+        self.executor.reset_scene()
+        self.executor.interaction.mouse_down(x, y, name=name)
+
+    def mouse_up(self, name=None):
+        frame = self.executor.nullable_frame()
+        communicate.emit_draw_box("mouse_up", self.box_of_screen(0.5, 0.5, width=0.01, height=0.01, name="click"),
+                                  "green",
+                                  frame)
+        self.executor.reset_scene()
+        self.executor.interaction.mouse_up()
+
     def swipe_relative(self, from_x, from_y, to_x, to_y, duration=0.5):
         self.swipe(int(self.width * from_x), int(self.height * from_y), int(self.width * to_x),
                    int(self.height * to_y), duration)
@@ -83,7 +98,7 @@ class ExecutorOperation:
             self.click_box(to_click, relative_x, relative_y)
             return to_click
 
-    def box_of_screen(self, x, y, to_x=1, to_y=1, width=0, height=0, name=None):
+    def box_of_screen(self, x, y, to_x: float = 1, to_y: float = 1, width: float = 0, height: float = 0, name=None):
         if name is None:
             name = f"{x} {y} {width} {height}"
         return relative_box(self.executor.method.width, self.executor.method.height, x, y,
@@ -138,8 +153,17 @@ class ExecutorOperation:
         self.executor.sleep(timeout)
 
     def send_key(self, key, down_time=0.02):
+        self.executor.reset_scene()
         self.executor.interaction.send_key(key, down_time)
 
+    def send_key_down(self, key):
+        self.executor.reset_scene()
+        self.executor.interaction.send_key_down(key)
+
+    def send_key_up(self, key):
+        self.executor.reset_scene()
+        self.executor.interaction.send_key_up(key)
+
     def wait_until(self, condition, time_out=0, pre_action=None, post_action=None, wait_until_before_delay=0):
         return self.executor.wait_condition(condition, time_out, pre_action, post_action, wait_until_before_delay)
 

{ok-script-0.0.82 → ok-script-0.0.83}/ok/task/TaskExecutor.py

@@ -279,7 +279,7 @@ class TaskExecutor:
                 traceback.print_exc()
                 stack_trace_str = traceback.format_exc()
                 logger.error(f"{name} exception: {e}, traceback: {stack_trace_str}")
-                if self._frame:
+                if self._frame is not None:
                     communicate.screenshot.emit(self.frame, name)
             self.current_task = None
             if isinstance(self.current_task, OneTimeTask):

{ok-script-0.0.82 → ok-script-0.0.83}/ok/task/TriggerTask.py

@@ -8,10 +8,11 @@ class TriggerTask(BaseTask):
 
     def __init__(self):
         super().__init__()
-        self.default_config = {'_enabled': True}
+        self.default_config = {'_enabled': False}
         self.trigger_count = 0
 
     def on_create(self):
+        self._enabled = self.config.get('_enabled', False)
         pass
 
     def get_status(self):

{ok-script-0.0.82 → ok-script-0.0.83}/ok_script.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ok-script
-Version: 0.0.82
+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.82 → ok-script-0.0.83}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setuptools.setup(
     name="ok-script",
-    version="0.0.82",
+    version="0.0.83",
     author="ok-oldking",
     author_email="firedcto@gmail.com",
     description="Automation with Computer Vision for Python",

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

@@ -1,42 +0,0 @@
-import cv2
-
-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_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