AIWROK软件安卓总结图像视觉处理[opencv]方法

发帖软件 · 发表于 7 小时前

AIWROK软件安卓总结图像视觉处理[opencv]方法
AIWROK软件安卓总结图像视觉处理[opencv]方法群发软件发帖工具

//🍎交流 QQ 群 711841924 群一，苹果内测群，528816639
//适用本文档ES5系统安卓 JavaScript引擎Rhino
// 方法1：获取区域颜色数量 (getcolorNum)
/**
* 功能：从图像指定区域中，统计符合目标颜色（含相似度）的像素数量
* 返回值：int - 匹配到的颜色数量
* 参数：
* arg0: Mat - 输入的mat格式图片
* arg1: String[] - 目标颜色数组（格式如['#AE5454', '10,9,#123233']）
* arg2: double - 颜色相似度（0.0~1.0）
* arg3: double[] - 检测区域比例（[左,上,右,下]，范围0.0~1.0）
*/
function getColorCountDemo() {
var mat = screen.screenShot(432, 768, 100).getMat();
var matchNum = opencv.getcolorNum(mat, ['#AE5454', '#AE5454'], 0.90, [0.0799, 0.3008, 0.9167, 0.8242]);
printl("匹配颜色数量：" + matchNum);
mat = null;
}
// 方法2：计算梯度 (gradientProcessing)
/**
* 功能：计算图像梯度，突出边缘信息
* 返回值：Mat - 梯度处理后的图像
* 参数：arg0: Mat - 输入的mat格式图片
*/
function gradientDemo() {
var mat = screen.screenShot(432, 768, 100).getMat();
var gradientMat = opencv.gradientProcessing(mat);
printl("梯度图像尺寸：" + gradientMat.width() + "x" + gradientMat.height());
mat = null;
gradientMat = null;
}
// 方法3：颜色翻转 (invertColor)
/**
* 功能：翻转图像像素颜色（类似底片效果）
* 返回值：Mat - 颜色翻转后的图像
* 参数：arg0: Mat - 输入的mat格式图片
*/
function invertColorDemo() {
function getInvertedMat() {
var mat = screen.screenShot(900, 1600, 100).getMat();
opencv.invertColor(mat);
return mat;
}
let invertedMat = getInvertedMat();
printl("颜色翻转后Mat：" + invertedMat);
}
// 方法4：开运算 (openImg)
/**
* 功能：先腐蚀后膨胀，去除小噪点、平滑边界
* 返回值：Mat - 开运算后的图像
* 参数：
* arg0: Mat - 输入的mat格式图片
* arg1: int - 核大小（必须>0）
*/
function openImgDemo() {
function openImageProcess(mat, kernelSize) {
kernelSize = kernelSize <= 0 ? 1 : kernelSize;
return opencv.openImg(mat, kernelSize);
}
var mat = screen.screenShot(432, 768, 100).getMat();
var resultMat = openImageProcess(mat, 3);
printl("开运算结果尺寸：" + resultMat.width() + "x" + resultMat.height());
mat = null;
resultMat = null;
}
// 方法5：去杂点 (removeSmallObjects)
/**
* 功能：移除面积小于阈值的小物体（需输入灰度图）
* 返回值：Mat - 去杂点后的图像
* 参数：
* arg0: Mat - 输入的灰度mat图片（CV_8UC1）
* arg1: double - 面积阈值（<该值的物体被移除）
*/
function removeSmallObjectsDemo() {
var mat = screen.screenShot(900, 1600, 100).getMat();
var grayMat = new Mat();
opencv.cvtColor(mat, grayMat, opencv.COLOR_BGR2GRAY);
var resultMat = opencv.removeSmallObjects(grayMat, 100);
printl("去杂点后Mat：" + resultMat);
mat = null;
grayMat = null;
resultMat = null;
}
// 方法6：分隔提取 (shapeSplit)
/**
* 功能：转黑白图后提取黑色图形，返回图形数组
* 返回值：detect[] - 图形数组（含坐标、面积等，支持click()）
* 参数：
* arg0: Mat - 输入的mat格式图片
* arg1: int - 排序方式（0=Y坐标，1=X坐标，2=面积）
* arg2: int - 排序规则（0=正序，1=倒序）
*/
function shapeSplitDemo() {
function extractShapes() {
var mat = screen.screenShot(900, 1600, 100).getMat();
var detects = opencv.shapeSplit(mat, 0, 0);
mat = null;
return detects;
}
var shapes = extractShapes();
if (shapes) shapes[0]?.click();
}
// 方法7：CV文件分隔提取 (shapeSplitEx)
/**
* 功能：从CV文件提取图形
* 返回值：detect[] - 图形数组（支持click()）
* 参数：arg0: String - CV文件名（如"图色710035.cv"）
*/
function shapeSplitExDemo() {
var detects = opencv.shapeSplitEx('图色710035.cv');
if (detects) detects[0]?.click();
}
// 方法8：模板匹配 (templateMatch)
/**
* 功能：多模板匹配定位目标，返回匹配结果数组
* 返回值：detect[] - 匹配结果数组
* 参数：
* arg0: Mat - 输入图片
* arg1: String[] - 模板Base64数组
* arg2: double - 相似度阈值
* arg3: double[] - 区域比例（[左,上,右,下]）
* arg4: boolean - 是否只返回最优值
*/
function templateMatchDemo() {
var mat = screen.screenShot(432, 768, 100).getMat();
var templates = [64位图的Base64编码]; // 替换为实际模板
var results = opencv.templateMatch(mat, templates, 0.8, [0,0,1,1], false);
if (results) results[0]?.click();
mat = null;
}
// 方法9：二值化 (threshold)
/**
* 功能：阈值内转黑色，阈值外转白色
* 返回值：Mat - 二值化后的图像
* 参数：
* arg0: Mat - 输入图片
* arg1: int - 最小阈值
* arg2: int - 最大阈值
*/
function thresholdDemo() {
function getBinaryMat() {
var mat = screen.screenShot(900, 1600, 100).getMat();
opencv.threshold(mat, 53, 150);
return mat;
}
let binaryMat = getBinaryMat();
printl("二值化Mat：" + binaryMat);
}
// 方法10：转灰度图 (toGray)
/**
* 功能：彩色图转灰度图（单通道）
* 返回值：Mat - 灰度图
* 参数：arg0: Mat - 输入的彩色mat图片
*/
function toGrayDemo() {
function getGrayMat() {
var mat = screen.screenShot(900, 1600, 100).getMat();
opencv.toGray(mat);
return mat;
}
let grayMat = getGrayMat();
printl("灰度图类型：" + grayMat.type());
}
// 方法11：转HSV (toHSV)
/**
* 功能：BGR颜色空间转HSV
* 返回值：Mat - HSV图像
* 参数：arg0: Mat - 输入的彩色mat图片
*/
function toHSVDemo() {
function getHSVMat() {
var mat = screen.screenShot(900, 1600, 100).getMat();
opencv.toHSV(mat);
return mat;
}
let hsvMat = getHSVMat();
printl("HSV Mat：" + hsvMat);
}
// 方法12：Mat转Base64 (mat.ToBase64())
/**
* 功能：Mat图像转Base64字符串
* 返回值：String - Base64编码
* 调用：Mat对象直接调用（无参数）
*/
function matToBase64Demo() {
var mat = screen.screenShot(900, 1600, 100).getMat();
var base64 = mat.ToBase64();
printl("Base64前50字符：" + base64.substring(0, 50) + "...");
mat = null;
}
// 方法13：findImageOneSift（SIFT算法找图）
/**
* 功能：基于SIFT算法查找图像匹配区域
* 返回值：detect[] - 匹配结果数组
* 参数：（方法签名待确认，以下为示例参数）
* arg0: Mat - 大图（待搜索图像）
* arg1: Mat - 小图（模板图像）
* arg2: int - 匹配阈值1
* arg3: int - 匹配阈值2
* arg4: float[] - 检测区域比例
*/
function findImageOneSiftDemo() {
printl("开始SIFT算法找图示例");
try {
// 截取大图和小图
var bigMat = screen.screenShot(900, 1600, 100).getMat();
var smallMat = screen.screenShot(300, 300, 100).getMat();
// 注意：方法签名可能需调整（原示例存在调用错误）
// var results = opencv.findImageOneSift(bigMat, smallMat, 60, 50, [0,0,1,1]);
printl("SIFT找图需确认方法签名后调用");
// 释放资源
bigMat = null;
smallMat = null;
} catch (e) {
printl("SIFT找图错误：" + e);
}
}
// 方法14：findImagesEx（cv文件找图）
/**
* 功能：从指定CV文件中查找匹配图形
* 返回值：detect[] - 匹配结果数组（支持click()）
* 参数：arg0: String - CV文件名（如"图色564976.cv"）
*/
function findImagesExDemo() {
// 从CV文件找图
var detects = opencv.findImagesEx('图色564976.cv');
if (detects && detects.length > 0) {
printl("找到" + detects.length + "个匹配图形");
detects[0].click(); // 点击第一个结果
} else {
printl("未找到匹配图形");
}
}
// 方法15：findMultiColor（多点找色）
/**
* 功能：根据基点和多个颜色点查找匹配区域
* 返回值：detect[] - 匹配结果数组（支持click()）
* 参数：
* arg0: Mat - 输入图片
* arg1: String - 基点（格式"x,y,#色值"，如"546,325,#51752F"）
* arg2: String[] - 多色点数组（同基点格式）
* arg3: int - 偏色阈值
* arg4: int - 偏移阈值
* arg5: float[] - 检测区域比例（[左,上,右,下]）
* arg6: double - 相似度
*/
function findMultiColorDemo() {
function 图色850610() {
var mat = screen.screenShot(900, 1600, 100).getMat();
// 基点+多色点找色
return opencv.findMultiColor(mat, '546,325,#51752F', ['552,355,#429D60', '534,367,#63FA87'], 2, 5, [0,0,1,1], 0.95);
}
var result = 图色850610();
if (result) {
result[0].click();
} else {
print.err('查找图色850610失败');
}
}
// 方法16：findMultiColorEx（cv文件多点找色）
/**
* 功能：从指定CV文件中执行多点找色
* 返回值：detect[] - 匹配结果数组（支持click()）
* 参数：arg0: String - CV文件名（如"图色850610.cv"）
*/
function findMultiColorExDemo() {
// 从CV文件执行多点找色
var detects = opencv.findMultiColorEx('图色850610.cv');
if (detects && detects.length > 0) {
printl("找到" + detects.length + "个颜色匹配点");
detects[0].click(); // 点击第一个结果
} else {
printl("未找到颜色匹配点");
}
}
// 方法17：gaussianBlur（高斯滤波）
/**
* 功能：对图像进行高斯滤波，平滑边缘、去除噪点
* 返回值：Mat - 滤波后的图像
* 参数：
* arg0: Mat - 输入图像
* arg1: int - 卷积核大小（影响平滑程度）
*/
function gaussianBlurDemo() {
function 图色770562() {
var mat = screen.screenShot(900, 1600, 100).getMat();
// 高斯滤波（卷积核5）
opencv.gaussianBlur(mat, 5);
return mat;
}
let mat = 图色770562();
printl("高斯滤波后Mat：" + mat);
mat = null;
}
// 方法18：getAllShap（获取所有Shape）
/**
* 功能：从图像中提取所有形状（Shape）
* 返回值：ArrayList - 包含所有形状的列表
* 参数：arg0: Mat - 输入图像（建议先转灰度图）
*/
function getAllShapDemo() {
printl("开始获取所有Shape示例");
try {
var mat = screen.screenShot(900, 1600, 100).getMat();
// 转灰度图预处理
var grayMat = new Mat();
opencv.cvtColor(mat, grayMat, opencv.COLOR_RGB2GRAY);
// 获取所有Shape
var shapes = opencv.getAllShap(grayMat);
if (shapes) {
printl("共获取到" + shapes.size() + "个Shape");
} else {
printl("未获取到Shape");
}
// 释放资源
mat = null;
grayMat = null;
shapes = null;
} catch (e) {
printl("获取Shape错误：" + e);
}
}
// 方法19：getContours（获取轮廓图）
/**
* 功能：从图像中提取轮廓并返回轮廓图
* 返回值：Mat - 包含轮廓的图像
* 参数：arg0: Mat - 输入图像（建议先转灰度图）
*/
function getContoursDemo() {
printl("开始获取轮廓图示例");
try {
var mat = screen.screenShot(900, 1600, 100).getMat();
// 转灰度图预处理
var grayMat = new Mat();
opencv.cvtColor(mat, grayMat, opencv.COLOR_RGB2GRAY);
// 获取轮廓
var contoursMat = opencv.getContours(grayMat);
if (contoursMat) {
printl("轮廓图尺寸：" + contoursMat.width() + "x" + contoursMat.height());
} else {
printl("未获取到轮廓");
}
// 释放资源
mat = null;
grayMat = null;
contoursMat = null;
} catch (e) {
printl("获取轮廓错误：" + e);
}
}
// 方法20：coverageArea（图片抹除）
/**
* 功能：对图像指定区域进行抹除（填充指定灰度值）
* 返回值：Mat - 抹除后的图像
* 参数：
* arg0: Mat - 输入的mat格式图片
* arg1: double - 填充灰度值（0~255，0为黑色，255为白色）
* arg2: int[] - 抹除区域比例（[左,上,右,下]，范围0~1，如[0,0,1,1]表示全图）
*/
function coverageAreaDemo() {
printl("开始图片抹除示例");
try {
// 截取400x400屏幕区域转Mat
var mat = screen.screenShot(400, 400, 100).getMat();
printl("原始图像尺寸：" + mat.width() + "x" + mat.height());
// 定义抹除区域（全图）
var eraseRegion = [0, 0, 1, 1];
// 执行抹除（填充灰度值0，即黑色）
var resultMat = opencv.coverageArea(mat, 0, eraseRegion);
printl("抹除后图像信息：" + resultMat);
// 释放资源
mat = null;
resultMat = null;
} catch (e) {
printl("图片抹除错误：" + e);
}
printl("图片抹除示例结束");
}
// 方法21：dilateImage（图像膨胀）
/**
* 功能：对图像进行膨胀处理，扩大亮区、连接断裂区域
* 返回值：Mat - 膨胀后的图像
* 参数：
* arg0: Mat - 输入的mat格式图片
* arg1: int - 水平膨胀系数（值越大，水平方向膨胀越明显）
* arg2: int - 竖直膨胀系数（值越大，竖直方向膨胀越明显）
*/
function dilateImageDemo() {
// 封装截图+膨胀处理函数
function 图色930021() {
var mat = screen.screenShot(900, 1600, 100).getMat();
// 水平+竖直膨胀系数均为4
opencv.dilateImage(mat, 4, 4);
return mat;
}
// 执行膨胀并输出结果
let matDilate = 图色930021();
printl("图像膨胀后信息：" + matDilate);
matDilate = null;
}
// 方法22：drawRect（Shape绘制）
/**
* 功能：在图像上绘制矩形Shape（参数与函数声明待补充，以下为常见功能示例）
* 返回值：Mat - 绘制后的图像（推测）
* 参数：（推测，需根据实际接口调整）
* arg0: Mat - 输入的mat格式图片
* arg1: int[] - 矩形坐标（如[x1,y1,x2,y2]，左上角与右下角坐标）
* arg2: int[] - 线条颜色（如[B,G,R]，默认可能为红色）
* arg3: int - 线条宽度（默认可能为1）
*/
function drawRectDemo() {
printl("开始Shape矩形绘制示例（参数待确认）");
try {
var mat = screen.screenShot(900, 1600, 100).getMat();
// 推测参数：图像、矩形坐标[100,100,300,300]、红色[0,0,255]、线条宽度2
// 注意：实际函数名与参数需按真实接口调整
// opencv.drawRect(mat, [100,100,300,300], [0,0,255], 2);
printl("矩形绘制需按实际函数接口调整参数");
mat = null;
} catch (e) {
printl("Shape绘制错误：" + e);
}
}
// 方法23：erodeImage（图像腐蚀）
/**
* 功能：对图像进行腐蚀处理，缩小亮区、去除小噪点
* 返回值：Mat - 腐蚀后的图像
* 参数：
* arg0: Mat - 输入的mat格式图片
* arg1: int - 水平腐蚀系数（值越大，水平方向腐蚀越明显）
* arg2: int - 竖直腐蚀系数（值越大，竖直方向腐蚀越明显）
*/
function erodeImageDemo() {
// 封装截图+腐蚀处理函数
function 图色152593() {
var mat = screen.screenShot(900, 1600, 100).getMat();
// 水平+竖直腐蚀系数均为4
opencv.erodeImage(mat, 4, 4);
return mat;
}
// 执行腐蚀并输出结果
let matErode = 图色152593();
printl("图像腐蚀后信息：" + matErode);
matErode = null;
}
// 方法24：filtersEx（cv文件滤镜）
/**
* 功能：加载指定CV文件中的滤镜配置，对图像应用滤镜效果
* 返回值：Mat - 应用滤镜后的图像
* 参数：arg0: String - CV滤镜文件名（如"图色358384.cv"，需确保文件路径正确）
*/
function filtersExDemo() {
// 加载CV文件滤镜并应用
var matFilter = opencv.filtersEx('图色358384.cv');
if (matFilter) {
printl("滤镜应用后图像尺寸：" + matFilter.width() + "x" + matFilter.height());
printl("滤镜图像信息：" + matFilter);
} else {
printl("CV文件滤镜加载失败");
}
matFilter = null;
}
// 方法25：findImageOneKAZE（KAZE算法找图）
/**
* 功能：基于KAZE算法查找图像匹配区域（比SIFT更稳定，无需专利授权）
* 返回值：detect - 单个匹配结果（含坐标、相似度等）
* 参数：
* arg0: Mat - 大图（待搜索的目标图像）
* arg1: Mat - 小图（模板图像）
* arg2: Mat - 结果存储Mat（用于辅助计算，推测）
*/
function findImageOneKAZEDemo() {
printl("开始KAZE算法找图示例");
try {
// 读取本地模板图和目标图（路径需根据实际存储调整）
var templateImg = new image();
templateImg.read("sdcard/auto/1.jpg"); // 小图（模板）
var targetImg = new image();
targetImg.read("sdcard/auto/2.jpg"); // 大图（目标）
// 创建辅助结果Mat
var resultMat = new Mat();
// 执行KAZE找图
var resKAZE = opencv.findImageOneKAZE(targetImg.getMat(), templateImg.getMat(), resultMat);
if (resKAZE) {
printl("KAZE找图结果：" + resKAZE);
} else {
printl("KAZE找图未匹配到目标");
}
// 释放资源
templateImg = null;
targetImg = null;
resultMat = null;
} catch (e) {
printl("KAZE找图错误：" + e);
}
}
// 方法26：HSV颜色变换（HSV通道调整）
/**
* 功能：对图像进行HSV通道颜色变换，调整色相、饱和度、对比度
* 返回值：Mat - 处理后的图像
* 参数：
* arg0: Mat - 输入的mat格式图像
* arg1: int - 色相参数（调整颜色基调）
* arg2: int - 饱和度参数（调整颜色鲜艳程度）
* arg3: int - 对比度参数（调整明暗对比）
*/
function hsvTransformDemo() {
function hsvTransform() {
var mat = screen.screenShot(432, 768, 100).getMat();
// 调整色相17、饱和度17、对比度17
opencv.HSV(mat, 17, 17, 17);
printl("HSV变换后图像：" + mat);
return mat;
}
let hsvResult = hsvTransform();
hsvResult = null;
}
// 方法27：对比度调整（adjustContrast）
/**
* 功能：调整图像对比度，阈值控制强弱（值越大对比度越强）
* 返回值：Mat - 调整后的图像
* 参数：
* arg0: Mat - 输入的mat格式图像
* arg1: double - 对比度阈值（>1增强，<1减弱，1不变）
*/
function adjustContrastDemo() {
function adjustContrast() {
var mat = screen.screenShot(432, 768, 100).getMat();
// 降低对比度（阈值0.5）
opencv.adjustContrast(mat, 0.5);
printl("对比度调整后图像：" + mat);
return mat;
}
let contrastResult = adjustContrast();
contrastResult = null;
}
// 方法28：Bitmap转Mat（bitmapToMat）
/**
* 功能：将Bitmap格式图像转换为OpenCV处理用的Mat格式
* 返回值：Mat - 转换后的图像
* 参数：arg0: Bitmap - 输入的Bitmap格式图像
*/
function bitmapToMatDemo() {
function bitmapToMat() {
// 获取屏幕截图的Bitmap
var screenshot = screen.screenShot(432, 768, 100);
var bmp = screenshot.getBitmap();
// 转换为Mat
var mat = opencv.bitmapToMat(bmp);
printl("Bitmap转Mat结果：" + mat);
return mat;
}
let matFromBmp = bitmapToMat();
matFromBmp = null;
}
// 方法29：颜色过滤（colorFilter）
/**
* 功能：保留设定的目标颜色，过滤其他颜色（适用于固定颜色目标筛选）
* 返回值：Mat - 过滤后的图像
* 参数：
* arg0: Mat - 输入的mat格式图像
* arg1: String[] - 目标颜色数组（格式["#RRGGBB",...]）
* arg2: int - 匹配阈值（允许的颜色偏差，值越大容错性越强）
*/
function colorFilterDemo() {
function colorFilter() {
var mat = screen.screenShot(432, 768, 100).getMat();
// 目标颜色：土黄、金黄等
var colors = ["#615018", "#D9C15D", "#010000", "#F4C51F"];
// 过滤颜色（阈值2，允许轻微偏差）
mat = opencv.colorFilter(mat, colors, 2);
printl("颜色过滤后图像：" + mat);
return mat;
}
let filterResult = colorFilter();
filterResult = null;
}
// 方法30：区域截图（extractRegion）
/**
* 功能：按百分比裁剪图像或保留指定区域（区域外变白）
* 返回值：Mat - 处理后的区域图像
* 参数：
* arg0: Mat - 输入的mat格式图像
* arg1: double[] - 区域范围（[左上角x%,左上角y%,右下角x%,右下角y%]，范围0~1）
* arg2: boolean - 是否裁剪（true=裁剪为区域大小，false=区域外变白保留原图大小）
*/
function extractRegionDemo() {
function extractRegion() {
var mat = screen.screenShot(432, 768, 100).getMat();
// 区域：左上角(3.935%,16.406%)到右下角(53.472%,63.281%)
var region = [0.03935, 0.16406, 0.53472, 0.63281];
// 区域外变白（不裁剪）
opencv.extractRegion(mat, region, false);
printl("区域处理后图像：" + mat);
return mat;
}
let regionResult = extractRegion();
regionResult = null;
}
// 方法31：面积过滤（inArea）
/**
* 功能：保留图像中面积在指定范围内的区域，过滤过小/过大区域
* 返回值：Mat - 过滤后的图像
* 参数：
* arg0: Mat - 输入的mat格式图像
* arg1: double - 最小面积（保留≥该值的区域）
* arg2: double - 最大面积（保留≤该值的区域）
*/
function inAreaDemo() {
function inArea() {
var mat = screen.screenShot(432, 768, 100).getMat();
// 保留面积1~10000的区域
opencv.inArea(mat, 1, 10000);
printl("面积过滤后图像：" + mat);
return mat;
}
let areaResult = inArea();
areaResult = null;
}
// 方法32：边缘提取（Canny）
/**
* 功能：基于Canny算法提取图像边缘（高阈值通常为低阈值2~3倍）
* 返回值：Mat - 边缘提取后的图像
* 参数：
* arg0: Mat - 输入的mat格式图像
* arg1: double - 低阈值（控制弱边缘检测）
* arg2: double - 高阈值（控制强边缘检测，通常为低阈值2~3倍）
*/
function cannyEdgeDemo() {
function cannyEdge() {
var mat = screen.screenShot(432, 768, 100).getMat();
// 低阈值50，高阈值100（符合2倍关系）
opencv.Canny(mat, 50, 100);
printl("边缘提取后图像：" + mat);
return mat;
}
let cannyResult = cannyEdge();
cannyResult = null;
}
// 方法33：OCR识别（OCR）
/**
* 功能：通过训练字库识别指定区域文字，返回识别结果
* 返回值：ocrResult - 含识别文字及位置信息的对象
* 参数：
* arg0: Mat - 输入的mat格式图像
* arg1: String - 字库路径（如"图色976442.ocr"）
* arg2: double - 相似度（0~1，值越高匹配越严格）
* arg3: int - 预期文字数（0表示不限制）
* arg4: double[] - 识别区域（[左,上,右,下]比例，0~1）
*/
function ocrDemo() {
function ocr() {
var mat = screen.screenShot(432, 768, 100).getMat();
// 识别区域：全图
var ocrRegion = [0, 0, 1, 1];
// 调用OCR：字库"图色976442.ocr"，相似度0.8
var ocrRes = opencv.OCR(mat, '图色976442.ocr', 0.8, 0, ocrRegion);
ocrRes ? printl("OCR识别结果：" + ocrRes.getAllString()) : print.err('OCR识别失败');
return ocrRes;
}
let ocrResult = ocr();
ocrResult = null;
}
// 方法34：CV文件OCR（OCREx）
/**
* 功能：通过预定义的CV文件（含字库和区域）进行OCR识别
* 返回值：ocrResult - 含识别结果的对象
* 参数：arg0: String - CV文件路径（如"图色598321.cv"）
*/
function ocrExDemo() {
function ocrEx() {
// 读取CV文件并识别
var ocrExRes = opencv.OCREx('图色598321.cv');
ocrExRes ? printl("CV文件OCR结果：" + ocrExRes.getAllString()) : print.err('CV文件OCR失败');
return ocrExRes;
}
let cvOcrResult = ocrEx();
cvOcrResult = null;
}
// 方法35：图像平滑（Smooth）
/**
* 功能：减少图像噪声、模糊图像（通过滤波和去毛边实现）
* 返回值：Mat - 平滑后的图像
* 参数：
* arg0: Mat - 输入的mat格式图像
* arg1: int - 滤波值（值越大平滑效果越强）
* arg2: int - 去毛边大小（控制边缘平滑程度）
*/
function smoothDemo() {
function smooth() {
var mat = screen.screenShot(432, 768, 100).getMat();
// 滤波值3，去毛边2
var smoothMat = opencv.Smooth(mat, 3, 2);
printl("平滑处理后图像：" + smoothMat);
return smoothMat;
}
let smoothResult = smooth();
smoothResult = null;
}
// 方法36：多点比色（checkColors）
/**
* 功能：验证图像中多个指定坐标的颜色是否符合预期（全匹配返回true）
* 返回值：boolean - 是否全匹配
* 参数：
* arg0: Mat - 输入的mat格式图像
* arg1: String[] - 目标点数组（格式"x,y,#RRGGBB"，如"325,317,#F4C51F"）
* arg2: int - 颜色误差（允许的色值偏差）
* arg3: int - 坐标误差（允许的位置偏差）
* arg4: double - 相似度（0~1，匹配严格程度）
*/
function checkColorsDemo() {
function checkColors() {
var mat = screen.screenShot(900, 1600, 100).getMat();
// 目标点：坐标+颜色
var points = ['325,317,#F4C51F', '357,364,#070200', '336,345,#100500', '356,386,#F4C51F'];
// 颜色误差2，坐标误差5，相似度0.95
var isMatch = opencv.checkColors(mat, points, 2, 5, 0.95);
isMatch ? printl('多点比色成功') : print.err('多点比色失败');
return isMatch;
}
let colorCheckResult = checkColors();
}
// 方法37：CV文件多点比色（checkColorsEx）
/**
* 功能：通过预定义的CV文件（含多点坐标和颜色）验证匹配
* 返回值：boolean - 是否匹配成功
* 参数：arg0: String - CV文件路径（如"图色246814.cv"）
*/
function checkColorsExDemo() {
function checkColorsEx() {
// 基于CV文件验证多点比色
var isExMatch = opencv.checkColorsEx('图色246814.cv');
isExMatch ? printl('CV文件多点比色成功') : printl('CV文件多点比色失败');
return isExMatch;
}
let cvColorCheckResult = checkColorsEx();
}
// 方法38：闭运算（closeImg）
/**
* 功能：先膨胀后腐蚀，用于填充图像小孔、连接邻近区域
* 返回值：Mat - 闭运算处理后的图像
* 参数：
* arg0: Mat - 输入的mat格式图像
* arg1: int - 核大小（值越大效果越强）
*/
function closeImgDemo() {
function closeImg() {
var mat = screen.screenShot(900, 1600, 100).getMat();
// 闭运算：核大小3
opencv.closeImg(mat, 3);
printl("闭运算后图像：" + mat);
return mat;
}
let closeResult = closeImg();
closeResult = null;
}

复制代码

方法1：getcolorNum：获取区域颜色数量 [size=1em]

类别[size=1em]	内容[size=1em]
功能说明[size=1em]	从图像中遍历查找所有的坐标和对应的颜色是否符合并返回找到颜色的数量[size=1em]
函数定义[size=1em]	int getcolorNum(Mat arg0, String[] arg1, double arg2, double[] arg3)[size=1em]
返回值[size=1em]	int[size=1em]
参数[size=1em]	-Mat arg0: mat 格式图片-String[] arg1: 颜色数组，示例['10,9,#123233','9,9,#434323']-double arg2: 相似度-double[] arg3: 区域比例，示例[0,0,1,1][size=1em]
案例[size=1em]	var mat=screen.screenShot(432,768,100).getMat(); var num=opencv.getcolorNum(mat,['#AE5454','#AE5454'],0.90,[0.0799,0.3008,0.9167,0.8242]); printl(num) [size=1em]

方法2：gradientProcessing：计算梯度 [size=1em]

类别[size=1em]	内容[size=1em]
功能说明[size=1em]	计算梯度[size=1em]
函数定义[size=1em]	Mat gradientProcessing(Mat arg0)[size=1em]
返回值[size=1em]	Mat[size=1em]
参数[size=1em]	Mat arg0[size=1em] ：输入的 mat 格式图片[size=1em]
案例[size=1em]	// 梯度处理示例函数function gradientProcessingExample() {printl("开始执行梯度处理示例");// 1. 截取屏幕区域并转换为Mat格式// 使用432x768分辨率，100质量的截图var mat = screen.screenShot(432, 768, 100).getMat();// 验证Mat对象是否成功创建printl("截图成功，Mat尺寸: " + mat.width() + "x" + mat.height());// 2. 调用gradientProcessing方法计算梯度// 根据API文档，该方法接收一个Mat参数并返回处理后的Matvar gradientMat = null;// 执行梯度处理gradientMat = opencv.gradientProcessing(mat);// 输出处理结果printl("梯度处理完成");printl("梯度图像尺寸: " + gradientMat.width() + "x" + gradientMat.height());// 释放原始图像资源mat = null;// 3. 处理结果输出// 输出梯度图像信息printl("梯度图像类型: " + gradientMat.type());// 释放梯度图像资源gradientMat = null;printl("梯度处理示例执行完毕");}// 主函数：运行示例function main() {printl("=== 梯度处理功能示例 ===");// 执行梯度处理示例gradientProcessingExample();printl("=== 示例执行完毕 ===");}// 立即执行主函数main(); [size=1em]

方法3：invertColor：颜色翻转 [size=1em]

类别[size=1em]	内容[size=1em]
功能说明[size=1em]	颜色翻转[size=1em]
函数定义[size=1em]	Mat invertColor(Mat arg0)[size=1em]
返回值[size=1em]	Mat[size=1em]
参数[size=1em]	Mat arg0[size=1em] ：输入的 mat 格式图片[size=1em]
案例[size=1em]	let mat:Mat=图色973264();printl(mat);function 图色973264(){//截屏并转成mat格式var mat=screen.screenShot(900,1600,100).getMat();//颜色翻转opencv.invertColor(mat)return mat;} [size=1em]

方法4：openImg：开运算 [size=1em]

类别[size=1em]	内容[size=1em]
功能说明[size=1em]	开运算[size=1em]
函数定义[size=1em]	Mat openImg(Mat arg0, int arg1)[size=1em]
返回值[size=1em]	Mat[size=1em]
参数[size=1em]	- Mat arg0[size=1em] ：输入图片- int arg1[size=1em] ：核大小[size=1em]
案例[size=1em]	// 开运算功能示例// 该示例演示如何使用OpenCV的openImg函数进行图像开运算操作/** * 开运算函数 * 功能：执行图像开运算操作（先腐蚀后膨胀） * 参数说明： * - Mat arg0: 输入图像矩阵 * - int arg1: 核大小（结构元素大小）- 注意：核大小不能为0 * 返回值：开运算处理后的Mat图像 * * 开运算原理： * 开运算 = 腐蚀 + 膨胀 * 主要用于： * 1. 去除小的噪点和小物体 * 2. 分离物体 * 3. 平滑边界 * 4. 保留物体的整体形状和大小 */// 示例1：基本开运算示例 - 经过测试可正常工作function basicOpenImgExample() {printl("开始基本开运算示例");try {// 截取屏幕图像并转换为Mat格式var mat = screen.screenShot(432, 768, 100).getMat();printl("截屏成功，原始图像尺寸: " + mat.width() + "x" + mat.height());// 调用开运算函数，核大小为3（有效参数）var openedMat = opencv.openImg(mat, 3);printl("开运算完成，核大小: 3");// 输出结果信息printl("开运算结果Mat尺寸: " + openedMat.width() + "x" + openedMat.height());printl(openedMat);// 释放资源mat = null;if (openedMat != null) {openedMat = null;}printl("基本开运算示例完成");returntrue;} catch (e) {printl("执行开运算时发生错误: " + String(e));returnfalse;}}// 示例2：简化的核大小对比示例（避免使用核大小0）function simpleKernelCompareExample() {printl("开始简化的核大小对比示例");try {// 1. 获取屏幕图像var originalMat = screen.screenShot(432, 768, 100).getMat();printl("原始图像尺寸: " + originalMat.width() + "x" + originalMat.height());// 2. 使用有效核大小进行开运算（避免使用0）var kernelSizes = [1, 3, 5];for (var i = 0; i < kernelSizes.length; i++) {var kernelSize = kernelSizes;printl("正在测试核大小: " + kernelSize);try {var openedMat = opencv.openImg(originalMat, kernelSize);printl("核大小 " + kernelSize + " 的开运算完成");printl(openedMat);// 释放资源openedMat = null;} catch (e) {printl("核大小 " + kernelSize + " 处理失败: " + String(e));}}// 释放资源originalMat = null;printl("简化的核大小对比示例完成");returntrue;} catch (e) {printl("执行开运算对比时发生错误: " + String(e));returnfalse;}}// 封装函数式示例（简洁版）- 修复版function 开运算处理(mat, kernelSize) {// 验证参数有效性if (kernelSize <= 0) {printl("警告：核大小必须大于0，已自动调整为1");kernelSize = 1;}// 执行开运算return opencv.openImg(mat, kernelSize);}// 使用封装函数的示例 - 修复版function encapsulatedOpenImgExample() {printl("开始使用封装函数的开运算示例");try {// 获取图像var mat = screen.screenShot(432, 768, 100).getMat();// 使用有效核大小3代替0var resultMat = 开运算处理(mat, 3);printl("封装函数开运算结果:");printl(resultMat);// 释放资源mat = null;resultMat = null;printl("封装函数开运算示例完成");returntrue;} catch (e) {printl("执行封装函数开运算时发生错误: " + String(e));returnfalse;}}// 主函数：运行有效的开运算示例function runAllOpenImgExamples() {printl("\n===== 开始运行开运算示例 =====\n");// 运行基本示例basicOpenImgExample();printl("\n------------------------------------\n");// 运行简化的核大小对比示例simpleKernelCompareExample();printl("\n------------------------------------\n");// 运行修复后的封装函数示例encapsulatedOpenImgExample();printl("\n===== 开运算示例运行完成 =====\n");}// 运行示例runAllOpenImgExamples(); [size=1em]

方法5：removeSmallObjects：去杂点 [size=1em]

项目[size=1em]	说明[size=1em]
函数功能[size=1em]	去杂点[size=1em]
函数声明[size=1em]	Mat removeSmallObjects(Mat arg0, double arg1)[size=1em]
返回值[size=1em]	Mat[size=1em]
参数 1[size=1em]	Mat arg0[size=1em] : mat 图片[size=1em]
参数 2[size=1em]	double arg1[size=1em] : 面积小于（指定面积阈值，面积小于该值的对象会被移除）[size=1em]
案例[size=1em]	// removeSmallObjects函数实用示例 - 去杂点功能/** * 使用removeSmallObjects函数去除图像中的小杂点 * @returns 处理后的Mat对象 */ function 去除图像杂点() { // 1. 获取屏幕截图并转换为Mat对象 var mat = screen.screenShot(900, 1600, 100).getMat(); printl("已获取屏幕截图"); // 2. 将彩色图像转换为灰度图像 // 根据错误信息，removeSmallObjects函数要求输入图像必须是CV_8UC1格式(灰度图) var grayMat = new Mat(); opencv.cvtColor(mat, grayMat, opencv.COLOR_BGR2GRAY); printl(grayMat); // 3. 使用removeSmallObjects函数去除小杂点 // 参数2设置为100，表示移除面积小于100的对象 var resultMat = opencv.removeSmallObjects(grayMat, 100); printl(resultMat); // 4. 返回处理后的图像 return resultMat; } // 主程序调用示例 function 主程序() { try { // 调用去杂点函数 var processedMat = 去除图像杂点(); // 显示处理结果 printl(processedMat); printl("Mat尺寸: " + processedMat.width() + "x" + processedMat.height()); // 如果需要保存结果到文件 // opencv.imwrite("/sdcard/处理后图像.jpg", processedMat); return processedMat; } catch (e) { printl("处理过程中出错: " + e); returnnull; } } // 运行主程序主程序(); [size=1em]

方法7：shapeSplit：分隔提取 [size=1em]

项目[size=1em]	说明[size=1em]
函数功能[size=1em]	先通过滤镜把图片处理成黑白图，然后提取黑色图形（分隔提取）[size=1em]
函数声明[size=1em]	detect[] shapeSplit(Mat arg0, int arg1, int arg2)[size=1em]
返回值[size=1em]	detect[][size=1em]
参数 1[size=1em]	Mat arg0[size=1em] : mat 格式图片[size=1em]
参数 2[size=1em]	int arg1[size=1em] : 结果排序（0 起点 Y 坐标排序；1 起点 X 坐标排序；2 面积排序）[size=1em]
参数 3[size=1em]	int arg2[size=1em] : 排序规则（0 正序；1 倒序）[size=1em]
案例[size=1em]	var result:detect[]=图色141387();if(result!=null){result[0].click();}else{print.err('查找图色141387失败')}function 图色141387(){//截屏并转成mat格式var mat=screen.screenShot(900,1600,100).getMat();//分隔提取return opencv.shapeSplit(mat,0,0)} [size=1em]

方法8：shapeSplitEx：cv 文件分隔提取 [size=1em]

项目[size=1em]	说明[size=1em]
函数功能[size=1em]	cv 文件分隔提取[size=1em]
函数声明[size=1em]	detect[] shapeSplitEx(String arg0)[size=1em]
返回值[size=1em]	detect[][size=1em]
参数[size=1em]	String arg0[size=1em] : cv 文件名[size=1em]
案例[size=1em]	//返回目标数组[size=1em] var detects=opencv.shapeSplitEx('图色710035.cv');[size=1em] if(detects!=null){[size=1em] printl(detects);[size=1em] detects[0].click();[size=1em] }[size=1em]

[size=1em]
方法9：templateMatch：模板匹配 [size=1em]

项目[size=1em]	说明[size=1em]
函数功能[size=1em]	通过多模板匹配定位目标，返回值是一个目标数组（模板匹配）[size=1em]
函数声明[size=1em]	detect[] templateMatch(Mat arg0, String[] arg1, double arg2, double[] arg3, boolean arg4)[size=1em]
返回值[size=1em]	detect[][size=1em]
参数 1[size=1em]	Mat arg0[size=1em] : 图片[size=1em]
参数 2[size=1em]	String[] arg1[size=1em] : 模板图片 base64 数组[size=1em]
参数 3[size=1em]	double arg2[size=1em] : 相似度阈值[size=1em]
参数 4[size=1em]	double[] arg3[size=1em] : 百分比区域[size=1em]
参数 5[size=1em]	boolean arg4[size=1em] : 只返回最优值[size=1em]
案例[size=1em]	printl('图色419496');[size=1em] var detects = auto.findImages([64位图], 0.8, 5000, 1, [0,0,1,1]);[size=1em] if(detects!=null){[size=1em] detects[0].click();[size=1em] }[size=1em]

[size=1em]
方法10：threshold：二值化 [size=1em]

项目[size=1em]	说明[size=1em]
函数功能[size=1em]	阈值区间内的转成黑色，阈值区间外的转成白色（二值化）[size=1em]
函数声明[size=1em]	Mat threshold(Mat arg0, int arg1, int arg2)[size=1em]
返回值[size=1em]	Mat[size=1em]
参数 1[size=1em]	Mat arg0[size=1em] : 要处理的图片[size=1em]
参数 2[size=1em]	int arg1[size=1em] : 最小阈值[size=1em]
参数 3[size=1em]	int arg2[size=1em] : 最大阈值[size=1em]
案例[size=1em]	let mat:Mat=图色718883();printl(mat);function 图色718883(){//截屏并转成mat格式var mat=screen.screenShot(900,1600,100).getMat();//二值化opencv.threshold(mat,53,150);return mat;} [size=1em]

[size=1em]
方法11：toGray：转灰度图 [size=1em]

项目[size=1em]	说明[size=1em]
函数功能[size=1em]	转灰度图[size=1em]
函数声明[size=1em]	Mat toGray(Mat arg0)[size=1em]
返回值[size=1em]	Mat[size=1em]
参数[size=1em]	Mat arg0[size=1em] : mat 格式图像[size=1em]
案例[size=1em]	[size=1em] let mat:Mat=图色676235();[size=1em] printl(mat);[size=1em] [size=1em] [size=1em] [size=1em] function 图色676235(){[size=1em] //截屏并转成mat格式[size=1em] var mat=screen.screenShot(900,1600,100).getMat();[size=1em] [size=1em] //转灰度图[size=1em] opencv.toGray(mat);[size=1em] return mat;[size=1em] [size=1em] }[size=1em]

方法12：toHSV：转 HSV[size=1em]

项目[size=1em]	说明[size=1em]
函数功能[size=1em]	转 HSV[size=1em]
函数声明[size=1em]	Mat toHSV(Mat arg0)[size=1em]
返回值[size=1em]	Mat[size=1em]
参数[size=1em]	Mat arg0[size=1em] : mat 格式图像[size=1em]
案例[size=1em]	[size=1em] let mat:Mat=图色136443();[size=1em] printl(mat);[size=1em] [size=1em] [size=1em] [size=1em] function 图色136443(){[size=1em] //截屏并转成mat格式[size=1em] var mat=screen.screenShot(900,1600,100).getMat();[size=1em] [size=1em] //HSV颜色变换[size=1em] opencv.HSV(mat,0,0,0)[size=1em] return mat;[size=1em] [size=1em] }[size=1em]

方法13：mat.ToBase64()方法[size=1em]

项目[size=1em]	说明[size=1em]
函数功能[size=1em]	转 base64 字符串[size=1em]
函数声明[size=1em]	String ToBase64()[size=1em]
返回值[size=1em]	String[size=1em]
参数[size=1em]	无[size=1em]
案例[size=1em]	/** * Mat对象toString和ToBase64方法使用示例 * 演示如何使用Mat对象的toString()和ToBase64()方法 */// 主函数function main() {printl("=== Mat toString和ToBase64方法示例 ===");// 获取屏幕截图并转换为Mat对象var mat = screen.screenShot(900, 1600, 100).getMat();printl("已获取Mat对象，尺寸: " + mat.width() + "x" + mat.height());// 使用toString()方法获取字符串表示var strResult = mat.toString();printl("Mat对象字符串表示: " + strResult);// 使用ToBase64()方法获取Base64编码var base64Result = mat.ToBase64();printl("Mat对象Base64编码: " + base64Result);// 验证结果是否有效printl("成功获取Mat对象的字符串和Base64表示");printl("=== 示例执行完毕 ===");}// 运行主程序main(); [size=1em]

[size=1em]

[24小时收录超级好的网站] AIWROK软件安卓总结图像视觉处理[opencv]方法

相关帖子