移动设备RPA脚本
view | history | commit | commitdiff
panchengyong
10 days ago b2d3f7caf927e5b83ec52efb74f1f818dbb15236
commit | author | age
bc5e1e 1 function PointIndex(javaPoint) {
X 2     this.x = 0;
3     this.y = 0;
4     this.index = -1;
5     if (javaPoint != null) {
6         this.x = javaPoint["x"];
7         this.y = javaPoint["y"];
8         this.index = javaPoint["index"];
9     }
10 }
11
12 PointIndex.get = function () {
13     return new PointIndex(null);
14 };
15 PointIndex.jsonToObject = function (res) {
16     if (res == null || res == "") {
17         return null;
18     }
19     res = JSON.parse(res);
20     if (res == null) {
21         return null;
22     }
23     return new Point(res);
24 };
25 PointIndex.prototype.setX = function (x) {
26     this.x = x;
27     return this;
28 };
29 PointIndex.prototype.setY = function (y) {
30     this.y = y;
31     return this;
32 };
33 PointIndex.prototype.setIndex = function (index) {
34     this.index = index;
35     return this;
36 };
37 PointIndex.prototype.toJSONString = function () {
38     return JSON.stringify(this);
39 };
40
41
42 function ImageWrapper() {
43
44 }
45
46 var image = new ImageWrapper();
47 /**
48  * 设置图色模块初始化参数，可用于多分辨率兼容
49  * @param param
b2d3f7 50  * auto_click_request_dialog: true 自动点击截图权限对话框
P 51  * auto_detect_orientation: true 自动检测方向 false 不检测方向
bc5e1e 52  */
X 53 ImageWrapper.prototype.setInitParam = function (param) {
54     if (imageWrapper == null) {
55         return;
56     }
57     imageWrapper.setInitParam(JSON.stringify(param));
58 };
b2d3f7 59 /**
P 60  * 切换图片存储模式为opencv的mat格式
61  * 这个函数调用会初始化OPENCV，所以打包的时候组件要包含opencv组件(找图组件)
62  * 适合 EC  10.18.0+
63  * 切换后抓图、读取图片、找图、找色等都会切换到mat格式，速度更快内存更少
64  * 如果让图片格式切换请参考 imageToMatFormat和matToImageFormat两个函数
65  * @param use 1 是 0 否
66  * @return {boolean}  true 成功 false 失败
67  */
68 ImageWrapper.prototype.useOpencvMat = function (use) {
69     if (imageWrapper == null) {
70         return false;
71     }
72     return imageWrapper.useOpencvMat(use);
73 };
74
75 /**
76  * 截屏时候如果转换mat失败，可以是这个函数试试，一般用不上
77  * 这个函数调用会初始化OPENCV，所以打包的时候组件要包含opencv组件
78  * 先转为bitmap再转为mat
79  * 适合 EC  10.18.0+
80  * @param use 1 是 0 否
81  * @return {boolean}  true 成功 false 失败
82  */
83 ImageWrapper.prototype.setConvertMatWithBitmap = function (use) {
84     if (imageWrapper == null) {
85         return false;
86     }
87     return imageWrapper.setConvertMatWithBitmap(use);
88 };
89
bc5e1e 90
X 91 /**
92  * 设置找色找图的算法模式
93  * 适合EC 9.10.0+
94  * @param type 1 代表老的查找算法，2代表新的查找算法
b2d3f7 95  * @return {boolean}
bc5e1e 96  */
X 97 ImageWrapper.prototype.setFindColorImageMode = function (type) {
98     if (imageWrapper == null) {
99         return false;
100     }
101     return imageWrapper.setFindColorImageMode(type);
102 };
103
b2d3f7 104
P 105 /**
106  * 转换Mat存储格式
107  * 适合 EC  10.18.0+
108  * @param img {AutoImage} 图片对象
109  * @return {null|AutoImage} MAT存储格式的AutoImage 对象或者null
110  */
111 ImageWrapper.prototype.imageToMatFormat = function (img) {
112     if (img == null) {
113         return null;
114     }
115     let xd = imageWrapper.imageToMatFormat(img.uuid);
116     if (xd != null && xd != undefined && xd != "") {
117         return new AutoImage(javaString2string(xd));
118     }
119     return null;
120 };
121
122 /**
123  * 转换普通image存储格式
124  * 适合 EC  10.18.0+
125  * @param img {AutoImage} 图片对象
126  * @return {null|AutoImage} 普通存储格式的AutoImage 对象或者null
127  */
128 ImageWrapper.prototype.matToImageFormat = function (img) {
129     if (img == null) {
130         return null;
131     }
132     let xd = imageWrapper.matToImageFormat(img.uuid);
133     if (xd != null && xd != undefined && xd != "") {
134         return new AutoImage(javaString2string(xd));
135     }
136     return null;
137 };
bc5e1e 138 /**
X 139  * 初始化OPENCV 类库
140  * 如果使用找图请先调用这个函数，第一次初始化需要复制类库，时间可能较长，以后再次执行就很快
b2d3f7 141  * @return {boolean} true 代表成功 false代表失败
bc5e1e 142  */
X 143 ImageWrapper.prototype.initOpenCV = function () {
144     if (imageWrapper == null) {
145         return false;
146     }
147     return imageWrapper.initOpenCV();
148 };
149
150
151 /**
152  * 向系统申请屏幕截图权限，返回是否请求成功。
153  * <p>
154  * 第一次使用该函数会弹出截图权限请求，建议选择“总是允许”。
155  * </p>
156  * <p>
157  * 这个函数只是申请截图权限，并不会真正执行截图，真正的截图函数是captureScreen()。
158  * </p>
159  * 该函数在截图脚本中只需执行一次，而无需每次调用captureScreen()都调用一次。
160  * <p>
161  * 建议在本软件界面运行该函数，在其他软件界面运行时容易出现一闪而过的黑屏现象。
162  * </P>
163  * <Br/>
164  * 运行环境: 无限制
165  * <Br/>
166  * 兼容版本: Android 5.0 以上
167  * @param timeout 超时时间，单位是毫秒
168  * @param type 截屏的类型，0 自动选择，1 代表授权模式，2 代表无需权限模式（该模式前提条件：运行模式为代理模式）
169  *
b2d3f7 170  * @return {boolean} true 代表成功 false代表失败
bc5e1e 171  */
X 172 ImageWrapper.prototype.requestScreenCapture = function (timeout, type) {
173     if (imageWrapper == null) {
174         return false;
175     }
176     return imageWrapper.requestScreenCapture(timeout, type);
177 };
178
179
180 /**
181  * 释放截屏请求
182  * <Br/>
183  * 运行环境: 无限制
184  * <Br/>
185  * 兼容版本: Android 5.0 以上
186  */
187 ImageWrapper.prototype.releaseScreenCapture = function () {
188     if (imageWrapper == null) {
189         return;
190     }
191     imageWrapper.releaseScreenCapture();
192 };
193
194
195 /**
196  * 截取当前屏幕并返回一个Image对象。
197  * 运行环境: 无限制
198  * <Br/>
199  * 兼容版本: Android 5.0 以上
200  * <Br/>
201  * 如果区域空或则有负数的，就会是全屏
202  * @param retryNumber 重试次数，直到能截到图为止，默认是3
203  * @param x 截图的起始X坐标
204  * @param y 截图的起始Y坐标
205  * @param ex 终点X坐标
206  * @param ey 终点Y坐标
b2d3f7 207  * @return {null|AutoImage} AutoImage对象或者null
bc5e1e 208  */
X 209 ImageWrapper.prototype.captureScreen = function (retryNumber, x, y, ex, ey) {
210     if (imageWrapper == null) {
211         return null;
212     }
213     var uuid = imageWrapper.captureScreen(retryNumber, x, y, ex - x, ey - y);
214     if (uuid != null && uuid != undefined && uuid != "") {
215         return new AutoImage(uuid);
216     }
217     return null;
218 };
219
220 /**
221  * 将屏幕抓取为Bitmap对象，如果中间有-1或者宽度、宽度为-1，将会是全屏
222  * @param format jpg或者png，代理模式下有用
223  * @param x 开始X坐标
224  * @param y 开始Y坐标
225  * @param ex 终点X坐标
226  * @param ey 终点Y坐标
227  * @param q 图片质量，1 - 100，代理模式下有用
b2d3f7 228  * @return {null|Bitmap} null或者bitmap对象
bc5e1e 229  */
X 230 ImageWrapper.prototype.captureScreenBitmap = function (format, x, y, ex, ey, q) {
231     if (imageWrapper == null) {
232         return null;
233     }
234     return imageWrapper.captureScreenBitmap(format, x, y, ex - x, ey - y, q);
235 };
236 /**
237  * 将屏幕抓取为Bitmap对象，在代理模式下和captureScreenBitmap实现不一样，速度比captureScreenBitmap快
238  * 适合版本 EC 8.3.+
b2d3f7 239  * @return {null|Bitmap} null或者bitmap对象
bc5e1e 240  */
X 241 ImageWrapper.prototype.captureScreenBitmapEx = function () {
242     if (imageWrapper == null) {
243         return null;
244     }
245     return imageWrapper.captureScreenBitmapEx("png");
246 };
247
248
249 /**
250  * 抓取全屏
251  * @return {null|AutoImage}
252  */
253 ImageWrapper.prototype.captureFullScreen = function () {
254     if (imageWrapper == null) {
255         return null;
256     }
257     var uuid = imageWrapper.captureFullScreen();
258     if (uuid != null && uuid != undefined && uuid != "") {
259         return new AutoImage(uuid);
260     }
261     return null;
262 };
263
264
265 /**
266  * 抓取全屏函数，代理模式下并且requestScreenCapture函数的type为0的时候，会使用截屏函数，尽力消除色差问题。
267  * 其他的和captureFullScreen一致
268  * @return {null|AutoImage}
269  */
270 ImageWrapper.prototype.captureFullScreenEx = function () {
271     if (imageWrapper == null) {
272         return null;
273     }
274     var uuid = imageWrapper.captureFullScreenEx();
275     if (uuid != null && uuid != undefined && uuid != "") {
276         return new AutoImage(uuid);
277     }
278     return null;
279 };
280
281 /**
282  * 截取当前屏幕并以PNG格式保存到path中。如果文件不存在会被创建；文件存在会被覆盖。
283  * <Br/>
284  * 运行环境: 无限制
285  * <Br/>
286  * 兼容版本: Android 5.0 以上
287  *<Br/>
288  * 如果区域空或则有负数的，就会是全屏
289  * @param retryNumber 重试次数，直到能截到图为止，默认是3
290  * @param x 截图的起始X坐标
291  * @param y 截图的起始Y坐标
292  * @param ex 终点X坐标
293  * @param ey 终点Y坐标
294  * @param path 截图保存路径
b2d3f7 295  * @return {boolean} true 截图成功 false 代表不成功
bc5e1e 296  */
X 297 ImageWrapper.prototype.captureToFile = function (retryNumber, x, y, ex, ey, path) {
298     if (imageWrapper == null) {
299         return false;
300     }
301     return imageWrapper.captureScreenToFile(retryNumber, x, y, ex - x, ey - y, path);
302 };
303
304 /**
305  * 读取在路径path的图片文件并返回一个{@link AutoImage}对象。
306  * 如果文件不存在或者文件无法解码则返回null。
307  * [注意]: 如果使用代理模式，但是代理服务未启动，将返回null，可以使用readImageNotAgent读取image对象
308  * <Br/>
309  * 运行环境: 无限制
310  * <Br/>
311  * 兼容版本: Android 5.0 以上
312  *
313  * @param path 图片路径
b2d3f7 314  * @return {null|AutoImage} AutoImage对象或者null
bc5e1e 315  */
X 316 ImageWrapper.prototype.readImage = function (path) {
317     if (imageWrapper == null) {
318         return null;
319     }
320     var uuid = imageWrapper.readImage(path);
321     if (uuid != null && uuid != undefined && uuid != "") {
322         return new AutoImage(uuid);
323     }
324     return null;
325 };
326
327
328 /**
329  * 读取在路径path的图片文件并返回一个{@link AutoImage}对象。
330  * 如果文件不存在或者文件无法解码则返回null。
331  * [注意]: 这个函数是将图片读取到app进程中，如果你使用的是代理模式并且已经打开了代理服务，请使用readImage函数
332  * 适合版本: EC 9.41.0+
333  * @param path 图片路径
b2d3f7 334  * @return {null|AutoImage} AutoImage对象或者null
bc5e1e 335  */
X 336 ImageWrapper.prototype.readImageNotAgent = function (path) {
337     if (imageWrapper == null) {
338         return null;
339     }
340     var uuid = imageWrapper.readImageNotAgent(path);
341     if (uuid != null && uuid != undefined && uuid != "") {
342         return new AutoImage(uuid);
343     }
344     return null;
345 };
346
347 /**
348  * 将安卓原生的Bitmap对象转换为AutoImage
349  * 适合版本: EC 9.41.0+
350  * [注意]: 这个函数是将图片读取到app进程中，如果你使用的是代理模式并且已经打开了代理服务，请使用 bitmapToImage 函数
351  * @param bitmap {Bitmap}对象
b2d3f7 352  * @return {null|AutoImage} 对象
bc5e1e 353  */
X 354 ImageWrapper.prototype.bitmapToImageNotAgent = function (bitmap) {
355     if (imageWrapper == null) {
356         return null;
357     }
358     var uuid = imageWrapper.bitmapToImageNotAgent(bitmap);
359     if (uuid != null && uuid != undefined && uuid != "") {
360         return new AutoImage(uuid);
361     }
362     return null;
363 };
364
365 /**
366  * 将res文件夹的文件转换为AutoImage
367  * 适合版本: EC 9.41.0+
368  * [注意]: 这个函数是将图片读取到app进程中，如果你使用的是代理模式并且已经打开了代理服务，请使用 readResAutoImage 函数
369  * @param res {string} res文件夹下的文件路径
b2d3f7 370  * @return {null|AutoImage} 对象
bc5e1e 371  */
X 372 ImageWrapper.prototype.readResAutoImageNotAgent = function (res) {
373     if (res == null) {
374         return false;
375     }
376     let uuid = imageWrapper.readResAutoImageNotAgent(res);
377     if (uuid != null && uuid != undefined && uuid != "") {
378         return new AutoImage(uuid);
379     }
380     return null;
381 };
382
383 /**
384  * 读取在路径path的图片文件并返回一个{@link Bitmap}对象。如果文件不存在或者文件无法解码则返回null。
385  * <Br/>
386  * 运行环境: 无限制
387  * <Br/>
388  * 兼容版本: Android 5.0 以上
389  *
390  * @param path 图片路径
b2d3f7 391  * @return {null|Bitmap} android的bitmap对象或者null
bc5e1e 392  */
X 393 ImageWrapper.prototype.readBitmap = function (path) {
394     if (imageWrapper == null) {
395         return null;
396     }
397     return imageWrapper.readBitmap(path);
398 };
399
400 /**
401  * 返回图片image在点(x, y)处的像素的ARGB值。
402  * <p>
403  * 该值的格式为0xAARRGGBB，是一个"32位整数"
404  * <p>
405  * 坐标系以图片左上角为原点。以图片左侧边为y轴，上侧边为x轴。
406  *
407  * @param image1 图片
408  * @param x     要获取的像素的横坐标。
409  * @param y     要获取的像素的纵坐标。
b2d3f7 410  * @return {number}
bc5e1e 411  */
X 412 ImageWrapper.prototype.pixelInImage = function (image1, x, y) {
413     if (imageWrapper == null || image1 == null) {
414         return null;
415     }
416     return imageWrapper.pixelInImage(image1.uuid, x, y);
417 };
418
419
420 /**
421  * 找图。在大图片image中查找小图片template的位置（模块匹配），找到时返回位置坐标区域(Rect)，找不到时返回null。
422  * <Br/>
423  * 运行环境: 无限制
424  * <Br/>
425  * 兼容版本: Android 5.0 以上
426  *
427  * @param image1     大图片
428  * @param template  小图片（模板）
429  * @param x         找图区域 x 起始坐标
430  * @param y         找图区域 y 起始坐标
431  * @param ex 终点X坐标
432  * @param ey 终点Y坐标
433  * @param weakThreshold  图片相似度。取值范围为0~1的浮点数。默认值为0.9。
434  * @param threshold 图片相似度。取值范围为0~1的浮点数。默认值为0.9。
435  * @param limit 限制结果的数量，如果要找到1个，就填写1，如果是多个请填写多个
436  * @param method 0: TM_SQDIFF平方差匹配法,1: TM_SQDIFF_NORMED归一化平方差匹配方法,2: TM_CCORR相关匹配法,3: TM_CCORR_NORMED归一化相关匹配法,4: TM_CCOEFF系数匹配法,5: TM_CCOEFF_NORMED归一化系数匹配法
b2d3f7 437  * @return {null|Rect[]} 区域坐标对象数组或者null
bc5e1e 438  */
X 439 ImageWrapper.prototype.findImage = function (image1, template, x, y, ex, ey, weakThreshold, threshold, limit, method) {
440     if (imageWrapper == null || image1 == null || template == null) {
441         return null;
442     }
443     var res = imageWrapper.findImage(image1.uuid, template.uuid, x, y, ex - x, ey - y, weakThreshold, threshold, limit, method);
444     return this.toRectList(res);
445 };
446 /**
447  * 找图。在大图片image中查找小图片template的位置（模块匹配），找到时返回位置坐标区域(Rect)，找不到时返回null。
448  * 找图函数缩放找图，比findImage更精准
449  * 适合版本 EC 9.41.0+
450  * @param image1     大图片
451  * @param template  小图片（模板）
452  * @param x         找图区域 x 起始坐标
453  * @param y         找图区域 y 起始坐标
454  * @param ex 终点X坐标
455  * @param ey 终点Y坐标
456  * @param weakThreshold  图片相似度。取值范围为0~1的浮点数。默认值为0.9。
457  * @param threshold 图片相似度。取值范围为0~1的浮点数。默认值为0.9。
458  * @param limit 限制结果的数量，如果要找到1个，就填写1，如果是多个请填写多个
459  * @param method 0: TM_SQDIFF平方差匹配法,1: TM_SQDIFF_NORMED归一化平方差匹配方法,2: TM_CCORR相关匹配法,3: TM_CCORR_NORMED归一化相关匹配法,4: TM_CCOEFF系数匹配法,5: TM_CCOEFF_NORMED归一化系数匹配法
b2d3f7 460  * @return {null|Rect[]} 区域坐标对象数组或者null
bc5e1e 461  */
X 462 ImageWrapper.prototype.findImage2 = function (image1, template, x, y, ex, ey, weakThreshold, threshold, limit, method) {
463     if (imageWrapper == null || image1 == null || template == null) {
464         return null;
465     }
466     var res = imageWrapper.findImage2(image1.uuid, template.uuid, x, y, ex - x, ey - y, weakThreshold, threshold, limit, method);
467     return this.toRectList(res);
468 };
469 /**
470  * 找图。在当前屏幕中查找小图片template的位置（模块匹配），找到时返回位置坐标区域(Rect)，找不到时返回null。
471  * <Br/>
472  * 运行环境: 无限制
473  * <Br/>
474  * 兼容版本: Android 5.0 以上
475  * @param template  小图片（模板）
476  * @param x         找图区域 x 起始坐标
477  * @param y         找图区域 y 起始坐标
478  * @param ex 终点X坐标
479  * @param ey 终点Y坐标
480  * @param weakThreshold  图片相似度。取值范围为0~1的浮点数。默认值为0.9。
481  * @param threshold 图片相似度。取值范围为0~1的浮点数。默认值为0.9。
482  * @param limit 限制结果的数量，如果要找到1个，就填写1，如果是多个请填写多个
483  * @param method 0: TM_SQDIFF平方差匹配法,1: TM_SQDIFF_NORMED归一化平方差匹配方法,2: TM_CCORR相关匹配法,3: TM_CCORR_NORMED归一化相关匹配法,4: TM_CCOEFF系数匹配法,5: TM_CCOEFF_NORMED归一化系数匹配法
b2d3f7 484  * @return {null|Rect[]} 区域坐标对象数组或者null
bc5e1e 485  */
X 486 ImageWrapper.prototype.findImageEx = function (template, x, y, ex, ey, weakThreshold, threshold, limit, method) {
487     if (imageWrapper == null || template == null) {
488         return null;
489     }
490     var res = imageWrapper.findImageCurrentScreen(template.uuid, x, y, ex - x, ey - y, weakThreshold, threshold, limit, method);
491     return this.toRectList(res);
492 };
493
494
495 /**
496  * OpenCV模板匹配封装
497  * <Br/>
498  * 运行环境: 无限制
499  * <Br/>
500  * 兼容版本: Android 5.0 以上
501  *
502  * @param image1         大图片
503  * @param template      小图片（模板）
504  * @param weakThreshold 图片相似度。取值范围为0~1的浮点数。默认值为0.9。
505  * @param threshold     图片相似度。取值范围为0~1的浮点数。默认值为0.9。
506  * @param rect          找图区域。参见findColor函数关于 rect 的说明
507  * @param maxLevel      默认为-1，一般而言不必修改此参数。不加此参数时该参数会根据图片大小自动调整。找图算法是采用图像金字塔进行的, level参数表示金字塔的层次,
508  *                      level越大可能带来越高的找图效率，但也可能造成找图失败（图片因过度缩小而无法分辨）或返回错误位置。因此，除非您清楚该参数的意义并需要进行性能调优，否则不需要用到该参数。
509  * @param limit 限制结果的数量，如果要找到1个，就填写1，如果是多个请填写多个
510  * @param method 0: TM_SQDIFF平方差匹配法,1: TM_SQDIFF_NORMED归一化平方差匹配方法,2: TM_CCORR相关匹配法,3: TM_CCORR_NORMED归一化相关匹配法,4: TM_CCOEFF系数匹配法,5: TM_CCOEFF_NORMED归一化系数匹配法
b2d3f7 511  * @return {null|Match[]} 匹配到的集合
bc5e1e 512  */
X 513 ImageWrapper.prototype.matchTemplate = function (image1, template, weakThreshold, threshold, rect, maxLevel, limit, method) {
514     if (imageWrapper == null || image1 == null || template == null) {
515         return null;
516     }
517     var drect = rect == null ? null : rect.toJSONString();
518     var res = imageWrapper.matchTemplate(image1.uuid, template.uuid, weakThreshold, threshold, drect, maxLevel, limit, method);
519     if (res == null || res == "") {
520         return null;
521     }
b2d3f7 522     try {
P 523         var d = JSON.parse(res);
524         var x = [];
525         for (var i = 0; i < d.length; i++) {
526             x.push(new Match(d[i]));
527         }
528         return x;
529     } catch (e) {
530
bc5e1e 531     }
b2d3f7 532     return null;
bc5e1e 533 };
X 534
535 /**
536  * OpenCV模板匹配封装
537  * 包含缩放找图功能
538  * 适配版本 EC 9.41.0+
539  * @param image1         大图片
540  * @param template      小图片（模板）
541  * @param weakThreshold 图片相似度。取值范围为0~1的浮点数。默认值为0.9。
542  * @param threshold     图片相似度。取值范围为0~1的浮点数。默认值为0.9。
543  * @param rect          找图区域。参见findColor函数关于 rect 的说明
544  * @param maxLevel      默认为-1，一般而言不必修改此参数。不加此参数时该参数会根据图片大小自动调整。找图算法是采用图像金字塔进行的, level参数表示金字塔的层次,
545  *                      level越大可能带来越高的找图效率，但也可能造成找图失败（图片因过度缩小而无法分辨）或返回错误位置。因此，除非您清楚该参数的意义并需要进行性能调优，否则不需要用到该参数。
546  * @param limit 限制结果的数量，如果要找到1个，就填写1，如果是多个请填写多个
547  * @param method 0: TM_SQDIFF平方差匹配法,1: TM_SQDIFF_NORMED归一化平方差匹配方法,2: TM_CCORR相关匹配法,3: TM_CCORR_NORMED归一化相关匹配法,4: TM_CCOEFF系数匹配法,5: TM_CCOEFF_NORMED归一化系数匹配法
b2d3f7 548  * @return {null|Match[]} 匹配到的集合
bc5e1e 549  */
X 550 ImageWrapper.prototype.matchTemplate2 = function (image1, template, weakThreshold, threshold, rect, maxLevel, limit, method) {
551     if (imageWrapper == null || image1 == null || template == null) {
552         return null;
553     }
554     var drect = rect == null ? null : rect.toJSONString();
555     var res = imageWrapper.matchTemplate2(image1.uuid, template.uuid, weakThreshold, threshold, drect, maxLevel, limit, method);
556     if (res == null || res == "") {
557         return null;
558     }
b2d3f7 559     try {
P 560         var d = JSON.parse(res);
561         var x = [];
562         for (var i = 0; i < d.length; i++) {
563             x.push(new Match(d[i]));
564         }
565         return x;
566     } catch (e) {
567
bc5e1e 568     }
b2d3f7 569     return null;
P 570
bc5e1e 571 };
X 572 /**
573  * OpenCV模板匹配封装，在当前屏幕截图中进行匹配
574  * <Br/>
575  * 运行环境: 无限制
576  * <Br/>
577  * 兼容版本: Android 5.0 以上
578  *
579  * @param template      小图片（模板）
580  * @param weakThreshold 图片相似度。取值范围为0~1的浮点数。默认值为0.9。
581  * @param threshold     图片相似度。取值范围为0~1的浮点数。默认值为0.9。
582  * @param rect          找图区域。参见findColor函数关于 rect 的说明
583  * @param maxLevel      默认为-1，一般而言不必修改此参数。不加此参数时该参数会根据图片大小自动调整。找图算法是采用图像金字塔进行的, level参数表示金字塔的层次,
584  *                      level越大可能带来越高的找图效率，但也可能造成找图失败（图片因过度缩小而无法分辨）或返回错误位置。因此，除非您清楚该参数的意义并需要进行性能调优，否则不需要用到该参数。
585  * @param limit 限制结果的数量，如果要找到1个，就填写1，如果是多个请填写多个
586  * @param method 0: TM_SQDIFF平方差匹配法,1: TM_SQDIFF_NORMED归一化平方差匹配方法,2: TM_CCORR相关匹配法,3: TM_CCORR_NORMED归一化相关匹配法,4: TM_CCOEFF系数匹配法,5: TM_CCOEFF_NORMED归一化系数匹配法
b2d3f7 587  * @return {null|Match[]} 匹配到的集合
bc5e1e 588  */
X 589 ImageWrapper.prototype.matchTemplateEx = function (template, weakThreshold, threshold, rect, maxLevel, limit, method) {
590     if (imageWrapper == null || template == null) {
591         return null;
592     }
593     var drect = rect == null ? null : rect.toJSONString();
594     var res = imageWrapper.matchTemplateCurrentScreen(template.uuid, weakThreshold, threshold, drect, maxLevel, limit, method);
595     if (res == null || res == "") {
596         return null;
597     }
598     var d = JSON.parse(res);
599     var x = [];
600     for (var i = 0; i < d.length; i++) {
601         x.push(new Match(d[i]));
602     }
603     return x;
604 };
605
606
607 /**
608  * 找非色
609  * 在图片中找到颜色和color完全不相等的点，如果没有找到，则返回null。
610  * 适配EC 9.22.0+
611  * 兼容版本: Android 5.0 以上
612  * @param image1 图片
613  * @param color 要寻找的颜色，用ec工具可以生成
614  * @param threshold 找色时颜色相似度取值为 0.0 ~ 1.0
615  * @param x 区域的X起始坐标
616  * @param y 区域的Y起始坐标
617  * @param ex 终点X坐标
618  * @param ey 终点Y坐标
619  * @param limit 限制个数
620  * @param orz 方向，分别从1-8
b2d3f7 621  * @return {null|PointIndex[]}多个 PointIndex 坐标点数组或者null
bc5e1e 622  */
X 623 ImageWrapper.prototype.findNotColor = function (image1, color, threshold, x, y, ex, ey, limit, orz) {
624     if (imageWrapper == null || image1 == null) {
625         return null;
626     }
627
628     color = this.convertFirstColorArrayToString2(color);
629     // allNotEquals 这个是用于处理全部判断相等 展示保留，全部设置为true
630     let res = imageWrapper.findNotColor(image1.uuid, color, threshold, x, y, ex - x, ey - y, limit, orz, true);
631     if (res == null || res == "") {
632         return null;
633     }
b2d3f7 634     try {
P 635         let d = JSON.parse(res);
636         let x1 = [];
637         for (let i = 0; i < d.length; i++) {
638             x1.push(new PointIndex(d[i]));
639         }
640         return x1;
641     } catch (e) {
bc5e1e 642
X 643     }
b2d3f7 644     return null;
P 645
bc5e1e 646 };
X 647 /**
648  * 在图片中找到颜色和color完全相等的点，；如果没有找到，则返回null。
649  * 运行环境: 无限制
650  * 兼容版本: Android 5.0 以上
651  * @param image1 图片
652  * @param color     要寻找的颜色
653  * @param threshold 找色时颜色相似度取值为 0.0 ~ 1.0
654  * @param x 区域的X起始坐标
655  * @param y 区域的Y起始坐标
656  * @param ex 终点X坐标
657  * @param ey 终点Y坐标
658  * @param limit 限制个数
659  * @param orz 方向，分别从1-8
b2d3f7 660  * @return {null|PointIndex[]} 坐标点数组或者null
bc5e1e 661  */
X 662 ImageWrapper.prototype.findColor = function (image1, color, threshold, x, y, ex, ey, limit, orz) {
663     if (imageWrapper == null || image1 == null) {
664         return null;
665     }
666
667     color = this.convertFirstColorArrayToString2(color);
668     let res = imageWrapper.findColor(image1.uuid, color, threshold, x, y, ex - x, ey - y, limit, orz);
669     if (res == null || res == "") {
670         return null;
671     }
672
b2d3f7 673     try {
P 674         let d = JSON.parse(res);
675         let x1 = [];
676         for (let i = 0; i < d.length; i++) {
677             x1.push(new PointIndex(d[i]));
678         }
679         return x1;
680     } catch (e) {
681
bc5e1e 682     }
b2d3f7 683     return null;
bc5e1e 684 };
X 685
686
687 /**
688  * 在图片中找到颜色和color完全相等的点，参数从JSON中获取如果没有找到，则返回null。
689  * <Br/>
690  * 运行环境: 无限制
691  * <Br/>
692  * 兼容版本: Android 5.0 以上
693  *
694  * @param image 图片
695  * @param jsonFileName     res文件中取色工具生成的JSON文件，只要填写文件名称即可，后缀不用填写
b2d3f7 696  * @return {null|PointIndex[]} 坐标点数组或者null
bc5e1e 697  */
X 698 ImageWrapper.prototype.findColorJ = function (image1, jsonFileName) {
699     if (imageWrapper == null || image1 == null) {
700         return null;
701     }
702     var data = readResString(jsonFileName + ".json");
703     if (data == null || data == "") {
704         return null;
705     }
706     data = JSON.parse(data);
707     var firstColor = data['firstColor'];
708     var threshold = data['threshold'];
709     var x = data['x'];
710     var y = data['y'];
711     var ex = data['ex'];
712     var ey = data['ey'];
713     var limit = data['limit'];
714     var orz = data['orz']
715     return this.findColor(image1.uuid, firstColor, threshold, x, y, ex - x, ey - y, limit, orz);
716 };
717
718 /**
719  * 在当前屏幕中找到颜色和color完全相等的点，如果没有找到，则返回null。
720  * <Br/>
721  * 运行环境: 无限制
722  * <Br/>
723  * 兼容版本: Android 5.0 以上
724  *
725  * @param color     要寻找的颜色
726  * @param threshold 找色时颜色相似度取值为 0.0 ~ 1.0
727  * @param x 区域的X起始坐标
728  * @param y 区域的Y起始坐标
729  * @param ex 终点X坐标
730  * @param ey 终点Y坐标
731  * @param limit 限制个数
732  * @param orz 方向，分别从1-8
b2d3f7 733  * @return {null|PointIndex[]} 坐标点数组或者null
bc5e1e 734  */
X 735 ImageWrapper.prototype.findColorEx = function (color, threshold, x, y, ex, ey, limit, orz) {
736     if (imageWrapper == null) {
737         return null;
738     }
739     color = this.convertFirstColorArrayToString2(color);
740     let res = imageWrapper.findColorCurrentScreen(color, threshold, x, y, ex - x, ey - y, limit, orz);
741     if (res == null || res == "") {
742         return null;
743     }
b2d3f7 744     try {
P 745         let d = JSON.parse(res);
746         let x1 = [];
747         for (var i = 0; i < d.length; i++) {
748             x1.push(new PointIndex(d[i]));
749         }
750         return x1;
751     } catch (e) {
752         return null;
bc5e1e 753     }
b2d3f7 754
bc5e1e 755 };
X 756
757
758 /**
759  * 在当前屏幕中找到颜色和color完全相等的点，参数从JSON中获取如果没有找到，则返回null。
760  * <Br/>
761  * 运行环境: 无限制
762  * <Br/>
763  * 兼容版本: Android 5.0 以上
764  *
765  * @param jsonFileName     res文件中取色工具生成的JSON文件，只要填写文件名称即可，后缀不用填写
b2d3f7 766  * @return {null|PointIndex[]} 坐标点数组或者null
bc5e1e 767  */
X 768 ImageWrapper.prototype.findColorExJ = function (jsonFileName) {
769     if (imageWrapper == null) {
770         return null;
771     }
772     var data = readResString(jsonFileName + ".json");
773     if (data == null || data == "") {
774         return null;
775     }
776     data = JSON.parse(data);
777     var firstColor = data['firstColor'];
778     var threshold = data['threshold'];
779     var x = data['x'];
780     var y = data['y'];
781     var ex = data['ex'];
782     var ey = data['ey'];
783     var limit = data['limit'];
784     var orz = data['orz']
785     return this.findColorCurrentScreen(firstColor, threshold, x, y, ex - x, ey - y, limit, orz);
786 };
787
788
789 /**
790  * 多点找色，找到所有符合标准的点，类似于按键精灵的多点找色
791  * <p>
792  * 整张图片都找不到时返回null
793  * <Br/>
794  * 运行环境: 无限制
795  * <Br/>
796  * 兼容版本: Android 5.0 以上
797  *
798  * @param image1      要找色的图片
799  * @param firstColor 第一个点的颜色
800  * @param threshold 找色时颜色相似度取值为 0.0 ~ 1.0
801  * @param points     字符串类似这样 6|1|0x969696-0x000010,1|12|0x969696,-4|0|0x969696
802  * @param x 区域的X起始坐标
803  * @param y 区域的Y起始坐标
804  * @param ex 终点X坐标
805  * @param ey 终点Y坐标
806  * @param limit 限制个数
807  * @param orz 方向，分别从1-8
b2d3f7 808  * @return {null|Point[]} 坐标点数组或者null
bc5e1e 809  */
X 810 ImageWrapper.prototype.findMultiColor = function (image1, firstColor, points, threshold, x, y, ex, ey, limit, orz) {
811     if (imageWrapper == null || image1 == null) {
812         return null;
813     }
814     firstColor = this.convertFirstColorArrayToString(firstColor);
815     points = this.convertMultiColorArrayToString(points);
816     let res = imageWrapper.findMultiColor(image1.uuid, firstColor, points, threshold, x, y, ex - x, ey - y, limit, orz);
817     if (res == null || res == "") {
818         return null;
819     }
b2d3f7 820     try {
P 821         let d = JSON.parse(res);
822         let x1 = [];
823         for (let i = 0; i < d.length; i++) {
824             x1.push(new Point(d[i]));
825         }
826         return x1;
827     } catch (e) {
bc5e1e 828     }
b2d3f7 829     return null;
P 830
bc5e1e 831 };
X 832
833
834 /**
835  * 多点找色，找到所有符合标准的点，参数从JSON文件中读取，类似于按键精灵的多点找色
836  * <p>
837  * 整张图片都找不到时返回null
838  * <Br/>
839  * 运行环境: 无限制
840  * <Br/>
841  * 兼容版本: Android 5.0 以上
842  *
843  * @param image1      要找色的图片
844  * @param jsonFileName res文件中取色工具生成的JSON文件，只要填写文件名称即可，后缀不用填写
b2d3f7 845  * @return {null|Point[]} 坐标点数组或者null
bc5e1e 846  */
X 847 ImageWrapper.prototype.findMultiColorJ = function (image1, jsonFileName) {
848     //String image, String firstColor, String points, float threshold, int x, int y, int w, int h,int limit
849     if (imageWrapper == null || image1 == null) {
850         return null;
851     }
852     var data = readResString(jsonFileName + ".json");
853     if (data == null || data == "") {
854         return null;
855     }
856     data = JSON.parse(data);
857     var firstColor = data['firstColor'];
858     var threshold = data['threshold'];
859     var points = data['points'];
860     var x = data['x'];
861     var y = data['y'];
862     var ex = data['ex'];
863     var ey = data['ey'];
864     var limit = data['limit'];
865     var orz = data['orz'];
866     return imageWrapper.findMultiColor(image1.uuid, firstColor, points, threshold, x, y, ex - x, ey - y, limit, orz);
867 };
868
869
870 /**
871  * 多点找色，找到所有符合标准的点，自动抓取当前屏幕的图片，类似于按键精灵的多点找色
872  * <p>
873  * 整张图片都找不到时返回null
874  * <Br/>
875  * 运行环境: 无限制
876  * <Br/>
877  * 兼容版本: Android 5.0 以上
878  *
879  * @param firstColor 第一个点的颜色
880  * @param threshold  找色时颜色相似度取值为 0.0 ~ 1.0
881  * @param points     字符串类似这样 6|1|0x969696-0x000010,1|12|0x969696,-4|0|0x969696
882  * @param x 区域的X起始坐标
883  * @param y 区域的Y起始坐标
884  * @param ex 终点X坐标
885  * @param ey 终点Y坐标
886  * @param limit 限制个数
887  * @param orz 方向，分别从1-8
b2d3f7 888  * @return {null|Point[]} 坐标点数组或者null
bc5e1e 889  */
X 890 ImageWrapper.prototype.findMultiColorEx = function (firstColor, points, threshold, x, y, ex, ey, limit, orz) {
891     //String firstColor, String points, float threshold, int x, int y, int w, int h
892     if (imageWrapper == null) {
893         return null;
894     }
895     firstColor = this.convertFirstColorArrayToString(firstColor);
896     points = this.convertMultiColorArrayToString(points);
897     let res = imageWrapper.findMultiColorCurrentScreen(firstColor, points, threshold, x, y, ex - x, ey - y, limit, orz);
898     if (res == null || res == "") {
899         return null;
900     }
901     try {
902         let d = JSON.parse(res);
903         let x1 = [];
904         for (let i = 0; i < d.length; i++) {
905             x1.push(new Point(d[i]));
906         }
907         return x1;
908     } catch (e) {
909     }
910     return null;
911
912 };
913
914
915 /**
916  * 多点找色，找到所有符合标准的点，自动抓取当前屏幕的图片,参数从JSON文件中读取，类似于按键精灵的多点找色
917  * 整张图片都找不到时返回null
918  * <Br/>
919  * 运行环境: 无限制
920  * <Br/>
921  * 兼容版本: Android 5.0 以上
922  *
923  * @param jsonFileName res文件中取色工具生成的JSON文件，只要填写文件名称即可，后缀不用填写
b2d3f7 924  * @return {null|Point[]} 坐标点数组或者null
bc5e1e 925  */
X 926 ImageWrapper.prototype.findMultiColorExJ = function (jsonFileName) {
927     if (imageWrapper == null) {
928         return null;
929     }
930     var data = readResString(jsonFileName + ".json");
931     if (data == null || data == "") {
932         return null;
933     }
934     data = JSON.parse(data);
935     var firstColor = data['firstColor'];
936     var threshold = data['threshold'];
937     var points = data['points'];
938     var x = data['x'];
939     var y = data['y'];
940     var ex = data['ex'];
941     var ey = data['ey'];
942     var limit = data['limit'];
943     var orz = data['orz'];
944     return imageWrapper.findMultiColorCurrentScreen(firstColor, points, threshold, x, y, ex - x, ey - y, limit, orz);
945 };
946
947 /**
948  * 单点或者多点比色，找到所有符合标准的点，如果都符合返回true，否则是false
949  * 运行环境: 无限制
950  * <Br/>
951  * 兼容版本: Android 5.0 以上
952  *
953  * @param image1 图片
954  * @param points     字符串类似这样 6|1|0x969696-0x000010,2|3|0x969696-0x000010
955  * @param threshold  找色时颜色相似度取值为 0.0 ~ 1.0
956  * @param x 区域的X起始坐标，默认填写0全屏查找
957  * @param y 区域的Y起始坐标，默认填写0全屏查找
958  * @param ex 终点X坐标，默认填写0全屏查找
959  * @param ey 终点Y坐标，默认填写0全屏查找
b2d3f7 960  * @return {boolean} true代表找到了 false代表未找到
bc5e1e 961  */
X 962 ImageWrapper.prototype.cmpColor = function (image1, points, threshold, x, y, ex, ey) {
963     if (imageWrapper == null || image1 == null) {
964         return false;
965     }
966     points = this.convertMultiColorArrayToString(points);
967     let index = imageWrapper.cmpColor(image1.uuid, points, threshold, x, y, ex - x, ey - y);
968     if (index === -1) {
969         return false;
970     }
971     return true;
972 };
973
974 /**
975  * 单点或者多点比色，找到所有符合标准的点，默认自己截图，如果都符合返回true，否则是false
976  * 运行环境: 无限制
977  * <Br/>
978  * 兼容版本: Android 5.0 以上
979  *
980  * @param points     字符串类似这样 6|1|0x969696-0x000010,2|3|0x969696-0x000010
981  * @param threshold  找色时颜色相似度取值为 0.0 ~ 1.0
982  * @param x 区域的X起始坐标，默认填写0全屏查找
983  * @param y 区域的Y起始坐标，默认填写0全屏查找
984  * @param ex 终点X坐标，默认填写0全屏查找
985  * @param ey 终点Y坐标，默认填写0全屏查找
b2d3f7 986  * @return {boolean} true代表找到了 false代表未找到
bc5e1e 987  */
X 988 ImageWrapper.prototype.cmpColorEx = function (points, threshold, x, y, ex, ey) {
989     if (imageWrapper == null) {
990         return false;
991     }
992     points = this.convertMultiColorArrayToString(points);
993     let index = imageWrapper.cmpColorCurrentScreen(points, threshold, x, y, ex - x, ey - y);
994     if (index === -1) {
995         return false;
996     }
997     return true;
998 };
999
1000 /**
1001  * 多点或者多点数组比色，找到所有符合标准的点，依次查找，如果找到就返回当前points的索引值，如果返回-1，说明都没有找到
1002  * 运行环境: 无限制
1003  * <Br/>
1004  * 兼容版本: Android 5.0 以上
1005  * @param image1 图片
1006  * @param points     数组类似这样 ["6|1|0x969696-0x000010,1|12|0x969696,-4|0|0x969696","6|1|0x969696"]
1007  * @param threshold  找色时颜色相似度取值为 0.0 ~ 1.0
1008  * @param x 区域的X起始坐标，默认填写0全屏查找
1009  * @param y 区域的Y起始坐标，默认填写0全屏查找
1010  * @param ex 终点X坐标，默认填写0全屏查找
1011  * @param ey 终点Y坐标，默认填写0全屏查找
b2d3f7 1012  * @return {number} 如果找到就返回当前points的索引值，如果返回-1，说明都没有找到
bc5e1e 1013  */
X 1014 ImageWrapper.prototype.cmpMultiColor = function (image1, points, threshold, x, y, ex, ey) {
1015     if (imageWrapper == null || image1 == null) {
1016         return -1;
1017     }
1018
1019     if (points != null) {
1020         // "6|1|0x969696-0x000010,1|12|0x969696,-4|0|0x969696","6|1|0x969696"
1021         // 类似这样的字符串 直接 转成数组的 JSON
1022         if ((typeof points) == "string") {
1023             return imageWrapper.cmpMultiColor(image1.uuid, JSON.stringify([points]), threshold, x, y, ex - x, ey - y);
1024         }
1025         //走老的逻辑
1026         if ((typeof points[0]) == "string") {
1027             if (/#|0x/.test(points[0])) {
1028                 return imageWrapper.cmpMultiColor(image1.uuid, JSON.stringify(points), threshold, x, y, ex - x, ey - y);
1029             }
1030         }
1031         let newPoint = [];
1032         for (let i = 0; i < points.length; i++) {
1033             newPoint[i] = this.convertMultiCmpColorArrayToString(points[i]);
1034         }
1035         return imageWrapper.cmpMultiColor(image1.uuid, JSON.stringify(newPoint), threshold, x, y, ex - x, ey - y);
1036     }
1037     return -1;
1038 };
1039 /**
1040  * 多点或者多点数组比色，找到所有符合标准的点，自动截屏，依次查找，如果找到就返回当前points的索引值，如果返回-1，说明都没有找到
1041  * 运行环境: 无限制
1042  * <Br/>
1043  * 兼容版本: Android 5.0 以上
1044  * @param points     数组类似这样 ["6|1|0x969696-0x000010,1|12|0x969696,-4|0|0x969696","6|1|0x969696"]
1045  * @param threshold  找色时颜色相似度取值为 0.0 ~ 1.0
1046  * @param x 区域的X起始坐标，默认填写0全屏查找
1047  * @param y 区域的Y起始坐标，默认填写0全屏查找
1048  * @param ex 终点X坐标，默认填写0全屏查找
1049  * @param ey 终点Y坐标，默认填写0全屏查找
b2d3f7 1050  * @return {number} 如果找到就返回当前points的索引值，如果返回-1，说明都没有找到
bc5e1e 1051  */
X 1052 ImageWrapper.prototype.cmpMultiColorEx = function (points, threshold, x, y, ex, ey) {
1053     if (imageWrapper == null) {
1054         return -1;
1055     }
1056     if (points != null) {
1057         // "6|1|0x969696-0x000010,1|12|0x969696,-4|0|0x969696","6|1|0x969696"
1058         // 类似这样的字符串 直接 转成数组的 JSON
1059         if ((typeof points) == "string") {
1060             return imageWrapper.cmpMultiColorCurrentScreen(JSON.stringify([points]), threshold, x, y, ex - x, ey - y);
1061         }
1062         //走老的逻辑
1063         if ((typeof points[0]) == "string") {
1064             if (/#|0x/.test(points[0])) {
1065                 return imageWrapper.cmpMultiColorCurrentScreen(JSON.stringify(points), threshold, x, y, ex - x, ey - y);
1066             }
1067         }
1068         let newPoint = [];
1069         for (let i = 0; i < points.length; i++) {
1070             newPoint[i] = this.convertMultiCmpColorArrayToString(points[i]);
1071         }
1072         return imageWrapper.cmpMultiColorCurrentScreen(JSON.stringify(newPoint), threshold, x, y, ex - x, ey - y);
1073     }
1074     return -1;
1075 };
1076
1077
1078 /**
1079  * 取得宽度
1080  * @param img 图片对象
b2d3f7 1081  * @return {number}
bc5e1e 1082  */
X 1083 ImageWrapper.prototype.getWidth = function (img) {
1084     if (img == null) {
1085         return 0;
1086     }
1087     return imageWrapper.getWidth(img.uuid);
1088 };
1089
1090 /**
1091  * 取得高度
1092  * @param img 图片对象
b2d3f7 1093  * @return {number}
bc5e1e 1094  */
X 1095 ImageWrapper.prototype.getHeight = function (img) {
1096     if (img == null) {
1097         return 0;
1098     }
1099     return imageWrapper.getHeight(img.uuid);
1100 };
1101
1102 /**
1103  * 保存到文件中
1104  * @param img 图片对象
1105  * @param path 路径
b2d3f7 1106  * @return {boolean} true代表成功，false 代表失败
bc5e1e 1107  */
X 1108 ImageWrapper.prototype.saveTo = function (img, path) {
1109     if (img == null) {
1110         return false;
1111     }
1112     return imageWrapper.saveTo(img.uuid + "", path);
1113 };
1114 /**
1115  * 转成base64的字符串
1116  * @param img 图片对象
b2d3f7 1117  * @return {string}
bc5e1e 1118  */
X 1119 ImageWrapper.prototype.toBase64 = function (img) {
1120     if (img == null) {
1121         return null;
1122     }
1123     return javaString2string(imageWrapper.toBase64(img.uuid, "jpg", 100));
1124 };
1125
1126 /**
1127  *  转成base64的字符串, jpg格式较小，可以减少内存
1128  * @param img 图片对象
1129  * @param format 格式  jpg或者 png
1130  * @param q 质量  1-100，质量越大 越清晰
b2d3f7 1131  * @return {string}
bc5e1e 1132  */
X 1133 ImageWrapper.prototype.toBase64Format = function (img, format, q) {
1134     if (img == null) {
1135         return null;
1136     }
1137     return javaString2string(imageWrapper.toBase64(img.uuid, format, q));
1138 };
1139 /**
1140  * 剪切图片
1141  * @param img 图片对象
1142  * @param x x起始坐标
1143  * @param y y起始坐标
1144  * @param ex 终点X坐标
1145  * @param ey 终点Y坐标
b2d3f7 1146  * @return {null|AutoImage} 对象或者null
bc5e1e 1147  */
X 1148 ImageWrapper.prototype.clip = function (img, x, y, ex, ey) {
1149     if (img == null) {
1150         return null;
1151     }
1152     var xd = imageWrapper.clip(img.uuid, x, y, ex - x, ey - y);
1153     if (xd != null && xd != undefined && xd != "") {
1154         return new AutoImage(javaString2string(xd));
1155     }
1156     return null;
1157 };
1158
1159 /**
1160  * 缩放图片
1161  * 适合EC 9.42.0+
1162  * @param img 图片对象
1163  * @param w 目标宽度
1164  * @param h 目标高度
b2d3f7 1165  * @return {null|AutoImage} 对象或者null
bc5e1e 1166  */
X 1167 ImageWrapper.prototype.scaleImage = function (img, w, h) {
1168     if (img == null) {
1169         return null;
1170     }
1171     var xd = imageWrapper.scaleImage(img.uuid, w, h);
1172     if (xd != null && xd != undefined && xd != "") {
1173         return new AutoImage(javaString2string(xd));
1174     }
1175     return null;
1176 };
1177
1178
1179 /**
1180  * 取得图片的某个点的颜色值
1181  * @param img 图片对象
1182  * @param x x坐标点
1183  * @param y y坐标点
b2d3f7 1184  * @return {number} 颜色值
bc5e1e 1185  */
X 1186 ImageWrapper.prototype.pixel = function (img, x, y) {
1187     if (img == null) {
1188         return 0;
1189     }
1190     return imageWrapper.pixel(img.uuid, x, y);
1191 };
1192
1193 /**
1194  * 将整型的颜色值转成16进制RGB字符串
1195  * @param color 整型值
b2d3f7 1196  * @return {null|string} 颜色字符串
bc5e1e 1197  */
X 1198 ImageWrapper.prototype.argb = function (color) {
1199     if (color == null) {
1200         return null;
1201     }
1202     return imageWrapper.argb(color);
1203 };
1204
1205
1206 /**
1207  * 取得Bitmap图片的某个点的颜色值
1208  * @param bitmap 图片对象
1209  * @param x x坐标点
1210  * @param y y坐标点
b2d3f7 1211  * @return {number} 颜色值
bc5e1e 1212  */
X 1213 ImageWrapper.prototype.getPixelBitmap = function (bitmap, x, y) {
1214     if (imageWrapper == null) {
1215         return 0;
1216     }
1217     return imageWrapper.getPixelBitmap(bitmap, x, y);
1218 };
1219
1220
1221 /**
1222  * 取得Bitmap图片的某个区域点的颜色值，等同于 Bitmap.getPixels
1223  * @param bitmap 图片对象
1224  * @param arraySize 要返回的区域数组的大小
1225  * @param offset      写入到pixels[]中的第一个像素索引值
1226  * @param stride      pixels[]中的行间距个数值(必须大于等于位图宽度)。可以为负数
1227  * @param x          　从位图中读取的第一个像素的x坐标值。
1228  * @param y           从位图中读取的第一个像素的y坐标值
1229  * @param width    　　从每一行中读取的像素宽度
1230  * @param height 　　　读取的行数
b2d3f7 1231  * @return {number} 颜色值数组
bc5e1e 1232  */
X 1233 ImageWrapper.prototype.getPixelsBitmap = function (bitmap, arraySize, offset, stride, x, y, width, height) {
1234     if (imageWrapper == null) {
1235         return null;
1236     }
1237     return imageWrapper.getPixelsBitmap(bitmap, arraySize, offset, stride, x, y, width, height);
1238 };
1239
1240 /**
1241  * 是否被回收了
1242  * @param img 图片对象
b2d3f7 1243  * @return {boolean} true代表已经被回收了
bc5e1e 1244  */
X 1245 ImageWrapper.prototype.isRecycled = function (img) {
1246     if (img == null) {
1247         return false;
1248     }
1249     try {
1250         let d = img.getClass();
1251         if (d == "class android.graphics.Bitmap") {
1252             return img.isRecycled();
1253         }
1254     } catch (e) {
1255     }
1256     if (img.uuid == null) {
1257         return false;
1258     }
1259
1260     return imageWrapper.isRecycled(img.uuid);
1261 };
1262
1263 /**
1264  * 回收图片
1265  * @param img 图片对象
b2d3f7 1266  * @return {boolean}
bc5e1e 1267  */
X 1268 ImageWrapper.prototype.recycle = function (img) {
1269     if (img == null) {
1270         return false;
1271     }
1272
1273     try {
1274         let d = img.getClass();
1275         if (d == "class android.graphics.Bitmap") {
1276             img.recycle();
1277             return true;
1278         }
1279     } catch (e) {
1280     }
1281
1282     if (img.uuid == null) {
1283         return false;
1284     }
1285
1286     return imageWrapper.recycle(img.uuid);
1287 };
1288
b2d3f7 1289 /**
P 1290  * 回收所有图片
1291  * @return {boolean}
1292  */
1293 ImageWrapper.prototype.recycleAllImage = function () {
1294     return imageWrapper.recycleAllImage();
1295 }
bc5e1e 1296
b2d3f7 1297 /**
P 1298  *
1299  * @param res
1300  * @return {null|Rect[]}
1301  */
bc5e1e 1302 ImageWrapper.prototype.toRectList = function (res) {
X 1303     if (res == null || res == "") {
1304         return null;
1305     }
1306     var ps = JSON.parse(res);
1307     if (ps == null) {
1308         return null;
1309     }
1310     var d = [];
1311     for (var i = 0; i < ps.length; i++) {
1312         d.push(new Rect(ps[i]));
1313     }
1314     return d;
1315 };
1316
1317 /**
1318  * 对AutoImage图片进行二值化
1319  * @param img AutoImage图片对象
1320  * @param type 二值化类型，一般写1即可
1321  * 0    灰度值大于阈值为最大值，其他值为<br/>
1322  * 1    灰度值大于阈值为0，其他值为最大值<br/>
1323  * 2    灰度值大于阈值的为阈值，其他值不变<br/>
1324  * 3    灰度值大于阈值的不变，其他值为0<br/>
1325  * 4    灰度值大于阈值的为零，其他值不变<br/>
1326  * 7    暂不支持<br/>
1327  * 8    大津法自动寻求全局阈值<br/>
1328  * 16    三角形法自动寻求全局阈值<br/>
1329  * @param threshold 二值化系数，0 ~ 255
b2d3f7 1330  * @return {null|AutoImage} 对象或者null
bc5e1e 1331  */
X 1332 ImageWrapper.prototype.binaryzation = function (img, type, threshold) {
1333     if (img == null) {
1334         return null;
1335     }
1336     var xd = imageWrapper.binaryzation(img.uuid, type, threshold);
1337     if (xd != null && xd != undefined && xd != "") {
1338         return new AutoImage(javaString2string(xd));
1339     }
1340     return null;
1341 };
1342
1343 /**
1344  * 自适应二值化，使用了opencv的adaptiveThreshold函数实现
1345  * 适合版本 EC 8.3.0+
1346  * @param img AutoImage图片对象
1347  * @param map MAP 参数
1348  *  diameter : 去噪直径 参考opencv的bilateralFilter函数
1349  *  adaptiveMethod：自适应二值化方式分别是0和1 ，ADAPTIVE_THRESH_MEAN_C=0，ADAPTIVE_THRESH_GAUSSIAN_C = 1
1350  *  blockSize：计算单位是像素的邻域块，邻域块取多大，就由这个值作决定，3，5，7这样的奇数
1351  *  c: 偏移值调整量，
1352  *  {
1353  *   "diameter":20,
1354  *   "adaptiveMethod":1,
1355  *   "c":9,"blockSize":51}
1356  * @return {null|AutoImage}
1357  */
1358 ImageWrapper.prototype.binaryzationEx = function (img, map) {
1359     if (img == null) {
1360         return null;
1361     }
1362     var xd = imageWrapper.binaryzationEx(img.uuid, JSON.stringify(map));
1363     if (xd != null && xd != undefined && xd != "") {
1364         return new AutoImage(javaString2string(xd));
1365     }
1366     return null;
1367 };
1368 /**
1369  * 自适应二值化，使用了opencv的adaptiveThreshold函数实现
1370  * 适合版本 EC 8.3.0+
1371  * @param bitmap Bitmap 图片对象
1372  * @param map MAP 参数
1373  *  diameter : 去噪直径 参考opencv的bilateralFilter函数
1374  *  adaptiveMethod：自适应二值化方式分别是0和1 ，ADAPTIVE_THRESH_MEAN_C=0，ADAPTIVE_THRESH_GAUSSIAN_C = 1
1375  *  blockSize：计算单位是像素的邻域块，邻域块取多大，就由这个值作决定，3，5，7这样的奇数
1376  *  c: 偏移值调整量，
1377  *   {"diameter":20,
1378  *   "adaptiveMethod":1,
1379  *   "c":9,"blockSize":51}
b2d3f7 1380  * @return {null|Bitmap} 对象或者null
bc5e1e 1381  **/
X 1382 ImageWrapper.prototype.binaryzationBitmapEx = function (bitmap, map) {
1383     if (bitmap == null) {
1384         return null;
1385     }
1386     return imageWrapper.binaryzationBitmapEx(bitmap, JSON.stringify(map));
1387 };
1388
1389 /**
1390  * 对安卓的 Bitmap 图片进行二值化
1391  * @param bitmap Bitmap 图片对象
1392  * @param type 二值化类型，一般写1即可
1393  * 0    灰度值大于阈值为最大值，其他值为<br/>
1394  * 1    灰度值大于阈值为0，其他值为最大值<br/>
1395  * 2    灰度值大于阈值的为阈值，其他值不变<br/>
1396  * 3    灰度值大于阈值的不变，其他值为0<br/>
1397  * 4    灰度值大于阈值的为零，其他值不变<br/>
1398  * 7    暂不支持<br/>
1399  * 8    大津法自动寻求全局阈值<br/>
1400  * 16    三角形法自动寻求全局阈值<br/>
1401  * @param threshold 二值化系数，0 ~ 255
b2d3f7 1402  * @return {null|Bitmap} 对象或者null
bc5e1e 1403  */
X 1404 ImageWrapper.prototype.binaryzationBitmap = function (bitmap, type, threshold) {
1405     if (bitmap == null) {
1406         return null;
1407     }
1408     return imageWrapper.binaryzationBitmap(bitmap, type, threshold);
1409 };
1410
1411 /**
1412  * 剪裁图片，请自行判断参数，正确性
1413  * @param bitmap 图片
1414  * @param x 开始X坐标
1415  * @param y 开始Y坐标
1416  * @param w 剪裁宽度
1417  * @param h 剪裁高度
b2d3f7 1418  * @return {null|Bitmap} 安卓的Bitmap对象
bc5e1e 1419  */
X 1420 ImageWrapper.prototype.clipBitmap = function (bitmap, x, y, w, h) {
1421     if (bitmap == null) {
1422         return null;
1423     }
1424     return imageWrapper.clipBitmap(bitmap, x, y, w, h);
1425 };
1426 /**
1427  * 缩放bitmap
1428  * 适合EC 9.42.0+
1429  * @param bitmap 图片
1430  * @param w 目标宽度
1431  * @param h 目标高度
b2d3f7 1432  * @return {null|Bitmap} 安卓的Bitmap对象
bc5e1e 1433  */
X 1434 ImageWrapper.prototype.scaleBitmap = function (bitmap, w, h) {
1435     if (bitmap == null) {
1436         return null;
1437     }
1438     return imageWrapper.scaleBitmap(bitmap, w, h);
1439 };
1440 /**
1441  * base64字符串转为Bitmap图片
1442  * @param data base64 数据
1443  * @param flag base64格式的标示，一般为0，
1444  * 可选参数为 ：0 默认， 1 无填充模式，2 无换行模式，4 换行模式
b2d3f7 1445  * @return {null|Bitmap} 安卓的Bitmap对象
bc5e1e 1446  */
X 1447 ImageWrapper.prototype.base64Bitmap = function (data, flag) {
1448     if (data == null) {
1449         return null;
1450     }
1451     return imageWrapper.base64Bitmap(data, flag);
1452 };
1453 /**
1454  * 将AutoImage转换为安卓原生的Bitmap对象
1455  * @param img {AutoImage}
b2d3f7 1456  * @return {null|Bitmap} 对象
bc5e1e 1457  */
X 1458 ImageWrapper.prototype.imageToBitmap = function (img) {
1459     if (img == null) {
1460         return null;
1461     }
1462     return imageWrapper.imageToBitmap(img.uuid);
1463 };
1464
1465 /**
1466  * 将安卓原生的Bitmap对象转换为AutoImage
1467  * 适合EC 6.15.0+版本
1468  * @param img {Bitmap}对象
b2d3f7 1469  * @return {null|AutoImage} 对象
bc5e1e 1470  */
X 1471 ImageWrapper.prototype.bitmapToImage = function (bitmap) {
1472     var xd = imageWrapper.bitmapToImage(bitmap);
1473     if (xd != null && xd != undefined && xd != "") {
1474         return new AutoImage(javaString2string(xd));
1475     }
1476     return null;
1477 };
1478
1479
1480 /**
1481  * bitmap转为base64
1482  * @param bitmap 图片
1483  * @param format 格式，jpg或者png
1484  * @param q 质量  1 - 100
1485  * @return {string} base64字符串
1486  */
1487 ImageWrapper.prototype.bitmapBase64 = function (bitmap, format, q) {
1488     if (bitmap == null) {
1489         return null;
1490     }
1491     var d = imageWrapper.bitmapBase64(bitmap, format, q);
1492     return javaString2string(d);
1493 };
1494 /**
1495  * 保存bitmap图像
1496  * @param bitmap 图片
1497  * @param format 要保存图像格式，有 png，jpg，webp
1498  * @param q 要保存图像质量，1-100
1499  * @param path 要保存图像路径
b2d3f7 1500  * @return {boolean} true 成功 false 失败
bc5e1e 1501  */
X 1502 ImageWrapper.prototype.saveBitmap = function (bitmap, format, q, path) {
1503     if (bitmap == null) {
1504         return false;
1505     }
1506     return imageWrapper.saveBitmap(bitmap, format, q, path);
1507 };
1508 /**
1509  * 旋转Bitmap
1510  * 支持EC 10.11.0+
1511  * @param bitmap 安卓的bitmap对象
1512  * @param degree 度数，-90代表逆时针旋转90度，home键在右，90度代表顺时针旋转90度，home键在左
b2d3f7 1513  * @return {null|Bitmap} 对象或者null
bc5e1e 1514  */
X 1515 ImageWrapper.prototype.rotateBitmap = function (bitmap, degree) {
1516     if (bitmap == null) {
1517         return false;
1518     }
1519     return imageWrapper.rotateBitmap(bitmap, degree);
1520 };
1521
1522
1523 /**
1524  * 旋转图片
1525  * 支持EC 10.11.0+
1526  * @param img 图片对象
1527  * @param degree 度数，-90代表逆时针旋转90度，home键在右，90度代表顺时针旋转90度，home键在左
b2d3f7 1528  * @return {null|AutoImage} 对象或者null
bc5e1e 1529  */
X 1530 ImageWrapper.prototype.rotateImage = function (img, degree) {
1531     if (img == null) {
1532         return null;
1533     }
1534     let uuid = imageWrapper.rotateImage(img.uuid, degree);
1535     if (uuid != null && uuid != undefined && uuid != "") {
1536         return new AutoImage(uuid);
1537     }
1538     return null;
1539 };
1540
b2d3f7 1541 /**
P 1542  *
1543  * @param res
1544  * @return {null|AutoImage}
1545  */
bc5e1e 1546 ImageWrapper.prototype.readResAutoImage = function (res) {
X 1547     if (res == null) {
b2d3f7 1548         return null;
bc5e1e 1549     }
X 1550     let uuid = imageWrapper.readResAutoImage(res);
1551     if (uuid != null && uuid != undefined && uuid != "") {
1552         return new AutoImage(uuid);
1553     }
1554     return null;
1555 };
1556
1557
1558 /**
1559  * 使用系统的screencap命令截图AutoImage，适合root或者代理模式, 有root权限或者开启了代理服务
1560  * 适合版本 EC 6.8.0+
1561  * @param root 是否优先使用root方式截图
b2d3f7 1562  * @return {null|AutoImage} 对象或者null
bc5e1e 1563  */
X 1564 ImageWrapper.prototype.screencapImage = function (root) {
1565     let xd = imageWrapper.screencapImage(root);
1566     if (xd != null && xd != undefined && xd != "") {
1567         return new AutoImage(javaString2string(xd));
1568     }
1569     return null;
1570 };
1571
1572
1573 /**
1574  * 使用系统的screencap命令截图为bitmap，适合root或者代理模式, 有root权限或者开启了代理服务
1575  * 适合版本 EC 6.8.0+
1576  * @param root 是否优先使用root方式截图
1577  * @return {Bitmap} 对象
1578  */
1579 ImageWrapper.prototype.screencapBitmap = function (root) {
1580     return imageWrapper.screencapBitmap(root);
1581 };
1582
1583
1584 function OCRWrapper() {
1585
1586 }
1587
1588 function OcrInst(s) {
1589     this.ocrUtil = s;
1590 }
1591
1592 var ocr = new OCRWrapper();
1593
1594
1595 OCRWrapper.prototype.newOcr = function () {
1596     let u = ocrWrapper.newOcr();
1597     if (u == null) {
1598         return null;
1599     }
1600     let ins = new OcrInst(u);
1601     return ins;
1602 }
1603 /**
1604  * 初始化OCR模块
1605  * @param map map参数表
1606  * key分别为：<br/>
1607  * type : OCR类型，值分别为 tess = Tesseract模块，baiduOnline=百度在在线识别模块，paddleocr=百度离线的paddleocr，easyedge=百度AI OCR<br/>
1608  * ocrLite = ocrLite, paddleOcrOnline = EC自带的PC端的paddleOcr服务程序<br/>
1609  * 如果类型是 tess,请将训练的模型放到 /sdcard/tessdata/ 文件夹下 <br/>
1610  *  - 参数设置为 : {"type":"tess","language":"chi_sim","debug":false,"ocrEngineMode":3}<br/>
1611  *  - language: 语言数据集文件， 例如 chi_sim.traineddata 代表是中文简体语言，参数就填写 chi_sim,多个可以用+链接，例如:chi_sim+eng+num<br/>
1612  *  - ocrEngineMode: 识别引擎类型，0 OEM_TESSERACT_ONLY ， 1 OEM_LSTM_ONLY,2 OEM_TESSERACT_LSTM_COMBINED,3 OEM_DEFAULT<br/>
1613  *  - rilLevel: PageIteratorLevel 参数，-1 自适应， 0: RIL_BLOCK, 1: RIL_PARA, 2: RIL_TEXTLINE, 3: RIL_WORD, 4:RIL_SYMBOL<br/>
1614  *  - debug: 代码是否设置调试模式，一般设置false即可<br/>
1615  *  - path： 放tessdata的文件夹路径，不要加上tessdata，是tessdata文件夹的父级<br/>
1616  * 如果类型是 baiduOnline, 参数设置为 : {"type":"baiduOnline","ak":"xxx","sk":"xx"}<br/>
1617  *  - ak = api key,sk = secret key, 百度OCR文档地址 : https://ai.baidu.com/ai-doc/OCR/Ck3h7y2ia<br/>
1618  * 如果类型是 ocrLite,
1619  *  - 参数设置为 : {"type":"ocrLite","numThread":4,"padding":10,"maxSideLen":0}<br/>
1620  *  - numThread: 线程数量。 <br/>
1621  *  - padding: 图像预处理，在图片外周添加白边，用于提升识别率，文字框没有正确框住所有文字时，增加此值。<br/>
1622  *  - maxSideLen: 按图片最长边的长度，此值为0代表不缩放，例：1024，如果图片长边大于1024则把图像整体缩小到1024再进行图像分割计算，如果图片长边小于1024则不缩放，如果图片长边小于32，则缩放到32。<br/>
1623  * 如果类型设置为: paddleOcrOnline 请到网盘中下载**EasyClick-PaddleOcr.zip文件解压运行**<br/>
1624  *  - 例子{
1625  *      "type": "paddleOcrOnline",
1626  *      "ocrType":"ONNX_PPOCR_V3",
1627  *      "padding": 50,
1628  *      "maxSideLen": 0,
1629  *      "boxScoreThresh": 0.5,
1630  *      "boxThresh": 0.3,
1631  *      "unClipRatio": 1.6,
1632  *      "doAngleFlag": 0,
1633  *      "mostAngleFlag": 0
1634  *  }<br/>
1635  *  - ocrType : 模型 ONNX_PPOCR_V3,ONNX_PPOCR_V4,NCNN_PPOCR_V3
1636  *  - serverUrl：paddle ocr服务器地址，可以在其他电脑部署，然后中控链接，例如 192.168.2.8，部署在电脑就改ip地址即可，端口是 9022 可以不写
1637  *  - padding 图像外接白框，用于提升识别率，文字框没有正确框住所有文字时，增加此值。默认50。<br/>
1638  *  - maxSideLen 按图像长边进行总体缩放，放大增加识别耗时但精度更高，缩小减小耗时但精度降低，maxSideLen为0表示不缩放。<br/>
1639  *  - boxScoreThresh 文字框置信度门限，文字框没有正确框住所有文字时，减小此值 <br/>
1640  *  - boxThresh 同上，自行试验。<br/>
1641  *  - unClipRatio 单个文字框大小倍率，越大时单个文字框越大。<br/>
1642  *  - doAngleFlag 启用(1)/禁用(0) 文字方向检测，只有图片倒置的情况下(旋转90~270度的图片)，才需要启用文字方向检测，默认关闭。<br/>
1643  *  - mostAngleFlag 启用(1)/禁用(0) 角度投票(整张图片以最大可能文字方向来识别)，当禁用文字方向检测时，此项也不起作用，默认关闭。<br/>
1644  *  - limit 代表每1秒执行ocr请求个数 默认1000。可以适当降低减少cpu占用<br/>
1645  *  - checkImage 检查数据是否是图像(1是 0否)默认关闭。<br/>
b2d3f7 1646  * @return {boolean} 布尔型 成功或者失败
bc5e1e 1647  */
X 1648 OcrInst.prototype.initOcr = function (map) {
1649     if (map == null) {
1650         return ocrWrapper.initOcr(this.ocrUtil, null);
1651     }
1652     return ocrWrapper.initOcr(this.ocrUtil, JSON.stringify(map));
1653 };
1654
1655 /**
1656  * 初始化OCR远程服务，只有使用easyedge和paddleocr的时候需要调用
1657  * @param timeout 超时时间，毫秒
b2d3f7 1658  * @return {boolean} 成功或者失败
bc5e1e 1659  */
X 1660 OcrInst.prototype.initOcrServer = function (timeout) {
1661     return ocrWrapper.initOcrServer(this.ocrUtil, timeout);
1662 };
1663
1664 /**
1665  * OCR远程服务连接上，只有使用easyedge和paddleocr的时候可用
1666  * @return {bool} 成功或者失败
1667  */
1668 OCRWrapper.prototype.isOcrServerOk = function () {
1669     return ocrWrapper.isOcrServerOk(this.ocrUtil);
1670 };
1671
1672
1673 /**
1674  * 设置OCR实现方式
1675  * @param type 值分别为 tess = Tesseract模块，baiduOnline=百度在在线识别模块
b2d3f7 1676  * @return {boolean} 成功或者失败
bc5e1e 1677  */
X 1678 OcrInst.prototype.setOcrType = function (type) {
1679     return ocrWrapper.setOcrType(this.ocrUtil, type);
1680 };
1681
1682
1683 /**
1684  * 设置是否守护OCR服务
1685  * 适合版本 EC 6.9.0+
1686  * @param daemon true 代表守护，false代表不守护
1687  * @param delay 每次守护间隔，单位是毫秒
b2d3f7 1688  * @return {boolean} 成功或者失败
bc5e1e 1689  */
X 1690 OcrInst.prototype.setDaemonServer = function (daemon, delay) {
1691     return ocrWrapper.setDaemonServer(this.ocrUtil, daemon, delay);
1692 };
1693
1694
1695 /**
1696  * 释放OCR占用的资源
b2d3f7 1697  * @return {boolean} 成功或者失败
bc5e1e 1698  */
X 1699 OcrInst.prototype.releaseAll = function () {
1700     return ocrWrapper.releaseAll(this.ocrUtil);
1701 };
1702
1703
1704 /**
1705  * 获取错误消息
1706  * @return {string} null代表没有错误
1707  */
1708 OcrInst.prototype.getErrorMsg = function () {
1709     return ocrWrapper.getErrorMsg(this.ocrUtil);
1710 };
1711
1712
1713 /**
1714  * 对Bitmap进行OCR，返回的是JSON数据，其中数据类似于与：
1715  *
1716  * [{
1717  *    "label": "奇趣装扮三阶盘化",
1718  *    "confidence": 0.48334712,
1719  *    "x": 11,
1720  *    "y": 25,
1721  *    "width": 100,
1722  *    "height": 100
1723  * }]
1724  *  <br/>
1725  *  label: 代表是识别的文字
1726  *  confidence：代表识别的准确度
1727  *  x: 代表X开始坐标
1728  *  Y: 代表Y开始坐标
1729  *  width: 代表宽度
1730  *  height: 代表高度
1731  * @param bitmap 图片
1732  * @param timeout 超时时间 单位毫秒
1733  * @param extra 扩展参数，map形式，例如 {"token":"xxx"}
b2d3f7 1734  * @return {null|JSON} JSON对象
bc5e1e 1735  */
X 1736 OcrInst.prototype.ocrBitmap = function (bitmap, timeout, extra) {
1737     if (bitmap == null) {
1738         return null;
1739     }
1740     var d = ocrWrapper.ocrBitmap(this.ocrUtil, bitmap, timeout, JSON.stringify(extra));
1741     if (d != null && d != "") {
1742         return JSON.parse(d);
1743     }
1744     return d;
1745 };
b2d3f7 1746 /**
P 1747  *
1748  * @param img
1749  * @param timeout
1750  * @param extra
1751  * @return {null|JSON} JSON对象
1752  */
bc5e1e 1753 OcrInst.prototype.ocrImage = function (img, timeout, extra) {
X 1754     if (img == null) {
1755         return null;
1756     }
1757     let bitmap = image.imageToBitmap(img)
1758     if (bitmap == null) {
1759         return null
1760     }
1761     let d = ocrWrapper.ocrBitmap(this.ocrUtil, bitmap, timeout, JSON.stringify(extra));
1762     if (bitmap != null) {
1763         bitmap.recycle();
1764         bitmap = null;
1765     }
1766     if (d != null && d != "") {
1767         return JSON.parse(d);
1768     }
1769     return d;
1770 };
1771
b2d3f7 1772 /**
P 1773  *
1774  * @param arr
1775  * @return {string|null}
1776  */
bc5e1e 1777 ImageWrapper.prototype.convertFirstColorArrayToString = function (arr) {
X 1778     if (arr) {
1779         if (typeof arr == "string") {
1780
1781             return arr;
1782         }
1783         if (arr[1] == null || arr[1].length <= 0 || "" == arr[1]) {
1784             return arr[0];
1785         }
1786         return arr[0] + "-" + arr[1];
1787     }
1788     return null;
1789 }
1790
b2d3f7 1791 /**
P 1792  *
1793  * @param arr
1794  * @return {string|null|*}
1795  */
bc5e1e 1796 ImageWrapper.prototype.convertMultiColorArrayToString = function (arr) {
X 1797     if (arr) {
1798         if (typeof arr == "string") {
1799             return arr;
1800         }
1801         //转换成类似的字符串 6|1|0x969696-0x000010,1|12|0x969696,-4|0|0x969696
1802         let length = arr.length;
1803         let result = "";
1804         for (let i = 0; i < length; i = i + 4) {
1805             if (result.length > 0) {
1806                 result = result + ","
1807             }
1808             let p = arr[i + 3];
1809             if (p == null || p.length <= 0 || "" == p) {
1810                 result = result + arr[i] + "|" + arr[i + 1] + "|" + arr[i + 2];
1811             } else {
1812                 result = result + arr[i] + "|" + arr[i + 1] + "|" + arr[i + 2] + "-" + arr[i + 3];
1813             }
1814
1815         }
1816         return result;
1817     }
1818     return null;
1819 }
1820
b2d3f7 1821 /**
P 1822  *
1823  * @param arr
1824  * @return {string|null}
1825  */
bc5e1e 1826 ImageWrapper.prototype.convertFirstColorArrayToString2 = function (arr) {
X 1827     if (arr) {
1828         if (typeof arr == "string") {
1829             return arr;
1830         }
1831         //转换成类似的字符串 0x969696-0x000010,0x969696,0x969696
1832         let length = arr.length;
1833         let result = "";
1834         for (let i = 0; i < length; i = i + 2) {
1835             if (result.length > 0) {
1836                 result = result + ","
1837             }
1838             let p = arr[i + 1];
1839             if (p == null || p.length <= 0 || "" == p) {
1840                 result = result + arr[i];
1841             } else {
1842                 result = result + arr[i] + "-" + arr[i + 1];
1843             }
1844
1845         }
1846         return result;
1847     }
1848     return null;
1849 }
1850
b2d3f7 1851 /**
P 1852  *
1853  * @param arr
1854  * @return {string|null|string[]}
1855  */
bc5e1e 1856 ImageWrapper.prototype.convertMultiCmpColorArrayToString = function (arr) {
X 1857     if (arr) {
1858         if (typeof arr == "string") {
1859             return arr;
1860         }
1861         //转换成类似的字符串 6|1|0x969696-0x000010,1|12|0x969696,-4|0|0x969696
1862         let length = arr.length;
1863         let result = [];
1864         for (let i = 0; i < length; i = i + 4) {
1865             let p = arr[i + 3];
1866             if (p == null || p.length <= 0 || "" == p) {
1867                 let tmp = arr[i] + "|" + arr[i + 1] + "|" + arr[i + 2];
1868                 result.push(tmp)
1869             } else {
1870                 let tmp = arr[i] + "|" + arr[i + 1] + "|" + arr[i + 2] + "-" + arr[i + 3];
1871                 result.push(tmp)
1872             }
1873         }
1874         return result;
1875     }
1876     return null;
1877 }
1878
1879 /**
1880  * 通过颜色找图，支持透明图，这个不需要处理话opencv
1881  * <p>
1882  * 整张图片都找不到时返回null
1883  * <Br/>
1884  * 运行环境: 无限制
1885  * <Br/>
1886  * 兼容版本: Android 5.0 以上
1887  * @param image1     大图片
1888  * @param template  小图片（模板）
1889  * @param x         找图区域 x 起始坐标
1890  * @param y         找图区域 y 起始坐标
1891  * @param ex 终点X坐标
1892  * @param ey 终点Y坐标
1893  * @param threshold 图片相似度。取值范围为0~1的浮点数。默认值为0.9。
1894  * @param limit 限制结果的数量，如果要找到1个，就填写1，如果是多个请填写多个
b2d3f7 1895  * @return {null|Point[]} 坐标点数组或者null
bc5e1e 1896  */
X 1897 ImageWrapper.prototype.findImageByColor = function (image1, template, x, y, ex, ey, threshold, limit) {
1898     if (imageWrapper == null || image1 == null || template == null) {
1899         return null;
1900     }
1901     let res = imageWrapper.findImageByColor(image1.uuid, template.uuid, x, y, ex - x, ey - y, threshold, limit);
1902     if (res == null || res == "") {
1903         return null;
1904     }
b2d3f7 1905     try {
P 1906         let d = JSON.parse(res);
1907         let x1 = [];
1908         for (let i = 0; i < d.length; i++) {
1909             x1.push(new Point(d[i]));
1910         }
1911         return x1;
1912     } catch (e) {
1913
bc5e1e 1914     }
b2d3f7 1915     return null;
P 1916
bc5e1e 1917 };
X 1918 /**
1919  * 通过颜色找图，支持透明图，这个不需要处理话opencv
1920  * <p>
1921  * 整张图片都找不到时返回null
1922  * @param image1     大图片
1923  * @param template  小图片（模板）
1924  * @param x         找图区域 x 起始坐标
1925  * @param y         找图区域 y 起始坐标
1926  * @param ex 终点X坐标
1927  * @param ey 终点Y坐标
1928  * @param limit 限制结果的数量，如果要找到1个，就填写1，如果是多个请填写多个
1929  * @param extra 扩展函数，map结构例如<Br/>
1930  * {"firstColorOffset":"#101010","firstColorThreshold":1.0,"firstColorOffset":"#101010","otherColorThreshold":0.9,"cmpColorSucThreshold":1.0}
1931  * <Br/>firstColorOffset: 第一个匹配到的颜色偏色,例如 #101010 <Br/>
1932  * firstColorThreshold: 第一个匹配到的颜色偏色系数，例如 0.9<Br/>
1933  * firstColorOffset: 剩下需要找的颜色 偏色,例如 #101010<Br/>
1934  * otherColorThreshold: 剩下需要找的颜色 偏色系数，例如 0.9<Br/>
1935  * cmpColorSucThreshold: 成功匹配多少个颜色系数 就认为是成功的，例如 0.9 = 90%个点<Br/>
1936  * startX: 第一个点从哪里开始找的X坐标<Br/>
1937  * startY: 第一个点从哪里开始找的Y坐标<Br/>
b2d3f7 1938  * @return {null|Point[]}  坐标点数组或者null
bc5e1e 1939  */
X 1940 ImageWrapper.prototype.findImageByColorEx = function (image1, template, x, y, ex, ey, limit, extra) {
1941     if (imageWrapper == null || image1 == null || template == null) {
1942         return;
1943     }
1944     if (extra) {
1945         extra = JSON.stringify(extra);
1946     }
1947     let res = imageWrapper.findImageByColorEx(image1.uuid, template.uuid, x, y, ex - x, ey - y, limit, extra);
1948     if (res == null || res == "") {
1949         return null;
1950     }
b2d3f7 1951     try {
P 1952         let d = JSON.parse(res);
1953         let x1 = [];
1954         for (let i = 0; i < d.length; i++) {
1955             x1.push(new Point(d[i]));
1956         }
1957         return x1;
1958     } catch (e) {
1959
bc5e1e 1960     }
b2d3f7 1961     return null;
P 1962
bc5e1e 1963 };
X 1964
1965 function Yolov8Wrapper() {
1966
1967 }
1968
1969 let yolov8Api = new Yolov8Wrapper();
1970
1971 function Yolov8Util(instance) {
1972     this.yolov8Instance = instance;
1973 }
1974
1975 /**
1976  * 获取YOLOV8错误消息
1977  * 适配EC 10.15.0+
b2d3f7 1978  * @return {string} 字符串
bc5e1e 1979  */
X 1980 Yolov8Util.prototype.getErrorMsg = function () {
1981     return ocrWrapper.getYolov8ErrorMsg(this.yolov8Instance);
1982 }
1983
1984 /**
1985  * 获取 yolov8 默认配置
1986  * 适配EC 10.15.0+
1987  * @param model_name 模型名称 默认写  yolov8s-640 即可
1988  * @param input_size yolov8训练时候的imgsz参数，默认写640即可
b2d3f7 1989  * @param box_thr 检测框系数，默认写0.25即可
bc5e1e 1990  * @param iou_thr 输出系数，，默认写0.35 即可
X 1991  * @param bind_cpu 是否绑定CPU，选项为ALL,BIG,LITTLE 三个,默认写ALL
1992  * @param use_vulkan_compute 是否启用硬件加速，1是，0否
1993  * @param obj_names JSON数组，训练的时候分类名称例如 ["star","common","face"]
b2d3f7 1994  * @return {JSON|null|*} 数据
bc5e1e 1995  */
X 1996 Yolov8Util.prototype.getDefaultConfig = function (model_name, input_size, box_thr, iou_thr, bind_cpu, use_vulkan_compute, obj_names) {
1997     if ((typeof obj_names) == "string") {
1998         obj_names = obj_names.split(",");
1999     }
2000     let data = {
2001         "name": "yolov8s-640",
2002         "input_size": 640,
2003         "box_thr": 0.25,
2004         "iou_thr": 0.35,
2005         "ver": 8,
2006         "bind_cpu": "ALL",
2007         "use_vulkan_compute": 0,
2008         "input_name": "in0",
2009         "names": [],
2010         "outputs": [
2011             {
2012                 "name": "out0",
2013                 "stride": 0,
2014                 "anchors": [
2015                     0,
2016                     0
2017                 ]
2018             }
2019         ]
2020     }
2021     data["name"] = model_name;
2022     data["names"] = obj_names;
2023     data["input_size"] = input_size;
2024     data["box_thr"] = box_thr;
b2d3f7 2025     data["num_thread"] = 4;
bc5e1e 2026     data["iou_thr"] = iou_thr;
X 2027     data["use_vulkan_compute"] = use_vulkan_compute;
2028     data["bind_cpu"] = bind_cpu;
2029     return data;
2030 }
2031
2032 /**
2033  * 初始化yolov8模型
2034  * 具体如何生成param和bin文件，请参考文件的yolo使用章节，通过yolo的pt转成ncnn的param、bin文件
2035  * 适配EC 10.15.0+
2036  * @param map 参数表 参考 getDefaultConfig函数获取默认的参数
2037  * @param paramPath param文件路径
2038  * @param binPath bin文件路径
b2d3f7 2039  * @return {boolean} true代表成功 false代表失败
bc5e1e 2040  */
X 2041 Yolov8Util.prototype.initYoloModel = function (map, paramPath, binPath) {
2042     if (map == null) {
2043         return false;
2044     }
2045     let data = JSON.stringify(map);
2046     return ocrWrapper.initYoloModel(this.yolov8Instance, data, paramPath, binPath);
2047 }
2048
2049 /**
2050  * 检测图片
2051  * 适配EC 10.15.0+
2052  * 返回数据例如
2053  * [{"name":"heart","confidence":0.92,"left":957,"top":986,"right":1050,"bottom":1078}]
2054  * name: 代表是分类，confidence:代表可信度，left,top,right,bottom代表结果坐标选框
2055  * @param bitmap 安卓的bitmap对象
2056  * @param obj_names JSON数组，不写代表不过滤，写了代表只取填写的分类
b2d3f7 2057  * @return {string|null} 字符串数据
bc5e1e 2058  */
X 2059 Yolov8Util.prototype.detectBitmap = function (bitmap, obj_names) {
2060     if (bitmap == null) {
2061         return null;
2062     }
2063     if (obj_names == null || obj_names == undefined) {
2064         obj_names = "[]"
2065     } else {
2066         obj_names = JSON.stringify(obj_names)
2067     }
2068     return ocrWrapper.detectBitmap(this.yolov8Instance, bitmap, obj_names);
2069 }
2070
b2d3f7 2071
P 2072 /**
2073  * 检测Image
2074  * 适配EC 10.16.0+
2075  * 返回数据例如
2076  * [{"name":"heart","confidence":0.92,"left":957,"top":986,"right":1050,"bottom":1078}]
2077  * name: 代表是分类，confidence:代表可信度，left,top,right,bottom代表结果坐标选框
2078  * @param img AutoImage对象
2079  * @param obj_names JSON数组，不写代表不过滤，写了代表只取填写的分类
2080  * @return {string|null} 字符串数据
2081  */
2082 Yolov8Util.prototype.detectImage = function (img, obj_names) {
2083     let bitmap = image.imageToBitmap(img)
2084     if (bitmap == null) {
2085         return null
2086     }
2087     if (obj_names == null || obj_names == undefined) {
2088         obj_names = "[]"
2089     } else {
2090         obj_names = JSON.stringify(obj_names)
2091     }
2092     let result = ocrWrapper.detectBitmap(this.yolov8Instance, bitmap, obj_names);
2093     if (bitmap != null) {
2094         try {
2095             bitmap.recycle();
2096         } catch (e) {
2097         }
2098         bitmap = null;
2099     }
2100     return result;
2101 }
2102
2103
bc5e1e 2104 /**
X 2105  * 释放yolov8资源
2106  * 适配EC 10.15.0+
b2d3f7 2107  * @return {boolean}
bc5e1e 2108  */
X 2109 Yolov8Util.prototype.release = function () {
2110     return ocrWrapper.releaseYolo(this.yolov8Instance);
2111 }
2112
2113 /**
2114  * 初始化yolov8实例
2115  * 适配EC 10.15.0+
b2d3f7 2116  * @return  {Yolov8Util} 实例对象
bc5e1e 2117  */
X 2118 Yolov8Wrapper.prototype.newYolov8 = function () {
2119     let instance = ocrWrapper.newYolov8();
2120     return new Yolov8Util(instance)
2121 }
2122
2123
2124