ms-vite-plugin 1.4.17 → 1.4.19

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (18) hide show
  1. package/docs/AGENTS.md +1 -1
  2. package/docs/api/appleocr.md +46 -164
  3. package/docs/api/image.md +16 -84
  4. package/docs/api/media.md +6 -7
  5. package/docs/api/paddleocr.md +77 -123
  6. package/docs/api/yolo.md +52 -96
  7. package/docs/apicn/appleocr.md +47 -169
  8. package/docs/apicn/image.md +15 -81
  9. package/docs/apicn/media.md +6 -7
  10. package/docs/apicn/paddleocr.md +77 -130
  11. package/docs/apicn/yolo.md +52 -101
  12. package/docs/apipython/appleocr.md +45 -155
  13. package/docs/apipython/image.md +17 -77
  14. package/docs/apipython/media.md +7 -8
  15. package/docs/apipython/paddleocr.md +78 -104
  16. package/docs/apipython/yolo.md +36 -85
  17. package/docs/mcp-agent-description.md +1 -1
  18. package/package.json +1 -1
package/docs/apipython/paddleocr.md CHANGED
@@ -5,6 +5,8 @@ PaddleOCR 模块基于百度飞桨 PaddleOCR 技术，提供强大的光学字
5
5
  ## 功能概览
6
6
 
7
7
  - **自动加载**: 识别和查找方法会自动加载所需模型，无需先手动加载
8
+ - **模型选择**: 同一时间只保留一个 active 模型，默认 `ppocr-v6-small`，可通过模型 ID 手动加载 `ppocr-v6-tiny` 或 `ppocr-v5`
9
+ - **长边设置**: 可单独调整检测阶段最大边长，不需要重新加载已加载模型
8
10
  - **多源识别**: 支持屏幕截图、图片文件、URL 等多种输入源
9
11
  - **区域识别**: 支持指定区域的精确文字识别
10
12
  - **结构化结果**: 提供详细的文本位置、置信度和方向信息
@@ -38,91 +40,81 @@ class OCRResult(TypedDict):
38
40
 
39
41
  ### 模型管理
40
42
 
41
- #### `loadV5` - 可选预加载 PP-OCRv5 模型
43
+ #### `loadModel` - 按模型 ID 手动加载内置 PaddleOCR 模型
42
44
 
43
- 识别和查找方法会自动加载所需模型，通常不需要先调用 `loadV5`。只有需要提前加载或指定模型参数时才调用。
45
+ 识别和查找方法默认自动加载 `ppocr-v6-small`。只有需要切换模型或指定 GPU 参数时才调用 `loadModel`。PaddleOCR 同一时间只保留一个 active 模型，`loadModel` 加载成功后会替换已加载模型；检测长边请使用 `setMaxSideLen` 单独设置。
44
46
 
45
47
  ```python
46
- def loadV5(maxSideLen: int = 640, useGpu: bool = False) -> bool
48
+ def loadModel(modelId: str, useGpu: bool = False) -> bool
47
49
  ```
48
50
 
49
51
  **参数：**
50
52
 
51
- | 参数名 | 类型 | 是否必填 | 默认值 | 描述 |
52
- | ------------ | ---- | -------- | ------ | -------------------------------- |
53
- | `maxSideLen` | int | 否 | 640 | 输入图像的最大边长，默认值为 640 |
54
- | `useGpu` | bool | 否 | False | 是否启用 GPU 加速 |
53
+ | 参数名 | 类型 | 是否必填 | 默认值 | 描述 |
54
+ | --------- | ---- | -------- | ------ | ------------------------------------------------------------ |
55
+ | `modelId` | str | 是 | | 内置模型 ID，支持 `"ppocr-v6-tiny"`、`"ppocr-v6-small"`、`"ppocr-v5"` |
56
+ | `useGpu` | bool | 否 | False | 是否启用 GPU 加速 |
55
57
 
56
58
  **返回值：**
57
59
 
58
- | 类型 | 描述 |
59
- | ------ | --------------------------------------------------- |
60
- | `bool` | 加载成功或模型已加载返回 `True`，否则返回 `False` |
60
+ | 类型 | 描述 |
61
+ | ------ | ---------------------------------------------------------- |
62
+ | `bool` | 加载成功或目标模型已加载返回 `True`，模型 ID 不支持或加载失败返回 `False` |
61
63
 
62
- ### 文字识别
64
+ **示例：**
63
65
 
64
- #### `recognize` - 执行 OCR 文字识别
66
+ ```python
67
+ from kuaijs import paddleocr
65
68
 
66
- 执行 OCR 文字识别，支持多种输入源和指定识别区域。
69
+ # 手动加载 PP-OCRv6 tiny 模型
70
+ paddleocr.loadModel("ppocr-v6-tiny", False)
71
+
72
+ # 手动加载 PP-OCRv6 small 模型
73
+ loaded = paddleocr.loadModel("ppocr-v6-small", False)
74
+ print(f"PP-OCRv6 small 加载结果: {loaded}")
75
+
76
+ # 手动切换到 PP-OCRv5 模型
77
+ paddleocr.loadModel("ppocr-v5", False)
78
+ ```
79
+
80
+ #### `setMaxSideLen` - 单独设置检测阶段输入最大边长
81
+
82
+ 该方法只调整后续检测输入缩放，不会重新加载已加载的 PP-OCRv5/v6 模型。如果当前尚未加载模型，后续识别或查找触发默认 PP-OCRv6 small 自动加载时会沿用该设置。
67
83
 
68
84
  ```python
69
- def recognize(
70
- input: str,
71
- x: int = 0,
72
- y: int = 0,
73
- ex: int = 0,
74
- ey: int = 0,
75
- confidenceThreshold: float = 0.6
76
- ) -> List[OCRResult]
85
+ def setMaxSideLen(maxSideLen: int = 768) -> bool
77
86
  ```
78
87
 
79
88
  **参数：**
80
89
 
81
- | 参数名 | 类型 | 是否必填 | 默认值 | 描述 |
82
- | --------------------- | ----- | -------- | ------ | ----------------------------------------------------------------------------------------------------------------------------- |
83
- | `input` | str | 是 | - | 输入源，支持以下类型：<br>- `"screen"` - 当前屏幕截图<br>- 图片文件路径或 URL<br>- `imageId` - 图片 ID（通过 image 模块获取） |
84
- | `x` | int | 否 | 0 | 识别区域左上角 x 坐标 |
85
- | `y` | int | 否 | 0 | 识别区域左上角 y 坐标 |
86
- | `ex` | int | 否 | 0 | 识别区域右下角 x 坐标 |
87
- | `ey` | int | 否 | 0 | 识别区域右下角 y 坐标 |
88
- | `confidenceThreshold` | float | 否 | 0.6 | 置信度阈值，默认值为 0.6 |
90
+ | 参数名 | 类型 | 是否必填 | 默认值 | 描述 |
91
+ | ------------ | ---- | -------- | ------ | ----------------------------------------- |
92
+ | `maxSideLen` | int | 否 | 768 | 输入图像的最大边长；传 0 或负数时使用 768 |
89
93
 
90
94
  **返回值：**
91
95
 
92
- | 类型 | 描述 |
93
- | ----------------- | -------------------------------------------------------------- |
94
- | `List[OCRResult]` | 识别结果数组，每个元素包含文本内容、位置信息和置信度等详细数据 |
96
+ | 类型 | 描述 |
97
+ | ------ | -------------------- |
98
+ | `bool` | 设置成功返回 `True` |
95
99
 
96
100
  **示例：**
97
101
 
98
102
  ```python
99
103
  from kuaijs import paddleocr
100
104
 
101
- # 识别整个屏幕
102
- full_screen_results = paddleocr.recognize("screen", 0, 0, 0, 0)
103
- print(f"识别到 {len(full_screen_results)} 个文本区域")
104
- for r in full_screen_results:
105
- print(f"文本: {r.text}, 置信度: {r.confidence}")
106
-
107
- # 识别屏幕指定区域
108
- region_results = paddleocr.recognize("screen", 100, 100, 500, 300)
109
- if region_results:
110
- top = region_results[0]
111
- print(f"指定区域文本: {top.text}, 中心: ({top.centerX}, {top.centerY})")
112
-
113
- # 识别图片文件
114
- image_results = paddleocr.recognize("/path/to/image.png", 0, 0, 800, 600)
115
- for r in image_results:
116
- print(f"图片文字: {r.text}")
117
-
118
- # 识别网络图片
119
- url_results = paddleocr.recognize("https://example.com/image.jpg", 0, 0, 1000, 800)
120
- print(f"网络图片识别结果数量: {len(url_results)}")
105
+ # 只更新检测长边，不重新加载模型
106
+ paddleocr.setMaxSideLen(960)
107
+
108
+ # 后续识别会使用新的检测长边
109
+ results = paddleocr.recognizeAbs("screen", 0, 0, 0, 0)
110
+ print(f"识别数量: {len(results)}")
121
111
  ```
122
112
 
113
+ ### 文字识别
114
+
123
115
  #### `recognizeAbs` - 执行 OCR 识别，并将结果坐标映射为原图/全屏绝对坐标
124
116
 
125
- 参数与 `recognize` 相同。传入裁剪区域时，返回坐标可直接用于全屏点击。
117
+ 传入裁剪区域时，返回坐标会映射回原图或全屏坐标，可直接用于点击。
126
118
 
127
119
  ```python
128
120
  def recognizeAbs(
@@ -135,6 +127,23 @@ def recognizeAbs(
135
127
  ) -> List[OCRResult]
136
128
  ```
137
129
 
130
+ **参数：**
131
+
132
+ | 参数名 | 类型 | 是否必填 | 默认值 | 描述 |
133
+ | --------------------- | ----- | -------- | ------ | ----------------------------------------------------------- |
134
+ | `input` | str | 是 | | 输入源，支持 imageId、URL 字符串、文件路径或 `"screen"` |
135
+ | `x` | int | 否 | 0 | 裁剪区域左上角 x 坐标；全屏识别传 0 |
136
+ | `y` | int | 否 | 0 | 裁剪区域左上角 y 坐标；全屏识别传 0 |
137
+ | `ex` | int | 否 | 0 | 裁剪区域右下角 x 坐标；全屏识别传 0 |
138
+ | `ey` | int | 否 | 0 | 裁剪区域右下角 y 坐标；全屏识别传 0 |
139
+ | `confidenceThreshold` | float | 否 | 0.6 | 置信度阈值，低于该值的识别结果会被过滤 |
140
+
141
+ **返回值：**
142
+
143
+ | 类型 | 描述 |
144
+ | ----------------- | ------------------------------------------------ |
145
+ | `List[OCRResult]` | 识别结果数组，坐标为原图或全屏绝对坐标 |
146
+
138
147
  **示例：**
139
148
 
140
149
  ```python
@@ -143,12 +152,12 @@ if abs_results:
143
152
  print(f"绝对坐标中心点: ({abs_results[0].centerX}, {abs_results[0].centerY})")
144
153
  ```
145
154
 
146
- #### `findText` - 在识别结果中查找目标文本并返回对应子串坐标
155
+ #### `findTextAbs` - 查找目标文本，并将结果坐标映射为原图/全屏绝对坐标
147
156
 
148
- 在 OCR 识别结果中查找指定文本，返回匹配文本的坐标和置信度等信息。
157
+ 传入裁剪区域时，返回坐标会映射回原图或全屏坐标，可直接用于点击。
149
158
 
150
159
  ```python
151
- def findText(
160
+ def findTextAbs(
152
161
  input: str,
153
162
  targetTexts: List[str],
154
163
  x: int = 0,
@@ -162,57 +171,22 @@ def findText(
162
171
 
163
172
  **参数：**
164
173
 
165
- | 参数名 | 类型 | 是否必填 | 默认值 | 描述 |
166
- | --------------------- | --------- | -------- | ------ | ----------------------------------------------------------------------------------------------------------------------------- |
167
- | `input` | str | 是 | - | 输入源，支持以下类型：<br>- `"screen"` - 当前屏幕截图<br>- 图片文件路径或 URL<br>- `imageId` - 图片 ID（通过 image 模块获取） |
168
- | `targetTexts` | List[str] | 是 | - | 目标文本数组，例如 `["登录", "确定"]` |
169
- | `x` | int | 否 | 0 | 查找区域左上角 x 坐标 |
170
- | `y` | int | 否 | 0 | 查找区域左上角 y 坐标 |
171
- | `ex` | int | 否 | 0 | 查找区域右下角 x 坐标 |
172
- | `ey` | int | 否 | 0 | 查找区域右下角 y 坐标 |
173
- | `confidenceThreshold` | float | 否 | 0.6 | 置信度阈值，默认值为 0.6 |
174
- | `exactMatch` | bool | 否 | False | 是否完整匹配；`False` 表示包含匹配，`True` 表示整条 OCR 识别结果文本必须等于目标文本 |
174
+ | 参数名 | 类型 | 是否必填 | 默认值 | 描述 |
175
+ | --------------------- | --------- | -------- | ------ | ------------------------------------------------------------------------ |
176
+ | `input` | str | 是 | | 输入源，支持 imageId、URL 字符串、文件路径或 `"screen"` |
177
+ | `targetTexts` | List[str] | 是 | | 目标文本数组，例如 `["你好", "确定"]` |
178
+ | `x` | int | 否 | 0 | 裁剪区域左上角 x 坐标；全屏识别传 0 |
179
+ | `y` | int | 否 | 0 | 裁剪区域左上角 y 坐标；全屏识别传 0 |
180
+ | `ex` | int | 否 | 0 | 裁剪区域右下角 x 坐标；全屏识别传 0 |
181
+ | `ey` | int | 否 | 0 | 裁剪区域右下角 y 坐标；全屏识别传 0 |
182
+ | `confidenceThreshold` | float | 否 | 0.6 | 置信度阈值，低于该值的识别结果会被过滤 |
183
+ | `exactMatch` | bool | 否 | False | 是否完整匹配；`False` 表示包含匹配，`True` 要求整条 OCR 文本等于目标文本 |
175
184
 
176
185
  **返回值：**
177
186
 
178
- | 类型 | 描述 |
179
- | ----------------- | ----------------------------------------------------------------------------------------------------------------- |
180
- | `List[OCRResult]` | 匹配结果数组。每个元素为命中的文本片段坐标信息，`text` 字段为命中的目标文本，其他字段包含位置、方向和置信度等信息 |
181
-
182
- **示例：**
183
-
184
- ```python
185
- from kuaijs import paddleocr
186
-
187
- # 在整个屏幕中查找目标文本
188
- hit_results = paddleocr.findText("screen", ["登录", "确定"], 0, 0, 0, 0, 0.6, False)
189
- if hit_results:
190
- for i, r in enumerate(hit_results, 1):
191
- print(f"命中{i}: {r.text}, 中心点=({r.centerX}, {r.centerY}), 置信度={r.confidence}")
192
- else:
193
- print("未命中目标文本")
194
-
195
- # 在指定区域查找目标文本
196
- region_hits = paddleocr.findText("screen", ["下一步"], 100, 100, 500, 400)
197
- print(f"区域命中数量: {len(region_hits)}")
198
- ```
199
-
200
- #### `findTextAbs` - 查找目标文本，并将结果坐标映射为原图/全屏绝对坐标
201
-
202
- 参数与 `findText` 相同。传入裁剪区域时，返回坐标可直接用于全屏点击。
203
-
204
- ```python
205
- def findTextAbs(
206
- input: str,
207
- targetTexts: List[str],
208
- x: int = 0,
209
- y: int = 0,
210
- ex: int = 0,
211
- ey: int = 0,
212
- confidenceThreshold: float = 0.6,
213
- exactMatch: bool = False
214
- ) -> List[OCRResult]
215
- ```
187
+ | 类型 | 描述 |
188
+ | ----------------- | ---------------------------------------------------------- |
189
+ | `List[OCRResult]` | 匹配到的子串结果数组，坐标为原图或全屏绝对坐标 |
216
190
 
217
191
  **示例：**
218
192
 
package/docs/apipython/yolo.md CHANGED
@@ -99,59 +99,20 @@ model_id = yolo.load(
99
99
  )
100
100
  ```
101
101
 
102
- #### loadV11 - 加载 YOLOv11 模型（兼容 yolov8）
103
-
104
- 加载模型是使用目标检测功能的前提。
105
-
106
- ```python
107
- def loadV11(paramPath: str, binPath: str, nc: int = 0, useGpu: bool = False) -> Optional[str]
108
- ```
109
-
110
- **参数:**
111
-
112
- | 参数名 | 类型 | 是否必填 | 默认值 | 描述 |
113
- | ----------- | ---- | -------- | ------ | ------------------------------------------- |
114
- | `paramPath` | str | 是 | - | NCNN 模型的 param 文件绝对路径 |
115
- | `binPath` | str | 是 | - | NCNN 模型的 bin 文件绝对路径 |
116
- | `nc` | int | 否 | 0 | 模型的标签数量；传 `0` 或省略时根据模型输出自动推断，显式传入但不匹配时检测返回空列表 |
117
- | `useGpu` | bool | 否 | False | 是否启用 GPU 加速 |
118
-
119
- **返回值:**
120
-
121
- | 类型 | 描述 |
122
- | ------------- | ------------------------------------ |
123
- | `str \| None` | 加载成功返回模型 ID，失败返回 `None` |
124
-
125
- **示例:**
126
-
127
- ```python
128
- from kuaijs import yolo
129
-
130
- # 加载 YOLOv11 模型
131
- # 模型放在res目录
132
- model_id = yolo.loadV11(
133
- "yolo11n_ncnn_model/model.ncnn.param",
134
- "yolo11n_ncnn_model/model.ncnn.bin",
135
- 0, # 自动根据模型输出推断类别数量
136
- False,
137
- )
138
-
139
- if model_id:
140
- print(f"模型加载成功，ID: {model_id}")
141
- else:
142
- print("模型加载失败，请检查文件路径和格式")
143
- ```
144
-
145
102
  ### 目标检测
146
103
 
147
- #### detect - 执行目标检测
104
+ #### detectAbs - 对指定区域执行目标检测，并将结果坐标映射为原图/全屏绝对坐标
148
105
 
149
- 识别图像中的物体并返回检测结果。
106
+ 识别图像中的物体并返回检测结果。传入裁剪区域时，结果坐标会映射回原图或全屏坐标，可直接用于点击；全屏检测时 `x/y/ex/ey` 传 `0`。
150
107
 
151
108
  ```python
152
- def detect(
109
+ def detectAbs(
153
110
  modelId: str,
154
111
  img: str,
112
+ x: int = 0,
113
+ y: int = 0,
114
+ ex: int = 0,
115
+ ey: int = 0,
155
116
  targetSize: int = 640,
156
117
  threshold: float = 0.4,
157
118
  nmsThreshold: float = 0.5
@@ -160,19 +121,23 @@ def detect(
160
121
 
161
122
  **参数:**
162
123
 
163
- | 参数名 | 类型 | 是否必填 | 默认值 | 描述 |
164
- | -------------- | ----- | -------- | ------ | ----------------------------------------------------------------------------------------------------------------------------------------- |
165
- | `modelId` | str | 是 | - | 模型 ID（通过 `loadV11` 获取） |
166
- | `img` | str | 是 | - | 图像输入源：<br>- `"screen"` - 使用当前屏幕截图<br>- `str` - 图片文件路径或 HTTP 图片地址<br>- `imageId` - 图片 ID（通过 image 模块获取） |
167
- | `targetSize` | int | 否 | 640 | 图像缩放的检测大小，通常为 640（与模型训练时一致） |
168
- | `threshold` | float | 否 | 0.4 | 置信度阈值，默认 0.4，低于此值的检测结果会被过滤 |
169
- | `nmsThreshold` | float | 否 | 0.5 | 非极大值抑制阈值，默认 0.5，用于去除重叠检测框 |
124
+ | 参数名 | 类型 | 是否必填 | 默认值 | 描述 |
125
+ | -------------- | ----- | -------- | ------ | ---------------------------------------------------------- |
126
+ | `modelId` | str | 是 | | 模型 ID，通过 `load` 获取 |
127
+ | `img` | str | 是 | | 输入源，支持 `"screen"`、图片文件路径、HTTP 图片地址或 imageId |
128
+ | `x` | int | 否 | 0 | 裁剪区域左上角 x 坐标；全屏检测传 0 |
129
+ | `y` | int | 否 | 0 | 裁剪区域左上角 y 坐标；全屏检测传 0 |
130
+ | `ex` | int | 否 | 0 | 裁剪区域右下角 x 坐标；全屏检测传 0 |
131
+ | `ey` | int | 否 | 0 | 裁剪区域右下角 y 坐标；全屏检测传 0 |
132
+ | `targetSize` | int | 否 | 640 | 模型推理输入边长，通常为 640（与模型训练时一致） |
133
+ | `threshold` | float | 否 | 0.4 | 置信度阈值，低于此值的检测结果会被过滤 |
134
+ | `nmsThreshold` | float | 否 | 0.5 | 非极大值抑制阈值，用于去除重叠检测框 |
170
135
 
171
136
  **返回值:**
172
137
 
173
138
  | 类型 | 描述 |
174
139
  | ------------------ | ---------------------------------------------- |
175
- | `List[YoloResult]` | 检测结果数组，每个元素包含一个检测到的物体信息 |
140
+ | `List[YoloResult]` | 检测结果数组，坐标为原图或全屏绝对坐标 |
176
141
 
177
142
  **示例:**
178
143
 
@@ -180,15 +145,19 @@ def detect(
180
145
  from kuaijs import yolo
181
146
 
182
147
  # 首先加载模型
183
- mid = yolo.loadV11("yolo11n_ncnn_model/model.ncnn.param", "yolo11n_ncnn_model/model.ncnn.bin", 0)
148
+ mid = yolo.load("yolo11n_ncnn_model/model.ncnn.param", "yolo11n_ncnn_model/model.ncnn.bin", 0, 11, False)
184
149
 
185
150
  if not mid:
186
151
  print("模型加载失败")
187
152
  else:
188
153
  # 检测当前屏幕
189
- screen_results = yolo.detect(
154
+ screen_results = yolo.detectAbs(
190
155
  mid,
191
156
  "screen", # 使用当前屏幕
157
+ 0,
158
+ 0,
159
+ 0,
160
+ 0,
192
161
  640, # 标准检测尺寸
193
162
  0.4, # 置信度阈值
194
163
  0.5 # NMS 阈值
@@ -204,10 +173,14 @@ else:
204
173
  print(f" 中心点: ({r.centerX}, {r.centerY})")
205
174
  print(f" 尺寸: {r.width} x {r.height}")
206
175
 
207
- # 检测图片文件
208
- image_results = yolo.detect(
176
+ # 检测图片文件的指定区域
177
+ image_results = yolo.detectAbs(
209
178
  mid,
210
179
  "/path/to/test_image.jpg",
180
+ 100,
181
+ 100,
182
+ 500,
183
+ 400,
211
184
  640,
212
185
  0.3, # 降低置信度阈值以检测更多物体
213
186
  0.5
@@ -221,9 +194,13 @@ else:
221
194
  print("图片中未检测到任何物体")
222
195
 
223
196
  # 检测网络图片
224
- url_results = yolo.detect(
197
+ url_results = yolo.detectAbs(
225
198
  mid,
226
199
  "https://example.com/test_image.jpg",
200
+ 0,
201
+ 0,
202
+ 0,
203
+ 0,
227
204
  640,
228
205
  0.5, # 提高置信度阈值以获得更可靠的结果
229
206
  0.4
@@ -231,32 +208,6 @@ else:
231
208
  print(f"网络图片检测结果: {len(url_results)} 个物体")
232
209
  ```
233
210
 
234
- #### detectAbs - 对指定区域执行目标检测，并将结果坐标映射为原图/全屏绝对坐标
235
-
236
- ```python
237
- def detectAbs(
238
- modelId: str,
239
- img: str,
240
- x: int = 0,
241
- y: int = 0,
242
- ex: int = 0,
243
- ey: int = 0,
244
- targetSize: int = 640,
245
- threshold: float = 0.4,
246
- nmsThreshold: float = 0.5
247
- ) -> List[YoloResult]
248
- ```
249
-
250
- **示例:**
251
-
252
- ```python
253
- from kuaijs import yolo, action
254
-
255
- abs_results = yolo.detectAbs(mid, "screen", 100, 100, 500, 400, 640, 0.4, 0.5)
256
- if abs_results:
257
- action.click(abs_results[0]["centerX"], abs_results[0]["centerY"])
258
- ```
259
-
260
211
  ### 资源管理
261
212
 
262
213
  #### free - 释放指定模型
package/docs/mcp-agent-description.md CHANGED
@@ -177,7 +177,7 @@ UI 预览发起后不需要长时间等待结果，可以通过 `take_screenshot
177
177
  - 从本地图片指定坐标取色：使用 `image_pick_color` 或 `npx ms image-pick-color`。
178
178
  - 从当前设备截图指定坐标取色：使用 `screen_pick_color` 或 `npx ms screen-pick-color`。
179
179
  - 执行 OCR 识别、数字识别或查找文字：使用 `ocr_recognize` 或 `npx ms ocr`。
180
- - OCR 识别支持 `appleocr` 和 `paddleocr`，默认 `appleocr`，PaddleOCR 识别方法会自动加载所需模型，不需要手动调用 `loadV5`。
180
+ - OCR 识别支持 `appleocr` 和 `paddleocr`，默认 `appleocr`，PaddleOCR 同一时间只保留一个 active 模型，识别方法默认自动加载 PP-OCRv6 small；如需 PP-OCRv6 tiny 请调用 `loadModel("ppocr-v6-tiny")`，如需 PP-OCRv5 请调用 `loadModel("ppocr-v5")`，加载成功后会替换当前模型。
181
181
  - 制作透明找图模板：使用 `image_make_transparent` 或 `npx ms image-transparent`，输出到 `res`。
182
182
  - 获取节点 XML：使用 `get_node_source` 或 `npx ms source --mode 1`。
183
183
  - 查看日志：使用 `get_logs` 或 `npx ms logs`。
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "ms-vite-plugin",
3
- "version": "1.4.17",
3
+ "version": "1.4.19",
4
4
  "type": "commonjs",
5
5
  "license": "MIT",
6
6
  "publishConfig": {