ok-script 0.0.7__py3-none-any.whl

autohelper/config/Config.py

@@ -0,0 +1,79 @@
+from autohelper.util.json import read_json_file, write_json_file
+from autohelper.util.path import get_path_relative_to_exe
+
+
+class Config:
+    def __init__(self, default, folder, name):
+        super().__init__()
+        self.config_file = get_path_relative_to_exe(folder, f"{name}.json")
+        self.config = read_json_file(self.config_file)
+        if self.config is None:
+            self.config = default
+        elif verify_config(self.config, default):
+            self.save_file()
+
+    def save_file(self):
+        write_json_file(self.config_file, self.config)
+
+    def update(self, *args, **kwargs):
+        self.config.update(*args, **kwargs)
+        self.save_file()
+
+    def get(self, key, default=None):
+        return self.config.get(key, default)
+
+    def keys(self):
+        return self.config.keys()
+
+    def values(self):
+        return self.config.values()
+
+    def items(self):
+        return self.config.items()
+
+    def pop(self, key, default=None):
+        result = self.config.pop(key, default)
+        self.save_file()
+        return result
+
+    def popitem(self):
+        result = self.config.popitem()
+        self.save_file()
+        return result
+
+    def setdefault(self, key, default=None):
+        result = self.config.setdefault(key, default)
+        self.save_file()
+        return result
+
+    def clear(self):
+        self.config.clear()
+        self.save_file()
+
+    def __len__(self):
+        return len(self.config)
+
+    def __setitem__(self, key, value):
+        self.config[key] = value
+        self.save_file()
+
+    def __getitem__(self, key):
+        return self.config[key]
+
+
+def verify_config(config, default_config):
+    modified = False
+
+    # Remove entries that do not exist in default_config
+    for key in list(config.keys()):
+        if key not in default_config:
+            del config[key]
+            modified = True
+
+    # Check entries in default_config
+    for key, default_value in default_config.items():
+        if key not in config or type(config[key]) != type(default_value):
+            config[key] = default_value
+            modified = True
+
+    return not modified

autohelper/config/InfoDict.py

@@ -0,0 +1,16 @@
+from autohelper.gui.Communicate import communicate
+
+
+class InfoDict(dict):
+
+    def __delitem__(self, key):
+        super().__delitem__(key)
+        communicate.task_info.emit()
+
+    def clear(self):
+        super().clear()
+        communicate.task_info.emit()
+
+    def __setitem__(self, key, value):
+        super().__setitem__(key, value)
+        communicate.task_info.emit()

autohelper/feature/Box.py

@@ -0,0 +1,199 @@
+import math
+import random
+import re
+
+
+class Box:
+    def __init__(self, x: int, y: int, width: int, height: int, confidence: float = 1, name=None) -> None:
+        self.name = name
+        self.x = x
+        self.y = y
+        self.width = width
+        self.height = height
+        self.confidence = confidence
+
+    def __eq__(self, other):
+        if not isinstance(other, Box):
+            # Don't attempt to compare against unrelated types
+            return NotImplemented
+
+        return (self.x == other.x and
+                self.y == other.y and
+                self.width == other.width and
+                self.height == other.height and
+                self.confidence == other.confidence and
+                self.name == other.name)
+
+    def __repr__(self):
+        return self.name
+
+    def __str__(self) -> str:
+        if self.name is not None:
+            return f"Box(name='{self.name}', x={self.x}, y={self.y}, width={self.width}, height={self.height}, confidence={round(self.confidence * 100)})"
+        return f"Box(x={self.x}, y={self.y}, width={self.width}, height={self.height}, confidence={round(self.confidence * 100)})"
+
+    def closest_distance(self, other):
+        # Calculate the sides of the boxes
+        left1, right1 = self.x, self.x + self.width
+        top1, bottom1 = self.y, self.y + self.height
+        left2, right2 = other.x, other.x + other.width
+        top2, bottom2 = other.y, other.y + other.height
+
+        # Horizontal distance
+        if right1 < left2:
+            horizontal_distance = left2 - right1
+        elif right2 < left1:
+            horizontal_distance = left1 - right2
+        else:
+            horizontal_distance = 0
+
+        # Vertical distance
+        if bottom1 < top2:
+            vertical_distance = top2 - bottom1
+        elif bottom2 < top1:
+            vertical_distance = top1 - bottom2
+        else:
+            vertical_distance = 0
+
+        # If boxes overlap or touch, the closest distance is 0
+        if horizontal_distance == 0 and vertical_distance == 0:
+            return 0
+
+        # If boxes are diagonally aligned, calculate diagonal distance
+        return math.sqrt(horizontal_distance ** 2 + vertical_distance ** 2)
+
+    def relative_with_variance(self, relative_x=0.5, relative_y=0.5):
+        # Calculate the center of the box
+        center_x = self.x + self.width * relative_x
+        center_y = self.y + self.height * relative_y
+
+        # Add random variance
+        variance = random.uniform(0, 0.1)
+        center_x_with_variance = center_x + variance
+        center_y_with_variance = center_y + variance
+        return round(center_x_with_variance), round(center_y_with_variance)
+
+    def copy(self, x_offset=0, y_offset=0, width_offset=0, height_offset=0, name=None):
+        return Box(self.x + x_offset, self.y + y_offset, self.width + width_offset, self.height + height_offset,
+                   self.confidence, name or self.name)
+
+    def center(self):
+        return self.x + self.width / 2, self.y + self.height / 2
+
+    def find_closest_box(self, direction: str, boxes: list):
+        orig_center_x, orig_center_y = self.center()
+
+        def distance_criteria(box):
+            # Calculate center points for comparison
+            box_center_x, box_center_y = box.center()
+
+            dx = box_center_x - orig_center_x
+            dy = box_center_y - orig_center_y
+            distance = math.sqrt(dx ** 2 + dy ** 2)
+            if box == self:
+                return float('inf')
+            elif direction == 'up' and self.y - (box.y + box.height / 2) >= 0:
+                return distance
+            elif direction == 'down' and box.y - (self.y + self.height / 2) >= 0:
+                return distance
+            elif direction == 'left' and self.x - (box.x + box.width / 2) >= 0:
+                return distance
+            elif direction == 'right' and box.x - (self.x + self.width / 2) >= 0:
+                return distance
+            else:
+                return float('inf')
+
+        filtered_boxes = sorted(boxes, key=distance_criteria)
+        # Removed debug print statement for cleanliness
+
+        for box in filtered_boxes:
+            if distance_criteria(box) != float('inf'):
+                return box
+        return None
+
+
+def sort_boxes(boxes):
+    return sorted(boxes, key=lambda box: (box.y, box.x if abs(box.y - boxes[0].y) < 6 else 0))
+
+
+def find_box_by_name(boxes, names) -> Box:
+    if isinstance(names, (str, re.Pattern)):
+        names = [names]
+
+    result = None
+    priority = len(names)
+
+    for box in boxes:
+        for i, name in enumerate(names):
+            if (isinstance(name, str) and name == box.name) or (
+                    isinstance(name, re.Pattern) and re.search(name, box.name)):
+                if i < priority:
+                    priority = i
+                    result = box
+                    if i == 0:
+                        break
+
+    return result
+
+
+def find_boxes_within_boundary(boxes, boundary_box):
+    """
+    Find all boxes that are entirely within the specified boundary box.
+
+    Parameters:
+    - boxes (list[Box]): List of Box objects to check.
+    - boundary_box (Box): The boundary Box object.
+
+    Returns:
+    - list[Box]: Boxes found within the boundary box.
+    """
+    within_boundary = []
+
+    for box in boxes:
+        # Check if box is within boundary_box
+        if (box.x >= boundary_box.x and
+                box.y >= boundary_box.y and
+                box.x + box.width <= boundary_box.x + boundary_box.width and
+                box.y + box.height <= boundary_box.y + boundary_box.height):
+            within_boundary.append(box)
+
+    return within_boundary
+
+
+def crop_image(image, box=None):
+    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]):  # image.shape[0] is the height of the image
+
+            # Extract the region of interest (ROI) using slicing
+
+            return 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 image  # or None, or raise an exception
+    else:
+        return image
+
+
+def find_boxes_by_name(boxes, names) -> list[Box]:
+    # Ensure names is always a list
+    if isinstance(names, (str, re.Pattern)):
+        names = [names]
+
+    result = []
+
+    for box in boxes:
+        # Flag to track if the box has been matched and should be added
+        matched = False
+        for name in names:
+            if matched:
+                break  # Stop checking names if we've already matched this box
+            if (isinstance(name, str) and name == box.name) or (
+                    isinstance(name, re.Pattern) and re.search(name, box.name)):
+                matched = True
+        if matched:
+            result.append(box)
+
+    return result

autohelper/feature/Feature.py

@@ -0,0 +1,20 @@
+import numpy as np
+
+
+class Feature:
+    def __init__(self, mat: np.ndarray, x: int, y: int, width: int, height: int) -> None:
+        """
+        Initialize a Feature with an image (Mat) and its bounding box coordinates.
+
+        Args:
+            mat (np.ndarray): The OpenCV Mat object representing the image.
+            x (int): The x-coordinate of the top-left corner of the bounding box.
+            y (int): The y-coordinate of the top-left corner of the bounding box.
+            width (int): The width of the bounding box.
+            height (int): The height of the bounding box.
+        """
+        self.mat = mat
+        self.x = x
+        self.y = y
+        self.width = width
+        self.height = height

autohelper/feature/FeatureSet.py

@@ -0,0 +1,207 @@
+import json
+import os
+import sys
+from typing import Dict
+from typing import List
+
+import cv2
+import numpy as np
+
+from autohelper.feature.Box import Box, sort_boxes
+from autohelper.feature.Feature import Feature
+from autohelper.gui.Communicate import communicate
+from autohelper.logging.Logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class FeatureSet:
+    # Category_name to OpenCV Mat
+    featureDict: Dict[str, Feature] = {}
+
+    def __init__(self, coco_folder: 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.
+
+        Args:
+            coco_folder (str): Directory containing the JSON file and images.
+            width (int): Scale images to this width.
+            height (int): Scale images to this height.
+        """
+        self.coco_folder = coco_folder
+
+        # Process images and annotations
+        self.width = 0
+        self.height = 0
+        if default_threshold == 0:
+            default_threshold = 0.95
+        self.default_threshold = default_threshold
+        self.default_horizontal_variance = default_horizontal_variance
+        self.default_vertical_variance = default_vertical_variance
+
+    def check_size(self, frame):
+        height, width = frame.shape[:2]
+        if self.width != width or self.height != height and height > 0 and width > 0:
+            logger.info(f"FeatureSet: Width and height changed from {self.width}x{self.height} to {width}x{height}")
+            self.width = width
+            self.height = height
+            self.process_data()
+
+    def process_data(self) -> None:
+        """
+        Process the images and annotations from the COCO dataset.
+
+        Args:
+            width (int): Target width for scaling images.
+            height (int): Target height for scaling images.
+        """
+        self.featureDict.clear()
+        json_path = f'{self.coco_folder}/_annotations.coco.json'
+        with open(json_path, '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 = f'{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
+            scale_x, scale_y = self.width / image.shape[1], self.height / image.shape[0]
+            image = cv2.resize(image, (self.width, self.height))
+
+            # Calculate the scaled bounding box
+            x, y, w, h = bbox
+            x, y, w, h = round(x * scale_x), round(y * scale_y), round(w * scale_x), round(h * scale_y)
+
+            # Crop the image to the bounding box
+            cropped_image = image[y:y + h, x: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:{scale_x},scale_y:{scale_y}")
+            if category_name in self.featureDict:
+                raise ValueError(f"Multiple boxes found for category {category_name}")
+            self.featureDict[category_name] = Feature(cropped_image, x, y, w, h)
+
+    def save_images(self, target_folder: str) -> None:
+        """
+        Save all images in the featureDict to the specified folder.
+
+        Args:
+            target_folder (str): The folder where images will be saved.
+        """
+        # Ensure the target folder exists
+        os.makedirs(target_folder, exist_ok=True)
+
+        # Iterate through the featureDict and save each image
+        for category_name, image in self.featureDict.items():
+            # Construct the filename
+            file_name = f"{category_name}.jpg"
+            file_path = os.path.join(target_folder, file_name)
+
+            # 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,
+                 threshold=0) -> Box:
+        boxes = self.find_feature(mat, category_name, horizontal_variance=horizontal_variance,
+                                  vertical_variance=vertical_variance, threshold=threshold)
+        if len(boxes) > 1:
+            logger.warning(f"find_one:found too many {len(boxes)} return first", file=sys.stderr)
+        if len(boxes) >= 1:
+            return boxes[0]
+
+    def find_feature(self, mat: np.ndarray, category_name: str, horizontal_variance: float = 0,
+                     vertical_variance: float = 0, threshold: float = 0) -> List[Box]:
+        """
+        Find a feature within a given variance.
+
+        Args:
+            mat (np.ndarray): The image in which to find the feature.
+            category_name (str): The category name of the feature to find.
+            horizontal_variance (float): Allowed horizontal variance as a percentage of width.
+            vertical_variance (float): Allowed vertical variance as a percentage of height.
+            threshold: Allowed confidence threshold for the feature
+
+        Returns:
+            List[Box]: A list of boxes where the feature is found.
+        """
+        self.check_size(mat)
+
+        if threshold == 0:
+            threshold = self.default_threshold
+        if horizontal_variance == 0:
+            horizontal_variance = self.default_horizontal_variance
+        if vertical_variance == 0:
+            vertical_variance = self.default_vertical_variance
+        if category_name not in self.featureDict:
+            raise ValueError(f"FeatureSet: {category_name} not found in featureDict")
+
+        feature = self.featureDict[category_name]
+        feature_width, feature_height = feature.width, feature.height
+
+        # Define search area using 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
+        # print(f"search_area: ({self.width,self.height})({search_x1},{search_x2},{search_y1},{search_y2}) ({get_depth(search_area),get_depth(feature.mat)})")
+
+        # cv2.imwrite("images/test.jpg", search_area)
+
+        # Template matchingTM_CCORR_NORMED
+        # result = cv2.matchTemplate(search_area, feature.mat, cv2.TM_CCOEFF_NORMED)
+        result = cv2.matchTemplate(search_area, feature.mat, cv2.TM_CCOEFF_NORMED)
+
+        # Define a threshold for acceptable matches
+        locations = filter_and_sort_matches(result, threshold, feature_width, feature_height)
+        boxes = []
+
+        for loc in locations:  # Iterate through found locations            
+            x, y = loc[0] + search_x1, loc[1] + search_y1
+            confidence = result[loc[1], loc[0]]  # Retrieve the confidence score
+            boxes.append(Box(x, y, feature_width, feature_height, confidence, category_name))
+            # cv2.rectangle(mat, (x, y), (x + feature_width,y+feature_height),(0, 255, 0), 2)
+            # cv2.imwrite("images/test.jpg", mat)
+
+        result = sort_boxes(boxes)
+        communicate.draw_box.emit(category_name, result, "red")
+        return result
+
+
+def filter_and_sort_matches(result, threshold, width, height):
+    # Filter matches based on the threshold
+    loc = np.where(result >= threshold)
+
+    # Zip the locations into a list of tuples and sort by threshold in descending order
+    matches = sorted(zip(*loc[::-1]), key=lambda p: result[p[::-1]], reverse=True)
+
+    # Filter out overlapping matches
+    unique_matches = []
+    for pt in matches:
+        if all(not (pt[0] >= m[0] - width and pt[0] <= m[0] + width and
+                    pt[1] >= m[1] - height and pt[1] <= m[1] + height)
+               for m in unique_matches):
+            unique_matches.append(pt)
+
+    # print(f"result {len(result)} loc {len(loc)} matches {len(matches)} unique_matches {unique_matches}")
+    return unique_matches

autohelper/feature/FindFeature.py

@@ -0,0 +1,52 @@
+import sys
+from typing import List
+
+from autohelper.feature.Box import Box
+
+
+class FindFeature:
+
+    def __init__(self):
+        self.feature_set = None
+        self.executor = None
+
+    def find(self, feature_name, horizontal_variance=0, vertical_variance=0, threshold=0) -> List[Box]:
+        if self.executor.frame is None:
+            return list()
+        return self.feature_set.find_feature(self.executor.frame, feature_name, horizontal_variance, vertical_variance,
+                                             threshold)
+
+    def find_and_set(self, features, horizontal_variance=0, vertical_variance=0, threshold=0):
+        ret = True
+        if features is None:
+            raise Exception("features cannot be None")
+        if isinstance(features, str):
+            features = [features]
+        for feature in features:
+            result = self.find_one(feature, horizontal_variance, vertical_variance, threshold)
+            if result is None:
+                ret = False
+            setattr(self, feature, result)
+        return ret
+
+    def wait_and_click(self, feature, horizontal_variance=0, vertical_variance=0, threshold=0, relative_x=0.5,
+                       relative_y=0.5,
+                       time_out=0, pre_action=None, post_action=None):
+        box = self.wait_until(lambda: self.find_one(feature, horizontal_variance, vertical_variance, threshold),
+                              time_out,
+                              pre_action,
+                              post_action)
+        if box is not None:
+            self.click_box(box, relative_x, relative_y)
+            return True
+        return False
+
+    def find_one(self, feature_name, horizontal_variance=0, vertical_variance=0, threshold=0) -> Box:
+        boxes = self.find(feature_name, horizontal_variance, vertical_variance, threshold)
+        if len(boxes) > 0:
+            if len(boxes) > 1:
+                print(f"find_one:found {feature_name} too many {len(boxes)}", file=sys.stderr)
+            return boxes[0]
+
+    def on_feature(self, boxes):
+        pass