苹果脚本智能OCR自动化助手 - B2B网络软件

/*
🍎 AIWROK 智能OCR自动化助手系统 Pro
🍎 交流 QQ 群 711841924 群一，苹果内测群 528816639
🍎 功能：整合OCR识别、图像处理、配置管理、日志记录的完整自动化解决方案
*/
printl("========================================");
printl("🍎 AIWROK 智能OCR自动化助手系统 Pro");
printl("========================================\n");
// ==================== 工具函数 ====================
function printl(msg) {
console.log(msg);
}
function sleep(ms) {
return new Promise(resolve => setTimeout(resolve, ms));
}
// ==================== 配置管理器 ====================
class OCRConfigManager {
constructor() {
this.configPrefix = "OCR_ASSISTANT_";
this.defaultConfigs = {
"ocr_language": "zh-CN",
"ocr_confidence": "80",
"ocr_timeout": "5000",
"retry_times": "3",
"enable_cache": "true",
"enable_log": "true",
"auto_save_images": "true",
"image_save_path": "/ocr_images/",
"click_delay": "500",
"enable_smart_click": "true"
};
this.initConfig();
}
initConfig() {
for (var key in this.defaultConfigs) {
if (!this.hasConfig(key)) {
this.setConfig(key, this.defaultConfigs[key]);
}
}
printl("✓ 配置管理器初始化完成");
}
setConfig(key, value) {
config.setConfig(this.configPrefix + key, String(value));
}
getConfig(key, defaultValue) {
return config.getConfig(this.configPrefix + key, defaultValue);
}
hasConfig(key) {
var value = this.getConfig(key, null);
return value !== null && value !== "";
}
getAllConfigs() {
var result = {};
for (var key in this.defaultConfigs) {
result[key] = this.getConfig(key, this.defaultConfigs[key]);
}
return result;
}
}
// ==================== 日志记录器 ====================
class OCRLogger {
constructor(enableLog) {
this.enableLog = enableLog;
this.logs = [];
this.maxLogs = 100;
}
log(level, message, data) {
if (!this.enableLog) return;
var timestamp = new Date().toISOString();
var logEntry = {
timestamp: timestamp,
level: level,
message: message,
data: data || null
};
this.logs.push(logEntry);
if (this.logs.length > this.maxLogs) {
this.logs.shift();
}
var logMsg = "[" + timestamp + "] [" + level + "] " + message;
if (data) {
logMsg += " - " + JSON.stringify(data);
}
printl(logMsg);
}
info(message, data) {
this.log("INFO", message, data);
}
warn(message, data) {
this.log("WARN", message, data);
}
error(message, data) {
this.log("ERROR", message, data);
}
debug(message, data) {
this.log("DEBUG", message, data);
}
getLogs() {
return this.logs;
}
exportLogs() {
return JSON.stringify(this.logs, null, 2);
}
}
// ==================== 图像处理器 ====================
class OCRImageProcessor {
constructor(logger, configManager) {
this.logger = logger;
this.config = configManager;
this.currentImage = null;
this.currentMat = null;
}
captureFullScreenshot() {
try {
this.logger.info("开始全屏截图");
this.currentImage = screen.screenShotFull();
this.logger.debug("全屏截图完成");
return this.currentImage;
} catch (e) {
this.logger.error("全屏截图失败", e.message);
return null;
}
}
captureRegionScreenshot(left, top, right, bottom) {
try {
this.logger.info("开始区域截图", { region: [left, top, right, bottom] });
var width = Math.floor((right - left) * screen.getScreenWidth());
var height = Math.floor((bottom - top) * screen.getScreenHeight());
var x = Math.floor(left * screen.getScreenWidth());
var y = Math.floor(top * screen.getScreenHeight());
this.currentImage = screen.screenShot(x, y, Math.min(width, height));
this.logger.debug("区域截图完成");
return this.currentImage;
} catch (e) {
this.logger.error("区域截图失败", e.message);
return null;
}
}
loadImageFromFile(filePath) {
try {
this.logger.info("从文件加载图像", { path: filePath });
this.currentImage = new Image();
this.currentImage.readFile(filePath);
this.logger.debug("图像加载完成");
return this.currentImage;
} catch (e) {
this.logger.error("图像加载失败", e.message);
return null;
}
}
loadImageFromBase64(base64String) {
try {
this.logger.info("从Base64加载图像", { length: base64String.length });
this.currentImage = new Image();
this.currentImage.readBase64(base64String);
this.logger.debug("图像加载完成");
return this.currentImage;
} catch (e) {
this.logger.error("Base64图像加载失败", e.message);
return null;
}
}
getMat() {
try {
if (!this.currentImage) {
this.logger.warn("当前没有图像，无法获取Mat");
return null;
}
this.currentMat = this.currentImage.getMat();
this.logger.debug("Mat对象获取成功");
return this.currentMat;
} catch (e) {
this.logger.error("获取Mat失败", e.message);
return null;
}
}
processImageWithOpenCV() {
try {
if (!this.currentMat) {
this.currentMat = this.getMat();
}
if (!this.currentMat) {
this.logger.warn("无法进行图像处理，Mat对象为空");
return false;
}
this.logger.info("开始OpenCV图像处理");
opencv.toGray(this.currentMat);
this.logger.debug("灰度化完成");
opencv.threshold(this.currentMat, 100, 255);
this.logger.debug("二值化完成");
this.logger.info("图像处理完成");
return true;
} catch (e) {
this.logger.error("图像处理失败", e.message);
return false;
}
}
getBase64() {
try {
if (!this.currentImage) {
this.logger.warn("当前没有图像，无法获取Base64");
return null;
}
var base64 = this.currentImage.base64();
this.logger.debug("Base64获取成功", { length: base64.length });
return base64;
} catch (e) {
this.logger.error("获取Base64失败", e.message);
return null;
}
}
saveImage(filePath) {
try {
if (!this.currentImage) {
this.logger.warn("当前没有图像，无法保存");
return false;
}
this.logger.info("保存图像", { path: filePath });
return true;
} catch (e) {
this.logger.error("保存图像失败", e.message);
return false;
}
}
close() {
try {
if (this.currentImage) {
this.currentImage.close();
this.currentImage = null;
}
if (this.currentMat) {
this.currentMat.close();
this.currentMat = null;
}
this.logger.debug("图像资源已释放");
} catch (e) {
this.logger.error("释放图像资源失败", e.message);
}
}
}
// ==================== OCR识别引擎 ====================
class OCREngine {
constructor(logger, configManager) {
this.logger = logger;
this.config = configManager;
this.currentResult = null;
this.isLocked = false;
}
recognizeFullScreen() {
try {
this.logger.info("开始全屏OCR识别");
this.currentResult = screen.ocr(0, 0, 1, 1);
this.logger.debug("全屏OCR识别完成");
return this.currentResult;
} catch (e) {
this.logger.error("全屏OCR识别失败", e.message);
return null;
}
}
recognizeRegion(left, top, right, bottom) {
try {
this.logger.info("开始区域OCR识别", { region: [left, top, right, bottom] });
this.currentResult = screen.ocr(left, top, right, bottom);
this.logger.debug("区域OCR识别完成");
return this.currentResult;
} catch (e) {
this.logger.error("区域OCR识别失败", e.message);
return null;
}
}
recognizeImage(image) {
try {
this.logger.info("开始图像OCR识别");
this.currentResult = image.ocr(0, 0, 1, 1);
this.logger.debug("图像OCR识别完成");
return this.currentResult;
} catch (e) {
this.logger.error("图像OCR识别失败", e.message);
return null;
}
}
recognizeWithOpenCV(templatePath) {
try {
this.logger.info("开始OpenCV OCR识别", { template: templatePath });
this.currentResult = opencv.OCREx(templatePath);
if (this.currentResult) {
this.logger.debug("OpenCV OCR识别完成");
} else {
this.logger.warn("OpenCV OCR识别返回空结果");
}
return this.currentResult;
} catch (e) {
this.logger.error("OpenCV OCR识别失败", e.message);
return null;
}
}
getAllText() {
try {
if (!this.currentResult) {
this.logger.warn("当前没有OCR结果");
return "";
}
var text = this.currentResult.getAllString();
this.logger.debug("获取所有文本", { length: text.length });
return text;
} catch (e) {
this.logger.error("获取所有文本失败", e.message);
return "";
}
}
getAllDetects() {
try {
if (!this.currentResult) {
this.logger.warn("当前没有OCR结果");
return [];
}
var detects = this.currentResult.getAllDetect();
// 处理detects中的text可能是函数的情况
for (var i = 0; i < detects.length; i++) {
var detect = detects[i];
if (detect) {
// 尝试多种方式获取文本
var detectText = null;
try {
if (typeof detect.text === "function") {
// 避免直接调用可能的 native 方法
detectText = String(detect.text);
} else if (detect.text) {
detectText = String(detect.text);
} else if (detect.getText) {
detectText = String(detect.getText());
}
} catch (e) {
this.logger.warn("获取文本失败", e.message);
}
if (detectText) {
detect.text = detectText;
}
}
}
this.logger.debug("获取所有检测对象", { count: detects.length });
return detects;
} catch (e) {
this.logger.error("获取所有检测对象失败", e.message);
return [];
}
}
findText(text, region) {
try {
if (!this.currentResult) {
this.logger.warn("当前没有OCR结果");
return null;
}
var target = this.currentResult.findText(text, region || [0, 0, 1, 1]);
if (target) {
this.logger.info("找到精确文本", { text: text });
// 确保目标对象有正确的格式
if (typeof target === 'object' && target !== null) {
// 确保 target 有必要的属性
if (target.x === undefined) target.x = 0;
if (target.y === undefined) target.y = 0;
if (target.width === undefined) target.width = 0;
if (target.height === undefined) target.height = 0;
// 添加 clickRandom 方法作为后备
if (typeof target.clickRandom !== 'function') {
target.clickRandom = function() {
var centerX = this.x + (this.width || 0) / 2;
var centerY = this.y + (this.height || 0) / 2;
hid.mouseMove(centerX * 100, centerY * 100);
sleep(100);
hid.clickPercent(centerX, centerY);
};
}
}
} else {
this.logger.debug("未找到精确文本", { text: text });
}
return target;
} catch (e) {
this.logger.error("查找精确文本失败", e.message);
return null;
}
}
findIncludeText(text, region) {
try {
if (!this.currentResult) {
this.logger.warn("当前没有OCR结果");
return null;
}
var target = this.currentResult.findIncludeText(text, region || [0, 0, 1, 1]);
if (target) {
this.logger.info("找到包含文本", { text: text });
// 确保目标对象有正确的格式
if (typeof target === 'object' && target !== null) {
// 确保 target 有必要的属性
if (target.x === undefined) target.x = 0;
if (target.y === undefined) target.y = 0;
if (target.width === undefined) target.width = 0;
if (target.height === undefined) target.height = 0;
// 添加 clickRandom 方法作为后备
if (typeof target.clickRandom !== 'function') {
target.clickRandom = function() {
var centerX = this.x + (this.width || 0) / 2;
var centerY = this.y + (this.height || 0) / 2;
hid.mouseMove(centerX * 100, centerY * 100);
sleep(100);
hid.clickPercent(centerX, centerY);
};
}
}
} else {
this.logger.debug("未找到包含文本", { text: text });
}
return target;
} catch (e) {
this.logger.error("查找包含文本失败", e.message);
return null;
}
}
findIncludeTexts(text, region) {
try {
if (!this.currentResult) {
this.logger.warn("当前没有OCR结果");
return [];
}
var targets = this.currentResult.findIncludeTexts(text, region || [0, 0, 1, 1]);
this.logger.debug("查找包含文本结果", { text: text, count: targets.length });
return targets;
} catch (e) {
this.logger.error("查找包含文本失败", e.message);
return [];
}
}
findWithRegex(regex, region) {
try {
if (!this.currentResult) {
this.logger.warn("当前没有OCR结果");
return [];
}
var targets = this.currentResult.findTextWithRegex(regex, region || [0, 0, 1, 1]);
this.logger.debug("正则表达式查找结果", { regex: regex, count: targets.length });
return targets;
} catch (e) {
this.logger.error("正则表达式查找失败", e.message);
return [];
}
}
getJSON() {
try {
if (!this.currentResult) {
this.logger.warn("当前没有OCR结果");
return "{}";
}
var json = this.currentResult.getJSON();
this.logger.debug("获取JSON结果", { length: json.length });
return json;
} catch (e) {
this.logger.error("获取JSON结果失败", e.message);
return "{}";
}
}
lock() {
try {
if (!this.isLocked) {
OCR.lockOCR();
this.isLocked = true;
this.logger.info("OCR结果已锁定");
}
} catch (e) {
this.logger.error("锁定OCR失败", e.message);
}
}
unlock() {
try {
if (this.isLocked) {
OCR.unLock();
this.isLocked = false;
this.logger.info("OCR结果已解锁");
}
} catch (e) {
this.logger.error("解锁OCR失败", e.message);
}
}
}
// ==================== 智能点击器 ====================
class SmartClicker {
constructor(logger, configManager) {
this.logger = logger;
this.config = configManager;
}
clickTarget(target) {
try {
if (!target) {
this.logger.warn("点击目标为空");
return false;
}
var enableSmartClick = this.config.getConfig("enable_smart_click", "true") === "true";
var clickDelay = parseInt(this.config.getConfig("click_delay", "500"));
if (enableSmartClick && typeof target.clickRandom === 'function') {
this.logger.info("使用智能随机点击");
target.clickRandom();
} else if (target.x !== undefined && target.y !== undefined) {
var centerX = target.x + (target.width || 0) / 2;
var centerY = target.y + (target.height || 0) / 2;
this.logger.info("使用坐标点击", { x: centerX, y: centerY });
// 添加鼠标移动效果
this.logger.debug("移动鼠标到目标位置");
hid.mouseMove(centerX * 100, centerY * 100);
// 短暂延迟，模拟真实鼠标移动
sleep(100);
hid.clickPercent(centerX, centerY);
} else {
this.logger.warn("无法点击，没有可用的点击方法或坐标");
return false;
}
if (clickDelay > 0) {
sleep(clickDelay);
}
this.logger.info("点击执行成功");
return true;
} catch (e) {
this.logger.error("点击执行失败", e.message);
return false;
}
}
clickCoordinates(x, y) {
try {
this.logger.info("点击坐标", { x: x, y: y });
// 添加鼠标移动效果
this.logger.debug("移动鼠标到目标位置");
hid.mouseMove(x * 100, y * 100);
// 短暂延迟，模拟真实鼠标移动
sleep(100);
hid.clickPercent(x, y);
var clickDelay = parseInt(this.config.getConfig("click_delay", "500"));
if (clickDelay > 0) {
sleep(clickDelay);
}
this.logger.info("坐标点击成功");
return true;
} catch (e) {
this.logger.error("坐标点击失败", e.message);
return false;
}
}
}
// ==================== OCR自动化助手主类 ====================
class OCRAutomationAssistant {
constructor() {
this.configManager = new OCRConfigManager();
var enableLog = this.configManager.getConfig("enable_log", "true") === "true";
this.logger = new OCRLogger(enableLog);
this.imageProcessor = new OCRImageProcessor(this.logger, this.configManager);
this.ocrEngine = new OCREngine(this.logger, this.configManager);
this.smartClicker = new SmartClicker(this.logger, this.configManager);
this.logger.info("OCR自动化助手初始化完成");
this.displayConfig();
}
displayConfig() {
printl("\n=== 当前配置 ===");
var configs = this.configManager.getAllConfigs();
for (var key in configs) {
printl(" " + key + ": " + configs[key]);
}
printl("================\n");
}
findAndClick(text, options) {
options = options || {};
var region = options.region || [0, 0, 1, 1];
var exactMatch = options.exactMatch || false;
var retryTimes = options.retryTimes || parseInt(this.configManager.getConfig("retry_times", "3"));
this.logger.info("开始查找并点击文本", { text: text, exactMatch: exactMatch });
for (var i = 0; i < retryTimes; i++) {
try {
// 先执行OCR识别
this.logger.debug("执行OCR识别", { region: region });
if (region[0] === 0 && region[1] === 0 && region[2] === 1 && region[3] === 1) {
this.ocrEngine.recognizeFullScreen();
} else {
this.ocrEngine.recognizeRegion(region[0], region[1], region[2], region[3]);
}
var target = null;
if (exactMatch) {
target = this.ocrEngine.findText(text, region);
} else {
target = this.ocrEngine.findIncludeText(text, region);
}
if (target) {
this.logger.info("找到目标文本，准备点击", { text: text, attempt: i + 1 });
if (this.smartClicker.clickTarget(target)) {
return { success: true, target: target };
}
} else {
this.logger.debug("未找到目标文本", { text: text, attempt: i + 1 });
}
if (i < retryTimes - 1) {
sleep(1000);
}
} catch (e) {
this.logger.error("查找点击过程出错", e.message);
}
}
this.logger.warn("未找到目标文本或点击失败", { text: text });
return { success: false, target: null };
}
findAndClickAll(text, options) {
options = options || {};
var region = options.region || [0, 0, 1, 1];
var exactMatch = options.exactMatch || false;
var clickDelay = options.clickDelay || 500;
this.logger.info("开始查找并点击所有匹配文本", { text: text });
// 先执行OCR识别
this.logger.debug("执行OCR识别", { region: region });
if (region[0] === 0 && region[1] === 0 && region[2] === 1 && region[3] === 1) {
this.ocrEngine.recognizeFullScreen();
} else {
this.ocrEngine.recognizeRegion(region[0], region[1], region[2], region[3]);
}
var targets = [];
if (exactMatch) {
var allDetects = this.ocrEngine.getAllDetects();
for (var i = 0; i < allDetects.length; i++) {
var detect = allDetects[i];
if (!detect) continue;
// 尝试多种方式获取文本
var detectText = null;
try {
if (typeof detect.text === "function") {
// 避免直接调用可能的 native 方法
detectText = String(detect.text);
} else if (detect.text) {
detectText = String(detect.text);
} else if (detect.getText) {
detectText = String(detect.getText());
} else {
continue;
}
} catch (e) {
this.logger.warn("获取文本失败", e.message);
continue;
}
if (detectText === text) {
targets.push(detect);
}
}
} else {
targets = this.ocrEngine.findIncludeTexts(text, region);
}
this.logger.info("找到匹配目标", { count: targets.length });
var results = [];
for (var i = 0; i < targets.length; i++) {
this.logger.info("点击第 " + (i + 1) + " 个目标");
var result = this.smartClicker.clickTarget(targets[i]);
results.push({ success: result, target: targets[i] });
if (i < targets.length - 1 && clickDelay > 0) {
sleep(clickDelay);
}
}
return results;
}
extractNumbers(options) {
options = options || {};
var region = options.region || [0, 0, 1, 1];
var regex = options.regex || "\\d+";
this.logger.info("开始提取数字");
// 先执行OCR识别
this.logger.debug("执行OCR识别", { region: region });
if (region[0] === 0 && region[1] === 0 && region[2] === 1 && region[3] === 1) {
this.ocrEngine.recognizeFullScreen();
} else {
this.ocrEngine.recognizeRegion(region[0], region[1], region[2], region[3]);
}
var targets = this.ocrEngine.findWithRegex(regex, region);
var numbers = [];
for (var i = 0; i < targets.length; i++) {
var target = targets[i];
if (!target) continue;
// 尝试多种方式获取文本
var targetText = null;
try {
if (typeof target.text === "function") {
// 避免直接调用可能的 native 方法
targetText = String(target.text);
} else if (target.text) {
targetText = String(target.text);
} else if (target.getText) {
targetText = String(target.getText());
} else {
continue;
}
} catch (e) {
this.logger.warn("获取文本失败", e.message);
continue;
}
if (!targetText) continue;
var numStr = targetText.match(regex);
if (numStr) {
numbers.push({
text: targetText,
number: numStr[0],
position: {
x: target.x || 0,
y: target.y || 0,
width: target.width || 0,
height: target.height || 0
}
});
}
}
this.logger.info("数字提取完成", { count: numbers.length });
return numbers;
}
extractTextWithPattern(pattern, options) {
options = options || {};
var region = options.region || [0, 0, 1, 1];
this.logger.info("开始按模式提取文本", { pattern: pattern });
// 先执行OCR识别
this.logger.debug("执行OCR识别", { region: region });
if (region[0] === 0 && region[1] === 0 && region[2] === 1 && region[3] === 1) {
this.ocrEngine.recognizeFullScreen();
} else {
this.ocrEngine.recognizeRegion(region[0], region[1], region[2], region[3]);
}
var targets = this.ocrEngine.findWithRegex(pattern, region);
var texts = [];
for (var i = 0; i < targets.length; i++) {
var target = targets[i];
if (!target) continue;
// 尝试多种方式获取文本
var targetText = null;
try {
if (typeof target.text === "function") {
// 避免直接调用可能的 native 方法
targetText = String(target.text);
} else if (target.text) {
targetText = String(target.text);
} else if (target.getText) {
targetText = String(target.getText());
} else {
continue;
}
} catch (e) {
this.logger.warn("获取文本失败", e.message);
continue;
}
if (!targetText) continue;
texts.push({
text: targetText,
position: {
x: target.x || 0,
y: target.y || 0,
width: target.width || 0,
height: target.height || 0
}
});
}
this.logger.info("文本提取完成", { count: texts.length });
return texts;
}
verifyTextExists(text, options) {
options = options || {};
var region = options.region || [0, 0, 1, 1];
var exactMatch = options.exactMatch || false;
this.logger.info("验证文本是否存在", { text: text, exactMatch: exactMatch });
// 先执行OCR识别
this.logger.debug("执行OCR识别", { region: region });
if (region[0] === 0 && region[1] === 0 && region[2] === 1 && region[3] === 1) {
this.ocrEngine.recognizeFullScreen();
} else {
this.ocrEngine.recognizeRegion(region[0], region[1], region[2], region[3]);
}
var target = null;
if (exactMatch) {
target = this.ocrEngine.findText(text, region);
} else {
target = this.ocrEngine.findIncludeText(text, region);
}
var exists = target !== null;
this.logger.info("文本验证结果", { text: text, exists: exists });
return exists;
}
waitForText(text, options) {
options = options || {};
var timeout = options.timeout || 10000;
var interval = options.interval || 1000;
var exactMatch = options.exactMatch || false;
var region = options.region || [0, 0, 1, 1];
this.logger.info("等待文本出现", { text: text, timeout: timeout });
var startTime = Date.now();
while (Date.now() - startTime < timeout) {
var exists = this.verifyTextExists(text, { exactMatch: exactMatch, region: region });
if (exists) {
this.logger.info("文本已出现", { text: text });
return true;
}
sleep(interval);
}
this.logger.warn("等待文本超时", { text: text });
return false;
}
captureAndRecognize(options) {
options = options || {};
var region = options.region || null;
var processImage = options.processImage || false;
this.logger.info("开始截图并识别");
if (region) {
this.imageProcessor.captureRegionScreenshot(region[0], region[1], region[2], region[3]);
} else {
this.imageProcessor.captureFullScreenshot();
}
if (processImage) {
this.imageProcessor.processImageWithOpenCV();
}
var image = this.imageProcessor.currentImage;
if (!image) {
this.logger.error("截图失败");
return null;
}
var result = this.ocrEngine.recognizeImage(image);
if (!result) {
this.logger.error("OCR识别失败");
return null;
}
var allText = this.ocrEngine.getAllText();
var allDetects = this.ocrEngine.getAllDetects();
// 确保detects中的text字段已正确处理
for (var i = 0; i < allDetects.length; i++) {
var detect = allDetects[i];
if (detect && typeof detect.text === "function") {
detect.text = detect.text();
} else if (detect && detect.text) {
detect.text = String(detect.text);
}
}
this.logger.info("截图识别完成", { textLength: allText.length, detectCount: allDetects.length });
return {
text: allText,
detects: allDetects,
image: image,
base64: this.imageProcessor.getBase64()
};
}
copyTextToClipboard(text) {
try {
this.logger.info("复制文本到剪贴板", { length: text.length });
clipboard.copyToClipboard(text);
this.logger.info("文本复制成功");
return true;
} catch (e) {
this.logger.error("复制文本失败", e.message);
return false;
}
}
readTextFromClipboard() {
try {
this.logger.info("从剪贴板读取文本");
var text = clipboard.readFromClipboard();
this.logger.info("文本读取成功", { length: text ? text.length : 0 });
return text;
} catch (e) {
this.logger.error("读取文本失败", e.message);
return null;
}
}
getLogs() {
return this.logger.getLogs();
}
exportLogs() {
return this.logger.exportLogs();
}
cleanup() {
try {
this.logger.info("开始清理资源");
this.imageProcessor.close();
this.ocrEngine.unlock();
this.logger.info("资源清理完成");
} catch (e) {
this.logger.error("资源清理失败", e.message);
}
}
}
// ==================== 使用示例 ====================
function example1_basicUsage() {
printl("\n【示例1】基础使用 - 查找并点击文本");
var assistant = new OCRAutomationAssistant();
var result = assistant.findAndClick("设置");
if (result.success) {
printl("✓ 成功找到并点击 '设置'");
} else {
printl("✗ 未找到 '设置'");
}
assistant.cleanup();
}
function example2_advancedSearch() {
printl("\n【示例2】高级搜索 - 提取屏幕上的所有数字");
var assistant = new OCRAutomationAssistant();
var numbers = assistant.extractNumbers();
printl("找到 " + numbers.length + " 个数字:");
for (var i = 0; i < Math.min(5, numbers.length); i++) {
printl(" 数字" + (i + 1) + ": " + numbers[i].number + " (完整文本: " + numbers[i].text + ")");
}
assistant.cleanup();
}
function example3_automationFlow() {
printl("\n【示例3】自动化流程 - 模拟登录流程");
var assistant = new OCRAutomationAssistant();
var steps = [
{ text: "登录", action: "click" },
{ text: "用户名", action: "click" },
{ text: "密码", action: "click" },
{ text: "确定", action: "click" }
];
for (var i = 0; i < steps.length; i++) {
var step = steps[i];
printl("步骤 " + (i + 1) + ": " + step.text);
var result = assistant.findAndClick(step.text);
if (result.success) {
printl(" ✓ 成功");
sleep(1000);
} else {
printl(" ✗ 失败");
break;
}
}
assistant.cleanup();
}
function example4_imageProcessing() {
printl("\n【示例4】图像处理 - 截图、处理、识别");
var assistant = new OCRAutomationAssistant();
var result = assistant.captureAndRecognize({ processImage: true });
if (result) {
printl("✓ 截图识别成功");
printl(" 识别文本长度: " + result.text.length);
printl(" 识别目标数量: " + result.detects.length);
printl(" Base64编码长度: " + (result.base64 ? result.base64.length : 0));
if (result.detects.length > 0) {
printl(" 第一个识别目标: " + result.detects[0].text);
}
} else {
printl("✗ 截图识别失败");
}
assistant.cleanup();
}
function example5_clipboardIntegration() {
printl("\n【示例5】剪贴板集成 - 识别文本并复制到剪贴板");
var assistant = new OCRAutomationAssistant();
var result = assistant.captureAndRecognize();
if (result && result.text.length > 0) {
printl("✓ 识别到文本: " + result.text.substring(0, 50) + "...");
if (assistant.copyTextToClipboard(result.text)) {
printl("✓ 文本已复制到剪贴板");
var clipboardText = assistant.readTextFromClipboard();
if (clipboardText === result.text) {
printl("✓ 剪贴板验证成功");
} else {
printl("✗ 剪贴板验证失败");
}
}
} else {
printl("✗ 识别失败或无文本");
}
assistant.cleanup();
}
function example6_multiRegionSearch() {
printl("\n【示例6】多区域搜索 - 在不同区域查找文本");
var assistant = new OCRAutomationAssistant();
var regions = [
{ name: "顶部区域", region: [0, 0, 1, 0.3] },
{ name: "中间区域", region: [0, 0.3, 1, 0.7] },
{ name: "底部区域", region: [0, 0.7, 1, 1] }
];
for (var i = 0; i < regions.length; i++) {
var region = regions[i];
printl("在 " + region.name + " 查找文本...");
var result = assistant.findAndClick("确定", { region: region.region });
if (result.success) {
printl(" ✓ 在 " + region.name + " 找到并点击");
break;
} else {
printl(" ✗ 在 " + region.name + " 未找到");
}
}
assistant.cleanup();
}
function example7_patternExtraction() {
printl("\n【示例7】模式提取 - 提取特定格式的文本");
var assistant = new OCRAutomationAssistant();
var patterns = [
{ name: "手机号", pattern: "1[3-9]\\d{9}" },
{ name: "邮箱", pattern: "[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}" },
{ name: "金额", pattern: "\\d+\\.\\d{2}" }
];
for (var i = 0; i < patterns.length; i++) {
var pattern = patterns[i];
printl("提取 " + pattern.name + "...");
var texts = assistant.extractTextWithPattern(pattern.pattern);
printl(" 找到 " + texts.length + " 个" + pattern.name);
for (var j = 0; j < Math.min(3, texts.length); j++) {
printl(" " + (j + 1) + ": " + texts[j].text);
}
}
assistant.cleanup();
}
function example8_waitForText() {
printl("\n【示例8】等待文本 - 等待特定文本出现");
var assistant = new OCRAutomationAssistant();
printl("等待 '加载完成' 文本出现（最多10秒）...");
var found = assistant.waitForText("加载完成", { timeout: 10000 });
if (found) {
printl("✓ 文本已出现");
} else {
printl("✗ 等待超时");
}
assistant.cleanup();
}
function example9_logExport() {
printl("\n【示例9】日志导出 - 导出操作日志");
var assistant = new OCRAutomationAssistant();
assistant.findAndClick("设置");
assistant.extractNumbers();
printl("\n=== 操作日志 ===");
var logs = assistant.getLogs();
for (var i = 0; i < Math.min(5, logs.length); i++) {
var log = logs[i];
printl("[" + log.level + "] " + log.message);
}
printl("\n=== 导出JSON日志 ===");
var jsonLogs = assistant.exportLogs();
printl(jsonLogs.substring(0, 200) + "...");
assistant.cleanup();
}
function example10_comprehensiveDemo() {
printl("\n【示例10】综合演示 - 完整的自动化任务");
var assistant = new OCRAutomationAssistant();
printl("步骤1: 截图并识别");
var result = assistant.captureAndRecognize();
if (!result) {
printl("✗ 截图识别失败");
assistant.cleanup();
return;
}
printl("✓ 识别到 " + result.detects.length + " 个文本元素");
printl("\n步骤2: 查找并点击 '开始'");
var startResult = assistant.findAndClick("开始");
if (startResult.success) {
printl("✓ 点击成功");
} else {
printl("✗ 未找到 '开始'");
}
printl("\n步骤3: 等待 '加载完成'");
var loaded = assistant.waitForText("加载完成", { timeout: 5000 });
if (loaded) {
printl("✓ 加载完成");
} else {
printl("✗ 加载超时");
}
printl("\n步骤4: 提取所有数字");
var numbers = assistant.extractNumbers();
printl("✓ 提取到 " + numbers.length + " 个数字");
printl("\n步骤5: 复制识别结果到剪贴板");
if (result.text) {
assistant.copyTextToClipboard(result.text);
printl("✓ 已复制到剪贴板");
}
printl("\n步骤6: 导出操作日志");
var jsonLogs = assistant.exportLogs();
printl("✓ 日志已导出，长度: " + jsonLogs.length);
assistant.cleanup();
printl("\n✓ 综合演示完成");
}
function example11_buttonDemo() {
printl("\n【示例11】按钮演示 - 轮流点击三个按钮");
var assistant = new OCRAutomationAssistant();
var buttons = ["投屏", "快捷指令", "激活模式"];
for (var i = 0; i < buttons.length; i++) {
var button = buttons[i];
printl("点击按钮: " + button);
var result = assistant.findAndClick(button);
if (result && result.success) {
printl("✓ 成功点击 '" + button + "'");
} else {
printl("✗ 未能找到或点击 '" + button + "'");
}
// 等待2秒，让界面有时间响应
sleep(2000);
}
assistant.cleanup();
printl("\n✓ 按钮演示完成");
}
function example12_configCenterDemo() {
printl("\n【示例12】配置中心演示 - 点击配置管理中心页面元素");
var assistant = new OCRAutomationAssistant();
var elements = [
"全部",
"游戏配置",
"OCR配置",
"重置",
"保存"
];
for (var i = 0; i < elements.length; i++) {
var element = elements[i];
printl("点击元素: " + element);
var result = assistant.findAndClick(element);
if (result && result.success) {
printl("✓ 成功点击 '" + element + "'");
} else {
printl("✗ 未能找到或点击 '" + element + "'");
}
// 等待1秒，让界面有时间响应
sleep(1000);
}
assistant.cleanup();
printl("\n✓ 配置中心演示完成");
}
// ==================== 主函数 ====================
function main() {
printl("🍎 开始执行OCR自动化助手示例\n");
example1_basicUsage();
example2_advancedSearch();
example3_automationFlow();
example4_imageProcessing();
example5_clipboardIntegration();
example6_multiRegionSearch();
example7_patternExtraction();
example8_waitForText();
example9_logExport();
example10_comprehensiveDemo();
example11_buttonDemo();
example12_configCenterDemo();
printl("\n🍎 所有示例执行完毕");
}
main();

复制代码