项目调用opencv配合dxgi完成对桌面和窗口的截图并进行不规则形状的模板匹配，并以梦幻西游为例，用来搜查鼠标位置（其实就是为了能写点游戏脚本玩玩）。
但最终目的其实是分别用纯C++、python搭配C++打包的dll、纯python 对比3种渠道的速度
项目简介
项目调用opencv配合dxgi完成对桌面和窗口的截图并进行不规则形状的模板匹配，并以梦幻西游为例，用来搜查鼠标位置（其实就是为了能写点游戏脚本玩玩）。
但最终目的其实是分别用纯C++、python搭配C++打包的dll、纯python 对比3种渠道的速度，对比结果如下
程序/数据集下载
本文章只发布于博客园、爆米算法和CSDN，被抄袭后可能排版错乱或下载失效，作者：爆米LiuChen
C++部分
FindWindow.h，窗口定位头文件
#pragma once
#include <dwmapi.h>
#include <windows.h>
#include <vector>
#include <string>
#include <iostream>
struct WindowData {
HWND handle;//窗口句柄
char title[256];//窗口标题
};
struct WindowRect
{
int x;
int y;
int width;
int height;
};
BOOL CALLBACK WindowEnumerationCallback(HWND hwnd, LPARAM lParam);
HWND getWindowHWND(std::string titleSection);
RECT getWindowLoc(HWND hwnd);
WindowRect getWindowRect(std::string titleSection);
extern WindowRect windowRect;
extern std::vector<WindowData> windowDatas;
FindWindow.cpp，核心函数getWindowRect，输入桌面窗口标题包含的字符串，返回窗口的位置坐标
#include "FindWindow.h"
static std::vector<WindowData> windowDatas;
WindowRect windowRect{ 0,0,0,0 };
// 声明回调函数
BOOL CALLBACK WindowEnumerationCallback(HWND hwnd, LPARAM lParam) {
// 通过IsWindow函数检查窗口是否有效
if (IsWindow(hwnd)) {
// 通过IsWindowEnabled函数检查窗口是否启用
if (IsWindowEnabled(hwnd)) {
// 通过IsWindowVisible函数检查窗口是否可见
if (IsWindowVisible(hwnd)) {
// 获取窗口的文本，并打印
char windowText[256];
GetWindowTextA(hwnd, windowText, sizeof(windowText));
WindowData windowData;
windowData.handle = hwnd;
memcpy(windowData.title, windowText, 256);
windowDatas.push_back(windowData);
}
}
}
// 继续枚举其他窗口
return TRUE;
}
//返回包含titleSection的桌面窗口句柄
HWND getWindowHWND(std::string titleSection)
{
HWND handle = NULL;
//每次都要清空容器
windowDatas.clear();
// 使用EnumWindows函数枚举所有窗口，并传递给回调函数处理
EnumWindows(WindowEnumerationCallback, NULL);
//一个个找包含指定字符串的
for (auto it = windowDatas.begin(); it != windowDatas.end(); it++)
{
char title[256];
memcpy(title, it->title, 256);
std::string windowTitle(title);
if (windowTitle.find(titleSection) != std::string::npos)
{
handle = it->handle;
}
}
return handle;
}
//根据窗口句柄和桌面缩放获得窗口尺寸和位置
RECT getWindowLoc(HWND hwnd)
{
RECT frame;
DwmGetWindowAttribute(hwnd, DWMWA_EXTENDED_FRAME_BOUNDS, &frame, sizeof(RECT));
//std::cout << "窗口位置：(" << frame.left << ", " << frame.top << ")" << std::endl;
//std::cout << "窗口大小：(" << frame.right-frame.left << ", " << frame.bottom-frame.top << ")" << std::endl;
return frame;
}
//根据窗口名获得窗口位置尺寸
WindowRect getWindowRect(std::string titleSection)
{
windowRect = {0,0,0,0};
HWND hwnd = getWindowHWND(titleSection);
if (hwnd == NULL) {
printf("cant find window contains %s\n", titleSection.c_str());
return windowRect;
}
//如果窗口小化 就将其展示
if (IsIconic(hwnd)) {
ShowWindow(hwnd, SW_RESTORE);
}
SetForegroundWindow(hwnd); // 将窗口置顶
RECT rect = getWindowLoc(hwnd); // 窗口位置
windowRect.x = rect.left;
windowRect.y = rect.top;
windowRect.width = rect.right - rect.left;
windowRect.height = rect.bottom - rect.top;
return windowRect;
}
DxgiCapture.h 截图头文件
#pragma once
#include <d3d11.h>
#include <dxgi1_2.h>
#include <stdio.h>
#include <opencv2/opencv.hpp>
#pragma comment(lib, "d3d11.lib")
#pragma comment(lib, "dxgi.lib")
#include <time.h>
#include "FindWindow.h"
struct MatInfo
{
int windowX;//窗口在桌面的x坐标
int windowY;//窗口在桌面的Y坐标
int windowWidth;//窗口宽
int windowHeight;//窗口高
uchar* pMatUchar;
};
extern "C" __declspec(dllexport) void initDxgi();
extern "C" __declspec(dllexport) cv::Mat getDesktopMat();
extern "C" __declspec(dllexport) cv::Mat getWindowMat(std::string titleSection = "desktop");
extern "C" __declspec(dllexport) MatInfo getWindowMatInfo(const char* pTitleSection="desktop");
DxgiCapture.cpp 核心函数为getWindowMatInfo，输入窗口标题包含的字符串，返回窗口坐标和opencv的矩阵uchar*
#include "DxgiCapture.h"
static cv::Mat regionMat;
static cv::Mat regionMatClone;
static cv::Mat emptyMat;
static cv::Mat desktopMat;
static DXGI_OUTDUPL_FRAME_INFO frameInfo;
static HRESULT hr;
static D3D_DRIVER_TYPE DriverTypes[3];
static UINT NumDriverTypes;
static D3D_FEATURE_LEVEL FeatureLevels[4];
static UINT NumFeatureLevels;
static D3D_FEATURE_LEVEL FeatureLevel;
static ID3D11Device* _pDX11Dev;
static ID3D11DeviceContext* _pDX11DevCtx;
static IDXGIDevice* _pDXGIDev;
static IDXGIAdapter* _pDXGIAdapter;
static IDXGIOutput* _pDXGIOutput;
static DXGI_OUTPUT_DESC DesktopDesc;
static IDXGIOutput1* _pDXGIOutput1;
static IDXGIOutputDuplication* _pDXGIOutputDup;
static DXGI_MAPPED_RECT MappedSurface;
static IDXGIResource* desktopResource;
static ID3D11Texture2D* _pDX11Texture;
static ID3D11Texture2D* _pCopyBuffer;
static int desktopWidth, desktopHeight;
static byte* pDesktopByte;
/* 获取屏幕缩放值 */
double getZoom()
{
// 获取窗口当前显示的监视器
HWND hWnd = GetDesktopWindow();
HMONITOR hMonitor = MonitorFromWindow(hWnd, MONITOR_DEFAULTTONEAREST);
// 获取监视器逻辑宽度
MONITORINFOEX monitorInfo;
monitorInfo.cbSize = sizeof(monitorInfo);
GetMonitorInfo(hMonitor, &monitorInfo);
int cxLogical = (monitorInfo.rcMonitor.right - monitorInfo.rcMonitor.left);
// 获取监视器物理宽度
DEVMODE dm;
dm.dmSize = sizeof(dm);
dm.dmDriverExtra = 0;
EnumDisplaySettings(monitorInfo.szDevice, ENUM_CURRENT_SETTINGS, &dm);
int cxPhysical = dm.dmPelsWidth;
return cxPhysical * 1.0 / cxLogical;
}
//获得桌面二进制数据指针
cv::Mat getDesktopMat()
{
desktopResource = nullptr;
hr = _pDXGIOutputDup->AcquireNextFrame(10, &frameInfo, &desktopResource);
if (FAILED(hr))
{ //没有可用的刷新帧 返回上一帧
if (hr == DXGI_ERROR_WAIT_TIMEOUT)
{
if (desktopResource) {
desktopResource->Release();
desktopResource = nullptr;
}
hr = _pDXGIOutputDup->ReleaseFrame();
return desktopMat;
}
else
{
return emptyMat;
}
}
_pDX11Texture = nullptr;
// query next frame staging buffer 查询下一帧暂存缓冲区
if (desktopResource == nullptr) {
return emptyMat;
}
hr = desktopResource->QueryInterface(__uuidof(ID3D11Texture2D), reinterpret_cast<void**>(&_pDX11Texture));
desktopResource->Release();
desktopResource = nullptr;
if (FAILED(hr)) {
return emptyMat;
}
_pCopyBuffer = nullptr;
D3D11_TEXTURE2D_DESC desc;
// copy old description 复制旧描述
if (_pDX11Texture)
{
_pDX11Texture->GetDesc(&desc);
}
else if (_pCopyBuffer)
{
_pCopyBuffer->GetDesc(&desc);
}
else
{
return emptyMat;
}
// create a new staging buffer for fill frame image 为填充帧图像创建一个新的暂存缓冲区
if (_pCopyBuffer == nullptr) {
D3D11_TEXTURE2D_DESC CopyBufferDesc;
CopyBufferDesc.Width = desc.Width;
CopyBufferDesc.Height = desc.Height;
CopyBufferDesc.MipLevels = 1;
CopyBufferDesc.ArraySize = 1;
CopyBufferDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
CopyBufferDesc.SampleDesc.Count = 1;
CopyBufferDesc.SampleDesc.Quality = 0;
CopyBufferDesc.Usage = D3D11_USAGE_STAGING;
CopyBufferDesc.BindFlags = 0;
CopyBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
CopyBufferDesc.MiscFlags = 0;
hr = _pDX11Dev->CreateTexture2D(&CopyBufferDesc, nullptr, &_pCopyBuffer);
if (FAILED(hr)) {
return emptyMat;
}
}
if (_pDX11Texture)
{
// copy next staging buffer to new staging buffer 将下一个暂存缓冲区复制到新的暂存缓冲区
_pDX11DevCtx->CopyResource(_pCopyBuffer, _pDX11Texture);
}
IDXGISurface* CopySurface = nullptr;
// create staging buffer for map bits 为映射位创建暂存缓冲区
hr = _pCopyBuffer->QueryInterface(__uuidof(IDXGISurface), (void**)&CopySurface);
if (FAILED(hr)) {
return emptyMat;
}
// copy bits to user space 将位复制到用户空间
hr = CopySurface->Map(&MappedSurface, DXGI_MAP_READ);
CopySurface->Unmap();
hr = CopySurface->Release();
CopySurface = nullptr;
if (_pDXGIOutputDup)
{
hr = _pDXGIOutputDup->ReleaseFrame();
}
cv::Mat mat = cv::Mat(desktopHeight, desktopWidth, CV_8UC4, MappedSurface.pBits);
cv::cvtColor(mat, desktopMat, cv::COLOR_BGRA2BGR);// 转换为3通道图片
_pCopyBuffer->Release();
_pDX11Texture->Release();
_pDX11DevCtx->Release();
return desktopMat;
}
//根据窗口标题是否包含该字符串，获得窗口截图
cv::Mat getWindowMat(std::string titleSection)
{
getDesktopMat();
WindowRect rect;
if (titleSection != "desktop") {
rect = getWindowRect(titleSection);
regionMatClone = desktopMat(cv::Range(rect.y, rect.y + rect.height), cv::Range(rect.x, rect.x + rect.width));
regionMat = regionMatClone.clone();
return regionMat;
}
windowRect = { 0,0,desktopWidth,desktopHeight };//桌面截图 则它的窗口信息就是这样
regionMat = desktopMat;
return desktopMat;
}
void initDxgi()
{
double zoom = getZoom();
desktopWidth = GetSystemMetrics(SM_CXSCREEN) * zoom;
desktopHeight = GetSystemMetrics(SM_CYSCREEN) * zoom;
_pDXGIOutputDup = nullptr;
_pDX11Dev = nullptr;
D3D_DRIVER_TYPE DriverTypes[] = { D3D_DRIVER_TYPE_HARDWARE,D3D_DRIVER_TYPE_WARP,D3D_DRIVER_TYPE_REFERENCE, D3D_DRIVER_TYPE_UNKNOWN };
UINT NumDriverTypes = ARRAYSIZE(DriverTypes);
D3D_FEATURE_LEVEL FeatureLevels[] = { D3D_FEATURE_LEVEL_11_0,D3D_FEATURE_LEVEL_10_1,D3D_FEATURE_LEVEL_10_0,D3D_FEATURE_LEVEL_9_1 };
UINT NumFeatureLevels = ARRAYSIZE(FeatureLevels);
_pDX11DevCtx = nullptr;
// Create D3D device 创建D3D设备
for (UINT index = 0; index < NumDriverTypes; index++)
{
hr = D3D11CreateDevice(nullptr,
DriverTypes[index],
nullptr, 0,
NULL,
0,
D3D11_SDK_VERSION,
&_pDX11Dev,
&FeatureLevel,
&_pDX11DevCtx);
if (SUCCEEDED(hr)) {
break;
}
}
_pDXGIOutput = nullptr;
_pDXGIOutput1 = nullptr;
_pDXGIDev = nullptr;
// Get DXGI device 获取 DXGI 设备
hr = _pDX11Dev->QueryInterface(__uuidof(IDXGIDevice), reinterpret_cast<void**>(&_pDXGIDev));
if (FAILED(hr)) {
return;
}
IDXGIAdapter* _pDXGIAdapter = nullptr;
// Get DXGI adapter 获取 DXGI 适配器
hr = _pDXGIDev->GetParent(__uuidof(IDXGIAdapter), reinterpret_cast<void**>(&_pDXGIAdapter));
if (FAILED(hr)) {
return;
}
UINT i = 0;
// Get output 获取输出
hr = _pDXGIAdapter->EnumOutputs(i, &_pDXGIOutput);
if (FAILED(hr)) {
return;
}
// Get output description struct 获取输出描述结构
_pDXGIOutput->GetDesc(&DesktopDesc);
// QI for Output1 请求接口给Output1
hr = _pDXGIOutput->QueryInterface(__uuidof(IDXGIOutput1), reinterpret_cast<void**>(&_pDXGIOutput1));
if (FAILED(hr)) {
return;
}
// Create desktop duplication 创建桌面副本
hr = _pDXGIOutput1->DuplicateOutput(_pDX11Dev, &_pDXGIOutputDup);
if (FAILED(hr)) {
return;
}
getWindowMat();
getWindowMat();
}
MatInfo getWindowMatInfo(const char* pTitleSection)
{
std::string titleSection;
titleSection.insert(0, pTitleSection);
MatInfo matInfo{0,0,0,0,nullptr};
getWindowMat(titleSection);
if (regionMat.empty()) {
return matInfo;
}
matInfo.windowHeight = regionMat.rows;
matInfo.windowWidth = regionMat.cols;
matInfo.windowX = windowRect.x;
matInfo.windowY = windowRect.y;
matInfo.pMatUchar = static_cast<uchar*>(regionMat.data);
return matInfo;
}
OpenDetect.h 模板匹配头文件
#pragma once
#include "DxgiCapture.h"
#include <unordered_map>
struct MatchResult
{
int xInWindow;//模板匹配在窗口中的x坐标
int yInWindow;//模板匹配在窗口中的Y坐标
int xInDesktop;//模板匹配在桌面中的X坐标
int yInDesktop;//模板匹配在桌面中的Y坐标
int windowX;//窗口在桌面的x坐标
int windowY;//窗口在桌面的Y坐标
int windowWidth;//窗口宽
int windowHeight;//窗口高
int templateWidth;//模板宽
int templateHeight;//模板高
float diff;//匹配指标 差异度 越小越好
bool success;//匹配是否成功
};
struct TemplateAndMask
{
cv::Mat templateMat;//模板矩阵
cv::Mat maskMat;//掩膜矩阵
};
extern "C" __declspec(dllexport) void addTemplateMask(const char* pKey, const char* pTemplatePath, const char* pMaskPath = "");
extern "C" __declspec(dllexport) MatchResult matchInWindow(const char* pKey, const char* pTitleSection = "desktop");
OpenDetect.cpp 模板匹配，核心函数matchInWindow，输入模板名和窗口标题返回模板匹配后的位置，这里要配合掩膜才能匹配不规则模板
#include "OpenDetect.h"
static MatchResult matchResult;
static std::unordered_map<std::string, TemplateAndMask> templateMatMap;
//添加模板和掩膜到字典 入参 关键词 模板路径 掩膜路径
void addTemplateMask(const char* pKey, const char* pTemplatePath, const char* pMaskPath)
{
std::string key, templatePath, maskPath;
key.insert(0, pKey);
templatePath.insert(0, pTemplatePath);
maskPath.insert(0, pMaskPath);
cv::Mat maskMat;
cv::Mat templateMat = cv::imread(templatePath);
if (maskPath != "") {
maskMat = cv::imread(maskPath, -1);
// 根据透明通道修改像素值 透明通道值为0 则像素值置0
for (int y = 0; y < maskMat.rows; ++y) {
for (int x = 0; x < maskMat.cols; ++x) {
// 获取像素值，注意通道顺序是BGR(A)而不是RGBA
cv::Vec4b pixel = maskMat.at<cv::Vec4b>(y, x);
if (pixel[3] == 0) {
maskMat.at<cv::Vec4b>(y, x) = cv::Vec4b(0, 0, 0, 0);
}
}
}
//已经根据透明通道做了置0，已经不需要透明通道
cv::cvtColor(maskMat, maskMat, cv::COLOR_BGRA2BGR);
//转为灰度图
cv::cvtColor(maskMat, maskMat, cv::COLOR_BGR2GRAY);
//二值化
cv::threshold(maskMat, maskMat, 1, 255, cv::THRESH_BINARY);
//转换为3通道图片 因为每个通道有单独的遮罩
std::vector<cv::Mat> channels = { maskMat, maskMat, maskMat };
cv::merge(channels, maskMat);
}
if (maskMat.empty()) {
printf("add %s template without mask\n", key.c_str());
}
else {
printf("add %s template with mask\n", key.c_str());
}
TemplateAndMask tam = { templateMat,maskMat };
templateMatMap[key] = tam;
}
//寻找窗口标题若为desktop则就是对桌面截图 根据掩膜和模板匹配结果
MatchResult matchInWindow(const char* pKey, const char* pTitleSection)
{
std::string key, titleSection;
key.insert(0, pKey);
titleSection.insert(0, pTitleSection);
TemplateAndMask tam = templateMatMap[key];
cv::Mat templateMat = tam.templateMat;
cv::Mat maskMat = tam.maskMat;
cv::Mat windowMat = getWindowMat(titleSection);
if (windowMat.empty()) {
matchResult.success = FALSE;//没找到窗口
return matchResult;
}
cv::Mat result;//模板匹配
//cv::matchTemplate(windowMat, templateMat, result, cv::TM_SQDIFF_NORMED);//不用mask的对比
cv::matchTemplate(windowMat, templateMat, result, cv::TM_SQDIFF_NORMED, maskMat);//mask的对比
double minVal, maxVal;
cv::Point minLoc, maxLoc;
cv::minMaxLoc(result, &minVal, &maxVal, &minLoc, &maxLoc);
//匹配结果返回 取差异化最小值
matchResult.xInWindow = minLoc.x;
matchResult.yInWindow = minLoc.y;
matchResult.diff = minVal;
matchResult.templateWidth = templateMat.cols;
matchResult.templateHeight = templateMat.rows;
matchResult.xInDesktop = minLoc.x + windowRect.x;
matchResult.yInDesktop = minLoc.y + windowRect.y;
matchResult.windowX = windowRect.x;
matchResult.windowY = windowRect.y;
matchResult.windowWidth = windowRect.width;
matchResult.windowHeight = windowRect.height;
matchResult.success = TRUE;
return matchResult;
}
main.cpp 调用上面的函数 进行测试
#include "OpenDetect.h"
#include <opencv2/opencv.hpp>
#include <time.h>
int main()
{
clock_t start, finish;
double durationS;
cv::Mat mat;
MatchResult result;
initDxgi();
printf("开始截屏测试\n");
start = clock();
for (int i=0;i<1000;i++)
{
//MatInfo matInfo = getWindowMatInfo();
//cv::Mat mat(matInfo.windowHeight, matInfo.windowWidth, CV_8UC3, matInfo.pMatUchar);
mat = getDesktopMat();
}
finish = clock();
durationS = (double)(finish - start) / CLOCKS_PER_SEC;
printf("1000次桌面截图并转为opencv平均%.1f毫秒/帧\n", durationS);
printf("开始模板匹配测试\n");
addTemplateMask("mouse1","1号鼠标模板.png","1号鼠标遮罩.png");
addTemplateMask("mouse2", "2号鼠标模板.png", "");
getWindowMatInfo("梦幻");
start = clock();
for (int i = 0; i < 10; i++) {
result = matchInWindow("mouse1", "梦幻");
}
finish = clock();
durationS = (double)(finish - start) / CLOCKS_PER_SEC;
printf("10次桌面模板匹配平均%.0f毫秒/次\n", durationS/10*1000);
mat = getWindowMat();
cv::rectangle(mat, cv::Rect(result.xInDesktop, result.yInDesktop,result.templateWidth, result.templateHeight), cv::Scalar(0, 0, 255), 2);
cv::imshow("", mat);
cv::waitKey(0);
return 0;
}
python部分
将上面的C++代码打包成dll，然后python调用dll与不调用作对比
import cv2
import ctypes
import numpy as np
import d3dshot
import time
print("python-----------------------------------------")
d = d3dshot.create(capture_output="numpy")
d.display = d.displays[0]
start = time.time()
for i in range(1000):
img = d.screenshot()
end = time.time()
print("python 1000次桌面截图平均耗时%.1f毫秒/次"%(end-start))
#读取模板 遮罩
template = cv2.imdecode(np.fromfile("1号鼠标模板.png", dtype=np.uint8), -1)[:, :, :3]
mask = cv2.imdecode(np.fromfile("1号鼠标遮罩.png", dtype=np.uint8), -1)[:, :, :4]
w, h = template.shape[0],template.shape[1]
#遮罩透明点设为0权重
for i in range(mask.shape[0]):
for j in range(mask.shape[1]):
if mask[i,j,3]==0:
mask[i,j,:3]=(0,0,0)
mask = mask[:,:,:3]
#遮罩二值化
mask = cv2.cvtColor(mask, cv2.COLOR_BGR2GRAY)
_,mask = cv2.threshold(mask, 127, 255, cv2.THRESH_BINARY)
mask = np.stack([mask,mask,mask],axis=-1)
w, h = template.shape[0],template.shape[1]
#模板匹配
start = time.time()
for i in range(10):
img = d.screenshot()
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
res = cv2.matchTemplate(img,template,cv2.TM_SQDIFF_NORMED,mask=mask)
min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(res)
end = time.time()
print("python 10次桌面模板匹配平均耗时%.1f毫秒/次"%((end-start)/10*1000))
#可视化
top_left = min_loc
bottom_right = (top_left[0] + w, top_left[1] + h)
cv2.rectangle(img, top_left, bottom_right, (0,0,255), 2)
cv2.imshow("test", img)
cv2.waitKey(0)
raise Exception("注释掉啊混蛋")
print("注意运行下面代码需要注释掉上面的代码 因为dxgi重复初始化 python+dll-----------------------------------------")
#载入dll
openDetect = ctypes.WinDLL('OpenDetectDLL.dll')
openDetect.initDxgi()#dxgi截图需要初始化
#窗口截图矩阵信息
class MatInfo(ctypes.Structure):
_fields_ = [("windowX",ctypes.c_int),("windowY",ctypes.c_int),("windowWidth",ctypes.c_int),("windowHeight",ctypes.c_int),("pMatByte",ctypes.POINTER(ctypes.c_uint8))]
#getWindowMatInfo函数 输入 窗口标题 返回 窗口截图矩阵信息
openDetect.getWindowMatInfo.argtypes = [ctypes.c_char_p,]
openDetect.getWindowMatInfo.restype = MatInfo
start = time.time()
for i in range(1000):
t = time.time()
matInfo = openDetect.getWindowMatInfo(bytes("desktop","gbk"))
mat = np.ctypeslib.as_array(matInfo.pMatByte, shape=(matInfo.windowHeight,matInfo.windowWidth, 3))
end = time.time()
print("python+dll 1000次桌面截图平均耗时%.1f毫秒/次"%(end-start))
#addTemplateMask 增加模板遮罩对 函数输入 模板名 模板路径 遮罩路径
openDetect.addTemplateMask.argtypes = [ctypes.c_char_p,ctypes.c_char_p,ctypes.c_char_p,]
openDetect.addTemplateMask.restype = None
openDetect.addTemplateMask(bytes("mouse1","gbk"),bytes("1号鼠标模板.png","gbk"),bytes("1号鼠标遮罩.png","gbk"));
openDetect.addTemplateMask(bytes("mouse2","gbk"), bytes("2号鼠标模板.png","gbk"), bytes("","gbk"));
#模板匹配结果
class MatchResult(ctypes.Structure):
_fields_ = [
("xInWindow",ctypes.c_int),("yInWindow",ctypes.c_int),
("xInDesktop",ctypes.c_int),("yInDesktop",ctypes.c_int),
("windowX",ctypes.c_int),("windowY",ctypes.c_int),
("windowWidth",ctypes.c_int),("windowHeight",ctypes.c_int),
("templateWidth",ctypes.c_int),("templateHeight",ctypes.c_int),
("diff",ctypes.c_float),("success",ctypes.c_bool),
]
#matchInWindow 模板匹配 输入 模板名 窗口包含文字 返回匹配结构体
openDetect.matchInWindow.argtypes = [ctypes.c_char_p,ctypes.c_char_p,]
openDetect.matchInWindow.restype = MatchResult
openDetect.getWindowMatInfo(bytes("梦幻","gbk"))#让梦幻西游窗口前置
start = time.time()
for i in range(10):
result = openDetect.matchInWindow(bytes("mouse1","gbk"),bytes("desktop","gbk"))
end = time.time()
print("python+dll 10次桌面模板匹配平均耗时%.1f毫秒/次"%((end-start)/10*1000))
matInfo = openDetect.getWindowMatInfo(bytes("desktop","gbk"))
mat = np.ctypeslib.as_array(matInfo.pMatByte, shape=(matInfo.windowHeight,matInfo.windowWidth, 3))
cv2.rectangle(mat, (result.xInDesktop, result.yInDesktop), (result.xInDesktop+result.templateWidth, result.yInDesktop+result.templateHeight), (0,0, 255), 2)
cv2.imwrite("result.png",mat)
cv2.imshow("test", mat)
cv2.waitKey(0)
经测试，C++、python+dll、python都能得到下面模板匹配的截图，至于速度的对比结果请见开头
