QT+OpenCV+海康SDK环境搭建，调用海康相机实时显示

原创 已于 2025-09-05 21:23:14 修改 · 371 阅读 · 8 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#qt #开发语言

于 2025-09-05 21:22:30 首次发布

代码和流程基本仿照这位大佬Qt+OpenCV调用海康相机SDK采集图像(C++) - 威海云博客 - 博客园，只做了一些跟自己适配的调整。

一、版本

Qt 构建套件（Kit）版本：

OpenCV版本：4.5.5，vc15

海康SDK：V.4.1.3

相机：海康工业相机MV-CA020-20GC（网口版）

二、流程及代码

2.1确保相机可以正常使用

网线连接相机和电脑确保相机和电脑在同一网段，打开海康官方软件MVS，当自动识别到相机后点击连接，点击开始采集，确保相机可以正常使用。

2.2 新建一个QT项目，新建好后添加mycanera.cpp和mycanera.h(原作者camera写错了）并在该项目的根目录下新建includes和libs文件夹。

将SDK文件夹下代码MVS\Development\Libraries\win64中的MvCameraControl.lib复制到新建的libs中

和MVS\Development\Includes中的所有文件复制到includes中

2.3 代码

Test02.pro,注意修改其中opencv路径至自己的路径，即最后部分（约49-57行）

#-------------------------------------------------
#
# Project created by QtCreator 2025-09-03T19:32:08
#
#-------------------------------------------------

QT       += core gui

greaterThan(QT_MAJOR_VERSION, 4): QT += widgets

TARGET = Test02
TEMPLATE = app

# The following define makes your compiler emit warnings if you use
# any feature of Qt which has been marked as deprecated (the exact warnings
# depend on your compiler). Please consult the documentation of the
# deprecated API in order to know how to port your code away from it.
DEFINES += QT_DEPRECATED_WARNINGS

# You can also make your code fail to compile if you use deprecated APIs.
# In order to do so, uncomment the following line.
# You can also select to disable deprecated APIs only up to a certain version of Qt.
#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0


SOURCES += \
        main.cpp \
        mainwindow.cpp \
    mycanera.cpp

HEADERS += \
        mainwindow.h \
    mycanera.h \
    mycanera.h

FORMS += \
        mainwindow.ui

win32: LIBS += -L$$PWD/libs/ -lMvCameraControl

INCLUDEPATH += $$PWD/libs
DEPENDPATH += $$PWD/libs
INCLUDEPATH += $$PWD/includes/
INCLUDEPATH += $$PWD/includes/GenICam/

DEPENDPATH += $$PWD/includes/
DEPENDPATH += $$PWD/includes/GenICam/

win32: LIBS += -LD:/soft/OpenCV/opencv-4.5.5/opencv/build/x64/vc15/lib/ -lopencv_world455d

INCLUDEPATH += D:/soft/OpenCV/opencv-4.5.5/opencv/build/x64/vc15
DEPENDPATH += D:/soft/OpenCV/opencv-4.5.5/opencv/build/x64/vc15
INCLUDEPATH += D:/soft/OpenCV/opencv-4.5.5/opencv/build/include/
                D:/soft/OpenCV/opencv-4.5.5/opencv/build/include/opencv2
 DEPENDPATH += D:/soft/OpenCV/opencv-4.5.5/opencv/build/include/
                D:/soft/OpenCV/opencv-4.5.5/opencv/build/include/opencv2

mainwindow.h代码

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include "mycanera.h"
#include <Qtimer>

QT_BEGIN_NAMESPACE
namespace Ui { class MainWindow; }
QT_END_NAMESPACE

class MainWindow : public QMainWindow
{
    Q_OBJECT

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

    MyCanera *m_pcMycamera;
    MV_CC_DEVICE_INFO_LIST m_stDevList;//设备列表
    string cameraName; //相机名称
    Mat imageMat; //使用OpenCV接受采集图像
    QImage cvMat2QImage(const cv::Mat& mat);
    QImage image;


private slots:
    void on_pushButton_link_clicked();

    void on_pushButton_close_clicked();

    void on_pushButton_caiji_clicked();
    void on_pushButton_realtime_clicked(); // 实时显示按钮
    void updateFrame(); // 定时器超时槽函数

private:
    Ui::MainWindow *ui;
    QTimer *m_timer; // 用于定时获取图像
    bool m_bIsGrabbing; // 标记是否正在连续采集
};
#endif // MAINWINDOW_H

mycanera.h代码


#ifndef MYCANERA_H
#define MYCANERA_H
#include "MvCameraControl.h"
#pragma execution_character_set("utf-8")   //设置当前文件为UTF-8编码
#pragma warning( disable : 4819 )    //解决SDK中包含中文问题；忽略C4819错误
#include <stdio.h>
#include <iostream>
#include "opencv2/core/core.hpp"
#include "opencv2/opencv.hpp"
#include "opencv2/highgui/highgui.hpp"
#include <string>
#include <QDebug>
#include <QDateTime> // 用于生成时间戳文件名

using namespace std;
using namespace cv;
class MyCanera
{
public:
    MyCanera();
   ~MyCanera();
    //声明相关变量及函数等
    //枚举相机设备列表
  static int EnumDevices(MV_CC_DEVICE_INFO_LIST* pstDevList);

  // ch:连接相机
  int connectCamera(string id);

  //设置相机触发模式
  int setTriggerMode(unsigned int TriggerModeNum);

  //开启相机采集
  int startCamera();

  //发送软触发
  int softTrigger();

  //读取buffer
  int ReadBuffer(Mat &image);

  //设置心跳时间
  int setHeartBeatTime(unsigned int time);

  //设置曝光时间
  int setExposureTime(float ExposureTimeNum);
//关闭相机
  int closeCamera();
  private:
  void* m_hDevHandle;
public:
  unsigned char* m_pBufForSaveImage; // 用于保存图像的缓存
  unsigned int m_nBufSizeForSaveImage;
  unsigned char* m_pBufForDriver; // 用于从驱动获取图像的缓存
  unsigned int m_nBufSizeForDriver;
  MV_CC_DEVICE_INFO_LIST m_stDevList; // ch:设备信息列表结构体变量，用来存储设备列表
  MV_CC_DEVICE_INFO *m_Device = NULL; //设备对象
};
#endif // MYCANERA_H

mainwindow.cpp代码

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "mycanera.h"
#include <QDebug>
#include <QImage>
#include <QImageReader>
MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    // 初始化定时器和状态变量
     m_timer = new QTimer(this);
     m_bIsGrabbing = false;
     connect(m_timer, SIGNAL(timeout()), this, SLOT(updateFrame()));

    m_pcMycamera = new MyCanera;
    int neRt = m_pcMycamera->EnumDevices(&m_stDevList);
    qDebug() << neRt;
    qDebug() << m_stDevList.pDeviceInfo[0]->nTLayerType;
    //获取相机的IP地址
    if(1 == m_stDevList.pDeviceInfo[0]->nTLayerType){
        int nIp1,nIp2,nIp3,nIp4;
        nIp1 = ((m_stDevList.pDeviceInfo[0]->SpecialInfo.stGigEInfo.nCurrentIp & 0xff000000) >> 24);
        nIp2 = ((m_stDevList.pDeviceInfo[0]->SpecialInfo.stGigEInfo.nCurrentIp & 0x00ff0000) >> 16);
        nIp3 = ((m_stDevList.pDeviceInfo[0]->SpecialInfo.stGigEInfo.nCurrentIp & 0x0000ff00) >> 8);
        nIp4 = (m_stDevList.pDeviceInfo[0]->SpecialInfo.stGigEInfo.nCurrentIp & 0x000000ff);
        QString nIp = QString("%1.%2.%3.%4").arg(nIp1).arg(nIp2).arg(nIp3).arg(nIp4);
        qDebug() << nIp;
    }
}

MainWindow::~MainWindow()
{
    delete ui;
}

//连接相机
void MainWindow::on_pushButton_link_clicked()
{
    cameraName = (char *)m_stDevList.pDeviceInfo[0]->SpecialInfo.stGigEInfo.chUserDefinedName;
    qDebug() << "尝试连接相机:" << QString::fromStdString(cameraName);

    int linkCamera = m_pcMycamera->connectCamera(cameraName);
    qDebug() << "连接结果:" << linkCamera;

    if(linkCamera == 0){
        qDebug() << "连接相机成功";

        // 开启抓图
        int satrtCamera = m_pcMycamera->startCamera();
        if(satrtCamera != 0){
            qDebug() << "启动相机采集失败";
        }else {
            qDebug() << "正在启动相机采集信息";
        }
    }else {
        qDebug() << "连接相机失败，错误码:" << linkCamera;

        // 尝试使用序列号连接
        QString serialNumber = QString::fromLocal8Bit((char *)m_stDevList.pDeviceInfo[0]->SpecialInfo.stGigEInfo.chSerialNumber);
        qDebug() << "尝试使用序列号连接:" << serialNumber;

        int linkBySerial = m_pcMycamera->connectCamera(serialNumber.toStdString());
        qDebug() << "使用序列号连接结果:" << linkBySerial;
    }
}
//添加实时显示按钮的槽函数
void MainWindow::on_pushButton_realtime_clicked()
{
    if (!m_bIsGrabbing) {
        // 开始实时显示
        if (m_pcMycamera->setTriggerMode(0) == 0) { // 设置为连续采集模式
            m_timer->start(33); // 约30帧/秒
            m_bIsGrabbing = true;
            ui->pushButton_realtime->setText("停止实时显示");
        }
    } else {
        // 停止实时显示
        m_timer->stop();
        m_bIsGrabbing = false;
        ui->pushButton_realtime->setText("开始实时显示");
    }
}

// 定时器超时槽函数，用于更新画面
void MainWindow::updateFrame()
{
    // 读取相机中的图像
    int readInt = m_pcMycamera->ReadBuffer(imageMat);
    if(readInt != 0){
        qDebug() << "读取图像失败";
        return;
    }

    // 转换并显示图像
    image = cvMat2QImage(imageMat);
    ui->label_image->setPixmap(QPixmap::fromImage(image).scaled(
        ui->label_image->width(),
        ui->label_image->height(),
        Qt::KeepAspectRatio));
}

// 修改单张采集函数，确保在单张采集时使用触发模式
void MainWindow::on_pushButton_caiji_clicked()
{
    // 如果正在实时显示，先停止
    if (m_bIsGrabbing) {
        m_timer->stop();
        m_bIsGrabbing = false;
        ui->pushButton_realtime->setText("开始实时显示");
    }

    // 设置为触发模式
    m_pcMycamera->setTriggerMode(1);

    // 发送软触发
    int softTrigger = m_pcMycamera->softTrigger();
    if(softTrigger != 0){
        qDebug() << "软触发失败";
    }else {
        qDebug() << "成功触发一次";
    }

    // 读取相机中的图像
    int readInt = m_pcMycamera->ReadBuffer(imageMat);
    if(readInt != 0){
        qDebug() << "读取图像失败";
    }
    image = cvMat2QImage(imageMat);
    ui->label_image->setPixmap(QPixmap::fromImage(image).scaled(
        ui->label_image->width(),
        ui->label_image->height(),
        Qt::KeepAspectRatio));
}
//关闭设备
void MainWindow::on_pushButton_close_clicked()
{
    //关闭设备，释放资源
    int close = m_pcMycamera->closeCamera();
    if(close != 0){
        qDebug() << "相机关闭失败";
    }
}

//Mat转QImage函数
QImage MainWindow::cvMat2QImage(const cv::Mat& mat)
{
    // 8-bits unsigned, NO. OF CHANNELS = 1
    if(mat.type() == CV_8UC1)
    {
        QImage qimage(mat.cols, mat.rows, QImage::Format_Indexed8);
        // Set the color table (used to translate colour indexes to qRgb values)
        qimage.setColorCount(256);
        for(int i = 0; i < 256; i++)
        {
            qimage.setColor(i, qRgb(i, i, i));
        }
        // Copy input Mat
        uchar *pSrc = mat.data;
        for(int row = 0; row < mat.rows; row ++)
        {
            uchar *pDest = qimage.scanLine(row);
            memcpy(pDest, pSrc, mat.cols);
            pSrc += mat.step;
        }
        return qimage;
    }
    // 8-bits unsigned, NO. OF CHANNELS = 3
    else if(mat.type() == CV_8UC3)
    {
        // Copy input Mat
        const uchar *pSrc = (const uchar*)mat.data;
        // Create QImage with same dimensions as input Mat
        QImage image(pSrc, mat.cols, mat.rows, mat.step, QImage::Format_RGB888);
        return image.rgbSwapped();
    }
    else if(mat.type() == CV_8UC4)
    {
        // Copy input Mat
        const uchar *pSrc = (const uchar*)mat.data;
        // Create QImage with same dimensions as input Mat
        QImage image(pSrc, mat.cols, mat.rows, mat.step, QImage::Format_ARGB32);
        return image.copy();
    }
    else
    {
        return QImage();
    }
}

mycanera.h代码

#include "mycanera.h"
#include <QDebug>
MyCanera::MyCanera()
{
    m_hDevHandle = NULL;
        m_pBufForSaveImage = nullptr;
        m_nBufSizeForSaveImage = 0;
        m_pBufForDriver = nullptr;
        m_nBufSizeForDriver = 0;
        memset(&m_stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));
        m_Device = NULL;
}

MyCanera::~MyCanera()
{
    if (m_pBufForDriver != nullptr) {
            free(m_pBufForDriver);
            m_pBufForDriver = nullptr;
        }
        if (m_pBufForSaveImage != nullptr) {
            free(m_pBufForSaveImage);
            m_pBufForSaveImage = nullptr;
        }

        if (m_hDevHandle) {
            MV_CC_DestroyHandle(m_hDevHandle);
            m_hDevHandle = NULL;
        }
}

//查询设备列表
int MyCanera::EnumDevices(MV_CC_DEVICE_INFO_LIST* pstDevList)
{
    int temp= MV_CC_EnumDevices(MV_GIGE_DEVICE | MV_USB_DEVICE, pstDevList);
    if (MV_OK != temp)
    {
        return -1;
    }
    return 0;
}

//连接相机
//id:自定义相机名称
int MyCanera::connectCamera(string id)
{
    int temp = EnumDevices(&m_stDevList);
    if(temp != 0) {
        qDebug() << "枚举设备失败，错误码:" << temp;
        return -1;
    }

    if(m_stDevList.nDeviceNum == 0) {
        qDebug() << "未找到任何相机";
        return 2;
    }

    m_Device = NULL;
    for (unsigned int i = 0; i < m_stDevList.nDeviceNum; i++)
    {
        MV_CC_DEVICE_INFO* pDeviceInfo = m_stDevList.pDeviceInfo[i];
        if (NULL == pDeviceInfo)
        {
            continue;
        }

        if(id == (char*)pDeviceInfo->SpecialInfo.stGigEInfo.chUserDefinedName ||
           id == (char*)pDeviceInfo->SpecialInfo.stGigEInfo.chSerialNumber)
        {
            m_Device = m_stDevList.pDeviceInfo[i];
            break;
        }
    }

    if(m_Device == NULL) {
        qDebug() << "未找到指定名称的相机";
        return 3;
    }

    temp = MV_CC_CreateHandle(&m_hDevHandle, m_Device);
    if(temp != MV_OK) {
        qDebug() << "创建句柄失败，错误码:" << temp;
        return -1;
    }

    temp = MV_CC_OpenDevice(m_hDevHandle);
    if (temp != MV_OK) {
        qDebug() << "打开设备失败，错误码:" << temp;
        MV_CC_DestroyHandle(m_hDevHandle);
        m_hDevHandle = NULL;
        return -1;
    }

    // 设置触发模式为关闭（连续采集模式）
    int triggerResult = setTriggerMode(0);
    if (triggerResult != 0) {
        qDebug() << "设置触发模式失败";
        MV_CC_CloseDevice(m_hDevHandle);
        MV_CC_DestroyHandle(m_hDevHandle);
        m_hDevHandle = NULL;
        return -1;
    }

    return 0;
}
//设置相机是否开启触发模式
int MyCanera::setTriggerMode(unsigned int TriggerModeNum)
{
    int nRet = MV_CC_SetTriggerMode(m_hDevHandle,TriggerModeNum);
    if (MV_OK != nRet)
    {
        return -1;
    }

}
//启动相机采集
int MyCanera::startCamera()
{
    if (m_hDevHandle == NULL) {
            qDebug() << "相机句柄为空，无法启动采集";
            return -1;
        }

        int temp = MV_CC_StartGrabbing(m_hDevHandle);
        if(temp != 0)
        {
            qDebug() << "抓图失败，错误码:" << temp;
            return -1;
        }
        else
        {
            qDebug() << "抓图成功";
            return 0;
        }
}
//发送软触发
int MyCanera::softTrigger()
{
    int enumValue = MV_CC_SetEnumValue(m_hDevHandle,"TriggerSource",MV_TRIGGER_SOURCE_SOFTWARE);
    if(enumValue != 0){
        qDebug() << "设置软触发失败";
        return -1;
    }else {
        qDebug() << "设置软触发";
    }
    int comdValue= MV_CC_SetCommandValue(m_hDevHandle, "TriggerSoftware");
    if(comdValue!=0)
    {
        qDebug() << "软触发失败";
        return -1;
    }else
    {
        qDebug() << "软触发一次";
        return 0;
    }
}
//读取相机中的图像
int MyCanera::ReadBuffer(Mat &image)
{
    if (m_hDevHandle == NULL) {
        qDebug() << "相机句柄为空，无法读取图像";
        return -1;
    }

    // 释放之前分配的内存
    if (m_pBufForDriver != nullptr) {
        free(m_pBufForDriver);
        m_pBufForDriver = nullptr;
    }
    if (m_pBufForSaveImage != nullptr) {
        free(m_pBufForSaveImage);
        m_pBufForSaveImage = nullptr;
    }

    unsigned int nBufSize = 0;
    MVCC_INTVALUE stIntvalue;
    memset(&stIntvalue, 0, sizeof(MVCC_INTVALUE));

    int tempValue = MV_CC_GetIntValue(m_hDevHandle, "PayloadSize", &stIntvalue);
    if (tempValue != 0)
    {
        qDebug() << "GetIntValue失败，错误码:" << tempValue;
        return -1;
    }

    nBufSize = stIntvalue.nCurValue;
    m_pBufForDriver = (unsigned char *)malloc(nBufSize);
    if (m_pBufForDriver == nullptr) {
        qDebug() << "内存分配失败";
        return -1;
    }

    MV_FRAME_OUT_INFO_EX stImageInfo;
    memset(&stImageInfo, 0, sizeof(MV_FRAME_OUT_INFO_EX));

    int timeout = MV_CC_GetOneFrameTimeout(m_hDevHandle, m_pBufForDriver, nBufSize, &stImageInfo, 1000);
    if(timeout != 0)
    {
        qDebug() << "GetOneFrameTimeout失败，错误码:" << timeout;
        free(m_pBufForDriver);
        m_pBufForDriver = nullptr;
        return -1;
    }

    m_nBufSizeForSaveImage = stImageInfo.nWidth * stImageInfo.nHeight * 3 + 2048;
    m_pBufForSaveImage = (unsigned char*)malloc(m_nBufSizeForSaveImage);
    if (m_pBufForSaveImage == nullptr) {
        qDebug() << "内存分配失败";
        free(m_pBufForDriver);
        m_pBufForDriver = nullptr;
        return -1;
    }

    bool isMono;
    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)
    {
        image = Mat(stImageInfo.nHeight, stImageInfo.nWidth, CV_8UC1, m_pBufForDriver);
    }
    else
    {
        MV_CC_PIXEL_CONVERT_PARAM stConvertParam = {0};
        stConvertParam.nWidth = stImageInfo.nWidth;
        stConvertParam.nHeight = stImageInfo.nHeight;
        stConvertParam.pSrcData = m_pBufForDriver;
        stConvertParam.nSrcDataLen = stImageInfo.nFrameLen;
        stConvertParam.enSrcPixelType = stImageInfo.enPixelType;
        stConvertParam.enDstPixelType = PixelType_Gvsp_RGB8_Packed;
        stConvertParam.pDstBuffer = m_pBufForSaveImage;
        stConvertParam.nDstBufferSize = m_nBufSizeForSaveImage;

        int convertResult = MV_CC_ConvertPixelType(m_hDevHandle, &stConvertParam);
        if (convertResult != MV_OK) {
            qDebug() << "像素格式转换失败，错误码:" << convertResult;
            free(m_pBufForDriver);
            free(m_pBufForSaveImage);
            m_pBufForDriver = nullptr;
            m_pBufForSaveImage = nullptr;
            return -1;
        }

        image = Mat(stImageInfo.nHeight, stImageInfo.nWidth, CV_8UC3, m_pBufForSaveImage);
    }

    return 0;
}
//设置心跳时间
int MyCanera::setHeartBeatTime(unsigned int time)
{
    //心跳时间最小为500ms
    if(time<500)
        time=500;
    int temp=MV_CC_SetIntValue(m_hDevHandle, "GevHeartbeatTimeout", time);
    if(temp!=0)
    {
        return -1;
    }
    else
    {
        return 0;
    }
}
//设置曝光时间
int MyCanera::setExposureTime(float ExposureTimeNum)
{
    int temp= MV_CC_SetFloatValue(m_hDevHandle, "ExposureTime",ExposureTimeNum );
    if(temp!=0)
        return -1;
    return 0;
}
//关闭相机
int MyCanera::closeCamera()
{
    int nRet = MV_OK;
    if (NULL == m_hDevHandle)
    {
        qDebug() << "没有句柄，不用关闭";
        return -1;
    }
    MV_CC_CloseDevice(m_hDevHandle);
    nRet = MV_CC_DestroyHandle(m_hDevHandle);
    m_hDevHandle = NULL;
    return nRet;
}

main.cpp代码

#include "mainwindow.h"
#include <QApplication>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    MainWindow w;
    w.show();

    return a.exec();
}

mainwindow.ui,我的界面不好看，也可以自行美化，只要几个按钮对应上就好了

<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
 <class>MainWindow</class>
 <widget class="QMainWindow" name="MainWindow">
  <property name="geometry">
   <rect>
    <x>0</x>
    <y>0</y>
    <width>736</width>
    <height>509</height>
   </rect>
  </property>
  <property name="windowTitle">
   <string>MainWindow</string>
  </property>
  <widget class="QWidget" name="centralWidget">
   <widget class="QLabel" name="label_image">
    <property name="geometry">
     <rect>
      <x>40</x>
      <y>40</y>
      <width>641</width>
      <height>311</height>
     </rect>
    </property>
    <property name="text">
     <string/>
    </property>
   </widget>
   <widget class="QGroupBox" name="groupBox">
    <property name="geometry">
     <rect>
      <x>20</x>
      <y>10</y>
      <width>701</width>
      <height>351</height>
     </rect>
    </property>
    <property name="title">
     <string>相机实时画面</string>
    </property>
   </widget>
   <widget class="QWidget" name="">
    <property name="geometry">
     <rect>
      <x>60</x>
      <y>390</y>
      <width>631</width>
      <height>31</height>
     </rect>
    </property>
    <layout class="QHBoxLayout" name="horizontalLayout">
     <item>
      <widget class="QPushButton" name="pushButton_link">
       <property name="text">
        <string>连接相机</string>
       </property>
      </widget>
     </item>
     <item>
      <widget class="QPushButton" name="pushButton_realtime">
       <property name="text">
        <string>开始实时显示</string>
       </property>
      </widget>
     </item>
     <item>
      <widget class="QPushButton" name="pushButton_caiji">
       <property name="text">
        <string>采集单张图像</string>
       </property>
      </widget>
     </item>
     <item>
      <widget class="QPushButton" name="pushButton_close">
       <property name="text">
        <string>关闭相机</string>
       </property>
      </widget>
     </item>
    </layout>
   </widget>
  </widget>
  <widget class="QMenuBar" name="menuBar">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>736</width>
     <height>17</height>
    </rect>
   </property>
  </widget>
  <widget class="QToolBar" name="mainToolBar">
   <attribute name="toolBarArea">
    <enum>TopToolBarArea</enum>
   </attribute>
   <attribute name="toolBarBreak">
    <bool>false</bool>
   </attribute>
  </widget>
  <widget class="QStatusBar" name="statusBar"/>
 </widget>
 <layoutdefault spacing="6" margin="11"/>
 <resources/>
 <connections/>
</ui>

结果：运行后点击连接相机-点击开始实时显示

即可显示相机画面

问题：我这个还有逻辑不通的地方，关闭相机不成功，可以让AI改一下。

基于Qt和C++的海康网络摄像头SDK开发，详细步骤
YangAndyYangYang的博客
10-07 7314
在test文件夹里面新建一个MVS的文件夹，里面再新建两个文件夹，一个命名为lib，一个命名为include。右击进入属性页面，找到Internet协议版本4（TCP/IPv4），选择使用下面的IP地址，进行如下IP地址设置，设置IP地址必须为192.168.43.X，X可以为任意不为1的数。在mainwindow.cpp里面输入自己的IP，用户名，密码登录，可以在ui界面的widget里面播放摄像头画面。我这里电脑安装的是2022的VS，qt是qt5，所以MSVC是红色的，但是可以正常使用。
Qt联合海康威视工业相机采集，在线转Halcon变量并显示
lmfivzq的博客
08-31 658
综上所述，通过本文的介绍，我们可以了解到如何利用Qt和海康威视工业相机实现图像采集、在线转换和显示，同时支持多相机、黑白相机和彩色相机。我们可以利用Qt的信号和槽机制实现数据的传递和处理，同时利用多线程的方式，提高程序的运行效率和稳定性。在界面设计上，我们需要考虑不同相机的显示和控制，同时还需要对不同颜色空间、灰度等问题进行处理，以实现一个完整的图像处理系统。首先，我们需要准备一些必要的工具和环境，例如Qt的开发环境、海康威视工业相机的SDK、以及Halco的安装包等。接下来，我们可以开始编写代码了。
Qt 连接海康摄像头并显示视屏
05-29
使用Qt，实现了两种连接海康摄像头，并获取到视屏流，刷新在界面上显示。代码可以编译通过运行，代码是上线工程中的源码，可以直接拿到产品中进行使用。
Qt连接海康相机
qq_43470534的博客
11-09 820
1）将海康的SDK库文件夹Includes和Libraries复制到自己项目的文件夹下。1.配置opencv库（可看我前面配置）2）然后将库添加到.pro文件下。
树莓派上QT连接海康相机
maum61的专栏
12-10 5147
1、环境搭建： 不想再安装庞大的MVS，先下载Linux runtime包 机器视觉工业相机SDK V3.2.0版本Runtime组件包（Linux）.zip： 海康机器人-机器视觉-下载中心 然后解压出来 接着执行下面命令安装Lib: sudo dpkg -i MvCamCtrlSDK_Runtime-3.2.0_armhf_20210915.deb 第一次安装会让设置一个基础路径，我设置的是 ： /opt/MVS 可能是我不懂啊，安装后找不到include文件夹，无奈，还是得下载MVS，.
QT+opencv调用海康工业相机
weixin_53157219的博客
01-27 3562
这里写自定义目录标题QT+opencv调用海康工业相机开发环境引用海康开发文件直接上代码 QT+opencv调用海康工业相机 最近在使用Opencv调用海康工业相机的程序，从网上查了好多资料，也走了不少弯路，在这里分享下，希望大家少走弯路！ 开发环境 QT5.14.2 +MSVC2017 64bit + opencv4.5 引用海康开发文件 这里就不多少了 网上有好多，可以参考 记得工程文件添加引用路径 opencv ```cpp INCLUDEPATH += D:/Environment/ope
Qt+opencv+Linux+海康工业相机连接
12-08
利用Qt的网络编程能力，可以处理来自海康相机的数据流，并使用Qt的图形显示能力将实时视频展示给用户。 OpenCV在其中扮演了图像处理和分析的重要角色。通过OpenCV，开发者可以利用其丰富的图像处理函数库，如滤波、...
基于QT5.12.2 + opencv + 海康sdk 设计的网络摄像头监控项目
qq_46019455的博客
11-18 866
本文基于海康自带的sdk包和opencv使用qt创建一个加有深度学习功能的海康网络摄像头项目（使用opencv的目的是对采用自行回流的方式获取到的摄像机画面进行处理）最主要的调用海康网络摄像头的代码已经开源出来了，如果还想要paddle推理部分的代码，或者整个项目可以私信作者。
Qt - 海康SDK获取视频并OpenCv处理每帧图像进行显示
10-18
■ 本源码运行环境为Vs2017、Qt5.12.4、OpenCV3，主要功能获取海康摄像头视频，并对每一帧视频进行opencv图像处理后进行显示。 ■ 本源码对应的文章介绍：...
Qt+OpenCV调用海康相机SDK采集图像(C++)
QtCompany的博客
05-15 5498
配置环境：Qt5.12.5海康MVS3.1.0开发工具：QT Creator-4.11.0。
使用Qt调用海康威视SDK实现登陆、预览、抓图
08-17
使用Qt调用海康威视SDK实现登陆、预览、抓图，包括源代码和可执行文件，可以作为服务端自动抓图、客户端预览等，可执行文件的依赖项已经全部打包。
testHIKCamera_连接海康工业相机并显示图像_QT_
10-03
利用海康sdk，链接相机，获取图像，并在界面上显示图像
Qt环境下调用OpenCV和海康摄像头数据实现目标检测（项目源代码）
04-07
在本项目中，开发者在Qt环境下利用OpenCV库与海康摄像头进行集成，实现了目标检测功能。这是一个典型的计算机视觉应用，结合了多个重要的技术领域，包括图像处理、机器学习和实时视频流处理。 首先，Qt是一个跨平台...
（二）Qt多线程实现海康工业相机图像实时采集
热门推荐
XCJandLL的博客
12-31 1万+
本文主要讲述了使用Qt多线程实现海康工业相机图像的采集，并在界面上将两个相机采集到的图像信息同时显示出来。
Qt+海康虚拟相机的调试
whf227的博客
02-07 1328
将要显示图片添加到相机目录的文件夹中，彩色相机添加到RGB24文件夹中，黑白相机添加到Mono文件夹。3.回到软件主页，在左侧双击添加的虚拟相机，会打开相机，然后点击开始采集按钮，会出现图像，如果没有设置图片，会显示默认图片。右侧可修改相机参数。做机器视觉项目的时候，在没有相机或需要把现场采集的图片在本地跑一下做测试时，可以使用海康的虚拟相机调试。5.最后，可使用项目代码进行调试，可以查找到添加的虚拟相机，采集的图像为设置的图像。2.打开虚拟相机工具后，根据实际情况添加相机。图像尺寸需要和相机分辨率一致。
Qt调用海康相机实时显示
LonelyBHBH的博客
05-17 7883
一、配置环境变量 这一步真的是翻烂了CSDN最终还是通过下载一位大佬的原码最终解决了，马上分享给大家 首先把海康的库目录和包含目录复制到Qt的工程文件下，自己新建的两个文件夹分别存放包含和库。 然后在pro文件中添加如下代码 LIBS += -L$$PWD/Hik_Libs/ -lMvCameraControl INCLUDEPATH += $$PWD/Hik_Includes DEPENDPATH += $$PWD/Hik_Includes 至此海康环境配置完成..
Qt联合Halcon开发四：【详细图解】海康相机配置并链接测试
专注于 Qt/C++ 应用开发和机器视觉领域的开源项目分享。期待与您共同进步！
06-23 673
海康相机配置并链接测试
（二）Qt下多线程实现多个海康工业相机内触发采集回调取流显示
XCJandLL的博客
07-16 5768
本文主要讲述了在Qt下实现多个海康工业相机的连接，采用内触发采集模式，并结合多线程使用回调取流的方式来获取图像并实现界面上两个相机的显示图像。
Qt+OpenCV调用海康工业相机 模板匹配
最新发布
08-16
在使用 Qt 与 OpenCV 开发时，调用海康威视工业相机并实现模板匹配功能，需要完成以下几个核心步骤：配置海康 SDK 环境、通过 SDK 获取相机图像流、将图像数据转换为 OpenCV 可处理的格式，以及使用 OpenCV 的模板...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值