图像操作API

图像操作API为自动化流程提供了图片读写、处理以及比较的功能，而这些功能都是基于Image对象实现的。

`Image`对象

引用方式

在脚本顶部加入下面的脚本引用Image类

JavaScript

Python

const { Image } = require('leanpro.visual');

from leanproAuto import Image

Image对象提供以下方法和属性：

方法名	描述
width	图像宽度
height	图像高度
clip	按指定矩形区域裁剪图像，返回新的 `Image` 实例。
drawImage	在当前图像上绘制另一张图像，并返回新的 `Image` 实例。
filterColor	对图像应用颜色过滤器，支持单色或多色，返回处理后的图像。
getData	获取图像数据，支持 `Buffer` 或 Base64 编码字符串格式。
resize	按指定宽高缩放图像，返回缩放后的图像。
save	将图像保存到指定文件路径。
fromData	从二进制数据或字符串创建新的 `Image` 实例（静态方法）。
fromFile	从文件路径加载图像并创建新的 `Image` 实例（静态方法）。
imageEqual	比较两张图像是否相等，支持像素容差、区域忽略等选项（静态方法）。
imageCompare	对比两张图像并生成差异结果，返回对比分析数据（静态方法）。

类型定义

Image对象的内容比较多，它同时提供了成员属性、成员方法和静态方法三类内容，使得大部分图像操作都是在Image对象上实现的。

Image对象定义如下：

JavaScript

Python

class Image {
    width: number;
    height: number;
    clip(rect: {x: number, y: number, width: number, height: number}): Image;
    drawImage(image: Image, x: number, y: number): Image;
    filterColor(color: Colors | Colors[]): Promise<Image>;
    getData(option?: {encoding: 'base64' | null}): Promise<Buffer | string>;
    resize(width: number, height: number): Promise<Image>;
    save(filePath: string): Promise<void>;

    static fromData(bufferOrString: Buffer | string): Promise<Image>;
    static fromFile(filePath: string): Promise<Image>;
    static imageEqual(image1: Buffer | string | Image,
        image2: Buffer | string | Image, 
        options?: CompareOptions,
        compareInfo?: ImageCompareInfo): Promise<boolean>;
    static imageCompare(image1: Buffer | string | Image,
        image2: Buffer | string | Image, 
        options?: CompareOptions): Promise<ImageCompareResult>
}

class Image:
  def width(self) -> int:
  def height(self) -> int:
  def clip(self, rect: Rect) -> "Image":
  def drawImage(self, overlay_img: "Image", position=(0,0)) -> "Image":
  def getData(self, option: Optional[Any]) -> bytes:
  def save(self, filePath: str) -> None:
    
  @staticmethod
  def fromData(bytes: bytearray) -> "Image":
  @staticmethod
  def fromFile(filePath: str) -> "Image":
  @staticmethod
  def imageEqual(self, image1: Union[str, bytearray], image2: Union[str, bytearray], options: Optional[any]=None, compareInfo: Optional[any]=None) -> "bool":
  @staticmethod
  def imageCompare(self, image1: Union[str, bytearray], image2: Union[str, bytearray], options: Optional[any]=None) -> ImageCompareResult:

常见用法

Image对象最常见的一个用法就是读取两张图片并进行比较，比较的流程如下：

用Image.fromData()或Image.fromFile()分别读取两张图片生成各自的Image实例；
用Image.imageCompare()比较两个Image对象的差异。脚本如下：

JavaScript

Python

const { Image } = require('leanpro.visual');
const fs = require('fs');
(async function() {
    let buf1 = fs.readFileSync('c:/temp/image1.png');
    let image1 = await Image.fromData(buf1);
    console.log(`image1图片的宽为${image1.width}, 高为${image1.height}`);
    
    let image2 = await Image.fromFile('c:/temp/image2.png');
    console.log(`image2图片的宽为${image2.width}, 高为${image2.height}`);
})()

from leanproAuto import Image

buf1 = None
with open('c:/temp/image1.png', "rb") as f:
    buf1 = f.read()
image1 = Image.fromData(buf1)
print(f"image1图片的宽为{image1.width}, 高为{image1.height}")

image2 = Image.fromFile('c:/temp/image2.png')
print(f"image2图片的宽为{image2.width}, 高为{image2.height}")

Image.fromData()方法可以传入Buffer、base64字符串生成Image实例，具体查看Image.fromData()；

而Image.fromFile()方法可以传入一个图片文件的路径来生成Image实例，具体查看Image.fromFile()。

上面例子分别从Buffer和文件中读取图片数据并打印宽度和高度。

注意：无法直接通过new Image()的方式创建对象，需要通过fromData或者fromFile来生成Image实例。另外Image对象现只支持PNG格式的图片。

实例属性

width

表示图片的宽度，为一个数字类型。

JavaScript

Python

const width = image.width;
assert.equal(width, 200);

assert image1.width() == 200

height

表示图片的高度，为一个数字类型。

JavaScript

Python

const height = image.height;
assert.equal(height, 200);

assert image1.height() == 200

实例方法

clip(rect: Rect)

按指定矩形区域裁剪图像。

参数

rect: Rect 类型。指定裁剪的矩形区域，结构为 {x: number, y: number, width: number, height: number}。详见 Rect对象。

返回值

返回一个新的 Image 实例，表示裁剪后的图像。
如果传入数据不合法（如裁剪后的宽度或高度为 0），则返回 null。

示例代码

JavaScript

Python

const clipImage = image.clip({ x: 0, y: 0, width: 200, height: 200 });
assert.equal(clipImage.width, 200);
assert.equal(clipImage.height, 200);

clipImage = image.clip({"x": 0, "y": 0, "width": 200, "height": 200})

assert clipImage.width() == 200
assert clipImage.height() == 200

resize(width: number, height: number)

按指定宽高缩放图像。如果缩放比例与原图不一致，图像可能会出现拉伸扭曲。

注：本方法目前仅在 JavaScript 中支持。

参数

width: number 类型。新的目标宽度（像素）。
height: number 类型。新的目标高度（像素）。

返回值

异步返回一个 Promise<Image>，其 resolve 的值为缩放后的新 Image 对象实例。

示例代码

JavaScript

const resizeImage = await image.resize(200, 200);
assert.equal(resizeImage.width, 200);
assert.equal(resizeImage.height, 200);

filterColor(color: Colors | Colors[])

对图像应用颜色过滤器，提取指定的一种或多种颜色，过滤掉其他所有颜色并返回新的图像。

注：本方法目前仅在 JavaScript 中支持。

参数

color: Colors | Colors[] 类型。指定的目标过滤颜色或颜色数组。支持的颜色枚举及取值如下：

JavaScript

export enum Colors {
    black = 'black',
    grey = 'grey',
    white = 'white',
    red = 'red',
    orange = 'orange',
    yellow = 'yellow',
    green = 'green',
    cyan = 'cyan', //青色
    blue = 'blue',
    purple = 'purple'
  }

返回值

异步返回一个 Promise<Image>，其 resolve 的值为仅包含目标颜色的新 Image 对象实例。

示例代码

JavaScript

let image = await Image.fromFile(filePath);
let imageOnlyRed = await image.filterColor("red"); // 仅保留红色
let imageOnlyYellowGreen = await image.filterColor(["yellow", "green"]); // 仅保留黄色跟绿色

drawImage(image: Image, x: number, y: number)

在当前图像上绘制另一张图像。

参数

image: Image 类型。需要覆盖绘制的目标图像。
x: number 类型（Python 中以 position 参数形式的 (x, y) 元组传入）。绘制的起始 X 坐标位置（相对于当前图的左上角）。
y: number 类型（Python 中以 position 参数形式 of the (x, y) 元组传入）。绘制的起始 Y 坐标位置（相对于当前图的左上角）。

返回值

返回一个新的 Image 实例，表示合并绘制后的图像。

示例代码

以下示例展示了截取两个按钮图像、裁剪边缘、然后横向拼接 of the流程（间隔 5 像素）：

JavaScript

Python

let screenshot1 = await model.getButton("Five").takeScreenshot();
let screenshot2 = await model.getButton("Six").takeScreenshot();
let image1 = await Image.fromData(screenshot1);
let image2 = await Image.fromData(screenshot2);

image1 = image1.clip({ x: 10, y: 10, width: image1.width - 20, height: image1.height - 20 });
image2 = image2.clip({ x: 10, y: 10, width: image2.width - 20, height: image2.height - 20 });

let combinedImage = image1.drawImage(image2, image1.width + 5, 0);

# 获取截图
screenshot1 = model.getButton("Five").takeScreenshot()
screenshot2 = model.getButton("Six").takeScreenshot()

# 构建 Image 对象
image1 = Image.fromData(screenshot1)
image2 = Image.fromData(screenshot2)

# 裁剪 (去掉边框 10px)
image1 = image1.clip({
    "x": 10,
    "y": 10,
    "width": image1.width() - 20,
    "height": image1.height() - 20
})
image2 = image2.clip({
    "x": 10,
    "y": 10,
    "width": image2.width() - 20,
    "height": image2.height() - 20
})

# 合成：将 image2 绘制到 image1 右边，间隔 5px
combined_image = image1.drawImage(image2, position=(image1.width() + 5, 0))

其他排列场景：

上下排列：

JavaScript

let combinedImage = image1.drawImage(image2, 0, image1.height + 5);

Python

combined_image = image1.drawImage(image2, position=(0, image1.height() + 5))

反向（左侧）拼接：可以通过传入负的坐标值实现。例如，在 image1 的左侧绘制 image2：

JavaScript

let combinedImage = image1.drawImage(image2, -(image1.width + 5), 0);

Python

combined_image = image1.drawImage(image2, position=(-(image1.width() + 5), 0))

getData(option?: {encoding: 'base64' | null})

获取图像的内容数据，支持返回二进制 Buffer 或 Base64 编码的字符串形式。

参数

option: object 类型（可选）。
- encoding: 编码方式。设置为 'base64' 则以 Base64 字符串返回，默认或设为 null 则返回二进制 Buffer 数据（Python 中以 bytes 字节流返回）。

返回值

异步返回 Promise<Buffer | string>，其 resolve 的值为图像数据（在 Python 中同步返回 bytes 数据）。

示例代码

一个常见的用法是读取本地图片并作为附件添加到测试报告中：

JavaScript

Python

let image1 = await Image.fromFile('c:/temp/image1.png');
let image1Buffer = await image1.getData();
this.attach(image1Buffer, 'image/png');

image1 = Image.fromFile('c:/temp/image1.png')
image1_buffer = image1.getData()
request.attach(image1_buffer, 'image/png')

save(filePath: string)

将当前图像保存到指定的本地文件路径。

参数

filePath: string 类型。保存的目标文件路径，支持相对路径或绝对路径（仅限保存为 .png 格式）。

返回值

异步返回 Promise<void>，无实际返回值（在 Python 中为同步执行且无返回值）。

示例代码

JavaScript

Python

const imagePath = path.join(process.cwd(), './testing-cache', './image.png');
await image.save(imagePath);

image.save(image_path)

静态方法

Image对象静态方法，即不需要进行实例化，引用之后就可以通过Image.[静态方法名]()的方式调用。包含了Image对象的构造方法（如Image.fromData()和Image.fromFile()）、比较两张图片差别的方法（如Image.imageCompare()和Image.imageEqual()等）。

Image.fromData(bufferOrString: Buffer | string)

从二进制 Buffer 数据或 Base64 编码的字符串中加载并创建新的 Image 实例。

参数

bufferOrString: Buffer | string 类型（Python 中为 bytes 类型）。图片的二进制数据或 Base64 字符串。

返回值

异步返回 Promise<Image>，其 resolve 的值为创建的 Image 对象实例（在 Python 中同步返回 Image 实例）。

示例代码

JavaScript

Python

const { Image } = require('leanpro.visual');

const buffer = Buffer.from('image-data');
Image.fromData(buffer).then(image => {
  console.log(`已载入图像宽度: ${image.width}`);
});

from leanproAuto import Image

image_path = "image.png"
with open(image_path, "rb") as f:
  data = f.read()
image1 = Image.fromData(data)

Image.fromFile(filePath: string)

从指定的文件路径加载图像并创建新的 Image 实例。该方法目前仅支持 PNG 格式的图片文件，如需处理其他格式，请先将其转换为 PNG。

参数

filePath: string 类型。图片文件的本地路径（绝对或相对路径）。

返回值

异步返回 Promise<Image>，其 resolve 的值为创建的 Image 对象实例（在 Python 中同步返回 Image 实例）。
如果传入非 PNG 文件或文件路径不存在，将无法成功解析并创建图像对象。

示例代码

JavaScript

Python

const { Image } = require('leanpro.visual');

const filePath = '/path/to/image.png';   // 仅支持 PNG
Image.fromFile(filePath).then(image => {
  console.log(`已载入图像高度: ${image.height}`);
});

from leanproAuto import Image

image_path = "image.png"   # 仅支持 PNG
image1 = Image.fromFile(image_path)

如需处理其他格式（如 JPG、BMP 等），请先将文件转换为 PNG 格式后再调用 fromFile。

图片比较方法

在自动化过程中，为了验证结果的正确性，可以通过验证结果图片和期望图片的差异来判断执行结果是否正确。

目前图片判断提供了两种方式：

Image.imageEqual(): 比较图片差异，返回布尔值。
Image.imageCompare(): 比较图片差异，返回比较结果对象。这种方式能够取得将两幅图对应像素相减产生的差异结果图片，将差异点用色彩标出来。非常适合将差异图片显示在报表中，可以由人工二次判断是否正确。

由于操作系统、分辨率、颜色设置都可能影响图片的显示，同样的控件在不同的环境设置下可能显示不同，所以在比较截屏图片时，一般会设置比较容忍度。在容忍度阈值内认为两幅图片是相同的。容忍度有如下的分类：

颜色容忍度：针对两幅图片的两个对应像素点，如果它们的RGB颜色按照特定的距离算法在一定的范围内认为是相同的。
像素容忍度：针对两幅图整体而言，如果不同的像素点数量在一定的范围内，则认为两幅图是相同的。像素容忍度还可以根据百分比来设定，即不同的点占图片所有像素的百分比。

Image.imageEqual(image1, image2, options?, compareInfo?)

比较两张图像是否相同，返回一个表示比较结果的布尔值。此方法支持像素容差、区域忽略以及自动缩放等高级比较选项，适用于在自动化测试中快速验证图像一致性。若需获取展示差异位置的结果图像，请使用 imageCompare 方法。

参数

image1: Buffer | string | Image 类型。对比的第一张图片。支持传入图片文件的二进制 Buffer 数据、Base64 编码的字符串，或已加载的 Image 对象实例。
image2: Buffer | string | Image 类型。对比的第二张图片。支持的传入类型与 image1 相同。
options: CompareOptions 类型（可选）。用于指定图片比较的容差和匹配参数。其结构定义如下：
JavaScript
```
interface CompareOptions {
    colorTolerance?: number,        // 颜色容忍度，默认值为 0.1
    pixelNumberTolerance?: number,  // 像素数量容忍度，无默认值
    pixelPercentTolerance?: number, // 像素百分比容忍度，默认值为 1（表示 1%）
    ignoreExtraPart?: boolean,      // 是否忽略非重叠部分，默认值为 false
    auto?: boolean,                 // 是否自动识别缩放，默认值为 false
    masks?: Masks | Rect[] | string // 遮罩配置，用于在图像比对时忽略指定区域
  }
```
参数详细说明：
- colorTolerance：颜色容忍度，取值范围为 0 到 1，缺省为 0.1。一般无需修改。
- pixelNumberTolerance：允许出现差异的绝对像素数量。若未设置，则仅以百分比容忍度为准。
- pixelPercentTolerance：允许出现差异的像素占总像素的百分比，缺省为 1（即 1%）。例如，两幅图片各有 10000 像素，若允许最多 150 个像素不同，则可设置为 1.5。
- ignoreExtraPart：是否忽略超出或非重叠的部分。若设为 false（默认值），不同尺寸的图片按左上角对齐，超出的非重叠部分会被判定为差异像素；若设为 true，则直接忽略非重叠区域。
- auto：是否根据图像特征自动识别两幅图片并缩放到一致比例进行比较。若设为 true，会默认适应到较小尺寸图片的比例。
Warning
注意：auto 选项不适用于比较包含文本内容的图片。由于系统渲染文字时的差异，文字在不同缩放比例下的渲染效果并非简单的等比例缩放，在此情况下，开启 auto 可能会导致不准确的比较结果。
- masks：遮罩配置，用于在图像比对时忽略指定区域（坐标相对于被比对图像的左上角）。支持以下三种参数形式：
  - 组合形式 (配置对象)：同时指定 regions 和 maskImage。例如 { regions: [[390, 20, 54, 80]], maskImage: "C:/mask.png" }。
    - regions：Rect[]，需要忽略的矩形区域坐标数组。每个矩形区域由 [x, y, width, height] 表示。
    - maskImage：string，遮罩图片路径。要求白色背景，黑色区域用于遮罩（即黑色区域对应的部分在图像比对时被忽略）。
  - 仅 regions 形式：只传入矩形区域坐标数组。例如 [[390, 20, 54, 80], [230, 20, 54, 80]]。
  - 仅 maskImage 形式：只传入遮罩图片路径。例如 "C:/mask.png"。
- 参数判定逻辑：当 pixelNumberTolerance 和 pixelPercentTolerance 中的任意一项超出了设定值（或默认值）时，比较将返回 false。若只需使用其中一个设定，可将另一个设为极大值（例如将 pixelPercentTolerance 设为 100 以仅根据绝对像素数判定）。

compareInfo: ImageCompareInfo 类型（可选，输出参数）。用于接收详细的图片对比数据（如尺寸信息、差异像素数量及百分比）。使用时，需传入一个空对象（如 {}），方法在执行完毕后会向该对象中自动填充如下结构的数据：

JavaScript

interface ImageCompareInfo {
    image1: { width: number, height: number }, // image1 的尺寸信息
    image2: { width: number, height: number }, // image2 的尺寸信息
    diffPixels: number,                        // 不同的像素点绝对数量
    diffPercentage: number                     // 不同像素点占总像素的百分比
  }

返回值

异步返回 Promise<boolean>，其 resolve 的值为一个布尔值：
- 返回 true，表示两张图片在容忍度范围内相同；
- 返回 false，表示两张图片存在超出容忍度范围的差异。
- （在 Python 中同步执行并返回 bool 值）。

示例代码

以下代码示例展示了如何从本地加载两幅图片进行对比，并传入配置参数以忽略未重叠部分。如果不同的像素点超过 300 个，则判定两图不同，并输出 compareInfo 中的详细数据。

JavaScript

Python

const { Image } = require('leanpro.visual');
const path = require('path');

(async function() {
    try {
        let pngSource = await Image.fromFile(path.join(__dirname, '../source.png'));
        let pngTarget = await Image.fromFile(path.join(__dirname, '../target.png'));

        let compareInfo = {};
        let isEqual = await Image.imageEqual(
            pngSource,
            pngTarget, 
            { 
                pixelNumberTolerance: 300, 
                ignoreExtraPart: true, 
                auto: true,
                masks: { regions: [[390, 20, 54, 80], [230, 20, 54, 80]], maskImage: "C:/mask.png" }
            },
            compareInfo
        );
        
        console.log('是否相等？', isEqual);
        console.log('自动填充的 compareInfo 数据：', JSON.stringify(compareInfo, null, 2));
    } catch(err) {
        console.error('出错：', err);
    }
})();

import os
import json
from leanproAuto import Image

try:
    # 构造文件路径
    base_dir = os.path.dirname(__file__)
    png_source = Image.fromFile(os.path.join(base_dir, "../source.png"))
    png_target = Image.fromFile(os.path.join(base_dir, "../target.png"))

    # 传递对比参数
    options = {
        "pixelNumberTolerance": 300,
        "ignoreExtraPart": True,
        "auto": True,
        "masks": {
            "regions": [[390, 20, 54, 80], [230, 20, 54, 80]],
            "maskImage": "C:/mask.png"
        }
    }

    compare_info = {}
    is_equal = Image.imageEqual(png_source, png_target, options, compare_info)

    print("是否相等？", is_equal)
    print("自动填充的 compareInfo 数据：")
    print(json.dumps(compare_info, indent=2, ensure_ascii=False))

except Exception as err:
    print("出错：", err)

控制台输出示例

如果两张图片差异超过阈值，返回 false，同时输出的 compareInfo 数据如下：

是否相等？ false
自动填充的 compareInfo 数据： {
  "image1": {
    "width": 375,
    "height": 266
  },
  "image2": {
    "width": 402,
    "height": 224
  },
  "diffPixels": 3502,
  "diffPercentage": 3.3100814760203408
}

Image.imageCompare(image1, image2, options?)

对两张图像进行比较，并生成标示了差异区域的差分图像和详细统计数据的分析结果（静态方法）。

如果您除了获取对比是否相等的结论外，还需要获取显示具体差异位置的结果图像，请使用此 API。

参数

image1: Buffer | string | Image 类型。对比的第一张图片。
image2: Buffer | string | Image 类型。对比的第二张图片。
options: CompareOptions 类型（可选）。对比参数配置，与 imageEqual 的 options 完全相同。
注意：ignoreExtraPart 选项将直接影响差异图像的生成：
- 设为 false（默认）时，两幅图片的非重叠超出的部分会被标为红色高亮。
- 设为 true 时，非重叠的超出部分将不会被作为差异进行红色高亮处理。

返回值

Node.js 中返回值是名为 ImageCompareResult 的结构，Python 中返回值为一个字典（dict）：

JavaScript

Python

interface ImageCompareResult {
  equal: boolean,
  info: ImageCompareInfo,
  diffImage: Image
}

{
  "equal": bool,
  "info": { ... },        # ImageCompareInfo，同 imageEqual 中的 compareInfo
  "diffImage": "<base64 字符串>"
}

其中:

equal 表示是否根据容忍度设置认为图片相同。
info 的结构与 imageEqual 的 compareInfo 结构相同，包括像素尺寸，有多少点不同，不同的点的百分比等。
diffImage 是返回的差分图片的Image对象，相同的像素点以缺省白色表示，不同的点显示为红色。图像中原有的图案会以浅色显示在目标图片中，方便定位差异部分所在的位置。

这两个图片比较 API 中，imageEqual 是 imageCompare 的封装，为了更直观地返回两个图片是否相等的判断结果。如果只想知道是否相等就用 imageEqual，如果除了是否相等外，还想知道更详细的信息或需要差分图像，就用 imageCompare。

示例代码

以下代码演示了如何比较两张图片，打印它们的详细差异信息，并将生成的差异差分图像保存到本地的 diff.png 文件中：

JavaScript

Python

const { Image } = require('leanpro.visual');
const fs = require('fs');

(async function() {
  try {
    let pngSource = await Image.fromFile(__dirname + '/image1.png');
    let pngTarget = await Image.fromFile(__dirname + '/image2.png');

    let result = await Image.imageCompare(
      pngSource,
      pngTarget,
      { pixelNumberTolerance: 300, auto: true, masks: "C:/mask.png" }
    );

    let diffImage = result.diffImage;
    console.log('resultMeta', JSON.stringify(result.info, null, 2));

    let imageData = await diffImage.getData();
    fs.writeFileSync(__dirname + '/diff.png', imageData);
  } catch(err) {
    console.log(err);
  }
})();

import os
import json
import base64
from leanproAuto import Image

try:
    base_dir = os.path.dirname(__file__)

    # 读取两张图片
    png_source = Image.fromFile(os.path.join(base_dir, "image1.png"))
    png_target = Image.fromFile(os.path.join(base_dir, "image2.png"))

    # 调用比较方法
    result = Image.imageCompare(
        png_source,
        png_target,
        {"pixelNumberTolerance": 300, "auto": True, "masks": "C:/mask.png"}
    )

    # 打印对比信息
    print("resultMeta", json.dumps(result["info"], indent=2, ensure_ascii=False))

    # 获取 diff 图像的 base64 数据并保存为 PNG 文件
    diff_b64 = result["diffImage"]
    diff_bytes = base64.b64decode(diff_b64)
    with open(os.path.join(base_dir, "diff.png"), "wb") as f:
        f.write(diff_bytes)

except Exception as err:
    print("出错：", err)

此代码比较两幅图片，打印差异信息，并将差分图像保存为"diff.png"文件。

假如我们有下面两幅图片：

image1 (375 * 266)	image2 (402 * 224)

根据参数的不同，可以生成下面的差分图片：

ignoreExtraPart = true	ignoreExtraPart = false

左边是ignoreExtraPart = true的情况，超出部分也标记为红色，右边是ignoreExtraPart = false，忽略了超出部分。

控件与模型图片比较

Windows自动化中一个常见的场景是，将运行时控件的截屏与模型中的保存的对象截屏相比较。这可以通过调用测试对象的modelImage方法获得测试对象的截屏png图片，以base64字符串数据返回。如果模型中该对象没有对应的截屏图片，则返回null。

下面的样例从对象模型中获取按钮对象，同时拿到控件截屏和模型中的截屏，并做对比，将对比信息打印出来，同时将差分图片保存到目录中。

JavaScript

Python

const { Image } = require('leanpro.visual');
const { WinAuto } = require('leanpro.win');
const fs = require('fs');

// 加载对象模型（tmodel 文件路径请按实际情况填写）
const model = WinAuto.loadModel(__dirname + "\\test.tmodel");

(async function () {
  // 获取模型中的按钮对象
  let five = model.getButton("Five");

  // 控件当前截图
  let controlImage = await five.takeScreenshot();

  // 模型中保存的截图
  let modelImage = await five.modelImage();

  // 对比模型图与控件截图
  let result = await Image.imageCompare(modelImage, controlImage);

  // 保存 diff 图像
  fs.writeFileSync(__dirname + '/diff.png', await result.diffImage.getData());

  // 打印差异统计信息
  console.log(result.info)
})();

import os
import json
import base64
from leanproAuto import Image, WinAuto

try:
    base_dir = os.path.dirname(__file__)

    # 加载对象模型（tmodel 文件路径请按实际情况填写）
    model = WinAuto.loadModel(os.path.join(base_dir, "test.tmodel"))

    # 获取模型中的按钮对象
    five = model.getButton("Five")

    # 控件当前截图
    control_image = five.takeScreenshot()

    # 模型中保存的截图
    model_image = five.modelImage()

    # 对比模型图与控件截图
    result = Image.imageCompare(model_image, control_image)

    # 打印差异统计信息
    print("Diff Info:", json.dumps(result["info"], indent=2, ensure_ascii=False))

    # 保存 diff 图像
    diff_b64 = result["diffImage"]
    diff_bytes = base64.b64decode(diff_b64)
    diff_path = os.path.join(base_dir, "diff.png")
    with open(diff_path, "wb") as f:
        f.write(diff_bytes)
    print("差异图已保存到：", diff_path)

except Exception as err:
    print("出错：", err)

图片查看与比较

除了在自动化脚本中通过代码对图像进行处理和比较外，CukeTest 也在编辑器中提供了直观的图片查看与比较工具，方便在开发和调试中直观地核对差异：

图片查看：点击文件树中的图片文件，可在编辑器标签页中直接打开并进行预览。
图片比较：支持在文件树中选择两张图片进行比较，方便快速定位自动化测试截图、基准图和实际图之间的差异。

操作步骤

在左侧项目文件树中，按住 Ctrl 键，依次点击选择两张需要对比的图片文件。
右键点击选中的图片，在上下文菜单中选择 “比较文件”。
此时编辑器将打开一个专用的图片对比标签页，高亮并呈现两幅图的像素差异，帮助你快速找出两图的不同之处。

results matching ""

全部 API Walkthrough 其他

图像操作API

Image对象

引用方式

类型定义

常见用法

实例属性

width

height

实例方法

clip(rect: Rect)

resize(width: number, height: number)

filterColor(color: Colors | Colors[])

drawImage(image: Image, x: number, y: number)

getData(option?: {encoding: 'base64' | null})

save(filePath: string)

静态方法

Image.fromData(bufferOrString: Buffer | string)

Image.fromFile(filePath: string)

图片比较方法

Image.imageEqual(image1, image2, options?, compareInfo?)

Image.imageCompare(image1, image2, options?)

控件与模型图片比较

图片查看与比较

操作步骤

results matching ""

No results matching ""

`Image`对象