devbox
繁依Fanyi0
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Qt+opencv+Linux+海康工业相机连接_linux添加相机

作者：繁依Fanyi0 | 2024-02-17 02:10:15

赞

踩

linux添加相机

前言

       本人需要在树莓派上部署深度学习推理模型 ，由于本实验室只有海康工业相机，因此通过借鉴博客和自主调试，完成了模型的部署。本文主要讲述如何在基于linux的Qt中成功连接海康工业相机，第一次尝试写博客，练练手感。

一、前期准备

      1、安装海康工业相机自带的MVS

       官方网址：海康机器人-机器视觉-下载中心 (hikrobotics.com)，下载自己对应的版本，解压后有适应各种架构计算机的压缩包，其中常用的是：

① 树梅派：armhf架构

② jetson nano: aarch64架构

③ PC: x86_64架构

解压后安装：
里面有一个INSTALL文件可以参考步骤如下：

安装前，需要获取root权限：sudo su 或 su root

tar-xzvf 文件名： 解压压缩包

cd MVS-2.1.0_x86_64_20201228/ ： 进入文件根目录

./setup.sh  ：运行安装脚本

安装完成在路径下/opt/MVS下会看到：

其中：

Sample：示例程序

lib:封装好的so库

include：头文件

doc:说明文档

最后测试是否安装成功，进入到bin文件夹，即在终端输入命令

  1. cd /opt/MVS/bin               
  2. ./MVS

如果成功弹出如下界面，表示安装成功

       2、opencv的编译

        opencv的编译算是一个运气活，如果你是那个天选之子的话可能一次就成功，博主本人在ubuntu上安装基本比较顺利，但是在树莓派上编译经历了一整天的折磨，通过修改各种报错，最后总算是成功了，这里不再具体讲如何编译，直接上链接

          参考博客：linux下编译opencv_opencv linux编译-CSDN博客

        3、Qt的安装

        参考博客： linux环境下安装QT超详细_qt-opensource-linux-CSDN博客

二、qt中.pro文件配置opencv

需要添加的文件路径大概就是这些，具体需要根据自己的opencv编译路径来对应 

  1. QT       += core gui
  2.  
  3. greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
  4.  
  5. CONFIG += c++11
  6.  
  7. # The following define makes your compiler emit warnings if you use
  8. # any Qt feature that has been marked deprecated (the exact warnings
  9. # depend on your compiler). Please consult the documentation of the
  10. # deprecated API in order to know how to port your code away from it.
  11. DEFINES += QT_DEPRECATED_WARNINGS
  12.  
  13. # You can also make your code fail to compile if it uses deprecated APIs.
  14. # In order to do so, uncomment the following line.
  15. # You can also select to disable deprecated APIs only up to a certain version of Qt.
  16. #DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0
  17.  
  18. SOURCES += \
  19.     MvCamera.cpp \
  20.     main.cpp \
  21.     mainwidget.cpp \
  22.     mythread.cpp \
  23.     widget.cpp \
  24.     yolov5.cpp
  25.  
  26. HEADERS += \
  27.     MvCamera.h \
  28.     mainwidget.h \
  29.     mythread.h \
  30.     widget.h \
  31.     yolov5.h
  32.  
  33. FORMS += \
  34.     mainwidget.ui \
  35.     widget.ui
  36. QMAKE_LFLAGS += -no-pie
  37. ###################################对opencv的支持
  38. INCLUDEPATH += /usr/local/include \
  39. /usr/local/include/opencv4 \
  40. /usr/local/include/opencv4/opencv2\
  41. $$PWD/include
  42. LIBS += /usr/local/lib/libopencv_calib3d.so \
  43. /usr/local/lib/libopencv_core.so \
  44. /usr/local/lib/libopencv_features2d.so \
  45. /usr/local/lib/libopencv_flann.so \
  46. /usr/local/lib/libopencv_highgui.so \
  47. /usr/local/lib/libopencv_imgcodecs.so \
  48. /usr/local/lib/libopencv_imgproc.so \
  49. /usr/local/lib/libopencv_ml.so \
  50. /usr/local/lib/libopencv_objdetect.so \
  51. /usr/local/lib/libopencv_photo.so \
  52. #/usr/local/lib/libopencv_shape.so \
  53. /usr/local/lib/libopencv_stitching.so \
  54. #/usr/local/lib/libopencv_superres.so \
  55. /usr/local/lib/libopencv_videoio.so \
  56. /usr/local/lib/libopencv_video.so\
  57. /usr/local/lib/libopencv_dnn.so \
  58. -L$$PWD/64/ -lMvCameraControl
  59. /usr/local/lib/libopencv_videostab.so
  60. ###################################
  61.  
  62. # Default rules for deployment.
  63. qnx: target.path = /tmp/$${TARGET}/bin
  64. else: unix:!android: target.path = /opt/$${TARGET}/bin
  65. !isEmpty(target.path): INSTALLS += target
  66.  
  67. DISTFILES += \
  68.     test2.pro.user
  69.  
  70. RESOURCES += \
  71.     res.qrc

 

三、程序运行

1、相机依赖的h文件和c文件

 ①  .h文件

  1. #ifndef MVCAMERA_H
  2. #define MVCAMERA_H
  3.  
  4. #include "MvCameraControl.h"
  5. #include <string.h>
  6. #include <QDebug>
  7. #include <stdio.h>
  8.  
  9. #ifndef MV_NULL
  10. #define MV_NULL 0
  11. #endif
  12.  
  13. #include "opencv2/opencv.hpp"
  14. #include "opencv2/imgproc/types_c.h"
  15.  
  16. class CMvCamera
  17. {
  18. public:
  19.     CMvCamera();
  20.     ~CMvCamera();
  21.  
  22.     // ch:获取SDK版本号 | en:Get SDK Version
  23.     static int GetSDKVersion();
  24.  
  25.     // ch:枚举设备 | en:Enumerate Device
  26.     static int EnumDevices(unsigned int nTLayerType,
  27.                            MV_CC_DEVICE_INFO_LIST *pstDevList);
  28.  
  29.     // ch:判断设备是否可达 | en:Is the device accessible
  30.     static bool IsDeviceAccessible(MV_CC_DEVICE_INFO *pstDevInfo,
  31.                                    unsigned int nAccessMode);
  32.  
  33.     // ch:打开设备 | en:Open Device
  34.     int Open(MV_CC_DEVICE_INFO *pstDeviceInfo);
  35.  
  36.     // ch:关闭设备 | en:Close Device
  37.     int Close();
  38.  
  39.     // ch:判断相机是否处于连接状态 | en:Is The Device Connected
  40.     bool IsDeviceConnected();
  41.  
  42.     // ch:注册图像数据回调 | en:Register Image Data CallBack
  43.     int RegisterImageCallBack(
  44.         void(__stdcall *cbOutput)(unsigned char *pData,
  45.                                   MV_FRAME_OUT_INFO_EX *pFrameInfo,
  46.                                   void *pUser),
  47.         void *pUser);
  48.  
  49.     // ch:开启抓图 | en:Start Grabbing
  50.     int StartGrabbing();
  51.  
  52.     // ch:停止抓图 | en:Stop Grabbing
  53.     int StopGrabbing();
  54.  
  55.     // ch:主动获取一帧图像数据 | en:Get one frame initiatively
  56.     int GetImageBuffer(MV_FRAME_OUT *pFrame, int nMsec);
  57.  
  58.     // ch:释放图像缓存 | en:Free image buffer
  59.     int FreeImageBuffer(MV_FRAME_OUT *pFrame);
  60.  
  61.     // ch:主动获取一帧图像数据 | en:Get one frame initiatively
  62.     int GetOneFrameTimeout(unsigned char *pData, unsigned int *pnDataLen,
  63.                            unsigned int nDataSize,
  64.                            MV_FRAME_OUT_INFO_EX *pFrameInfo, int nMsec);
  65.  
  66.     // ch:显示一帧图像 | en:Display one frame image
  67.     int DisplayOneFrame(MV_DISPLAY_FRAME_INFO *pDisplayInfo);
  68.  
  69.     // ch:设置SDK内部图像缓存节点个数 | en:Set the number of the internal image
  70.     // cache nodes in SDK
  71.     int SetImageNodeNum(unsigned int nNum);
  72.  
  73.     // ch:获取设备信息 | en:Get device information
  74.     int GetDeviceInfo(MV_CC_DEVICE_INFO *pstDevInfo);
  75.  
  76.     // ch:获取GEV相机的统计信息 | en:Get detect info of GEV camera
  77.     int GetGevAllMatchInfo(MV_MATCH_INFO_NET_DETECT *pMatchInfoNetDetect);
  78.  
  79.     // ch:获取U3V相机的统计信息 | en:Get detect info of U3V camera
  80.     int GetU3VAllMatchInfo(MV_MATCH_INFO_USB_DETECT *pMatchInfoUSBDetect);
  81.  
  82.     // ch:获取和设置Int型参数，如 Width和Height，详细内容参考SDK安装目录下的
  83.     // MvCameraNode.xlsx 文件 en:Get Int type parameters, such as Width and
  84.     // Height, for details please refer to MvCameraNode.xlsx file under SDK
  85.     // installation directory
  86.     // int GetIntValue(IN const char* strKey, OUT MVCC_INTVALUE_EX* pIntValue);
  87.     int GetIntValue(IN const char *strKey, OUT unsigned int *pnValue);
  88.     int SetIntValue(IN const char *strKey, IN int64_t nValue);
  89.  
  90.     // ch:获取和设置Enum型参数，如 PixelFormat，详细内容参考SDK安装目录下的
  91.     // MvCameraNode.xlsx 文件 en:Get Enum type parameters, such as PixelFormat,
  92.     // for details please refer to MvCameraNode.xlsx file under SDK installation
  93.     // directory
  94.     int GetEnumValue(IN const char *strKey, OUT MVCC_ENUMVALUE *pEnumValue);
  95.     int SetEnumValue(IN const char *strKey, IN unsigned int nValue);
  96.     int SetEnumValueByString(IN const char *strKey, IN const char *sValue);
  97.  
  98.     // ch:获取和设置Float型参数，如
  99.     // ExposureTime和Gain，详细内容参考SDK安装目录下的 MvCameraNode.xlsx 文件
  100.     // en:Get Float type parameters, such as ExposureTime and Gain, for details
  101.     // please refer to MvCameraNode.xlsx file under SDK installation directory
  102.     int GetFloatValue(IN const char *strKey, OUT MVCC_FLOATVALUE *pFloatValue);
  103.     int SetFloatValue(IN const char *strKey, IN float fValue);
  104.  
  105.     // ch:获取和设置Bool型参数，如 ReverseX，详细内容参考SDK安装目录下的
  106.     // MvCameraNode.xlsx 文件 en:Get Bool type parameters, such as ReverseX, for
  107.     // details please refer to MvCameraNode.xlsx file under SDK installation
  108.     // directory
  109.     int GetBoolValue(IN const char *strKey, OUT bool *pbValue);
  110.     int SetBoolValue(IN const char *strKey, IN bool bValue);
  111.  
  112.     // ch:获取和设置String型参数，如 DeviceUserID，详细内容参考SDK安装目录下的
  113.     // MvCameraNode.xlsx 文件UserSetSave en:Get String type parameters, such as
  114.     // DeviceUserID, for details please refer to MvCameraNode.xlsx file under
  115.     // SDK installation directory
  116.     int GetStringValue(IN const char *strKey, MVCC_STRINGVALUE *pStringValue);
  117.     int SetStringValue(IN const char *strKey, IN const char *strValue);
  118.  
  119.     // ch:执行一次Command型命令，如 UserSetSave，详细内容参考SDK安装目录下的
  120.     // MvCameraNode.xlsx 文件 en:Execute Command once, such as UserSetSave, for
  121.     // details please refer to MvCameraNode.xlsx file under SDK installation
  122.     // directory
  123.     int CommandExecute(IN const char *strKey);
  124.  
  125.     // ch:探测网络最佳包大小(只对GigE相机有效) | en:Detection network optimal
  126.     // package size(It only works for the GigE camera)
  127.     int GetOptimalPacketSize(unsigned int *pOptimalPacketSize);
  128.  
  129.     // ch:注册消息异常回调 | en:Register Message Exception CallBack
  130.     int RegisterExceptionCallBack(
  131.         void(__stdcall *cbException)(unsigned int nMsgType, void *pUser),
  132.         void *pUser);
  133.  
  134.     // ch:注册单个事件回调 | en:Register Event CallBack
  135.     int RegisterEventCallBack(
  136.         const char *pEventName,
  137.         void(__stdcall *cbEvent)(MV_EVENT_OUT_INFO *pEventInfo, void *pUser),
  138.         void *pUser);
  139.  
  140.     // ch:强制IP | en:Force IP
  141.     int ForceIp(unsigned int nIP, unsigned int nSubNetMask,
  142.                 unsigned int nDefaultGateWay);
  143.  
  144.     // ch:配置IP方式 | en:IP configuration method
  145.     int SetIpConfig(unsigned int nType);
  146.  
  147.     // ch:设置网络传输模式 | en:Set Net Transfer Mode
  148.     int SetNetTransMode(unsigned int nType);
  149.  
  150.     // ch:像素格式转换 | en:Pixel format conversion
  151.     int ConvertPixelType(MV_CC_PIXEL_CONVERT_PARAM *pstCvtParam);
  152.  
  153.     // ch:保存图片 | en:save image
  154.     int SaveImage(MV_SAVE_IMAGE_PARAM_EX *pstParam);
  155.  
  156.     // ch:保存图片为文件 | en:Save the image as a file
  157.     //int SaveImageToFile(MV_SAVE_IMG_TO_FILE_PARAM *pstParam);
  158.  
  159.     //设置是否为触发模式
  160.     int setTriggerMode(unsigned int TriggerModeNum);
  161.  
  162.     //设置触发源
  163.     int setTriggerSource(unsigned int TriggerSourceNum);
  164.  
  165.     //软触发
  166.     int softTrigger();
  167.  
  168.     //读取buffer
  169.     int ReadBuffer(cv::Mat &image);
  170.  
  171.     //读取buffer
  172.     int ReadBuffer2(cv::Mat &image,bool saveFlag,QByteArray imageName);
  173.  
  174.     //设置曝光时间
  175.     int setExposureTime(float ExposureTimeNum);
  176.  
  177. public:
  178.     void *m_hDevHandle;
  179.     unsigned int m_nTLayerType;
  180.  
  181. public:
  182.     unsigned char *m_pBufForSaveImage; // 用于保存图像的缓存
  183.     unsigned int m_nBufSizeForSaveImage;
  184.  
  185.     unsigned char *m_pBufForDriver; // 用于从驱动获取图像的缓存
  186.     unsigned int m_nBufSizeForDriver;
  187. };
  188.  
  189. #endif // MVCAMERA_H

②  cpp文件

  1. #include "MvCamera.h"
  2. #include <stdio.h>
  3.  
  4. CMvCamera::CMvCamera()
  5. {
  6.     m_hDevHandle = MV_NULL;
  7. }
  8.  
  9. CMvCamera::~CMvCamera()
  10. {
  11.     if (m_hDevHandle) {
  12.         MV_CC_DestroyHandle(m_hDevHandle);
  13.         m_hDevHandle = MV_NULL;
  14.     }
  15. }
  16.  
  17. // ch:获取SDK版本号 | en:Get SDK Version
  18. int CMvCamera::GetSDKVersion()
  19. {
  20.     return MV_CC_GetSDKVersion();
  21. }
  22.  
  23. // ch:枚举设备 | en:Enumerate Device
  24. int CMvCamera::EnumDevices(unsigned int nTLayerType,
  25.                            MV_CC_DEVICE_INFO_LIST *pstDevList)
  26. {
  27.     return MV_CC_EnumDevices(nTLayerType, pstDevList);
  28. }
  29.  
  30. // ch:判断设备是否可达 | en:Is the device accessible
  31. bool CMvCamera::IsDeviceAccessible(MV_CC_DEVICE_INFO *pstDevInfo,
  32.                                    unsigned int nAccessMode)
  33. {
  34.     return MV_CC_IsDeviceAccessible(pstDevInfo, nAccessMode);
  35. }
  36.  
  37. // ch:打开设备 | en:Open Device
  38. int CMvCamera::Open(MV_CC_DEVICE_INFO *pstDeviceInfo)
  39. {
  40.     if (MV_NULL == pstDeviceInfo) {
  41.         return MV_E_PARAMETER;
  42.     }
  43.  
  44.     if (m_hDevHandle) {
  45.         return MV_E_CALLORDER;
  46.     }
  47.  
  48.     int nRet = MV_CC_CreateHandle(&m_hDevHandle, pstDeviceInfo);
  49.     if (MV_OK != nRet) {
  50.         return nRet;
  51.     }
  52.  
  53.     nRet = MV_CC_OpenDevice(m_hDevHandle);
  54.     if (MV_OK != nRet) {
  55.         MV_CC_DestroyHandle(m_hDevHandle);
  56.         m_hDevHandle = MV_NULL;
  57.     }
  58.  
  59.     return nRet;
  60. }
  61.  
  62. // ch:关闭设备 | en:Close Device
  63. int CMvCamera::Close()
  64. {
  65.     if (MV_NULL == m_hDevHandle) {
  66.         return MV_E_HANDLE;
  67.     }
  68.  
  69.     MV_CC_CloseDevice(m_hDevHandle);
  70.  
  71.     int nRet = MV_CC_DestroyHandle(m_hDevHandle);
  72.     m_hDevHandle = MV_NULL;
  73.  
  74.     return nRet;
  75. }
  76.  
  77. // ch:判断相机是否处于连接状态 | en:Is The Device Connected
  78. bool CMvCamera::IsDeviceConnected()
  79. {
  80.     return MV_CC_IsDeviceConnected(m_hDevHandle);
  81. }
  82.  
  83. // ch:注册图像数据回调 | en:Register Image Data CallBack
  84. int CMvCamera::RegisterImageCallBack(
  85.     void(__stdcall *cbOutput)(unsigned char *pData,
  86.                               MV_FRAME_OUT_INFO_EX *pFrameInfo, void *pUser),
  87.     void *pUser)
  88. {
  89.     return MV_CC_RegisterImageCallBackEx(m_hDevHandle, cbOutput, pUser);
  90. }
  91.  
  92. // ch:开启抓图 | en:Start Grabbing
  93. int CMvCamera::StartGrabbing()
  94. {
  95.     return MV_CC_StartGrabbing(m_hDevHandle);
  96. }
  97.  
  98. // ch:停止抓图 | en:Stop Grabbing
  99. int CMvCamera::StopGrabbing()
  100. {
  101.     return MV_CC_StopGrabbing(m_hDevHandle);
  102. }
  103.  
  104. // ch:主动获取一帧图像数据 | en:Get one frame initiatively
  105. int CMvCamera::GetImageBuffer(MV_FRAME_OUT *pFrame, int nMsec)
  106. {
  107.     return MV_CC_GetImageBuffer(m_hDevHandle, pFrame, nMsec);
  108. }
  109.  
  110. // ch:释放图像缓存 | en:Free image buffer
  111. int CMvCamera::FreeImageBuffer(MV_FRAME_OUT *pFrame)
  112. {
  113.     return MV_CC_FreeImageBuffer(m_hDevHandle, pFrame);
  114. }
  115.  
  116. // ch:主动获取一帧图像数据 | en:Get one frame initiatively
  117. int CMvCamera::GetOneFrameTimeout(unsigned char *pData, unsigned int *pnDataLen,
  118.                                   unsigned int nDataSize,
  119.                                   MV_FRAME_OUT_INFO_EX *pFrameInfo, int nMsec)
  120. {
  121.     if (NULL == pnDataLen) {
  122.         return MV_E_PARAMETER;
  123.     }
  124.  
  125.     int nRet = MV_OK;
  126.  
  127.     *pnDataLen = 0;
  128.  
  129.     nRet = MV_CC_GetOneFrameTimeout(m_hDevHandle, pData, nDataSize, pFrameInfo,
  130.                                     nMsec);
  131.     if (MV_OK != nRet) {
  132.         return nRet;
  133.     }
  134.  
  135.     *pnDataLen = pFrameInfo->nFrameLen;
  136.  
  137.     return nRet;
  138. }
  139.  
  140. // ch:设置显示窗口句柄 | en:Set Display Window Handle
  141. int CMvCamera::DisplayOneFrame(MV_DISPLAY_FRAME_INFO *pDisplayInfo)
  142. {
  143.     return MV_CC_DisplayOneFrame(m_hDevHandle, pDisplayInfo);
  144. }
  145.  
  146. // ch:设置SDK内部图像缓存节点个数 | en:Set the number of the internal image
  147. // cache nodes in SDK
  148. int CMvCamera::SetImageNodeNum(unsigned int nNum)
  149. {
  150.     return MV_CC_SetImageNodeNum(m_hDevHandle, nNum);
  151. }
  152.  
  153. // ch:获取设备信息 | en:Get device information
  154. int CMvCamera::GetDeviceInfo(MV_CC_DEVICE_INFO *pstDevInfo)
  155. {
  156.     return MV_CC_GetDeviceInfo(m_hDevHandle, pstDevInfo);
  157. }
  158.  
  159. // ch:获取GEV相机的统计信息 | en:Get detect info of GEV camera
  160. int CMvCamera::GetGevAllMatchInfo(MV_MATCH_INFO_NET_DETECT *pMatchInfoNetDetect)
  161. {
  162.     if (MV_NULL == pMatchInfoNetDetect) {
  163.         return MV_E_PARAMETER;
  164.     }
  165.  
  166.     MV_CC_DEVICE_INFO stDevInfo = { 0 };
  167.     GetDeviceInfo(&stDevInfo);
  168.     if (stDevInfo.nTLayerType != MV_GIGE_DEVICE) {
  169.         return MV_E_SUPPORT;
  170.     }
  171.  
  172.     MV_ALL_MATCH_INFO struMatchInfo = { 0 };
  173.  
  174.     struMatchInfo.nType = MV_MATCH_TYPE_NET_DETECT;
  175.     struMatchInfo.pInfo = pMatchInfoNetDetect;
  176.     struMatchInfo.nInfoSize = sizeof(MV_MATCH_INFO_NET_DETECT);
  177.     memset(struMatchInfo.pInfo, 0, sizeof(MV_MATCH_INFO_NET_DETECT));
  178.  
  179.     return MV_CC_GetAllMatchInfo(m_hDevHandle, &struMatchInfo);
  180. }
  181.  
  182. // ch:获取U3V相机的统计信息 | en:Get detect info of U3V camera
  183. int CMvCamera::GetU3VAllMatchInfo(MV_MATCH_INFO_USB_DETECT *pMatchInfoUSBDetect)
  184. {
  185.     if (MV_NULL == pMatchInfoUSBDetect) {
  186.         return MV_E_PARAMETER;
  187.     }
  188.  
  189.     MV_CC_DEVICE_INFO stDevInfo = { 0 };
  190.     GetDeviceInfo(&stDevInfo);
  191.     if (stDevInfo.nTLayerType != MV_USB_DEVICE) {
  192.         return MV_E_SUPPORT;
  193.     }
  194.  
  195.     MV_ALL_MATCH_INFO struMatchInfo = { 0 };
  196.  
  197.     struMatchInfo.nType = MV_MATCH_TYPE_USB_DETECT;
  198.     struMatchInfo.pInfo = pMatchInfoUSBDetect;
  199.     struMatchInfo.nInfoSize = sizeof(MV_MATCH_INFO_USB_DETECT);
  200.     memset(struMatchInfo.pInfo, 0, sizeof(MV_MATCH_INFO_USB_DETECT));
  201.  
  202.     return MV_CC_GetAllMatchInfo(m_hDevHandle, &struMatchInfo);
  203. }
  204.  
  205. // ch:获取和设置Int型参数，如 Width和Height，详细内容参考SDK安装目录下的
  206. // MvCameraNode.xlsx 文件 en:Get Int type parameters, such as Width and Height,
  207. // for details please refer to MvCameraNode.xlsx file under SDK installation
  208. // directory
  209. int CMvCamera::GetIntValue(IN const char *strKey, OUT unsigned int *pnValue)
  210. {
  211.     if (NULL == strKey || NULL == pnValue) {
  212.         return MV_E_PARAMETER;
  213.     }
  214.  
  215.     MVCC_INTVALUE stParam;
  216.     memset(&stParam, 0, sizeof(MVCC_INTVALUE));
  217.     int nRet = MV_CC_GetIntValue(m_hDevHandle, strKey, &stParam);
  218.     if (MV_OK != nRet) {
  219.         return nRet;
  220.     }
  221.  
  222.     *pnValue = stParam.nCurValue;
  223.  
  224.     return MV_OK;
  225. }
  226.  
  227. int CMvCamera::SetIntValue(IN const char *strKey, IN int64_t nValue)
  228. {
  229.     return MV_CC_SetIntValueEx(m_hDevHandle, strKey, nValue);
  230. }
  231.  
  232. // ch:获取和设置Enum型参数，如 PixelFormat，详细内容参考SDK安装目录下的
  233. // MvCameraNode.xlsx 文件 en:Get Enum type parameters, such as PixelFormat, for
  234. // details please refer to MvCameraNode.xlsx file under SDK installation
  235. // directory
  236. int CMvCamera::GetEnumValue(IN const char *strKey,
  237.                             OUT MVCC_ENUMVALUE *pEnumValue)
  238. {
  239.     return MV_CC_GetEnumValue(m_hDevHandle, strKey, pEnumValue);
  240. }
  241.  
  242. int CMvCamera::SetEnumValue(IN const char *strKey, IN unsigned int nValue)
  243. {
  244.     return MV_CC_SetEnumValue(m_hDevHandle, strKey, nValue);
  245. }
  246.  
  247. int CMvCamera::SetEnumValueByString(IN const char *strKey,
  248.                                     IN const char *sValue)
  249. {
  250.     return MV_CC_SetEnumValueByString(m_hDevHandle, strKey, sValue);
  251. }
  252.  
  253. // ch:获取和设置Float型参数，如 ExposureTime和Gain，详细内容参考SDK安装目录下的
  254. // MvCameraNode.xlsx 文件 en:Get Float type parameters, such as ExposureTime and
  255. // Gain, for details please refer to MvCameraNode.xlsx file under SDK
  256. // installation directory
  257. int CMvCamera::GetFloatValue(IN const char *strKey,
  258.                              OUT MVCC_FLOATVALUE *pFloatValue)
  259. {
  260.     return MV_CC_GetFloatValue(m_hDevHandle, strKey, pFloatValue);
  261. }
  262.  
  263. int CMvCamera::SetFloatValue(IN const char *strKey, IN float fValue)
  264. {
  265.     return MV_CC_SetFloatValue(m_hDevHandle, strKey, fValue);
  266. }
  267.  
  268. // ch:获取和设置Bool型参数，如 ReverseX，详细内容参考SDK安装目录下的
  269. // MvCameraNode.xlsx 文件 en:Get Bool type parameters, such as ReverseX, for
  270. // details please refer to MvCameraNode.xlsx file under SDK installation
  271. // directory
  272. int CMvCamera::GetBoolValue(IN const char *strKey, OUT bool *pbValue)
  273. {
  274.     return MV_CC_GetBoolValue(m_hDevHandle, strKey, pbValue);
  275. }
  276.  
  277. int CMvCamera::SetBoolValue(IN const char *strKey, IN bool bValue)
  278. {
  279.     return MV_CC_SetBoolValue(m_hDevHandle, strKey, bValue);
  280. }
  281.  
  282. // ch:获取和设置String型参数，如 DeviceUserID，详细内容参考SDK安装目录下的
  283. // MvCameraNode.xlsx 文件UserSetSave en:Get String type parameters, such as
  284. // DeviceUserID, for details please refer to MvCameraNode.xlsx file under SDK
  285. // installation directory
  286. int CMvCamera::GetStringValue(IN const char *strKey,
  287.                               MVCC_STRINGVALUE *pStringValue)
  288. {
  289.     return MV_CC_GetStringValue(m_hDevHandle, strKey, pStringValue);
  290. }
  291.  
  292. int CMvCamera::SetStringValue(IN const char *strKey, IN const char *strValue)
  293. {
  294.     return MV_CC_SetStringValue(m_hDevHandle, strKey, strValue);
  295. }
  296.  
  297. // ch:执行一次Command型命令，如 UserSetSave，详细内容参考SDK安装目录下的
  298. // MvCameraNode.xlsx 文件 en:Execute Command once, such as UserSetSave, for
  299. // details please refer to MvCameraNode.xlsx file under SDK installation
  300. // directory
  301. int CMvCamera::CommandExecute(IN const char *strKey)
  302. {
  303.     return MV_CC_SetCommandValue(m_hDevHandle, strKey);
  304. }
  305.  
  306. // ch:探测网络最佳包大小(只对GigE相机有效) | en:Detection network optimal
  307. // package size(It only works for the GigE camera)
  308. int CMvCamera::GetOptimalPacketSize(unsigned int *pOptimalPacketSize)
  309. {
  310.     if (MV_NULL == pOptimalPacketSize) {
  311.         return MV_E_PARAMETER;
  312.     }
  313.  
  314.     int nRet = MV_CC_GetOptimalPacketSize(m_hDevHandle);
  315.     if (nRet < MV_OK) {
  316.         return nRet;
  317.     }
  318.  
  319.     *pOptimalPacketSize = (unsigned int)nRet;
  320.  
  321.     return MV_OK;
  322. }
  323.  
  324. // ch:注册消息异常回调 | en:Register Message Exception CallBack
  325. int CMvCamera::RegisterExceptionCallBack(
  326.     void(__stdcall *cbException)(unsigned int nMsgType, void *pUser),
  327.     void *pUser)
  328. {
  329.     return MV_CC_RegisterExceptionCallBack(m_hDevHandle, cbException, pUser);
  330. }
  331.  
  332. // ch:注册单个事件回调 | en:Register Event CallBack
  333. int CMvCamera::RegisterEventCallBack(
  334.     const char *pEventName,
  335.     void(__stdcall *cbEvent)(MV_EVENT_OUT_INFO *pEventInfo, void *pUser),
  336.     void *pUser)
  337. {
  338.     return MV_CC_RegisterEventCallBackEx(m_hDevHandle, pEventName, cbEvent,
  339.                                          pUser);
  340. }
  341.  
  342. // ch:强制IP | en:Force IP
  343. int CMvCamera::ForceIp(unsigned int nIP, unsigned int nSubNetMask,
  344.                        unsigned int nDefaultGateWay)
  345. {
  346.     return MV_GIGE_ForceIpEx(m_hDevHandle, nIP, nSubNetMask, nDefaultGateWay);
  347. }
  348.  
  349. // ch:配置IP方式 | en:IP configuration method
  350. int CMvCamera::SetIpConfig(unsigned int nType)
  351. {
  352.     return MV_GIGE_SetIpConfig(m_hDevHandle, nType);
  353. }
  354.  
  355. // ch:设置网络传输模式 | en:Set Net Transfer Mode
  356. int CMvCamera::SetNetTransMode(unsigned int nType)
  357. {
  358.     return MV_GIGE_SetNetTransMode(m_hDevHandle, nType);
  359. }
  360.  
  361. // ch:像素格式转换 | en:Pixel format conversion
  362. int CMvCamera::ConvertPixelType(MV_CC_PIXEL_CONVERT_PARAM *pstCvtParam)
  363. {
  364.     return MV_CC_ConvertPixelType(m_hDevHandle, pstCvtParam);
  365. }
  366.  
  367. // ch:保存图片 | en:save image
  368. int CMvCamera::SaveImage(MV_SAVE_IMAGE_PARAM_EX *pstParam)
  369. {
  370.     return MV_CC_SaveImageEx2(m_hDevHandle, pstParam);
  371. }
  372.  
  373.  //ch:保存图片为文件 | en:Save the image as a file
  374. // int CMvCamera::SaveImageToFile(MV_SAVE_IMG_TO_FILE_PARAM *pstSaveFileParam)
  375. //{
  376. //    return MV_CC_SaveImageToFile(m_hDevHandle, pstSaveFileParam);
  377. //}
  378.  
  379. //设置是否为触发模式
  380. int CMvCamera::setTriggerMode(unsigned int TriggerModeNum)
  381. {
  382.     // 0：Off  1：On
  383.     int tempValue =
  384.         MV_CC_SetEnumValue(m_hDevHandle, "TriggerMode", TriggerModeNum);
  385.     if (tempValue != 0) {
  386.         return -1;
  387.     } else {
  388.         return 0;
  389.     }
  390. }
  391.  
  392. //设置触发源
  393. int CMvCamera::setTriggerSource(unsigned int TriggerSourceNum)
  394. {
  395.     // 0：Line0  1：Line1  7：Software
  396.     int tempValue =
  397.         MV_CC_SetEnumValue(m_hDevHandle, "TriggerSource", TriggerSourceNum);
  398.     if (tempValue != 0) {
  399.         return -1;
  400.     } else {
  401.         return 0;
  402.     }
  403. }
  404.  
  405. //发送软触发
  406. int CMvCamera::softTrigger()
  407. {
  408.     int tempValue = MV_CC_SetCommandValue(m_hDevHandle, "TriggerSoftware");
  409.     if (tempValue != 0) {
  410.         return -1;
  411.     } else {
  412.         return 0;
  413.     }
  414. }
  415.  
  416. //读取相机中的图像
  417. // int ReadBuffer(cv::Mat &image);
  418. int CMvCamera::ReadBuffer(cv::Mat &image)
  419. {
  420.     cv::Mat *getImage = new cv::Mat();
  421.     unsigned int nRecvBufSize = 0;
  422.     MVCC_INTVALUE stParam;
  423.     memset(&stParam, 0, sizeof(MVCC_INTVALUE));
  424.     int tempValue = MV_CC_GetIntValue(m_hDevHandle, "PayloadSize", &stParam);
  425.     if (tempValue != 0) {
  426.         return -1;
  427.     }
  428.     nRecvBufSize = stParam.nCurValue;
  429.     unsigned char *pDate;
  430.     pDate = (unsigned char *)malloc(nRecvBufSize);
  431.  
  432.     MV_FRAME_OUT_INFO_EX stImageInfo = { 0 };
  433.     tempValue = MV_CC_GetOneFrameTimeout(m_hDevHandle, pDate, nRecvBufSize,
  434.                                          &stImageInfo, 500);
  435.     if (tempValue != 0) {
  436.         return -1;
  437.     }
  438.     m_nBufSizeForSaveImage =
  439.         stImageInfo.nWidth * stImageInfo.nHeight * 3 + 2048;
  440.     unsigned char *m_pBufForSaveImage;
  441.     m_pBufForSaveImage = (unsigned char *)malloc(m_nBufSizeForSaveImage);
  442.  
  443.     bool isMono;
  444.     switch (stImageInfo.enPixelType) {
  445.     case PixelType_Gvsp_Mono8:
  446.     case PixelType_Gvsp_Mono10:
  447.     case PixelType_Gvsp_Mono10_Packed:
  448.     case PixelType_Gvsp_Mono12:
  449.     case PixelType_Gvsp_Mono12_Packed:
  450.         isMono = true;
  451.         break;
  452.     default:
  453.         isMono = false;
  454.         break;
  455.     }
  456.     if (isMono) {
  457.         *getImage =
  458.             cv::Mat(stImageInfo.nHeight, stImageInfo.nWidth, CV_8UC1, pDate);
  459.         // imwrite("d:\\测试opencv_Mono.tif", image);
  460.     } else {
  461.         //转换图像格式为BGR8
  462.         MV_CC_PIXEL_CONVERT_PARAM stConvertParam = { 0 };
  463.         memset(&stConvertParam, 0, sizeof(MV_CC_PIXEL_CONVERT_PARAM));
  464.         stConvertParam.nWidth = stImageInfo.nWidth; // ch:图像宽 | en:image
  465.                                                     // width
  466.         stConvertParam.nHeight =
  467.             stImageInfo.nHeight; // ch:图像高 | en:image height
  468.         // stConvertParam.pSrcData = m_pBufForDriver; //ch:输入数据缓存 |
  469.         // en:input data buffer
  470.         stConvertParam.pSrcData =
  471.             pDate; // ch:输入数据缓存 | en:input data buffer
  472.         stConvertParam.nSrcDataLen =
  473.             stImageInfo.nFrameLen; // ch:输入数据大小 | en:input data size
  474.         stConvertParam.enSrcPixelType =
  475.             stImageInfo.enPixelType; // ch:输入像素格式 | en:input pixel format
  476.         stConvertParam.enDstPixelType =
  477.             PixelType_Gvsp_BGR8_Packed; // ch:输出像素格式 | en:output pixel
  478.                                         // format  适用于OPENCV的图像格式
  479.         // stConvertParam.enDstPixelType = PixelType_Gvsp_RGB8_Packed;
  480.         //输出像素格式 | en:output pixel format
  481.         stConvertParam.pDstBuffer =
  482.             m_pBufForSaveImage; // ch:输出数据缓存 | en:output data buffer
  483.         stConvertParam.nDstBufferSize =
  484.             m_nBufSizeForSaveImage; // ch:输出缓存大小 | en:output buffer size
  485.         MV_CC_ConvertPixelType(m_hDevHandle, &stConvertParam);
  486.  
  487.         *getImage = cv::Mat(stImageInfo.nHeight, stImageInfo.nWidth, CV_8UC3,
  488.                             m_pBufForSaveImage);
  489.     }
  490.     (*getImage).copyTo(image);
  491.     (*getImage).release();
  492.     free(pDate);
  493.     free(m_pBufForSaveImage);
  494.     return 0;
  495. }
  496.  
  497.  
  498. //设置曝光时间
  499. int CMvCamera::setExposureTime(float ExposureTimeNum)
  500. {
  501.     int tempValue =
  502.         MV_CC_SetFloatValue(m_hDevHandle, "ExposureTime", ExposureTimeNum);
  503.     if (tempValue != 0) {
  504.         return -1;
  505.     } else {
  506.         return 0;
  507.     }
  508. }

 2、主界面的相关代码

       ①  h文件

  1. #ifndef WIDGET_H
  2. #define WIDGET_H
  3.  
  4. #include <QWidget>
  5.  
  6. #include <QMessageBox>
  7. #include <QCloseEvent>
  8. #include <QSettings>
  9. #include <QDate>
  10. #include <QDir>
  11.  
  12. #include "MvCamera.h"
  13. #include "mythread.h"
  14. #include "mainwidget.h"
  15.  
  16. #define MAX_DEVICE_NUM     2
  17. #define TRIGGER_SOURCE     7
  18. #define EXPOSURE_TIME      40000
  19. #define FRAME              30
  20. #define TRIGGER_ON         1
  21. #define TRIGGER_OFF        0
  22. #define START_GRABBING_ON  1
  23. #define START_GRABBING_OFF 0
  24. #define IMAGE_NAME_LEN     64
  25.  
  26.  
  27. QT_BEGIN_NAMESPACE
  28. namespace Ui {
  29. class Widget;
  30. }
  31. QT_END_NAMESPACE
  32.  
  33. class MainWidget;
  34. class Widget : public QWidget
  35. {
  36.     Q_OBJECT
  37.  
  38. public:
  39.     Widget(QWidget *parent = nullptr);
  40.     ~Widget();
  41. signals:
  42.     void closedWid();
  43.     void back();
  44.  
  45. public:
  46.     CMvCamera *m_pcMyCamera[MAX_DEVICE_NUM]; // 相机指针对象
  47.     MV_CC_DEVICE_INFO_LIST m_stDevList;      // 存储设备列表
  48.     cv::Mat *myImage_L = new cv::Mat(); //保存左相机图像的图像指针对象
  49.     cv::Mat *myImage_R = new cv::Mat(); //保存右相机有图像的图像指针对象
  50.     int devices_num;                    // 设备数量
  51.  
  52.     MainWidget *mainWid = NULL;           //创建一个存储主界面窗体的指针
  53. public:
  54.     MyThread *myThread_Camera_show = NULL; //相机实时显示线程对象
  55.  
  56. private slots:
  57.     void on_pbn_enum_camera_clicked();
  58.     void on_pbn_open_camera_clicked();
  59.     void on_rdo_continue_mode_clicked();
  60.     void on_rdo_softigger_mode_clicked();
  61.     void on_pbn_start_grabbing_clicked();
  62.     void on_pbn_stop_grabbing_clicked();
  63.     void on_pbn_software_once_clicked();
  64.     void display_myImage_L(const Mat *imagePrt);
  65.     void display_myImage_Main(const Mat *imagePrt);
  66.     void on_pbn_close_camera_clicked();
  67.     void on_pbn_save_BMP_clicked();
  68.     void on_pbn_save_JPG_clicked();
  69.     void on_le_set_exposure_textChanged(const QString &arg1);
  70.     void on_le_set_gain_textChanged(const QString &arg1);
  71.  
  72.  
  73.  
  74.     void on_pbn_return_main_clicked();
  75.  
  76. public:
  77.     // 状态
  78.     bool m_bOpenDevice;                  // 是否打开设备
  79.     bool m_bStartGrabbing;               // 是否开始抓图
  80.     int m_nTriggerMode;                  // 触发模式
  81.     int m_bContinueStarted;              // 开启过连续采集图像
  82.     MV_SAVE_IAMGE_TYPE m_nSaveImageType; // 保存图像格式
  83.  
  84. private:
  85.     QString PrintDeviceInfo(MV_CC_DEVICE_INFO *pstMVDevInfo, int num_index);
  86.     QString m_SaveImagePath;
  87.     void OpenDevices();
  88.     void CloseDevices();
  89.     void SaveImage();
  90.     void saveImage(QString format,int index);
  91.  
  92. private:
  93.     Ui::Widget *ui;
  94.  
  95. protected:
  96.     void closeEvent(QCloseEvent *event) override;     //重写关闭事件处理函数
  97. };
  98. #endif // WIDGET_H
  99.

    ②  cpp文件

  1. #include "widget.h"
  2. #include "./ui_widget.h"
  3.  
  4. #include <stdio.h>
  5. #include <string.h>
  6. #include <unistd.h>
  7. #include <stdlib.h>
  8. #include <fstream>
  9. #include <iostream>
  10. #include <QDebug>
  11.  
  12. Widget::Widget(QWidget *parent) : QWidget(parent), ui(new Ui::Widget)
  13. {
  14.     ui->setupUi(this);
  15.     ui->lbl_camera_L->setPixmap(QPixmap(":/icon/MVS.png"));
  16.     ui->lbl_camera_L->setScaledContents(true);
  17.  
  18.     //ui->lbl_camera_R->setPixmap(QPixmap("back_img.jpg"));
  19.     //ui->lbl_camera_R->setScaledContents(true);
  20.  
  21.     // 相机初始化控件
  22.     ui->pbn_enum_camera->setEnabled(true);
  23.     ui->pbn_open_camera->setEnabled(false);
  24.     ui->pbn_close_camera->setEnabled(false);
  25.     ui->cmb_camera_index->setEnabled(false);
  26.  
  27.     // 图像采集控件
  28.     ui->rdo_continue_mode->setEnabled(false);
  29.     ui->rdo_softigger_mode->setEnabled(false);
  30.     ui->pbn_start_grabbing->setEnabled(false);
  31.     ui->pbn_stop_grabbing->setEnabled(false);
  32.     ui->pbn_software_once->setEnabled(false);
  33.  
  34.     // 参数控件
  35.     ui->le_set_exposure->setEnabled(false);
  36.     ui->le_set_gain->setEnabled(false);
  37.  
  38.     // 保存图像控件
  39.     ui->pbn_save_BMP->setEnabled(false);
  40.     ui->pbn_save_JPG->setEnabled(false);
  41.  
  42.     // 线程对象实例化
  43.     myThread_Camera_show = new MyThread; //相机线程对象
  44.  
  45.  
  46.     //发送信号实现页面切换
  47.     connect(ui->pbn_return_main,SIGNAL(clicked()),this,SIGNAL(back()));
  48.  
  49.     connect(myThread_Camera_show, SIGNAL(Display(const Mat *)), this,
  50.             SLOT(display_myImage_L(const Mat *)));
  51.  
  52.  
  53.     // 曝光和增益的输入控件限制值
  54.     QRegExp int_rx("100000|([0-9]{0,5})");
  55.     ui->le_set_exposure->setValidator(new QRegExpValidator(int_rx, this));
  56.     QRegExp double_rx("15|([0-9]{0,1}[0-5]{1,2}[\.][0-9]{0,1})");
  57.     ui->le_set_gain->setValidator(new QRegExpValidator(double_rx, this));
  58.  
  59.  
  60. }
  61.  
  62. Widget::~Widget()
  63. {
  64.     delete ui;
  65.     delete mainWid;
  66.     delete myThread_Camera_show;
  67.     delete myImage_L;
  68. }
  69.  
  70. //创建关闭子窗体事件，显示主窗体
  71. void Widget::closeEvent(QCloseEvent *event)
  72. {
  73.     emit closedWid();     //发射closed信号
  74.     event->accept();
  75.  
  76. }
  77.  
  78.  
  79. void Widget::on_pbn_enum_camera_clicked()
  80. {
  81.     memset(&m_stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));
  82.     int nRet = MV_OK;
  83.     nRet = CMvCamera::EnumDevices(MV_GIGE_DEVICE | MV_USB_DEVICE, &m_stDevList);
  84.  
  85.     devices_num = m_stDevList.nDeviceNum;
  86.     if (devices_num == 0) {
  87.         QString cameraInfo;
  88.         cameraInfo =
  89.             QString::fromLocal8Bit("暂无设备可连接，请检查设备是否连接正确！");
  90.         ui->lbl_camera_messagee->setText(cameraInfo);
  91.     }
  92.     if (devices_num > 0) {
  93.         QString cameraInfo;
  94.         for (int i = 0; i < devices_num; i++) {
  95.             MV_CC_DEVICE_INFO *pDeviceInfo = m_stDevList.pDeviceInfo[i];
  96.             QString cameraInfo_i = PrintDeviceInfo(pDeviceInfo, i);
  97.             cameraInfo.append(cameraInfo_i);
  98.             cameraInfo.append("\n");
  99.             ui->cmb_camera_index->addItem(QString::number(i+1));
  100.         }
  101.         ui->lbl_camera_messagee->setText(cameraInfo);
  102.         ui->pbn_open_camera->setEnabled(true);
  103.         ui->cmb_camera_index->setEnabled(true);
  104.     }
  105. }
  106.  
  107. //打印相机的型号、ip等信息
  108. QString Widget::PrintDeviceInfo(MV_CC_DEVICE_INFO *pstMVDevInfo, int num_index)
  109. {
  110.     QString cameraInfo_index;
  111.     cameraInfo_index = QString::fromLocal8Bit("相机序号：");
  112.     cameraInfo_index.append(QString::number(num_index+1));
  113.     cameraInfo_index.append("\t\t");
  114.     // 海康GIGE协议的相机
  115.     if (pstMVDevInfo->nTLayerType == MV_GIGE_DEVICE) {
  116.         int nIp1 =
  117.             ((pstMVDevInfo->SpecialInfo.stGigEInfo.nCurrentIp & 0xff000000) >>
  118.              24);
  119.         int nIp2 =
  120.             ((pstMVDevInfo->SpecialInfo.stGigEInfo.nCurrentIp & 0x00ff0000) >>
  121.              16);
  122.         int nIp3 =
  123.             ((pstMVDevInfo->SpecialInfo.stGigEInfo.nCurrentIp & 0x0000ff00) >>
  124.              8);
  125.         int nIp4 =
  126.             (pstMVDevInfo->SpecialInfo.stGigEInfo.nCurrentIp & 0x000000ff);
  127.  
  128.         cameraInfo_index.append(QString::fromLocal8Bit("相机型号："));
  129.         std::string str_name =
  130.             (char *)pstMVDevInfo->SpecialInfo.stGigEInfo.chModelName;
  131.         cameraInfo_index.append(QString::fromStdString(str_name));
  132.         cameraInfo_index.append("\n");
  133.         cameraInfo_index.append(QString::fromLocal8Bit("当前相机IP地址："));
  134.         cameraInfo_index.append(QString::number(nIp1));
  135.         cameraInfo_index.append(".");
  136.         cameraInfo_index.append(QString::number(nIp2));
  137.         cameraInfo_index.append(".");
  138.         cameraInfo_index.append(QString::number(nIp3));
  139.         cameraInfo_index.append(".");
  140.         cameraInfo_index.append(QString::number(nIp4));
  141.         cameraInfo_index.append("\t");
  142.     } else if (pstMVDevInfo->nTLayerType == MV_USB_DEVICE) {
  143.         cameraInfo_index.append(QString::fromLocal8Bit("相机型号："));
  144.         std::string str_name =
  145.             (char *)pstMVDevInfo->SpecialInfo.stUsb3VInfo.chModelName;
  146.         cameraInfo_index.append(QString::fromStdString(str_name));
  147.         cameraInfo_index.append("\n");
  148.     } else {
  149.         cameraInfo_index.append(QString::fromLocal8Bit("相机型号：未知"));
  150.     }
  151.     cameraInfo_index.append(QString::fromLocal8Bit("相机品牌：海康威视"));
  152.     return cameraInfo_index;
  153. }
  154.  
  155. void Widget::on_pbn_open_camera_clicked()
  156. {
  157.     ui->pbn_open_camera->setEnabled(false);
  158.     ui->pbn_close_camera->setEnabled(true);
  159.     ui->rdo_continue_mode->setEnabled(true);
  160.     ui->rdo_softigger_mode->setEnabled(true);
  161.  
  162.     ui->rdo_continue_mode->setCheckable(true);
  163.     // 参数据控件
  164.     ui->le_set_exposure->setEnabled(true);
  165.     ui->le_set_gain->setEnabled(true);
  166.  
  167.  
  168.     OpenDevices();
  169. }
  170.  
  171. void Widget::OpenDevices()
  172. {
  173.     int nRet = MV_OK;
  174.     // 创建相机指针对象
  175.     for (unsigned int i = 0, j = 0; j < m_stDevList.nDeviceNum; j++, i++) {
  176.         m_pcMyCamera[i] = new CMvCamera;
  177.         // 相机对象初始化
  178.         m_pcMyCamera[i]->m_pBufForDriver = NULL;
  179.         m_pcMyCamera[i]->m_pBufForSaveImage = NULL;
  180.         m_pcMyCamera[i]->m_nBufSizeForDriver = 0;
  181.         m_pcMyCamera[i]->m_nBufSizeForSaveImage = 0;
  182.         m_pcMyCamera[i]->m_nTLayerType =
  183.             m_stDevList.pDeviceInfo[j]->nTLayerType;
  184.  
  185.         nRet = m_pcMyCamera[i]->Open(m_stDevList.pDeviceInfo[j]); //打开相机
  186.         //设置触发模式
  187.         m_pcMyCamera[i]->setTriggerMode(TRIGGER_ON);
  188.         //设置触发源为软触发
  189.         m_pcMyCamera[i]->setTriggerSource(TRIGGER_SOURCE);
  190.         //设置曝光时间,初始为40000，并关闭自动曝光模式
  191.         m_pcMyCamera[i]->setExposureTime(EXPOSURE_TIME);
  192.         m_pcMyCamera[i]->SetEnumValue("ExposureAuto",
  193.                                       MV_EXPOSURE_AUTO_MODE_OFF);
  194.     }
  195. }
  196.  
  197. void Widget::on_rdo_continue_mode_clicked()
  198. {
  199.     ui->pbn_start_grabbing->setEnabled(true);
  200.     m_nTriggerMode = TRIGGER_ON;
  201. }
  202.  
  203. void Widget::on_rdo_softigger_mode_clicked()
  204. {
  205.     // 如果开始选择的连续模式，切换到触发模式之前，需要先停止采集
  206.     if (m_bContinueStarted == 1) {
  207.         on_pbn_stop_grabbing_clicked(); //先执行停止采集
  208.     }
  209.  
  210.     ui->pbn_start_grabbing->setEnabled(false);
  211.     ui->pbn_software_once->setEnabled(true);
  212.  
  213.     m_nTriggerMode = TRIGGER_OFF;
  214.     for (unsigned int i = 0; i < m_stDevList.nDeviceNum; i++) {
  215.         m_pcMyCamera[i]->setTriggerMode(m_nTriggerMode);
  216.     }
  217. }
  218.  
  219. void Widget::on_pbn_start_grabbing_clicked()
  220. {
  221.     // 触发模式标记一下，切换触发模式时先执行停止采集图像函数
  222.     m_bContinueStarted = 1;
  223.  
  224.     ui->pbn_start_grabbing->setEnabled(false);
  225.     ui->pbn_stop_grabbing->setEnabled(true);
  226.     // 保存图像控件
  227.     ui->pbn_save_BMP->setEnabled(true);
  228.     // 图像采集控件
  229.     ui->pbn_save_JPG->setEnabled(true);
  230.  
  231.     int camera_Index = 0;
  232.  
  233.     // 先判断什么模式，再判断是否正在采集
  234.     if (m_nTriggerMode == TRIGGER_ON) {
  235.         // 开始采集之后才创建workthread线程
  236.         for (unsigned int i = 0; i < m_stDevList.nDeviceNum; i++) {
  237.             //开启相机采集
  238.             m_pcMyCamera[i]->StartGrabbing();
  239.             camera_Index = i;
  240.             if (camera_Index == 0) {
  241.                 myThread_Camera_show->getCameraPtr(
  242.                     m_pcMyCamera[0]); //线程获取左相机指针
  243.                 myThread_Camera_show->getImagePtr(
  244.                     myImage_L); //线程获取图像指针
  245.                 myThread_Camera_show->getCameraIndex(0); //相机 Index==0
  246.  
  247.                 if (!myThread_Camera_show->isRunning()) {
  248.                     myThread_Camera_show->start();
  249.                     m_pcMyCamera[0]->softTrigger();
  250.                     m_pcMyCamera[0]->ReadBuffer(*myImage_L); //读取Mat格式的图像
  251.                 }
  252.             }
  253.         }
  254.     }
  255. }
  256.  
  257. void Widget::on_pbn_stop_grabbing_clicked()
  258. {
  259.     ui->pbn_start_grabbing->setEnabled(true);
  260.     ui->pbn_stop_grabbing->setEnabled(false);
  261.  
  262.     for (unsigned int i = 0; i < m_stDevList.nDeviceNum; i++) {
  263.         //关闭相机
  264.         if (myThread_Camera_show->isRunning()) {
  265.             m_pcMyCamera[0]->StopGrabbing();
  266.             myThread_Camera_show->requestInterruption();
  267.             myThread_Camera_show->wait();
  268.         }
  269.     }
  270. }
  271.  
  272. void Widget::on_pbn_software_once_clicked()
  273. {
  274.     // 保存图像控件
  275.     ui->pbn_save_BMP->setEnabled(true);
  276.     ui->pbn_save_JPG->setEnabled(true);
  277.  
  278.     if (m_nTriggerMode == TRIGGER_OFF) {
  279.         int nRet = MV_OK;
  280.         for (unsigned int i = 0; i < m_stDevList.nDeviceNum; i++) {
  281.             //开启相机采集
  282.             m_pcMyCamera[i]->StartGrabbing();
  283.  
  284.             if (i == 0) {
  285.                 nRet = m_pcMyCamera[i]->CommandExecute("TriggerSoftware");
  286.                 m_pcMyCamera[i]->ReadBuffer(*myImage_L);
  287.                 display_myImage_L(myImage_L);       //左相机图像
  288.                 display_myImage_Main(myImage_L);    //主界面显示
  289.             }
  290.         }
  291.     }
  292. }
  293.  
  294. //在相机配置界面显示
  295. void Widget::display_myImage_L(const Mat *imagePrt)
  296. {
  297.  
  298.     cv::Mat rgb;
  299.  
  300.     //判断是黑白、彩色图像
  301.     QImage QmyImage_L;
  302.     if (myImage_L->channels() > 1) {
  303.         cv::cvtColor(*imagePrt, rgb, CV_BGR2RGB);
  304.         QmyImage_L = QImage((const unsigned char *)(rgb.data), rgb.cols,
  305.                             rgb.rows, QImage::Format_RGB888);
  306.     } else {
  307.         cv::cvtColor(*imagePrt, rgb, CV_GRAY2RGB);
  308.         QmyImage_L = QImage((const unsigned char *)(rgb.data), rgb.cols,
  309.                             rgb.rows, QImage::Format_RGB888);
  310.     }
  311.  
  312.     QmyImage_L = (QmyImage_L)
  313.             .scaled(ui->lbl_camera_L->size(), Qt::IgnoreAspectRatio,
  314.                     Qt::SmoothTransformation); //饱满填充
  315.     ui->lbl_camera_L->setPixmap(QPixmap::fromImage(QmyImage_L));
  316.  
  317. }
  318.  
  319. //在主界面显示
  320. void Widget::display_myImage_Main(const Mat *imagePrt)
  321. {
  322.     cv::Mat rgb;
  323.     cv::cvtColor(*imagePrt, rgb, CV_BGR2RGB);
  324.  
  325.     QImage QmyImage_L;
  326.     QmyImage_L = QImage((const unsigned char *)(rgb.data), rgb.cols,
  327.                             rgb.rows, QImage::Format_RGB888);
  328.  
  329.     QmyImage_L = (QmyImage_L)
  330.                      .scaled(ui->lbl_camera_L->size(), Qt::IgnoreAspectRatio,
  331.                              Qt::SmoothTransformation); //饱满填充
  332.     //显示图像
  333.     this->mainWid=new MainWidget();
  334.     //ui->lbl_camera_L->setPixmap(QPixmap::fromImage(QmyImage_L));
  335.     mainWid->ui->lbl_res_pic->setPixmap(QPixmap::fromImage(QmyImage_L));
  336. }
  337.  
  338. void Widget::CloseDevices()
  339. {
  340.     for (unsigned int i = 0; i < m_stDevList.nDeviceNum; i++) {
  341.         // 关闭线程、相机
  342.         if (myThread_Camera_show->isRunning()) {
  343.             myThread_Camera_show->requestInterruption();
  344.             myThread_Camera_show->wait();
  345.             m_pcMyCamera[0]->StopGrabbing();
  346.         }
  347.  
  348.         m_pcMyCamera[i]->Close();
  349.     }
  350.  
  351.     // 关闭之后再枚举一遍
  352.     memset(&m_stDevList, 0,
  353.            sizeof(MV_CC_DEVICE_INFO_LIST)); // 初始化设备信息列表
  354.     int devices_num = MV_OK;
  355.     devices_num =
  356.         CMvCamera::EnumDevices(MV_GIGE_DEVICE | MV_USB_DEVICE,
  357.                                &m_stDevList); // 枚举子网内所有设备,相机设备数量
  358. }
  359.  
  360. void Widget::on_pbn_close_camera_clicked()
  361. {
  362.     ui->pbn_open_camera->setEnabled(true);
  363.     ui->pbn_close_camera->setEnabled(false);
  364.     // 图像采集控件
  365.     ui->rdo_continue_mode->setEnabled(false);
  366.     ui->rdo_softigger_mode->setEnabled(false);
  367.     ui->pbn_start_grabbing->setEnabled(false);
  368.     ui->pbn_stop_grabbing->setEnabled(false);
  369.     ui->pbn_software_once->setEnabled(false);
  370.     // 参数控件
  371.     ui->le_set_exposure->setEnabled(false);
  372.     ui->le_set_gain->setEnabled(false);
  373.     // 保存图像控件
  374.     ui->pbn_save_BMP->setEnabled(false);
  375.     ui->pbn_save_JPG->setEnabled(false);
  376.  
  377.     // 关闭设备，销毁线程
  378.     CloseDevices();
  379.     ui->lbl_camera_messagee->clear();
  380.     ui->lbl_camera_L->clear();
  381.     ui->lbl_camera_L->setPixmap(QPixmap(":/icon/MVS.png"));
  382.     //ui->lbl_camera_R->clear();
  383. }
  384.  
  385. void Widget::on_pbn_save_BMP_clicked()
  386. {
  387.     m_nSaveImageType = MV_Image_Bmp;
  388.     SaveImage();
  389.  
  390. }
  391.  
  392. void Widget::on_pbn_save_JPG_clicked()
  393. {
  394.     m_nSaveImageType = MV_Image_Jpeg;
  395.     SaveImage();
  396. }
  397.  
  398. void Widget::SaveImage()
  399. {
  400.     // 获取1张图
  401.     MV_FRAME_OUT_INFO_EX stImageInfo = { 0 };
  402.     memset(&stImageInfo, 0, sizeof(MV_FRAME_OUT_INFO_EX));
  403.     unsigned int nDataLen = 0;
  404.     int nRet = MV_OK;
  405.  
  406.     //保存图片的路径
  407.     QString saveDirPath="/home/joe/program/VersionDetect/test2/image/1.jpg";
  408.     for (int i = 0; i < devices_num; i++) {
  409.  
  410.         //保存图像的缓存类指针
  411.         const char *imageName_c_str=NULL;
  412.         // 仅在第一次保存图像时申请缓存，在CloseDevice时释放
  413.         if (NULL == m_pcMyCamera[i]->m_pBufForDriver) {
  414.             unsigned int nRecvBufSize = 0;
  415.  
  416.             m_pcMyCamera[i]->GetIntValue("PayloadSize", &nRecvBufSize);
  417.  
  418.             m_pcMyCamera[i]->m_nBufSizeForDriver = nRecvBufSize; // 一帧数据大小
  419.  
  420.             m_pcMyCamera[i]->m_pBufForDriver =
  421.                 (unsigned char *)malloc(m_pcMyCamera[i]->m_nBufSizeForDriver);
  422.         }
  423.  
  424.         nRet = m_pcMyCamera[i]->GetOneFrameTimeout(
  425.             m_pcMyCamera[i]->m_pBufForDriver, &nDataLen,
  426.             m_pcMyCamera[i]->m_nBufSizeForDriver, &stImageInfo, 1000);
  427.         if (MV_OK == nRet) {
  428.             // 仅在第一次保存图像时申请缓存，在 CloseDevice 时释放
  429.             if (NULL == m_pcMyCamera[i]->m_pBufForSaveImage) {
  430.                 // BMP图片大小：width * height * 3 + 2048(预留BMP头大小)
  431.                 m_pcMyCamera[i]->m_nBufSizeForSaveImage =
  432.                     stImageInfo.nWidth * stImageInfo.nHeight * 3 + 2048;
  433.  
  434.                 m_pcMyCamera[i]->m_pBufForSaveImage = (unsigned char *)malloc(
  435.                     m_pcMyCamera[i]->m_nBufSizeForSaveImage);
  436.             }
  437.             // 设置对应的相机参数
  438.             MV_SAVE_IMAGE_PARAM_EX stParam = { 0 };
  439.             stParam.enImageType = m_nSaveImageType; // 需要保存的图像类型
  440.             stParam.enPixelType = stImageInfo.enPixelType; // 相机对应的像素格式
  441.             stParam.nBufferSize =
  442.                 m_pcMyCamera[i]->m_nBufSizeForSaveImage; // 存储节点的大小
  443.             stParam.nWidth = stImageInfo.nWidth;         // 相机对应的宽
  444.             stParam.nHeight = stImageInfo.nHeight;       // 相机对应的高
  445.             stParam.nDataLen = stImageInfo.nFrameLen;
  446.             stParam.pData = m_pcMyCamera[i]->m_pBufForDriver;
  447.             stParam.pImageBuffer = m_pcMyCamera[i]->m_pBufForSaveImage;
  448.             stParam.nJpgQuality = 90; // jpg编码，仅在保存Jpg图像时有效
  449.  
  450.             nRet = m_pcMyCamera[i]->SaveImage(&stParam);
  451.  
  452.  
  453.             QString image_name;
  454.             //图像名称
  455.             char chImageName[IMAGE_NAME_LEN] = {0};
  456.             if (MV_Image_Bmp == stParam.enImageType) {
  457.                 if (i == 0) {
  458.                     snprintf(chImageName, IMAGE_NAME_LEN,
  459.                              "Image_w%d_h%d_fn%d_L.bmp", stImageInfo.nWidth,
  460.                              stImageInfo.nHeight, stImageInfo.nFrameNum);
  461.                     image_name = "Image_w";
  462.                     image_name.append(QString::number(stImageInfo.nWidth));
  463.                     image_name.append("_h");
  464.                     image_name.append(QString::number(stImageInfo.nHeight));
  465.                     image_name.append("_fn");
  466.                     image_name.append(QString::number(stImageInfo.nFrameNum));
  467.                     image_name.append("_L.bmp");
  468.                 }
  469.                 if (i == 1) {
  470.                     snprintf(chImageName, IMAGE_NAME_LEN,
  471.                              "Image_w%d_h%d_fn%03d_R.bmp", stImageInfo.nWidth,
  472.                              stImageInfo.nHeight, stImageInfo.nFrameNum);
  473.                 }
  474.  
  475.             } else if (MV_Image_Jpeg == stParam.enImageType) {
  476.                 if (i == 0) {
  477.                     snprintf(chImageName, IMAGE_NAME_LEN,
  478.                              "Image_w%d_h%d_fn%d_L.jpg", stImageInfo.nWidth,
  479.                              stImageInfo.nHeight, stImageInfo.nFrameNum);
  480.                     image_name = "Image_w";
  481.                     image_name.append(QString::number(stImageInfo.nWidth));
  482.                     image_name.append("_h");
  483.                     image_name.append(QString::number(stImageInfo.nHeight));
  484.                     image_name.append("_fn");
  485.                     image_name.append(QString::number(stImageInfo.nFrameNum));
  486.                     image_name.append("_L.jpg");
  487.                 }
  488.                 if (i == 1) {
  489.                     snprintf(chImageName, IMAGE_NAME_LEN,
  490.                              "Image_w%d_h%d_fn%03d_R.jpg", stImageInfo.nWidth,
  491.                              stImageInfo.nHeight, stImageInfo.nFrameNum);
  492.                 }
  493.  
  494.             }
  495.  
  496.             QString imagePath = saveDirPath + image_name;
  497.             QByteArray ba = imagePath.toLatin1();
  498.             imageName_c_str = ba.data();
  499.  
  500.  
  501.             FILE *fp = fopen(imageName_c_str, "wb");
  502.  
  503.             fwrite(m_pcMyCamera[i]->m_pBufForSaveImage, 1, stParam.nImageLen,
  504.                    fp);
  505.             fclose(fp);
  506.  
  507.  
  508. //            ui->lbl_camera_R->setPixmap(QPixmap(image_name));
  509. //            ui->lbl_camera_R->setScaledContents(true);
  510.         }
  511.     }
  512. }
  513.  
  514.  
  515. void Widget::on_le_set_exposure_textChanged(const QString &arg1)
  516. {
  517.     //设置曝光时间
  518.     QString str = ui->le_set_exposure->text(); // 读取
  519.     int exposure_Time = str.toInt();
  520.  
  521.     for (int i = 0; i < devices_num; i++) {
  522.         m_pcMyCamera[i]->SetEnumValue("ExposureAuto",
  523.                                       MV_EXPOSURE_AUTO_MODE_OFF);
  524.         m_pcMyCamera[i]->SetFloatValue("ExposureTime", exposure_Time);
  525.     }
  526. }
  527.  
  528. void Widget::on_le_set_gain_textChanged(const QString &arg1)
  529. {
  530.     QString str = ui->le_set_gain->text(); // 读取
  531.     float gain = str.toFloat();
  532.  
  533.     for (int i = 0; i < devices_num; i++) {
  534.         m_pcMyCamera[i]->SetEnumValue("GainAuto", 0);
  535.         m_pcMyCamera[i]->SetFloatValue("Gain", gain);
  536.     }
  537. }
  538.  
  539.  
  540. void Widget::on_pbn_return_main_clicked()
  541. {
  542.     //发送信号实现页面切换
  543.     //connect(ui->pbn_return_main,SIGNAL(clicked()),this,SIGNAL(back()));
  544. }

3、界面效果

其中返回主界面的button是在部署深度学习模型中要用的，与相机连接无关 ，整体就是：

枚举相机->打开相机->连续模式->连续采集or软触发一次


参考博客：海康威视在linux下使用笔记——ros驱动相机_hikrobot工业相机ros驱动-CSDN博客

        

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/繁依Fanyi0/article/detail/99009
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号