ascript 1.3.27__py3-none-win_amd64.whl

ascript/windows/screen/color_algorithms.py

@@ -0,0 +1,277 @@
+import re
+from typing import Iterable, List, Sequence, Tuple
+
+import cv2
+import numpy as np
+
+from .as_cv import AsCv
+from ..daos.screen import Point
+
+
+ColorSpec = Tuple[np.ndarray, np.ndarray]
+
+
+def _source_image(image=None):
+    if image is None:
+        from .screen_core import Screen
+        image = Screen.capture()
+    result = AsCv.to_numpy(image)
+    if result is None or result.size == 0:
+        raise ValueError("图像为空")
+    if result.ndim == 2:
+        result = cv2.cvtColor(result, cv2.COLOR_GRAY2BGR)
+    if result.shape[2] == 4:
+        result = cv2.cvtColor(result, cv2.COLOR_BGRA2BGR)
+    return result
+
+
+def _crop(image: np.ndarray, rect=None):
+    height, width = image.shape[:2]
+    if not rect:
+        return image, 0, 0
+    left, top, right, bottom = (int(value) for value in rect)
+    left, right = sorted((max(0, left), min(width, right)))
+    top, bottom = sorted((max(0, top), min(height, bottom)))
+    if right <= left or bottom <= top:
+        raise ValueError("搜索区域无效")
+    return image[top:bottom, left:right], left, top
+
+
+def _hex_bgr(value: str) -> np.ndarray:
+    value = value.strip().lstrip("#")
+    if len(value) == 3:
+        value = "".join(char * 2 for char in value)
+    if not re.fullmatch(r"[0-9a-fA-F]{6}", value):
+        raise ValueError(f"颜色格式错误: {value}")
+    red, green, blue = (int(value[index:index + 2], 16) for index in (0, 2, 4))
+    return np.array((blue, green, red), dtype=np.int16)
+
+
+def _split_color_specs(colors: str) -> Iterable[str]:
+    return (item.strip() for item in re.split(r"[|,]", colors or "") if item.strip())
+
+
+def parse_color_specs(colors: str, similarity: float = 1.0) -> List[ColorSpec]:
+    default_tolerance = max(0, min(255, round(255 * (1.0 - float(similarity)))))
+    specs: List[ColorSpec] = []
+    for item in _split_color_specs(colors):
+        target_text, separator, tolerance_text = item.partition("-")
+        target = _hex_bgr(target_text)
+        tolerance = (
+            _hex_bgr(tolerance_text)
+            if separator and tolerance_text.strip()
+            else np.full(3, default_tolerance, dtype=np.int16)
+        )
+        specs.append((target, tolerance))
+    if not specs:
+        raise ValueError("至少需要一个颜色")
+    return specs
+
+
+def color_mask(image, colors: str, rect=None, similarity: float = 1.0, mode: int = 0):
+    source, offset_x, offset_y = _crop(_source_image(image), rect)
+    pixels = source.astype(np.int16)
+    mask = np.zeros(source.shape[:2], dtype=bool)
+    for target, tolerance in parse_color_specs(colors, similarity):
+        delta = np.abs(pixels - target)
+        if int(mode) == 1:
+            limit = max(1.0, float(np.linalg.norm(tolerance)))
+            current = np.linalg.norm(delta, axis=2) <= limit
+        elif int(mode) == 2:
+            lab = cv2.cvtColor(source, cv2.COLOR_BGR2LAB).astype(np.int16)
+            target_lab = cv2.cvtColor(np.uint8([[target[::-1]]]), cv2.COLOR_RGB2LAB)[0, 0].astype(np.int16)
+            limit = max(1.0, float(np.linalg.norm(tolerance)))
+            current = np.linalg.norm(lab - target_lab, axis=2) <= limit
+        else:
+            current = np.all(delta <= tolerance, axis=2)
+        mask |= current
+    return mask, source, offset_x, offset_y
+
+
+class Colors:
+    """颜色数量统计与过滤，兼容 Android ``Colors`` API。"""
+
+    DRAW_THRESHOLD = 1
+    DRAW_BLACK_BG = 2
+
+    @staticmethod
+    def count(colors: str, rect=None, sim: float = 1.0, bitmap=None, image=None, mode: int = 0) -> int:
+        source = image if image is not None else bitmap
+        mask, _, _, _ = color_mask(source, colors, rect=rect, similarity=sim, mode=mode)
+        return int(np.count_nonzero(mask))
+
+    @staticmethod
+    def filter(colors: str, rect=None, sim: float = 1.0, image=None,
+               draw_mode: int = DRAW_THRESHOLD, mode: int = 0):
+        mask, source, offset_x, offset_y = color_mask(image, colors, rect=rect, similarity=sim, mode=mode)
+        if draw_mode == Colors.DRAW_BLACK_BG:
+            output = np.zeros_like(source)
+            output[mask] = source[mask]
+        else:
+            output = np.zeros_like(source)
+            output[mask] = 255
+        return output, int(np.count_nonzero(mask)), (offset_x, offset_y)
+
+
+class CompareColors:
+    """按绝对坐标比色，支持 RGB、归一化 RGB 和 Lab 距离。"""
+
+    RGB = 0
+    NORM = 1
+    LAB = 2
+
+    @staticmethod
+    def _tolerance(diff):
+        if isinstance(diff, str):
+            value = diff.strip()
+            if value.startswith("#"):
+                return _hex_bgr(value)
+            parts = [part.strip() for part in value.strip("()[]").split(",") if part.strip()]
+            if len(parts) == 3:
+                red, green, blue = (max(0, min(255, int(part))) for part in parts)
+                return np.array((blue, green, red), dtype=np.int16)
+        if isinstance(diff, (tuple, list, np.ndarray)) and len(diff) == 3:
+            red, green, blue = (max(0, min(255, int(value))) for value in diff)
+            return np.array((blue, green, red), dtype=np.int16)
+        tolerance = max(0, min(255, round(255 * (1.0 - float(diff)))))
+        return np.full(3, tolerance, dtype=np.int16)
+
+    @staticmethod
+    def _parse(colors: str, diff):
+        default_tolerance = CompareColors._tolerance(diff)
+        points = []
+        for item in (part.strip() for part in (colors or "").split("|") if part.strip()):
+            fields = item.split(",", 2)
+            if len(fields) != 3:
+                raise ValueError(f"比色格式错误: {item}")
+            x, y = int(fields[0]), int(fields[1])
+            target, point_tolerance = parse_color_specs(fields[2], 1.0)[0]
+            if "-" not in fields[2]:
+                point_tolerance = default_tolerance
+            points.append((x, y, target, point_tolerance))
+        if not points:
+            raise ValueError("至少需要一个比色点")
+        return points
+
+    @staticmethod
+    def compare_detail(colors: str, diff=0.9, bitmap=None, mode: int = 0,
+                       sim: float = 1.0, image=None):
+        source = _source_image(image if image is not None else bitmap)
+        height, width = source.shape[:2]
+        points = CompareColors._parse(colors, diff)
+        matches = []
+        for x, y, target, tolerance in points:
+            if x < 0 or y < 0 or x >= width or y >= height:
+                matches.append({"x": x, "y": y, "matched": False, "score": 0.0, "reason": "坐标越界"})
+                continue
+            pixel = source[y, x].astype(np.int16)
+            delta = np.abs(pixel - target)
+            if int(mode) == CompareColors.NORM:
+                distance = float(np.linalg.norm(delta))
+                limit = max(1.0, float(np.linalg.norm(tolerance)))
+                matched = distance <= limit
+                score = max(0.0, 1.0 - distance / 441.67295593)
+            elif int(mode) == CompareColors.LAB:
+                pixel_lab = cv2.cvtColor(np.uint8([[pixel]]), cv2.COLOR_BGR2LAB)[0, 0].astype(np.int16)
+                target_lab = cv2.cvtColor(np.uint8([[target]]), cv2.COLOR_BGR2LAB)[0, 0].astype(np.int16)
+                distance = float(np.linalg.norm(pixel_lab - target_lab))
+                limit = max(1.0, float(np.linalg.norm(tolerance)))
+                matched = distance <= limit
+                score = max(0.0, 1.0 - distance / 441.67295593)
+            else:
+                matched = bool(np.all(delta <= tolerance))
+                score = max(0.0, 1.0 - float(np.max(delta)) / 255.0)
+            matches.append({
+                "x": x,
+                "y": y,
+                "matched": matched,
+                "score": round(score, 4),
+                "expected": f"#{int(target[2]):02X}{int(target[1]):02X}{int(target[0]):02X}",
+                "actual": f"#{int(pixel[2]):02X}{int(pixel[1]):02X}{int(pixel[0]):02X}",
+            })
+        matched_count = sum(1 for item in matches if item["matched"])
+        score = matched_count / len(matches)
+        return {"matched": score >= float(sim), "score": round(score, 4), "points": matches}
+
+    @staticmethod
+    def compare(colors: str, diff=0.9, bitmap=None, mode: int = 0,
+                until: int = 0, sim: float = 1.0, image=None) -> bool:
+        del until
+        return bool(CompareColors.compare_detail(colors, diff, bitmap, mode, sim, image)["matched"])
+
+    @staticmethod
+    def compare_multi(colors_list: Sequence[str], diff: float = 0.9, mode: int = 0,
+                      sim: float = 1.0, image=None) -> int:
+        for index, colors in enumerate(colors_list):
+            if CompareColors.compare(colors, diff=diff, mode=mode, sim=sim, image=image):
+                return index
+        return -1
+
+
+class FindBlock:
+    """基于颜色掩码的滑动窗口和连通域找色块。"""
+
+    RGB = 0
+    NORM = 1
+    LAB = 2
+
+    @staticmethod
+    def _matches(colors, rect, diff, mode, image):
+        return color_mask(image, colors, rect=rect, similarity=diff, mode=mode)
+
+    @staticmethod
+    def find_all(colors: str, width: int = 50, height: int = 50, count: int = 100,
+                 rect=None, diff: float = 0.9, mode: int = 0, space: int = 0,
+                 image=None, max_results: int = 200):
+        mask, _, offset_x, offset_y = FindBlock._matches(colors, rect, diff, mode, image)
+        block_width, block_height = max(1, int(width)), max(1, int(height))
+        if block_width > mask.shape[1] or block_height > mask.shape[0]:
+            return []
+        integral = cv2.integral(mask.astype(np.uint8), sdepth=cv2.CV_32S)
+        totals = (
+            integral[block_height:, block_width:]
+            - integral[:-block_height, block_width:]
+            - integral[block_height:, :-block_width]
+            + integral[:-block_height, :-block_width]
+        )
+        ys, xs = np.where(totals >= max(1, int(count)))
+        if not len(xs):
+            return []
+        candidates = sorted(
+            ((int(totals[y, x]), int(x), int(y)) for x, y in zip(xs, ys)),
+            key=lambda item: (-item[0], item[2], item[1]),
+        )
+        separation = max(int(space), min(block_width, block_height) // 2)
+        results = []
+        for matched, left, top in candidates:
+            center = Point(left + block_width // 2 + offset_x, top + block_height // 2 + offset_y)
+            if any(abs(center[0] - old[0]) <= separation and abs(center[1] - old[1]) <= separation for old in results):
+                continue
+            results.append(center)
+            if max_results > 0 and len(results) >= int(max_results):
+                break
+        return results
+
+    @staticmethod
+    def find(colors: str, width: int = 50, height: int = 50, count: int = 100,
+             rect=None, diff: float = 0.9, mode: int = 0, space: int = 0, image=None):
+        results = FindBlock.find_all(colors, width, height, count, rect, diff, mode, space, image, 1)
+        return results[0] if results else None
+
+    @staticmethod
+    def get_range(colors: str, rect=None, diff: float = 0.9, mode: int = 0,
+                  min_area: int = 10, image=None):
+        mask, _, offset_x, offset_y = FindBlock._matches(colors, rect, diff, mode, image)
+        count, _, stats, _ = cv2.connectedComponentsWithStats(mask.astype(np.uint8), connectivity=8)
+        ranges = []
+        for index in range(1, count):
+            left, top, width, height, area = (int(value) for value in stats[index])
+            if area >= max(1, int(min_area)):
+                ranges.append([left + offset_x, top + offset_y, width, height])
+        ranges.sort(key=lambda item: (item[1], item[0]))
+        return ranges
+
+    @staticmethod
+    def count_block(colors: str, rect=None, diff: float = 0.9, mode: int = 0,
+                    min_area: int = 10, image=None) -> int:
+        return len(FindBlock.get_range(colors, rect, diff, mode, min_area, image))

ascript/windows/screen/find_colors.py

@@ -0,0 +1,251 @@
+import numpy as np
+from .as_cv import AsCv
+from ..daos.screen import Point
+
+
+class FindColors:
+    """多点找色工具类。
+
+    基于向量化位移过滤算法实现高性能多点颜色匹配。
+    支持自定义搜索区域、容差阈值、排序方向等参数。
+    """
+
+    RGB = 0
+    NORM = 1
+
+    @staticmethod
+    def _hex_to_bgr(hex_str):
+        """将十六进制颜色字符串转换为 OpenCV BGR 格式元组。
+
+        Args:
+            hex_str: 十六进制颜色字符串，如 '#FF0000' 或 'FF0000'。
+
+        Returns:
+            tuple: BGR 格式颜色元组，如 (0, 0, 255) 表示红色。
+        """
+        hex_str = hex_str.lstrip('#')
+        r, g, b = tuple(int(hex_str[i:i + 2], 16) for i in (0, 2, 4))
+        return (b, g, r)
+
+    @staticmethod
+    def _parse_colors(colors_str, default_tolerance):
+        """解析多点找色的颜色描述字符串。
+
+        将形如 "x,y,color|dx,dy,color" 的字符串解析为基准色和偏移点列表。
+        第一个点作为基准点，后续点记录相对于基准点的偏移和目标颜色。
+
+        Args:
+            colors_str: 颜色描述字符串，格式为 "x,y,#RRGGBB|x,y,#RRGGBB|..."。
+
+        Returns:
+            tuple: (base_bgr, offsets)，其中：
+                - base_bgr (numpy.ndarray): 基准点的 BGR 颜色数组。
+                - offsets (list): 偏移点列表，每项为 (dy, dx, target_bgr) 元组。
+        """
+        parts = colors_str.split('|')
+        points = []
+        for p in parts:
+            x, y, color_and_diff = p.split(',', 2)
+            color, separator, point_diff = color_and_diff.partition('-')
+            tolerance = (
+                np.array(FindColors._hex_to_bgr(point_diff), dtype=np.int16)
+                if separator and point_diff.strip()
+                else default_tolerance
+            )
+            points.append((int(x), int(y), FindColors._hex_to_bgr(color), tolerance))
+
+        base_x, base_y, base_bgr, base_tolerance = points[0]
+        offsets = []
+        for i in range(1, len(points)):
+            curr_x, curr_y, curr_bgr, curr_tolerance = points[i]
+            # 计算相对于第一个点的偏移和对应的颜色数组
+            offsets.append((
+                curr_y - base_y,
+                curr_x - base_x,
+                np.array(curr_bgr, dtype=np.int16),
+                curr_tolerance,
+            ))
+
+        return np.array(base_bgr, dtype=np.int16), base_tolerance, offsets
+
+    @staticmethod
+    def find(colors: str, rect=None, threshold: float = 0.98, ori: int = 2, exclusion_radius: int = 5, im_source=None,
+             max_res: int = 1, **kwargs):
+        """查找第一个匹配的颜色目标。
+
+        对 find_all 的便捷封装，默认只返回第一个匹配结果。
+
+        Args:
+            colors: 多点颜色描述字符串，格式为 "x,y,#RRGGBB|x,y,#RRGGBB|..."。
+            rect: 搜索区域 [left, top, right, bottom]，为 None 时搜索全屏。
+            threshold: 颜色匹配精度，范围 0.0 ~ 1.0，默认与 Android 一致为 0.98。
+            ori: 搜索方向（1-8），控制结果的排序优先级，默认为 2（从上到下、从左到右）。
+            exclusion_radius: 排除半径（像素），同一区域内不重复返回，默认为 5。
+            im_source: 自定义图像源，为 None 时自动截取当前屏幕。
+            max_res: 最大返回结果数，默认为 1。
+
+        Returns:
+            Point: 与 Android 一致的坐标对象，可通过 ``.x`` / ``.y`` 访问；未找到返回 None。
+        """
+        res = FindColors.find_all(
+            colors, rect, threshold, ori, exclusion_radius, im_source, max_res=max_res, **kwargs
+        )
+        return res[0] if res else None
+
+    @staticmethod
+    def find_all(colors: str, rect=None, threshold: float = 0.98, ori: int = 2, exclusion_radius: int = 5,
+                 im_source=None, max_res: int = 0, **kwargs):
+        """全量查找所有匹配的颜色目标。
+
+        采用向量化位移过滤算法，通过 NumPy 整体矩阵运算实现高性能匹配，
+        避免逐像素 Python 循环导致的性能瓶颈。内置熔断机制防止海量结果卡死。
+
+        Args:
+            colors: 多点颜色描述字符串，格式为 "x,y,#RRGGBB|x,y,#RRGGBB|..."。
+            rect: 搜索区域 [left, top, right, bottom]，为 None 时搜索全屏。
+            threshold: 颜色匹配精度，范围 0.0 ~ 1.0，默认与 Android 一致为 0.98。
+                容差计算公式：tol = 255 * (1.0 - threshold)。
+            ori: 搜索方向（1-8），控制结果排序：
+                1=左到右/上到下，2=上到下/左到右，3=上到下/右到左，
+                4=右到左/上到下，5=右到左/下到上，6=下到上/右到左，
+                7=下到上/左到右，8=左到右/下到上。默认为 2。
+            exclusion_radius: 排除半径（像素），同一区域内不重复返回，默认为 5。
+            im_source: 自定义图像源，为 None 时自动截取当前屏幕。
+            max_res: 最大返回结果数，0 表示不限制。
+
+        Returns:
+            list: 与 Android 一致的 Point 坐标对象列表。
+        """
+
+        threshold = float(kwargs.pop("diff", threshold))
+        exclusion_radius = int(kwargs.pop("space", exclusion_radius))
+        im_source = kwargs.pop("image", im_source)
+        max_res = int(kwargs.pop("p_max_num", max_res))
+        mode = int(kwargs.pop("mode", 0))
+        kwargs.pop("until", None)
+        if kwargs:
+            raise TypeError(f"不支持的参数: {', '.join(kwargs)}")
+
+        # 获取图像源
+        if im_source is None:
+            from .screen_core import Screen
+            im_source = Screen.capture()
+
+        img = AsCv.to_numpy(im_source)
+
+        # 处理范围（ROI）
+        if rect:
+            l, t, r, b = rect
+            img = img[t:b, l:r]
+            offset_l, offset_t = l, t
+        else:
+            offset_l, offset_t = 0, 0
+
+        h, w, _ = img.shape
+        tol = int(255 * (1.0 - threshold))
+        default_tolerance = np.full(3, tol, dtype=np.int16)
+        base_bgr, base_tolerance, offsets = FindColors._parse_colors(colors, default_tolerance)
+
+        # 预转换图像类型，避免在循环中重复计算
+        img_int16 = img.astype(np.int16)
+
+        def matches(pixels, target, tolerance):
+            if mode == 1:
+                pixels_float = pixels.astype(np.float32)
+                target_float = target.astype(np.float32)
+                pixel_norm = np.linalg.norm(pixels_float, axis=-1)
+                target_norm = float(np.linalg.norm(target_float))
+                denominator = np.maximum(pixel_norm * max(target_norm, 1e-6), 1e-6)
+                cosine = np.sum(pixels_float * target_float, axis=-1) / denominator
+                return cosine >= threshold
+            return np.all(np.abs(pixels - target) <= tolerance, axis=-1)
+
+        # --- 步骤 1: 生成主色掩码 ---
+        final_mask = matches(img_int16, base_bgr, base_tolerance)
+
+        # 如果没有匹配到主色，直接返回
+        if not np.any(final_mask):
+            return []
+
+        # --- 步骤 2: 向量化位移过滤 (核心防卡死逻辑) ---
+        for dy, dx, target_bgr, point_tolerance in offsets:
+            # 计算有效区域（防止偏移后越界）
+            y_start, y_end = max(0, dy), min(h, h + dy)
+            x_start, x_end = max(0, dx), min(w, w + dx)
+            oy_start, oy_end = max(0, -dy), min(h, h - dy)
+            ox_start, ox_end = max(0, -dx), min(w, w - dx)
+
+            if oy_start >= oy_end or ox_start >= ox_end:
+                continue
+
+            # 核心：直接对整张掩码进行位移比对
+            # 这一步在 NumPy 内部完成，比 Python 循环快几个量级
+            shifted_pixels = img_int16[y_start:y_end, x_start:x_end]
+            match_offset = matches(shifted_pixels, target_bgr, point_tolerance)
+
+            # 对齐掩码并做逻辑“与”操作
+            aligned_mask = np.zeros((h, w), dtype=bool)
+            aligned_mask[oy_start:oy_end, ox_start:ox_end] = match_offset
+
+            final_mask &= aligned_mask
+
+            # 如果中间过程掩码已空，提前终止
+            if not np.any(final_mask):
+                return []
+
+        # --- 步骤 3: 提取剩下的合格点 ---
+        candidates = np.argwhere(final_mask)
+
+        # --- 步骤 4: 排序 (根据 ori 参数) ---
+        if len(candidates) > 1:
+            # 按照你原代码的 1-8 方向逻辑
+            # lexsort 是从后往前作为优先级排序的
+            y_values, x_values = candidates[:, 0], candidates[:, 1]
+            order_map = {
+                1: (y_values, x_values),    # 从左到右, 从上到下
+                2: (x_values, y_values),    # 从上到下, 从左到右
+                3: (-x_values, y_values),   # 从上到下, 从右到左
+                4: (y_values, -x_values),   # 从右到左, 从上到下
+                5: (-y_values, -x_values),  # 从右到左, 从下到上
+                6: (-x_values, -y_values),  # 从下到上, 从右到左
+                7: (x_values, -y_values),   # 从下到上, 从左到右
+                8: (-y_values, x_values),   # 从左到右, 从下到上
+            }
+            candidates = candidates[np.lexsort(order_map.get(ori, order_map[2]))]
+
+        # --- 步骤 5: 结果构建与排除半径处理 ---
+        results = []
+        if exclusion_radius > 0:
+            excluded = np.zeros((h, w), dtype=bool)
+            for y, x in candidates:
+                if excluded[y, x]:
+                    continue
+                results.append(Point(int(x + offset_l), int(y + offset_t)))
+                if max_res > 0 and len(results) >= max_res:
+                    break
+                # 标记半径内的点为已排除
+                y1, y2 = max(0, y - exclusion_radius), min(h, y + exclusion_radius)
+                x1, x2 = max(0, x - exclusion_radius), min(w, x + exclusion_radius)
+                excluded[y1:y2, x1:x2] = True
+        else:
+            for y, x in candidates:
+                results.append(Point(int(x + offset_l), int(y + offset_t)))
+                if max_res > 0 and len(results) >= max_res:
+                    break
+
+        return results
+
+    @staticmethod
+    def find_color(color: str, rect=None, diff: float = 0.98, mode: int = 0):
+        """Android-compatible single-color lookup returning ``{"x", "y"}``."""
+        result = FindColors.find(f"0,0,{color}", rect=rect, diff=diff, mode=mode)
+        return result.to_dict() if result is not None else None
+
+    @staticmethod
+    def find_all_color(color: str, rect=None, diff: float = 0.98, mode: int = 0,
+                       max_num: int = 999999):
+        """Android-compatible single-color lookup returning dictionaries."""
+        results = FindColors.find_all(
+            f"0,0,{color}", rect=rect, diff=diff, mode=mode, p_max_num=max_num
+        )
+        return [point.to_dict() for point in results] if results else None