（三）Qt+OpenCV调用海康工业相机SDK抓拍示例

news2024/11/13 9:47:29

系列文章目录

提示：这里是该系列文章的所有文章的目录
第一章： （一）Qt+OpenCV调用海康工业相机SDK示例开发
第二章： （二）Qt多线程实现海康工业相机图像实时采集
第三章： （三）Qt+OpenCV调用海康工业相机SDK抓拍示例

文章目录

  • 系列文章目录
  • 前言
  • 一、项目配置
  • 二、图像采集与保存
  • 三、示例完整代码
  • 总结

前言

在这系列文章中，讲述了Qt下结合OpenCV与海康工业相机的使用，对前文的功能进行拓展，在这里做了一个使用海康彩色工业相机定时抓拍的示例，并将相关代码展现出来以便大家学习，如有错误之处，欢迎大家批评指正。

项目效果
请添加图片描述

提示：以下是本篇文章正文内容，下面案例可供参考

一、项目配置

本文示例是在MSVC_64bit下Release构建的，然后引入了海康SDK和OpenCV对应的库，所以项目的pro文件如下：
MyCamera.pro

QT       += core gui

greaterThan(QT_MAJOR_VERSION, 4): QT += widgets

CONFIG += c++11

DEFINES += QT_DEPRECATED_WARNINGS

#设置字符
contains( CONFIG,"msvc" ):QMAKE_CXXFLAGS += /source-charset:utf-8 /execution-charset:utf-8
contains( CONFIG,"msvc" ):QMAKE_CFLAGS +=/source-charset:utf-8 /execution-charset:utf-8

SOURCES += \
    capturethread.cpp \
    cmvcamera.cpp \
    main.cpp \
    widget.cpp

HEADERS += \
    capturethread.h \
    cmvcamera.h \
    widget.h

FORMS += \
    widget.ui

# Default rules for deployment.
qnx: target.path = /tmp/$${TARGET}/bin
else: unix:!android: target.path = /opt/$${TARGET}/bin
!isEmpty(target.path): INSTALLS += target

#HikSDK
INCLUDEPATH += $$PWD/SDK/HikSDK/Includes
DEPENDPATH += $$PWD/SDK/HikSDK/Includes
LIBS += -L$$PWD/SDK/HikSDK/Lib/ -lMvCameraControl

#OpenCV
INCLUDEPATH += $$PWD/SDK/OpenCV/Includes
DEPENDPATH += $$PWD/SDK/OpenCV/Includes
LIBS += -L$$PWD/SDK/OpenCV/Lib/ -lopencv_world455

二、图像采集与保存

示例采集的原理：
//点击开始采集后,会关闭触发模式,相机就会不断回调,实时显示相机图像
//点击停止采集后,会开启触发模式并设置为软触发,需要调用命令触发回调

在设备打开后，通过点击抓拍按钮开启线程并打开保存标志位，在线程中使用OpenCV的imwrite函数来进行图像的保存。

//抓拍图像
void Widget::on_pb_grab_clicked()
{
    if(!m_bOpenDevice)
    {
        QMessageBox::warning(this,"警告","抓拍失败,请打开设备！");
        return;
    }

    int time = ui->le_time->text().toInt();
    int num = ui->le_num->text().toInt();
    m_captureThread->setCameraSignal(time,num);
    m_captureThread->setSwitchFlag(true);
    m_captureThread->setSaveFlag(true);
    m_captureThread->start();
}

......

//保存原图
void CaptureThread::saveOriginImage(cv::Mat imageMat)
{
    clock_t originClock = -clock();
    QString curTime = QTime::currentTime().toString("hhmmss");
    QString iamgeName = m_originPath + "GrabImage_" + curTime + ".jpg";
    cv::Mat saveMat;
    cvtColor(imageMat,saveMat,cv::COLOR_BGR2RGB);   //颜色格式转换
    imwrite(iamgeName.toStdString(),saveMat);
    originClock += clock();
    LOGDEBUG<<"保存原图耗时:"<<originClock<<"ms";   //测试在20ms左右
}

三、示例完整代码

示例的功能实现就不多说了，在下面的代码中有详细的注释，这里将完整代码展示出来：
1.cmvcamera.h(直接从海康提供的SDK中复制，进行了一些修改）

/************************************************************************/
/* 以C++接口为基础，对常用函数进行二次封装，方便用户使用                */
/************************************************************************/

#ifndef _MV_CAMERA_H_
#define _MV_CAMERA_H_

#include <string.h>
#include <QCoreApplication>
#include "MvCameraControl.h"
#include "opencv2/opencv.hpp"

//会跟系统函数定义冲突
//using namespace cv;

#ifndef MV_NULL
#define MV_NULL    0
#endif

class CMvCamera
{
public:
    CMvCamera();
    ~CMvCamera();

    // ch:获取SDK版本号 | en:Get SDK Version
    static int GetSDKVersion();

    // ch:枚举设备 | en:Enumerate Device
    static int EnumDevices(unsigned int nTLayerType, MV_CC_DEVICE_INFO_LIST* pstDevList);

    // ch:判断设备是否可达 | en:Is the device accessible
    static bool IsDeviceAccessible(MV_CC_DEVICE_INFO* pstDevInfo, unsigned int nAccessMode);

    // ch:打开设备 | en:Open Device
    int Open(MV_CC_DEVICE_INFO* pstDeviceInfo);

    // ch:关闭设备 | en:Close Device
    int Close();

    // ch:判断相机是否处于连接状态 | en:Is The Device Connected
    bool IsDeviceConnected();

    // ch:注册图像数据回调 | en:Register Image Data CallBack
    int RegisterImageCallBack(void(__stdcall* cbOutput)(unsigned char * pData, MV_FRAME_OUT_INFO_EX* pFrameInfo, void* pUser), void* pUser);

    // ch:注册彩色图像数据回调
    int RegisterImageCallBackRGB(void(__stdcall* cbOutput)(unsigned char * pData, MV_FRAME_OUT_INFO_EX* pFrameInfo, void* pUser), void* pUser);

    // ch:开启抓图 | en:Start Grabbing
    int StartGrabbing();

    // ch:停止抓图 | en:Stop Grabbing
    int StopGrabbing();

    // ch:主动获取一帧图像数据 | en:Get one frame initiatively
    int GetImageBuffer(MV_FRAME_OUT* pFrame, int nMsec);

    // ch:释放图像缓存 | en:Free image buffer
    int FreeImageBuffer(MV_FRAME_OUT* pFrame);

    // ch:显示一帧图像 | en:Display one frame image
    int DisplayOneFrame(MV_DISPLAY_FRAME_INFO* pDisplayInfo);

    // ch:设置SDK内部图像缓存节点个数 | en:Set the number of the internal image cache nodes in SDK
    int SetImageNodeNum(unsigned int nNum);

    // ch:获取设备信息 | en:Get device information
    int GetDeviceInfo(MV_CC_DEVICE_INFO* pstDevInfo);

    // ch:获取GEV相机的统计信息 | en:Get detect info of GEV camera
    int GetGevAllMatchInfo(MV_MATCH_INFO_NET_DETECT* pMatchInfoNetDetect);

    // ch:获取U3V相机的统计信息 | en:Get detect info of U3V camera
    int GetU3VAllMatchInfo(MV_MATCH_INFO_USB_DETECT* pMatchInfoUSBDetect);

    // ch:获取和设置Int型参数，如 Width和Height，详细内容参考SDK安装目录下的 MvCameraNode.xlsx 文件
    // en:Get Int type parameters, such as Width and Height, for details please refer to MvCameraNode.xlsx file under SDK installation directory
    int GetIntValue(IN const char* strKey, OUT MVCC_INTVALUE_EX *pIntValue);
    int SetIntValue(IN const char* strKey, IN int64_t nValue);

    // ch:获取和设置Enum型参数，如 PixelFormat，详细内容参考SDK安装目录下的 MvCameraNode.xlsx 文件
    // en:Get Enum type parameters, such as PixelFormat, for details please refer to MvCameraNode.xlsx file under SDK installation directory
    int GetEnumValue(IN const char* strKey, OUT MVCC_ENUMVALUE *pEnumValue);
    int SetEnumValue(IN const char* strKey, IN unsigned int nValue);
    int SetEnumValueByString(IN const char* strKey, IN const char* sValue);
    int GetEnumEntrySymbolic(IN const char* strKey, IN MVCC_ENUMENTRY* pstEnumEntry);

    // ch:获取和设置Float型参数，如 ExposureTime和Gain，详细内容参考SDK安装目录下的 MvCameraNode.xlsx 文件
    // en:Get Float type parameters, such as ExposureTime and Gain, for details please refer to MvCameraNode.xlsx file under SDK installation directory
    int GetFloatValue(IN const char* strKey, OUT MVCC_FLOATVALUE *pFloatValue);
    int SetFloatValue(IN const char* strKey, IN float fValue);

    // ch:获取和设置Bool型参数，如 ReverseX，详细内容参考SDK安装目录下的 MvCameraNode.xlsx 文件
    // en:Get Bool type parameters, such as ReverseX, for details please refer to MvCameraNode.xlsx file under SDK installation directory
    int GetBoolValue(IN const char* strKey, OUT bool *pbValue);
    int SetBoolValue(IN const char* strKey, IN bool bValue);

    // ch:获取和设置String型参数，如 DeviceUserID，详细内容参考SDK安装目录下的 MvCameraNode.xlsx 文件UserSetSave
    // en:Get String type parameters, such as DeviceUserID, for details please refer to MvCameraNode.xlsx file under SDK installation directory
    int GetStringValue(IN const char* strKey, MVCC_STRINGVALUE *pStringValue);
    int SetStringValue(IN const char* strKey, IN const char * strValue);

    // ch:执行一次Command型命令，如 UserSetSave，详细内容参考SDK安装目录下的 MvCameraNode.xlsx 文件
    // en:Execute Command once, such as UserSetSave, for details please refer to MvCameraNode.xlsx file under SDK installation directory
    int CommandExecute(IN const char* strKey);

    // ch:探测网络最佳包大小(只对GigE相机有效) | en:Detection network optimal package size(It only works for the GigE camera)
    int GetOptimalPacketSize(unsigned int* pOptimalPacketSize);

    // ch:注册消息异常回调 | en:Register Message Exception CallBack
    int RegisterExceptionCallBack(void(__stdcall* cbException)(unsigned int nMsgType, void* pUser), void* pUser);

    // ch:注册单个事件回调 | en:Register Event CallBack
    int RegisterEventCallBack(const char* pEventName, void(__stdcall* cbEvent)(MV_EVENT_OUT_INFO * pEventInfo, void* pUser), void* pUser);

    // ch:强制IP | en:Force IP
    int ForceIp(unsigned int nIP, unsigned int nSubNetMask, unsigned int nDefaultGateWay);

    // ch:配置IP方式 | en:IP configuration method
    int SetIpConfig(unsigned int nType);

    // ch:设置网络传输模式 | en:Set Net Transfer Mode
    int SetNetTransMode(unsigned int nType);

    // ch:像素格式转换 | en:Pixel format conversion
    int ConvertPixelType(MV_CC_PIXEL_CONVERT_PARAM* pstCvtParam);

    // ch:保存图片 | en:save image
    int SaveImage(MV_SAVE_IMAGE_PARAM_EX* pstParam);

    // ch:保存图片为文件 | en:Save the image as a file
    int SaveImageToFile(MV_SAVE_IMG_TO_FILE_PARAM* pstParam);

    // ch:绘制圆形辅助线 | en:Draw circle auxiliary line
    int DrawCircle(MVCC_CIRCLE_INFO* pCircleInfo);

    // ch:绘制线形辅助线 | en:Draw lines auxiliary line
    int DrawLines(MVCC_LINES_INFO* pLinesInfo);

    //读取相机中的图像
    int ReadBuffer(cv::Mat &image);

    //保存相机中的图像
    int SaveBuffer(QByteArray imageName);

private:

    void *m_hDevHandle;
};
#endif//_MV_CAMERA_H_

2.cmvcamera.cpp

#include "cmvcamera.h"

CMvCamera::CMvCamera()
{
    m_hDevHandle = MV_NULL;
}

CMvCamera::~CMvCamera()
{
    if (m_hDevHandle)
    {
        MV_CC_DestroyHandle(m_hDevHandle);
        m_hDevHandle = MV_NULL;
    }
}

// ch:获取SDK版本号 | en:Get SDK Version
int CMvCamera::GetSDKVersion()
{
    return MV_CC_GetSDKVersion();
}

// ch:枚举设备 | en:Enumerate Device
int CMvCamera::EnumDevices(unsigned int nTLayerType, MV_CC_DEVICE_INFO_LIST* pstDevList)
{
    return MV_CC_EnumDevices(nTLayerType, pstDevList);
}

// ch:判断设备是否可达 | en:Is the device accessible
bool CMvCamera::IsDeviceAccessible(MV_CC_DEVICE_INFO* pstDevInfo, unsigned int nAccessMode)
{
    return MV_CC_IsDeviceAccessible(pstDevInfo, nAccessMode);
}

// ch:打开设备 | en:Open Device
int CMvCamera::Open(MV_CC_DEVICE_INFO* pstDeviceInfo)
{
    if (MV_NULL == pstDeviceInfo)
    {
        return MV_E_PARAMETER;
    }

    if (m_hDevHandle)
    {
        return MV_E_CALLORDER;
    }

    int nRet  = MV_CC_CreateHandle(&m_hDevHandle, pstDeviceInfo);
    if (MV_OK != nRet)
    {
        return nRet;
    }

    nRet = MV_CC_OpenDevice(m_hDevHandle);
    if (MV_OK != nRet)
    {
        MV_CC_DestroyHandle(m_hDevHandle);
        m_hDevHandle = MV_NULL;
    }

    return nRet;
}

// ch:关闭设备 | en:Close Device
int CMvCamera::Close()
{
    if (MV_NULL == m_hDevHandle)
    {
        return MV_E_HANDLE;
    }

    MV_CC_CloseDevice(m_hDevHandle);

    int nRet = MV_CC_DestroyHandle(m_hDevHandle);
    m_hDevHandle = MV_NULL;

    return nRet;
}

// ch:判断相机是否处于连接状态 | en:Is The Device Connected
bool CMvCamera::IsDeviceConnected()
{
    return MV_CC_IsDeviceConnected(m_hDevHandle);
}

// ch:注册图像数据回调 | en:Register Image Data CallBack
int CMvCamera::RegisterImageCallBack(void(__stdcall* cbOutput)(unsigned char * pData, MV_FRAME_OUT_INFO_EX* pFrameInfo, void* pUser), void* pUser)
{
    return MV_CC_RegisterImageCallBackEx(m_hDevHandle, cbOutput, pUser);
}

// ch:注册彩色图像数据回调
int CMvCamera::RegisterImageCallBackRGB(void(__stdcall* cbOutput)(unsigned char * pData, MV_FRAME_OUT_INFO_EX* pFrameInfo, void* pUser), void* pUser)
{
    return MV_CC_RegisterImageCallBackForRGB(m_hDevHandle, cbOutput, pUser);
}

// ch:开启抓图 | en:Start Grabbing
int CMvCamera::StartGrabbing()
{
    return MV_CC_StartGrabbing(m_hDevHandle);
}

// ch:停止抓图 | en:Stop Grabbing
int CMvCamera::StopGrabbing()
{
    return MV_CC_StopGrabbing(m_hDevHandle);
}

// ch:主动获取一帧图像数据 | en:Get one frame initiatively
int CMvCamera::GetImageBuffer(MV_FRAME_OUT* pFrame, int nMsec)
{
    return MV_CC_GetImageBuffer(m_hDevHandle, pFrame, nMsec);
}

// ch:释放图像缓存 | en:Free image buffer
int CMvCamera::FreeImageBuffer(MV_FRAME_OUT* pFrame)
{
    return MV_CC_FreeImageBuffer(m_hDevHandle, pFrame);
}

// ch:设置显示窗口句柄 | en:Set Display Window Handle
int CMvCamera::DisplayOneFrame(MV_DISPLAY_FRAME_INFO* pDisplayInfo)
{
    return MV_CC_DisplayOneFrame(m_hDevHandle, pDisplayInfo);
}

// ch:设置SDK内部图像缓存节点个数 | en:Set the number of the internal image cache nodes in SDK
int CMvCamera::SetImageNodeNum(unsigned int nNum)
{
    return MV_CC_SetImageNodeNum(m_hDevHandle, nNum);
}

// ch:获取设备信息 | en:Get device information
int CMvCamera::GetDeviceInfo(MV_CC_DEVICE_INFO* pstDevInfo)
{
    return MV_CC_GetDeviceInfo(m_hDevHandle, pstDevInfo);
}

// ch:获取GEV相机的统计信息 | en:Get detect info of GEV camera
int CMvCamera::GetGevAllMatchInfo(MV_MATCH_INFO_NET_DETECT* pMatchInfoNetDetect)
{
    if (MV_NULL == pMatchInfoNetDetect)
    {
        return MV_E_PARAMETER;
    }

    MV_CC_DEVICE_INFO stDevInfo = {0};
    GetDeviceInfo(&stDevInfo);
    if (stDevInfo.nTLayerType != MV_GIGE_DEVICE)
    {
        return MV_E_SUPPORT;
    }

    MV_ALL_MATCH_INFO struMatchInfo = {0};

    struMatchInfo.nType = MV_MATCH_TYPE_NET_DETECT;
    struMatchInfo.pInfo = pMatchInfoNetDetect;
    struMatchInfo.nInfoSize = sizeof(MV_MATCH_INFO_NET_DETECT);
    memset(struMatchInfo.pInfo, 0, sizeof(MV_MATCH_INFO_NET_DETECT));

    return MV_CC_GetAllMatchInfo(m_hDevHandle, &struMatchInfo);
}

// ch:获取U3V相机的统计信息 | en:Get detect info of U3V camera
int CMvCamera::GetU3VAllMatchInfo(MV_MATCH_INFO_USB_DETECT* pMatchInfoUSBDetect)
{
    if (MV_NULL == pMatchInfoUSBDetect)
    {
        return MV_E_PARAMETER;
    }

    MV_CC_DEVICE_INFO stDevInfo = {0};
    GetDeviceInfo(&stDevInfo);
    if (stDevInfo.nTLayerType != MV_USB_DEVICE)
    {
        return MV_E_SUPPORT;
    }

    MV_ALL_MATCH_INFO struMatchInfo = {0};

    struMatchInfo.nType = MV_MATCH_TYPE_USB_DETECT;
    struMatchInfo.pInfo = pMatchInfoUSBDetect;
    struMatchInfo.nInfoSize = sizeof(MV_MATCH_INFO_USB_DETECT);
    memset(struMatchInfo.pInfo, 0, sizeof(MV_MATCH_INFO_USB_DETECT));

    return MV_CC_GetAllMatchInfo(m_hDevHandle, &struMatchInfo);
}

// ch:获取和设置Int型参数，如 Width和Height，详细内容参考SDK安装目录下的 MvCameraNode.xlsx 文件
// en:Get Int type parameters, such as Width and Height, for details please refer to MvCameraNode.xlsx file under SDK installation directory
int CMvCamera::GetIntValue(IN const char* strKey, OUT MVCC_INTVALUE_EX *pIntValue)
{
    return MV_CC_GetIntValueEx(m_hDevHandle, strKey, pIntValue);
}

int CMvCamera::SetIntValue(IN const char* strKey, IN int64_t nValue)
{
    return MV_CC_SetIntValueEx(m_hDevHandle, strKey, nValue);
}

// ch:获取和设置Enum型参数，如 PixelFormat，详细内容参考SDK安装目录下的 MvCameraNode.xlsx 文件
// en:Get Enum type parameters, such as PixelFormat, for details please refer to MvCameraNode.xlsx file under SDK installation directory
int CMvCamera::GetEnumValue(IN const char* strKey, OUT MVCC_ENUMVALUE *pEnumValue)
{
    return MV_CC_GetEnumValue(m_hDevHandle, strKey, pEnumValue);
}

int CMvCamera::SetEnumValue(IN const char* strKey, IN unsigned int nValue)
{
    return MV_CC_SetEnumValue(m_hDevHandle, strKey, nValue);
}

int CMvCamera::SetEnumValueByString(IN const char* strKey, IN const char* sValue)
{
    return MV_CC_SetEnumValueByString(m_hDevHandle, strKey, sValue);
}

int CMvCamera::GetEnumEntrySymbolic(IN const char* strKey, IN MVCC_ENUMENTRY* pstEnumEntry)
{
    return MV_CC_GetEnumEntrySymbolic(m_hDevHandle, strKey, pstEnumEntry);
}

// ch:获取和设置Float型参数，如 ExposureTime和Gain，详细内容参考SDK安装目录下的 MvCameraNode.xlsx 文件
// en:Get Float type parameters, such as ExposureTime and Gain, for details please refer to MvCameraNode.xlsx file under SDK installation directory
int CMvCamera::GetFloatValue(IN const char* strKey, OUT MVCC_FLOATVALUE *pFloatValue)
{
    return MV_CC_GetFloatValue(m_hDevHandle, strKey, pFloatValue);
}

int CMvCamera::SetFloatValue(IN const char* strKey, IN float fValue)
{
    return MV_CC_SetFloatValue(m_hDevHandle, strKey, fValue);
}

// ch:获取和设置Bool型参数，如 ReverseX，详细内容参考SDK安装目录下的 MvCameraNode.xlsx 文件
// en:Get Bool type parameters, such as ReverseX, for details please refer to MvCameraNode.xlsx file under SDK installation directory
int CMvCamera::GetBoolValue(IN const char* strKey, OUT bool *pbValue)
{
    return MV_CC_GetBoolValue(m_hDevHandle, strKey, pbValue);
}

int CMvCamera::SetBoolValue(IN const char* strKey, IN bool bValue)
{
    return MV_CC_SetBoolValue(m_hDevHandle, strKey, bValue);
}

// ch:获取和设置String型参数，如 DeviceUserID，详细内容参考SDK安装目录下的 MvCameraNode.xlsx 文件UserSetSave
// en:Get String type parameters, such as DeviceUserID, for details please refer to MvCameraNode.xlsx file under SDK installation directory
int CMvCamera::GetStringValue(IN const char* strKey, MVCC_STRINGVALUE *pStringValue)
{
    return MV_CC_GetStringValue(m_hDevHandle, strKey, pStringValue);
}

int CMvCamera::SetStringValue(IN const char* strKey, IN const char* strValue)
{
    return MV_CC_SetStringValue(m_hDevHandle, strKey, strValue);
}

// ch:执行一次Command型命令，如 UserSetSave，详细内容参考SDK安装目录下的 MvCameraNode.xlsx 文件
// en:Execute Command once, such as UserSetSave, for details please refer to MvCameraNode.xlsx file under SDK installation directory
int CMvCamera::CommandExecute(IN const char* strKey)
{
    return MV_CC_SetCommandValue(m_hDevHandle, strKey);
}

// ch:探测网络最佳包大小(只对GigE相机有效) | en:Detection network optimal package size(It only works for the GigE camera)
int CMvCamera::GetOptimalPacketSize(unsigned int* pOptimalPacketSize)
{
    if (MV_NULL == pOptimalPacketSize)
    {
        return MV_E_PARAMETER;
    }

    int nRet = MV_CC_GetOptimalPacketSize(m_hDevHandle);
    if (nRet < MV_OK)
    {
        return nRet;
    }

    *pOptimalPacketSize = (unsigned int)nRet;

    return MV_OK;
}

// ch:注册消息异常回调 | en:Register Message Exception CallBack
int CMvCamera::RegisterExceptionCallBack(void(__stdcall* cbException)(unsigned int nMsgType, void* pUser),void* pUser)
{
    return MV_CC_RegisterExceptionCallBack(m_hDevHandle, cbException, pUser);
}

// ch:注册单个事件回调 | en:Register Event CallBack
int CMvCamera::RegisterEventCallBack(const char* pEventName, void(__stdcall* cbEvent)(MV_EVENT_OUT_INFO * pEventInfo, void* pUser), void* pUser)
{
    return MV_CC_RegisterEventCallBackEx(m_hDevHandle, pEventName, cbEvent, pUser);
}

// ch:强制IP | en:Force IP
int CMvCamera::ForceIp(unsigned int nIP, unsigned int nSubNetMask, unsigned int nDefaultGateWay)
{
    return MV_GIGE_ForceIpEx(m_hDevHandle, nIP, nSubNetMask, nDefaultGateWay);
}

// ch:配置IP方式 | en:IP configuration method
int CMvCamera::SetIpConfig(unsigned int nType)
{
    return MV_GIGE_SetIpConfig(m_hDevHandle, nType);
}

// ch:设置网络传输模式 | en:Set Net Transfer Mode
int CMvCamera::SetNetTransMode(unsigned int nType)
{
    return MV_GIGE_SetNetTransMode(m_hDevHandle, nType);
}

// ch:像素格式转换 | en:Pixel format conversion
int CMvCamera::ConvertPixelType(MV_CC_PIXEL_CONVERT_PARAM* pstCvtParam)
{
    return MV_CC_ConvertPixelType(m_hDevHandle, pstCvtParam);
}

// ch:保存图片 | en:save image
int CMvCamera::SaveImage(MV_SAVE_IMAGE_PARAM_EX* pstParam)
{
    return MV_CC_SaveImageEx2(m_hDevHandle, pstParam);
}

// ch:保存图片为文件 | en:Save the image as a file
int CMvCamera::SaveImageToFile(MV_SAVE_IMG_TO_FILE_PARAM* pstSaveFileParam)
{
    return MV_CC_SaveImageToFile(m_hDevHandle, pstSaveFileParam);
}

// ch:绘制圆形辅助线 | en:Draw circle auxiliary line
int CMvCamera::DrawCircle(MVCC_CIRCLE_INFO* pCircleInfo)
{
    return MV_CC_DrawCircle(m_hDevHandle, pCircleInfo);
}

// ch:绘制线形辅助线 | en:Draw lines auxiliary line
int CMvCamera::DrawLines(MVCC_LINES_INFO* pLinesInfo)
{
    return MV_CC_DrawLines(m_hDevHandle, pLinesInfo);
}

//读取相机中的图像
int CMvCamera::ReadBuffer(cv::Mat &image)
{
    unsigned int nRecvBufSize = 0;
    MVCC_INTVALUE_EX stParam;
    memset(&stParam,0,sizeof(MVCC_INTVALUE_EX));
    int nRet = GetIntValue("PayloadSize",&stParam);
    if(MV_OK != nRet)
    {
        return nRet;
    }
    nRecvBufSize = stParam.nCurValue;
    unsigned char* pDate;
    pDate = (unsigned char *)malloc(nRecvBufSize);
    MV_FRAME_OUT_INFO_EX stImageInfo;
    memset(&stImageInfo,0,sizeof(MV_FRAME_OUT_INFO));
    nRet = MV_CC_GetOneFrameTimeout(m_hDevHandle,pDate,nRecvBufSize,&stImageInfo,500);
    if(MV_OK != nRet)
    {
        return nRet;
    }

    //用于保存图像的缓存
    unsigned int nBufSizeForSaveImage = stImageInfo.nWidth * stImageInfo.nHeight * 3 + 2048;
    unsigned char* pBufForSaveImage = (unsigned char*)malloc(nBufSizeForSaveImage);

    //判断是否为黑白图像
    bool isMono;
    cv::Mat getImage;
    switch(stImageInfo.enPixelType)
    {
    case PixelType_Gvsp_Mono8:
    case PixelType_Gvsp_Mono10:
    case PixelType_Gvsp_Mono10_Packed:
    case PixelType_Gvsp_Mono12:
    case PixelType_Gvsp_Mono12_Packed:
        isMono=true;
        break;
    default:
        isMono=false;
        break;
    }
    if(isMono)
    {
        getImage = cv::Mat(stImageInfo.nHeight,stImageInfo.nWidth,CV_8UC1,pDate);   //单色
    }
    else
    {
        //转换图像格式为RGB8
        MV_CC_PIXEL_CONVERT_PARAM stConvertParam;
        memset(&stConvertParam,0,sizeof(MV_CC_PIXEL_CONVERT_PARAM));
        stConvertParam.nWidth = stImageInfo.nWidth;
        stConvertParam.nHeight = stImageInfo.nHeight;
        stConvertParam.pSrcData = pDate;                                //输入数据缓存
        stConvertParam.nSrcDataLen = stImageInfo.nFrameLen;
        stConvertParam.enSrcPixelType = stImageInfo.enPixelType;
        //stConvertParam.enDstPixelType = PixelType_Gvsp_BGR8_Packed;   //输出像素格式
        stConvertParam.enDstPixelType = PixelType_Gvsp_RGB8_Packed;
        stConvertParam.pDstBuffer = pBufForSaveImage;                   //输出数据缓存
        stConvertParam.nDstBufferSize = nBufSizeForSaveImage;           //输出缓存大小
        MV_CC_ConvertPixelType(m_hDevHandle, &stConvertParam);
        getImage = cv::Mat(stImageInfo.nHeight,stImageInfo.nWidth,CV_8UC3,pBufForSaveImage);
    }
    getImage.copyTo(image);
    getImage.release();
    free(pDate);
    free(pBufForSaveImage);
    return MV_OK;
}

//读取保存相机中的图像
int CMvCamera::SaveBuffer(QByteArray imageName)
{
    unsigned int nRecvBufSize = 0;
    MVCC_INTVALUE_EX stParam;
    memset(&stParam,0,sizeof(MVCC_INTVALUE_EX));
    int nRet = GetIntValue("PayloadSize",&stParam);   //获取Integer属性值
    if(MV_OK != nRet)
    {
        return nRet;
    }
    nRecvBufSize = stParam.nCurValue;
    unsigned char* pDate;
    pDate = (unsigned char *)malloc(nRecvBufSize);
    MV_FRAME_OUT_INFO_EX stImageInfo;
    memset(&stImageInfo,0,sizeof(MV_FRAME_OUT_INFO));
    nRet = MV_CC_GetOneFrameTimeout(m_hDevHandle,pDate,nRecvBufSize,&stImageInfo,500);   //采用超时机制获取一帧图片
    if(MV_OK != nRet)
    {
        return nRet;
    }
    MV_SAVE_IMG_TO_FILE_PARAM stSaveFileParam;
    memset(&stSaveFileParam,0,sizeof(MV_SAVE_IMG_TO_FILE_PARAM));
    stSaveFileParam.enImageType = MV_Image_Bmp;
    stSaveFileParam.enPixelType = stImageInfo.enPixelType;
    stSaveFileParam.nWidth      = stImageInfo.nWidth;
    stSaveFileParam.nHeight     = stImageInfo.nHeight;
    stSaveFileParam.nDataLen    = stImageInfo.nFrameLen;
    stSaveFileParam.pData       = pDate;
    stSaveFileParam.iMethodValue = 0;
    sprintf_s(stSaveFileParam.pImagePath,256,imageName.data());   //文件名
    nRet = SaveImageToFile(&stSaveFileParam);   //保存图片为文件
    if(MV_OK != nRet)
    {
        return nRet;
    }
    free(pDate);
    return MV_OK;
}

3.capturethread.h

#ifndef CAPTURETHREAD_H
#define CAPTURETHREAD_H

#include <QObject>
#include <QThread>
#include <QImage>
#include <QDir>
#include <QTimer>
#include <QDate>
#include <QDateTime>
#include <QDebug>
#include "cmvcamera.h"

#define LOGDEBUG qDebug()<<QTime::currentTime().toString("[hh:mm:ss:zzz]")

class CaptureThread : public QThread
{
    Q_OBJECT

public:
     explicit CaptureThread(QObject *parent = nullptr);
     ~CaptureThread();

    void initThread();
    void setCameraPtr(CMvCamera *camera);
    void setCameraSignal(int time,int num);
    void setSavePath(QString originPath);
    void setSaveFlag(bool saveFlag);
    void setSwitchFlag(bool switchFlag);
    void setSoftModeFlag(bool softModeFlag);
    void setImageBuffer(cv::Mat imageMat);

    void run();

    QImage cvMatToImage(const cv::Mat imageMat);
    void saveOriginImage(cv::Mat imageMat);

signals:
    void signal_newImage(QImage newImage);

private:
    static void __stdcall ImageCallback(unsigned char * pData,MV_FRAME_OUT_INFO_EX* pFrameInfo,void* pUser);

private:
    CMvCamera *m_cameraPtr = NULL;
    int m_imageTime;   //抓拍间隔时间
    int m_imageNum;    //抓拍间隔次数
    QString m_originPath;   //原图保存路径

    bool m_saveFlag;        //保存图像标志
    bool m_switchFlag;      //线程开启标志
    bool m_softModeFlag;    //软触发模式标志

};
#endif // CAPTURETHREAD_H

4.capturethread.cpp

#include "capturethread.h"

CaptureThread::CaptureThread(QObject *parent)
    : QThread{parent}
{
    this->initThread();
}

CaptureThread::~CaptureThread()
{

}

//初始化图像捕获线程
void CaptureThread::initThread()
{
    m_imageTime = 1000;
    m_imageNum = 1;
    m_originPath = "";
    m_saveFlag = false;
    m_switchFlag = false;
    m_softModeFlag = false;
}

//设置相机指针
void CaptureThread::setCameraPtr(CMvCamera *camera)
{
    m_cameraPtr = camera;

    //注册回调函数
    int nRet = m_cameraPtr->RegisterImageCallBackRGB(ImageCallback,this);    //彩色相机
    if(MV_OK != nRet)
    {
        LOGDEBUG<<"相机注册回调函数失败";
    }
    else
    {
        LOGDEBUG<<"相机注册回调函数成功";
    }
}

//设置相机拍照间隔时间和次数
void CaptureThread::setCameraSignal(int time,int num)
{
    m_imageTime = time*1000;
    m_imageNum = num;
    if(m_imageTime <= 0)
    {
        m_imageTime = 1000;
    }
    if(m_imageNum <= 0)
    {
        m_imageNum = 1;
    }
}

//设置图像保存路径
void CaptureThread::setSavePath(QString originPath)
{
    m_originPath = originPath;
    LOGDEBUG<<"相机原图保存路径:"<<m_originPath;
}

//设置是否保存图像
void CaptureThread::setSaveFlag(bool saveFlag)
{
    m_saveFlag = saveFlag;
}

//设置线程开关
void CaptureThread::setSwitchFlag(bool switchFlag)
{
    m_switchFlag = switchFlag;
}

//设置软触发
void CaptureThread::setSoftModeFlag(bool softModeFlag)
{
    m_softModeFlag = softModeFlag;
}

//获取回调返回的图像
void CaptureThread::setImageBuffer(cv::Mat imageMat)
{
    LOGDEBUG<<"获取回调图像";
    if(m_saveFlag)
    {
        m_saveFlag = false;
        saveOriginImage(imageMat);
    }
    emit signal_newImage(cvMatToImage(imageMat));
}

//线程运行
void CaptureThread::run()
{
    static int startNum = 0;
    while(m_switchFlag)
    {
        if(startNum < m_imageNum)
        {
            startNum++;
            if(m_softModeFlag)
            {
                m_cameraPtr->CommandExecute("TriggerSoftware");
            }
            m_saveFlag = true;
        }
        else
        {
            startNum = 0;
            m_switchFlag = false;
        }
        msleep(m_imageTime);
    }
}

//cv::Mat转QImage
QImage CaptureThread::cvMatToImage(const cv::Mat imageMat)
{
    //颜色转换,opencv默认的彩色图像的颜色空间是BGR
    //cvtColor(imageMat,imageMat,cv::COLOR_BGR2RGB);

    QImage myImage;
    if(imageMat.channels() > 1)
    {
        myImage = QImage((const unsigned char*)(imageMat.data),imageMat.cols,imageMat.rows,QImage::Format_RGB888);   //彩色图
    }
    else
    {
        myImage = QImage((const unsigned char*)(imageMat.data),imageMat.cols,imageMat.rows,QImage::Format_Indexed8);   //灰度图
    }
    return myImage;
}

//保存原图
void CaptureThread::saveOriginImage(cv::Mat imageMat)
{
    clock_t originClock = -clock();
    QString curTime = QTime::currentTime().toString("hhmmss");
    QString iamgeName = m_originPath + "GrabImage_" + curTime + ".jpg";
    cv::Mat saveMat;
    cvtColor(imageMat,saveMat,cv::COLOR_BGR2RGB);   //颜色格式转换
    imwrite(iamgeName.toStdString(),saveMat);
    originClock += clock();
    LOGDEBUG<<"保存原图耗时:"<<originClock<<"ms";   //测试在20ms左右
}

//回调函数
void __stdcall CaptureThread::ImageCallback(unsigned char * pData,MV_FRAME_OUT_INFO_EX* pFrameInfo,void* pUser)
{
    //LOGDEBUG<<"回调触发";
    CaptureThread* pThread = static_cast<CaptureThread *>(pUser);

    //创建cv::Mat对象
    cv::Mat showMat(pFrameInfo->nHeight,pFrameInfo->nWidth,CV_8UC3,pData);   //彩色

    //将图像保存到容器中
    pThread->setImageBuffer(showMat);
}

5.widget.h

#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include <QMessageBox>
#include "capturethread.h"

QT_BEGIN_NAMESPACE
namespace Ui { class Widget; }
QT_END_NAMESPACE

class Widget : public QWidget
{
    Q_OBJECT

public:
    Widget(QWidget *parent = nullptr);
    ~Widget();

    void initWidget();

private slots:
    void slot_displayImage(QImage myImage);
    void on_pb_find_clicked();
    void on_pb_open_clicked();
    void on_pb_close_clicked();
    void on_pb_set_clicked();
    void on_pb_start_clicked();
    void on_pb_stop_clicked();
    void on_pb_grab_clicked();

private:
    Ui::Widget *ui;

    bool m_bOpenDevice;
    QSize m_showSize;

    CaptureThread *m_captureThread;

    MV_CC_DEVICE_INFO_LIST m_stDevList;
    CMvCamera *m_pcMyCamera = NULL;
    MV_SAVE_IAMGE_TYPE m_nSaveImageType = MV_Image_Bmp;

};
#endif // WIDGET_H

6.widget.cpp

#include "widget.h"
#include "ui_widget.h"

Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);

    initWidget();
}

Widget::~Widget()
{
    delete ui;
    if(m_pcMyCamera)
    {
        m_pcMyCamera->Close();
        delete m_pcMyCamera;
        m_pcMyCamera = NULL;
    }
}

//初始化
void Widget::initWidget()
{
    //设置窗口属性
    this->setWindowTitle("抓图测试");
    ui->pb_close->setEnabled(false);
    ui->pb_stop->setEnabled(false);

    //初始化变量
    m_bOpenDevice = false;
    m_showSize = QSize(768,512);

    //生成保存图片的文件夹
    QString imagePath = QCoreApplication::applicationDirPath() + "/SaveImage/";
    QDir dstDir(imagePath);
    if(!dstDir.exists())
    {
        if(!dstDir.mkdir(imagePath))
        {
            LOGDEBUG<<"创建图像保存文件夹失败！";
        }
        else
        {
            LOGDEBUG<<"创建图像保存文件夹成功!";
        }
    }

    //初始化线程
    m_captureThread = new CaptureThread();
    connect(m_captureThread,SIGNAL(signal_newImage(QImage)),this,SLOT(slot_displayImage(QImage)),Qt::BlockingQueuedConnection);
    m_captureThread->setSavePath(imagePath);

}

//显示图像
void Widget::slot_displayImage(QImage myImage)
{
    QPixmap newPixmap = QPixmap::fromImage(myImage).scaled(m_showSize,Qt::KeepAspectRatio,Qt::SmoothTransformation);
    ui->lb_show->setPixmap(newPixmap);
}

//查找设备
void Widget::on_pb_find_clicked()
{
    ui->cb_devices->clear();
    memset(&m_stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    //枚举子网内所有设备
    int nRet = CMvCamera::EnumDevices(MV_GIGE_DEVICE | MV_USB_DEVICE,&m_stDevList);
    if(MV_OK != nRet)
    {
        LOGDEBUG<<"设备枚举失败";
        return;
    }
    for(unsigned int i = 0; i < m_stDevList.nDeviceNum; i++)
    {
        MV_CC_DEVICE_INFO* pDeviceInfo = m_stDevList.pDeviceInfo[i];
        QString strModelName = "";
        if(pDeviceInfo->nTLayerType == MV_USB_DEVICE)
        {
            strModelName = (char*)pDeviceInfo->SpecialInfo.stUsb3VInfo.chModelName;
        }
        else if(pDeviceInfo->nTLayerType == MV_GIGE_DEVICE)
        {
            strModelName = (char*)pDeviceInfo->SpecialInfo.stGigEInfo.chModelName;
        }
        else
        {
            QMessageBox::warning(this,"警告","未知设备枚举！");
            return;
        }
        LOGDEBUG<<"相机型号:"<<strModelName;
        ui->cb_devices->addItem(strModelName);
    }
}

//打开设备
void Widget::on_pb_open_clicked()
{
    if(m_bOpenDevice)
    {
        return;
    }
    QString deviceModel = ui->cb_devices->currentText();
    if(deviceModel == "")
    {
        QMessageBox::warning(this,"警告","请先查找并选择设备！");
        return;
    }

    //相机对象
    m_pcMyCamera = new CMvCamera;

    //打开设备
    int nIndex = ui->cb_devices->currentIndex();
    int nRet = m_pcMyCamera->Open(m_stDevList.pDeviceInfo[nIndex]);
    if(MV_OK != nRet)
    {
        delete m_pcMyCamera;
        m_pcMyCamera = NULL;
        QMessageBox::warning(this,"警告","打开设备失败！");
        return;
    }
    else
    {
        LOGDEBUG<<"打开设备成功！";
    }

    //设置为触发模式,触发源为软触发
    m_pcMyCamera->SetEnumValue("TriggerMode",1);
    m_pcMyCamera->SetEnumValue("TriggerSource",7);

    //设置曝光时间和增益
    int exposureTime = ui->le_exposureTime->text().toInt();
    int gain = ui->le_gain->text().toInt();
    m_pcMyCamera->SetFloatValue("ExposureTime",exposureTime);
    m_pcMyCamera->SetEnumValue("GainAuto",0);
    m_pcMyCamera->SetFloatValue("Gain",gain);

    //相机线程设置,注册回调
    m_captureThread->setCameraPtr(m_pcMyCamera);

    //开启相机采集
    m_pcMyCamera->StartGrabbing();

    //开启标志位
    m_bOpenDevice = true;

    //使能按键
    ui->pb_find->setEnabled(false);
    ui->pb_open->setEnabled(false);
    ui->pb_close->setEnabled(true);
}

//关闭设备
void Widget::on_pb_close_clicked()
{
    if(m_bOpenDevice)
    {
        m_bOpenDevice = false;
        if(m_pcMyCamera)
        {
            m_pcMyCamera->Close();
            delete m_pcMyCamera;
            m_pcMyCamera = NULL;
        }
    }

    //使能按键
    ui->pb_find->setEnabled(true);
    ui->pb_open->setEnabled(true);
    ui->pb_close->setEnabled(false);
}

//设置
void Widget::on_pb_set_clicked()
{
    if(!m_bOpenDevice)
    {
        QMessageBox::warning(this,"警告","设置失败,请打开设备！");
        return;
    }

    int exposureTime = ui->le_exposureTime->text().toInt();
    int gain = ui->le_gain->text().toInt();
    //设置曝光时间
    m_pcMyCamera->SetFloatValue("ExposureTime",exposureTime);

    //设置增益前先把自动增益关闭，失败无需返回
    m_pcMyCamera->SetEnumValue("GainAuto",0);
    m_pcMyCamera->SetFloatValue("Gain",gain);

    //设置显示宽度和高度
    int showW = ui->le_w->text().toInt();
    int showH = ui->le_h->text().toInt();
    if(showW < 768)
    {
        showW = 768;
        ui->le_w->setText("768");
    }
    if(showH < 512)
    {
        showH = 512;
        ui->le_h->setText("512");
    }
    m_showSize = QSize(showW,showH);

}

//开始采集
//点击开始采集后,会关闭触发模式,相机就会不断回调,实时显示相机图像
void Widget::on_pb_start_clicked()
{
    if(!m_bOpenDevice)
    {
        QMessageBox::warning(this,"警告","采集失败,请打开设备！");
        return;
    }

    //不保存图像
    m_captureThread->setSaveFlag(false);

    //关闭触发模式
    m_captureThread->setSoftModeFlag(false);
    m_pcMyCamera->SetEnumValue("TriggerMode",0);

    //使能按键
    ui->pb_find->setEnabled(false);
    ui->pb_open->setEnabled(false);
    ui->pb_close->setEnabled(false);
    ui->pb_start->setEnabled(false);
    ui->pb_stop->setEnabled(true);
}

//停止采集
//点击停止采集后,会开启触发模式并设置为软触发,需要调用命令触发回调
void Widget::on_pb_stop_clicked()
{
    if(!m_bOpenDevice)
    {
        QMessageBox::warning(this,"警告","采集失败,请打开设备！");
        return;
    }

    //设置为触发模式,触发源为软触发
    m_captureThread->setSoftModeFlag(true);
    m_pcMyCamera->SetEnumValue("TriggerMode",1);
    m_pcMyCamera->SetEnumValue("TriggerSource",7);

    //使能按键
    ui->pb_find->setEnabled(false);
    ui->pb_open->setEnabled(false);
    ui->pb_close->setEnabled(true);
    ui->pb_start->setEnabled(true);
    ui->pb_stop->setEnabled(false);
    ui->pb_grab->setEnabled(true);
}

//抓拍图像
void Widget::on_pb_grab_clicked()
{
    if(!m_bOpenDevice)
    {
        QMessageBox::warning(this,"警告","抓拍失败,请打开设备！");
        return;
    }

    int time = ui->le_time->text().toInt();
    int num = ui->le_num->text().toInt();
    m_captureThread->setCameraSignal(time,num);
    m_captureThread->setSwitchFlag(true);
    m_captureThread->setSaveFlag(true);
    m_captureThread->start();
}

7.widget.ui
请添加图片描述

总结

这个示例相较于前文，也是增加了下设置相机曝光时间和增益这两个参数的功能，可以看到也是比较简单的，主要是要了解相机SDK相关的接口，并且海康相机的相关文档和示例也是很详细的，类似这样的开发，我们首先要做的就是从文档中找答案~

hello：
共同学习，共同进步，如果还有相关问题，可在评论区留言进行讨论。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1544655.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

STM32存储左右互搏 SPI总线FATS文件读写SD/MicroSD/TF卡

STM32存储左右互搏 SPI总线FATS文件读写SD/MicroSD/TF卡

STM32存储左右互搏 SPI总线FATS文件读写SD/MicroSD/TF卡 SD/MicroSD/TF卡是基于FLASH的一种常见非易失存储单元&#xff0c;由接口协议电路和FLASH构成。市面上由不同尺寸和不同容量的卡&#xff0c;手机领域用的TF卡实际就是MicroSD卡&#xff0c;尺寸比SD卡小&#xff0c;而…
阅读更多...
iOS - Runtime-isa详解（位域、union（共用体）、位运算）

iOS - Runtime-isa详解（位域、union（共用体）、位运算）

文章目录 iOS - Runtime-isa详解&#xff08;位域、union&#xff08;共用体&#xff09;、位运算&#xff09;前言1. 位域介绍1.1 思路1.2 示例 - 结构体1.3 示例 - union&#xff08;共用体&#xff09;1.3.1 说明 1.4 结构体 对比 union&#xff08;共用体&#xff09; 2. a…
阅读更多...
【python--罗马数字转换阿拉伯数字】

【python--罗马数字转换阿拉伯数字】

&#x1f680; 作者 &#xff1a;“码上有前” &#x1f680; 文章简介 &#xff1a;Python &#x1f680; 欢迎小伙伴们 点赞&#x1f44d;、收藏⭐、留言&#x1f4ac; 罗马数字转换阿拉伯数字相关 根据长度给出罗马序列的值生成字典根据长度给出罗马序列的值生成列表将所有…
阅读更多...
酷开系统让用户和电视双向传递，酷开科技实现商业变现

酷开系统让用户和电视双向传递，酷开科技实现商业变现

电视在我们的日常生活中扮演着重要的角色。虽然&#xff0c;作为客厅C位的扛把子——电视的娱乐作用深入人心&#xff0c;但是&#xff0c;它的涵义和影响力却因我们每个人的具体生活环境而存在着种种差异&#xff0c;而我们的生活环境又受到我们所处的社会及文化环境的影响。 …
阅读更多...
原生 HTML/CSS/JS 实现右键菜单和二级菜单

原生 HTML/CSS/JS 实现右键菜单和二级菜单

文章来源&#xff1a;www.huhailong.vip 站点 文章源地址&#xff1a;https://www.huhailong.vip/article/1764653112011841538 Demo效果演示地址 先看效果图 {{{width“auto” height“auto”}}} 需要注意的就是边界检测处理&#xff0c;到极端点击底部和右侧时如果不做处理会…
阅读更多...
【网络爬虫】(2) requests模块，案例：网络图片爬取，附Python代码

【网络爬虫】(2) requests模块，案例：网络图片爬取，附Python代码

1. 基本原理 1.1 requests 模块 requests 是 Python 中一个非常流行的 HTTP 客户端库&#xff0c;用于发送所有的 HTTP 请求类型。它基于 urllib&#xff0c;但比 urllib 更易用。 中文文档地址&#xff1a;Requests: 让 HTTP 服务人类 — Requests 2.18.1 文档 &#xff0…
阅读更多...
centos 虚拟机 增加硬盘 虚拟机centos磁盘扩容

centos 虚拟机 增加硬盘 虚拟机centos磁盘扩容

2 在centos 7 系统中挂载磁盘 2.1 查看磁盘信息 进入centos 7系统中&#xff0c;输入“# df -h”命令&#xff0c;查看磁盘信息。 这里没有写显示新增的磁盘信息。 2.2 对新加的磁盘进行分区操作 2.2.1 查看磁盘容量和分区 2.2.2 创建分区 a. 选择新增的磁盘&#xff08;这…
阅读更多...
游戏本续航@控制中心的省电模式效果如何

游戏本续航@控制中心的省电模式效果如何

文章目录 节能模式长续航模式&#x1f47a;相关工具 节能模式长续航模式&#x1f47a; 蓝天模具Control Center中的模式 根据我的试验,以及软件的提示,可以发现 Power Saving是最省电的,儿Quiet模式并不省电,它会启用独立显卡,只不过风扇的转速不像娱乐模式和性能模式那么积极而…
阅读更多...
前端删除列表数据后页码重置逻辑

前端删除列表数据后页码重置逻辑

问题描述 需要调整页码的例子&#xff1a; 列表一共有10页数据&#xff0c;用户把第10页数据全部删除后&#xff0c;需要把数据重置成上一页&#xff0c;也就是第9页 不用调整页码的例子&#xff1a; 列表一共有1页数据&#xff0c;用户把本页数据全部删除后&#xff0c;页码…
阅读更多...
代码随想录day30（2）回溯：组合（leetcode77）

代码随想录day30（2）回溯：组合（leetcode77）

题目要求&#xff1a;给定两个整数 n 和 k&#xff0c;返回 1 ... n 中所有可能的 k 个数的组合。 思路&#xff1a;首先定义两个变量&#xff0c;一个存放符合条件的单一结果&#xff0c;另一个存放符合条件结果的集合&#xff0c;for循环用来横向遍历&#xff0c;递归用来纵…
阅读更多...
Mac电脑虚拟显示器：BetterDisplay Pro for Mac v2.0.11激活版

Mac电脑虚拟显示器：BetterDisplay Pro for Mac v2.0.11激活版

BetterDisplay Pro是一款由waydabber开发的Mac平台上的显示器校准软件&#xff0c;可以帮助用户调整显示器的颜色和亮度&#xff0c;以获得更加真实、清晰和舒适的视觉体验。 软件下载&#xff1a;BetterDisplay Pro for Mac v2.0.11激活版 以下是BetterDisplay Pro的主要特点&…
阅读更多...
8.软件工程

8.软件工程

整个章节偏向于记忆、背诵&#xff1b; 主要议题&#xff1a; 软件体系&#xff1a;3层&#xff1b; UML重点&#xff0c;重点记3要素中的关系、图&#xff1b; 1.软件体系结构 分层 优点&#xff1a;利于软件的重复利用&#xff1b; 缺点&#xff1a;以什么方式分层&#…
阅读更多...
2024 Python3.10 系统入门+进阶（三）：Python变量类型和运算符

2024 Python3.10 系统入门+进阶（三）：Python变量类型和运算符

目录 一、Python变量的定义和使用二、Python整数类型&#xff08;int&#xff09;详解三、Python小数/浮点数&#xff08;float&#xff09;类型详解四、Python复数类型(complex)详解---了解五、Python字符串详解(包含长字符串和原始字符串)5.1 处理字符串中的引号5.2 字符串的…
阅读更多...
【Linux系统】冯诺依曼与操作系统

【Linux系统】冯诺依曼与操作系统

什么是冯诺依曼体系结构&#xff1f; 如图即为冯诺依曼大致的体系结构图&#xff0c; 我们知道这些都是由我们的计算机硬件组成 输入设备&#xff1a;键盘&#xff0c; 鼠标&#xff0c; 摄像头&#xff0c; 话筒&#xff0c; 磁盘&#xff0c; 网卡... 输出设备&#xff1a…
阅读更多...
[HGAME 2023 week2]Designer

[HGAME 2023 week2]Designer

[HGAME 2023 week2]Designer 考点&#xff1a;XSS跨站脚本攻击&#xff0c;模板注入 代码审计 function auth(req, res, next) {const token req.headers["authorization"]if (!token) {return res.redirect("/")}try {const decoded jwt.verify(token,…
阅读更多...
你在测试金字塔的哪一层（下）

你在测试金字塔的哪一层（下）

​在《你在测试金字塔的哪一层&#xff08;上&#xff09;》中介绍了自动化测试的重要性以及测试金字塔。测试金字塔分为单元测试、服务测试、UI测试&#xff0c;它们分别是什么呢&#xff1f;本期文章让我们一起详细看看测试金字塔的不同层次。 一、单元测试 单元测试是指对程…
阅读更多...
蓝桥杯练习07小兔子爬楼梯

蓝桥杯练习07小兔子爬楼梯

小兔子爬楼梯 介绍 小兔子想去月球上旅行&#xff0c;假设小兔子拥有一个阶梯子&#xff0c;当你爬完层就可以到达月球&#xff0c;小兔子每次可以跳1或者2个台阶&#xff0c;小兔子有多少种跳法可以到达月球呢&#xff1f; 给定n是一个正整数&#xff0c;代表梯子的阶数&…
阅读更多...
apisix创建https

apisix创建https

总结了下apisix 使用https 的问题和方法 1、apisix 默认https 端口是9443 2、apisix 需要上传证书后才可以使用https 否二curl测试会报错 SSL routines:CONNECT_CR_SRVR_HELLO 3、apisix 上传证书方法 我是使用的自签名证书&#xff0c;注意自签名证书的Common Name 要写你…
阅读更多...
【教程】高效数据加密混淆方法及实现简介

【教程】高效数据加密混淆方法及实现简介

背景 在需要对数据进行传输或者表达时&#xff0c;通常要求数据加密的安全级别不高&#xff0c;但希望加解密时间复杂度尽可能低。这时使用传统的对称加密&#xff08;如3DES、AES&#xff09;或非对称加密&#xff08;如RSA、ECC&#xff09;显然不太适合。因为加密的安全级别…
阅读更多...
基于深度学习的海洋鱼类识别算法matlab仿真

基于深度学习的海洋鱼类识别算法matlab仿真

目录 1.算法运行效果图预览 2.算法运行软件版本 3.部分核心程序 4.算法理论概述 5.算法完整程序工程 1.算法运行效果图预览 2.算法运行软件版本 MATLAB2022a 3.部分核心程序 ............................................................ % 对测试集进行分类预测 [Pr…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023