ascript 1.3.27__py3-none-win_amd64.whl

ascript/windows/screen/find_images.py

@@ -0,0 +1,217 @@
+from typing import Iterable
+
+import numpy as np
+
+from .as_cv import AsCv, MatchResult
+from .screen_core import Screen
+from ..window import Window
+
+
+class FindImages:
+    """Android-compatible Windows image matching API.
+
+    Public methods accept paths, PIL images, NumPy arrays, or a list of
+    templates. Legacy Windows keyword names remain supported.
+    """
+
+    _DEFAULT_CONFIDENCE = 0.9
+
+    @staticmethod
+    def _get_source_image(source):
+        if source is None:
+            return AsCv.to_numpy(Screen.capture())
+        if hasattr(source, "hwnd") and hasattr(source, "capture"):
+            return AsCv.to_numpy(source.capture())
+        if isinstance(source, int):
+            return AsCv.to_numpy(Window(hwnd=source).capture())
+        return AsCv.to_numpy(source)
+
+    @staticmethod
+    def _is_rect(value):
+        return isinstance(value, (list, tuple)) and len(value) == 4 and all(
+            isinstance(item, (int, float, np.integer, np.floating)) for item in value
+        )
+
+    @classmethod
+    def _arguments(cls, rect, confidence, source_img, image, kwargs):
+        if "threshold" in kwargs:
+            confidence = kwargs.pop("threshold")
+        if source_img is None:
+            source_img = kwargs.pop("im_source", None)
+        if source_img is None:
+            source_img = image
+        # Old Windows calls used the second positional argument as im_source.
+        if rect is not None and not cls._is_rect(rect):
+            if source_img is None:
+                source_img = rect
+            rect = None
+        return rect, float(cls._DEFAULT_CONFIDENCE if confidence is None else confidence), source_img
+
+    @staticmethod
+    def _crop_source(source, rect):
+        if rect is None:
+            return source, 0, 0
+        height, width = source.shape[:2]
+        left = max(0, min(width, int(rect[0])))
+        top = max(0, min(height, int(rect[1])))
+        right = max(0, min(width, int(rect[2])))
+        bottom = max(0, min(height, int(rect[3])))
+        if right <= left or bottom <= top:
+            raise ValueError("找图范围为空或超出图片边界")
+        return source[top:bottom, left:right], left, top
+
+    @staticmethod
+    def _template_items(part_img) -> Iterable:
+        return part_img if isinstance(part_img, (list, tuple)) else [part_img]
+
+    @staticmethod
+    def _offset(result: MatchResult, offset_x: int, offset_y: int, template, index: int) -> MatchResult:
+        if offset_x or offset_y:
+            result.center = (result.center[0] + offset_x, result.center[1] + offset_y)
+            result.rectangle = [
+                (point[0] + offset_x, point[1] + offset_y) for point in result.rectangle
+            ]
+            result.rect = [
+                result.rect[0] + offset_x,
+                result.rect[1] + offset_y,
+                result.rect[2] + offset_x,
+                result.rect[3] + offset_y,
+            ]
+        if isinstance(template, str):
+            result.template = template
+        result.index = index
+        return result
+
+    @staticmethod
+    def _iou(first: MatchResult, second: MatchResult) -> float:
+        left = max(first.rect[0], second.rect[0])
+        top = max(first.rect[1], second.rect[1])
+        right = min(first.rect[2], second.rect[2])
+        bottom = min(first.rect[3], second.rect[3])
+        intersection = max(0, right - left) * max(0, bottom - top)
+        if not intersection:
+            return 0.0
+        first_area = max(1, first.rect[2] - first.rect[0]) * max(1, first.rect[3] - first.rect[1])
+        second_area = max(1, second.rect[2] - second.rect[0]) * max(1, second.rect[3] - second.rect[1])
+        return intersection / float(first_area + second_area - intersection)
+
+    @classmethod
+    def _deduplicate(cls, results):
+        selected = []
+        for candidate in sorted(results, key=lambda item: item.confidence, reverse=True):
+            if any(cls._iou(candidate, existing) >= 0.75 for existing in selected):
+                continue
+            selected.append(candidate)
+        return selected
+
+    @staticmethod
+    def _sort(results, ori):
+        key_map = {
+            1: lambda item: (item.center[0], item.center[1]),
+            2: lambda item: (item.center[1], item.center[0]),
+            3: lambda item: (item.center[1], -item.center[0]),
+            4: lambda item: (-item.center[0], item.center[1]),
+            5: lambda item: (-item.center[0], -item.center[1]),
+            6: lambda item: (-item.center[1], -item.center[0]),
+            7: lambda item: (-item.center[1], item.center[0]),
+            8: lambda item: (item.center[0], -item.center[1]),
+        }
+        return sorted(results, key=key_map.get(int(ori), key_map[2]))
+
+    @classmethod
+    def _find_all_impl(cls, part_img, rect, confidence, rgb, maxcnt, source_img,
+                       ori, scale_range, mode):
+        source = cls._get_source_image(source_img)
+        if source is None:
+            raise RuntimeError("屏幕截图失败")
+        source, offset_x, offset_y = cls._crop_source(source, rect)
+        results = []
+        per_template_limit = int(maxcnt or 0)
+        for index, template in enumerate(cls._template_items(part_img)):
+            if mode == "mixed":
+                matches = AsCv.find(
+                    source, template, threshold=confidence, maxcnt=per_template_limit,
+                    use_scale=True, rgb=rgb, scale_range=scale_range,
+                )
+            elif scale_range:
+                matches = AsCv.find_all_multi_scale(
+                    source, template, threshold=confidence, maxcnt=per_template_limit,
+                    scale_range=tuple(scale_range), rgb=rgb,
+                )
+            else:
+                matches = AsCv.find_all_template(
+                    source, template, threshold=confidence, maxcnt=per_template_limit, rgb=rgb,
+                )
+            results.extend(cls._offset(match, offset_x, offset_y, template, index) for match in matches)
+        return cls._sort(results, ori)
+
+    @classmethod
+    def find_template(cls, part_img, rect=None, confidence=0.9, rgb=False,
+                      source_img=None, ori=2, scale_range=None, image=None,
+                      fast=True, **kwargs):
+        rect, confidence, source_img = cls._arguments(rect, confidence, source_img, image, kwargs)
+        results = cls._find_all_impl(
+            part_img, rect, confidence, rgb, 1, source_img, ori, scale_range, "template"
+        )
+        return results[0] if results else None
+
+    @classmethod
+    def find_all_template(cls, part_img, rect=None, confidence=0.9, rgb=False,
+                          maxcnt=0, source_img=None, ori=2, scale_range=None,
+                          image=None, fast=True, **kwargs):
+        if "max_res" in kwargs:
+            maxcnt = kwargs.pop("max_res")
+        rect, confidence, source_img = cls._arguments(rect, confidence, source_img, image, kwargs)
+        return cls._find_all_impl(
+            part_img, rect, confidence, rgb, maxcnt, source_img, ori, scale_range, "template"
+        )
+
+    @classmethod
+    def find_sift(cls, part_img, rect=None, confidence=0.9, rgb=False,
+                  source_img=None, ori=2, scale_range=None, image=None,
+                  fast=True, **kwargs):
+        """Compatibility entry point; Android currently falls back to template matching."""
+        return cls.find_template(
+            part_img, rect, confidence, rgb, source_img, ori, scale_range, image, fast, **kwargs
+        )
+
+    @classmethod
+    def find_all_sift(cls, part_img, rect=None, confidence=0.9, rgb=False,
+                      source_img=None, maxcnt=0, ori=2, scale_range=None,
+                      image=None, fast=True, **kwargs):
+        return cls.find_all_template(
+            part_img, rect, confidence, rgb, maxcnt, source_img, ori,
+            scale_range, image, fast, **kwargs
+        )
+
+    @classmethod
+    def find(cls, part_img, rect=None, confidence=None, rgb=False,
+             source_img=None, ori=2, scale_range=None, image=None,
+             method="mixed", fast=True, **kwargs):
+        rect, confidence, source_img = cls._arguments(rect, confidence, source_img, image, kwargs)
+        mode = "mixed" if str(method).lower() in {"mixed", "auto"} else "template"
+        results = cls._find_all_impl(
+            part_img, rect, confidence, rgb, 1, source_img, ori, scale_range, mode
+        )
+        return results[0] if results else None
+
+    @classmethod
+    def find_all(cls, part_img, rect=None, confidence=None, rgb=False,
+                 source_img=None, maxcnt=0, ori=2, scale_range=None,
+                 image=None, method="mixed", fast=True, **kwargs):
+        if "max_res" in kwargs:
+            maxcnt = kwargs.pop("max_res")
+        use_scale = kwargs.pop("use_scale", None)
+        rect, confidence, source_img = cls._arguments(rect, confidence, source_img, image, kwargs)
+        mode = "mixed" if use_scale is not False or str(method).lower() in {"mixed", "auto"} else "template"
+        return cls._find_all_impl(
+            part_img, rect, confidence, rgb, maxcnt, source_img, ori, scale_range, mode
+        )
+
+    @classmethod
+    def find_akaze(cls, part_img, im_source=None, threshold=0.5, min_match=10, **kwargs):
+        source = cls._get_source_image(kwargs.pop("source_img", im_source))
+        results = []
+        for template in cls._template_items(part_img):
+            results.extend(AsCv.find_akaze(source, template, threshold=threshold, min_match=min_match))
+        return results

ascript/windows/screen/ocr/__init__.py

@@ -0,0 +1,4 @@
+from .ocr import Ocr
+from .rapidocr_hook import NullOCRItem, OCRItem
+
+__all__ = ["Ocr", "OCRItem", "NullOCRItem"]

ascript/windows/screen/ocr/ocr.py

@@ -0,0 +1,223 @@
+import re
+import threading
+import time
+from importlib.metadata import PackageNotFoundError, version
+from typing import List
+
+import numpy as np
+
+from ..color_algorithms import _crop, _source_image
+from .rapidocr_hook import NullOCRItem, OCRItem
+
+
+class Ocr:
+    """RapidOCR/ONNXRuntime OCR wrapper using PP-OCRv6 small models."""
+
+    MODE_RAPID_V6 = 3
+    MODE_RAPID_V5 = MODE_RAPID_V6
+    MODE_PADDLE_V5 = MODE_RAPID_V6
+    MODE_PADDLE_V2 = MODE_RAPID_V6
+    MODE_PADDLE_V3 = MODE_RAPID_V6
+    MODE_MLK = 1
+    MODE_TESS = 4
+
+    _engine = None
+    _lock = threading.RLock()
+
+    @classmethod
+    def set_engine(cls, engine):
+        """注入自定义 RapidOCR 兼容引擎，传 ``None`` 恢复默认引擎。"""
+        with cls._lock:
+            cls._engine = engine
+
+    @classmethod
+    def _default_engine(cls):
+        with cls._lock:
+            if cls._engine is not None:
+                return cls._engine
+            try:
+                from rapidocr import EngineType, LangDet, LangRec, ModelType, OCRVersion, RapidOCR
+            except ImportError as exc:
+                raise RuntimeError("OCR 组件未安装，请安装 rapidocr 和 onnxruntime") from exc
+            cls._engine = RapidOCR(params={
+                "Det.engine_type": EngineType.ONNXRUNTIME,
+                "Det.lang_type": LangDet.CH,
+                "Det.model_type": ModelType.SMALL,
+                "Det.ocr_version": OCRVersion.PPOCRV6,
+                "Rec.engine_type": EngineType.ONNXRUNTIME,
+                "Rec.lang_type": LangRec.CH,
+                "Rec.model_type": ModelType.SMALL,
+                "Rec.ocr_version": OCRVersion.PPOCRV6,
+                "Cls.engine_type": EngineType.ONNXRUNTIME,
+                "Cls.lang_type": LangDet.CH,
+                "Cls.model_type": ModelType.MOBILE,
+                "Cls.ocr_version": OCRVersion.PPOCRV4,
+            })
+            return cls._engine
+
+    @staticmethod
+    def backend_info():
+        try:
+            rapidocr_version = version("rapidocr")
+        except PackageNotFoundError:
+            rapidocr_version = "not installed"
+        try:
+            onnxruntime_version = version("onnxruntime")
+        except PackageNotFoundError:
+            onnxruntime_version = "not installed"
+        return {
+            "engine": "RapidOCR",
+            "runtime": "ONNXRuntime",
+            "rapidocr_version": rapidocr_version,
+            "onnxruntime_version": onnxruntime_version,
+            "detection": "PP-OCRv6 small",
+            "recognition": "PP-OCRv6 small",
+            "classification": "PP-OCRv4 mobile",
+        }
+
+    @staticmethod
+    def _item(text, box, score, offset_x=0, offset_y=0):
+        points = np.asarray(box, dtype=float).reshape(-1, 2)
+        points[:, 0] += offset_x
+        points[:, 1] += offset_y
+        left, top = np.floor(points.min(axis=0)).astype(int)
+        right, bottom = np.ceil(points.max(axis=0)).astype(int)
+        left, top, right, bottom = map(int, (left, top, right, bottom))
+        return OCRItem(
+            txt=str(text), box=points.tolist(), score=float(score),
+            center=(int((left + right) // 2), int((top + bottom) // 2)),
+            rect=[left, top, right, bottom],
+        )
+
+    @classmethod
+    def recognize(cls, rect=None, pattern: str = None, confidence: float = 0.1,
+                  image=None, bitmap=None, file: str = None, binary: int = -1) -> List[OCRItem]:
+        """识别图像文字。``pattern`` 是正则表达式；``rect`` 使用 left,top,right,bottom。"""
+        if bitmap is not None:
+            if image is not None:
+                raise ValueError("image 和 bitmap 不能同时传入")
+            image = bitmap
+        source_input = file if file else (image if image is not None else bitmap)
+        source, offset_x, offset_y = _crop(_source_image(source_input), rect)
+        if binary >= 0:
+            import cv2
+            gray = cv2.cvtColor(source, cv2.COLOR_BGR2GRAY)
+            _, source = cv2.threshold(gray, int(binary), 255, cv2.THRESH_BINARY)
+        with cls._lock:
+            output = cls._default_engine()(source)
+        if output is None:
+            return []
+        texts = getattr(output, "txts", None)
+        boxes = getattr(output, "boxes", None)
+        scores = getattr(output, "scores", None)
+        if texts is None or boxes is None or scores is None:
+            raise RuntimeError(
+                "RapidOCR 返回了不兼容的结果结构 "
+                f"({type(output).__module__}.{type(output).__name__}); "
+                "请确认安装 rapidocr==3.10.0 和 onnxruntime==1.23.2"
+            )
+        if not (len(texts) == len(boxes) == len(scores)):
+            raise RuntimeError(
+                "RapidOCR 返回数据长度不一致: "
+                f"texts={len(texts)}, boxes={len(boxes)}, scores={len(scores)}"
+            )
+        matcher = re.compile(pattern) if pattern else None
+        results = []
+        for text, box, score in zip(texts, boxes, scores):
+            if float(score) < float(confidence) or (matcher and not matcher.search(str(text))):
+                continue
+            results.append(cls._item(text, box, score, offset_x, offset_y))
+        results.sort(key=lambda item: (item.center[1], item.center[0]))
+        return results
+
+    @classmethod
+    def paddleocr(cls, rect=None, pattern: str = None, confidence: float = 0.1,
+                  max_side_len: int = 1200, precision: int = 16, bitmap=None,
+                  file: str = None, binary: int = -1, language: str = "chinese", image=None):
+        del max_side_len, precision, language
+        return cls.recognize(rect, pattern, confidence, image, bitmap, file, binary)
+
+    rapidocr = paddleocr
+    paddleocr_v2 = paddleocr
+    paddleocr_v3 = paddleocr
+
+    @classmethod
+    def find_all(cls, text: str = None, rect=None, mode: int = None, binary: int = -1,
+                 confidence: float = 0.1, image=None, pattern: str = None,
+                 bitmap=None, file: str = None):
+        """Android-compatible alias; ``pattern`` and legacy ``text`` both accept regex."""
+        del mode  # Android engine selection is platform-specific; Windows uses RapidOCR.
+        if text is not None and pattern is not None:
+            raise ValueError("text 和 pattern 只能指定一个")
+        return cls.recognize(
+            rect=rect, pattern=pattern if pattern is not None else text,
+            confidence=confidence, image=image, bitmap=bitmap, file=file, binary=binary,
+        )
+
+    @classmethod
+    def find(cls, text: str = None, rect=None, mode: int = None, binary: int = -1,
+             confidence: float = 0.1, image=None, pattern: str = None,
+             bitmap=None, file: str = None):
+        results = cls.find_all(
+            text, rect, mode, binary, confidence, image,
+            pattern=pattern, bitmap=bitmap, file=file,
+        )
+        return results[0] if results else NullOCRItem()
+
+    @classmethod
+    def exists(cls, text: str = None, rect=None, mode: int = None, binary: int = -1,
+               confidence: float = 0.1, image=None, pattern: str = None,
+               bitmap=None, file: str = None) -> bool:
+        return bool(cls.find(
+            text, rect, mode, binary, confidence, image,
+            pattern=pattern, bitmap=bitmap, file=file,
+        ))
+
+    @classmethod
+    def wait(cls, text: str = None, timeout: float = 10, rect=None, mode: int = None,
+             binary: int = -1, confidence: float = 0.1, image=None,
+             pattern: str = None, interval: float = 0.3):
+        """Poll fresh screen captures until the regex matches or timeout expires."""
+        deadline = time.monotonic() + max(0.0, float(timeout))
+        current_image = image
+        while True:
+            item = cls.find(
+                text, rect=rect, mode=mode, binary=binary,
+                confidence=confidence, image=current_image, pattern=pattern,
+            )
+            current_image = None
+            if item:
+                return item
+            if time.monotonic() >= deadline:
+                return None
+            time.sleep(max(0.01, float(interval)))
+
+    @classmethod
+    def click(cls, text: str = None, rect=None, mode: int = None, binary: int = -1,
+              confidence: float = 0.1, timeout: float = 0, image=None,
+              pattern: str = None, window=None) -> bool:
+        """Find and click text center; supply ``window`` for window-relative coordinates."""
+        item = cls.wait(
+            text, timeout=timeout, rect=rect, mode=mode, binary=binary,
+            confidence=confidence, image=image, pattern=pattern,
+        ) if float(timeout) > 0 else cls.find(
+            text, rect=rect, mode=mode, binary=binary, confidence=confidence,
+            image=image, pattern=pattern,
+        )
+        if not item:
+            return False
+        item.click(window=window)
+        return True
+
+    @classmethod
+    def wait_click(cls, text: str = None, timeout: float = 10, rect=None,
+                   mode: int = None, binary: int = -1, confidence: float = 0.1,
+                   image=None, pattern: str = None, window=None) -> bool:
+        item = cls.wait(
+            text, timeout=timeout, rect=rect, mode=mode, binary=binary,
+            confidence=confidence, image=image, pattern=pattern,
+        )
+        if not item:
+            return False
+        item.click(window=window)
+        return True