linux下使用opencv读取大恒相机

最新推荐文章于 2024-01-31 11:56:26 发布
最新推荐文章于 2024-01-31 11:56:26 发布
阅读量4.1k 收藏 47
点赞数 5
分类专栏： 项目实战
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29462849/article/details/88243223
版权

前言

大恒网口相机真的有点坑，api很难用，还好技术支持比较有耐心，一点一点的帮着解决了问题。

驱动安装

首先去大恒官网去下载linux下面的驱动，除了C++版本，还有python版本。一定要注意：linux下面安装驱动时，要看自己的内核版本支不支持相机的驱动，这一点很坑，要问清楚，到后面，也是费了很大劲才更换的内核。
在这里插入图片描述
在这里插入图片描述这是我这个相机驱动支持的linux内核，然后，安装驱动即可。
在这里插入图片描述
安装完驱动后，在tools文件夹中，有一个可执行文件，可以用来监测网口，运行即可。除此之外，还有一个可视化界面GalaxyView。
在这里插入图片描述

搭建工程

编译完成的文件夹有一些例子，拿下图第一个例子为例，在QT中建立工程。
在这里插入图片描述在QT中配置好路径，包括头文件和库文件。
在这里插入图片描述

INCLUDEPATH += /home/oliver/software/dhcam_install_20181107/dh_camera/daheng-sdk-x64/sdk/include

LIBS += /home/oliver/software/dhcam_install_20181107/dh_camera/daheng-sdk-x64/sdk/lib/libdximageproc.so.1.0.1602.8161\
        /home/oliver/software/dhcam_install_20181107/dh_camera/daheng-sdk-x64/sdk/lib/libgxgvtl.so.1.0.1802.8051\
        /home/oliver/software/dhcam_install_20181107/dh_camera/daheng-sdk-x64/sdk/lib/libgxiapi.so.1.0.1810.8121\
        /home/oliver/software/dhcam_install_20181107/dh_camera/daheng-sdk-x64/sdk/lib/libgxu3vtl.so.1.0.1802.8051

INCLUDEPATH += /usr/local/include\
/usr/local/include/opencv\
/usr/local/include/opencv2


LIBS += /usr/local/lib/libopencv_*.so

对源文件进行修改，修改的内容主要在void ProcGetImage(void pParam)函数中，还有定义char* m_rgb_image=NULL，下面有标注。

//-------------------------------------------------------------
/**
\file      GxAcquireContinuous.cpp
\brief     sample to show how to acquire image continuously. 
\version   1.0.1605.9041
\date      2016-05-04
*/
//-------------------------------------------------------------

#include "GxIAPI.h"
#include"DxImageProc.h"
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include <iostream>
#include<sstream>
#include<fstream>
#include <opencv2/opencv.hpp>

using namespace std;
using namespace cv;
using namespace cv::dnn;

#define MEMORY_ALLOT_ERROR -1 
char* m_rgb_image=NULL; //增加的内容

GX_DEV_HANDLE g_device = NULL;              ///< 设备句柄
GX_FRAME_DATA g_frame_data = { 0 };         ///< 采集图像参数
pthread_t g_acquire_thread = 0;             ///< 采集线程ID
bool g_get_image = false;                   ///< 采集线程是否结束的标志：true 运行；false 退出

//获取图像大小并申请图像数据空间
int PreForImage();

//释放资源
int UnPreForImage();

//采集线程函数
void *ProcGetImage(void* param);

//获取错误信息描述
void GetErrorString(GX_STATUS error_status);

int main()
{
    uid_t user = 0;
    user = geteuid();
    if(user != 0)
    {
        printf("\n");  
        printf("Please run this application with 'sudo -E ./GxAcquireContinuous' or"
                              " Start with root !\n");
        printf("\n");
        return 0;
    }

    printf("\n");
    printf("-------------------------------------------------------------\n");
    printf("sample to show how to acquire image continuously.\n");
    #ifdef __x86_64__
    printf("version: 1.0.1605.8041\n");
    #elif __i386__
    printf("version: 1.0.1605.9041\n");
    #endif
    printf("-------------------------------------------------------------\n");
    printf("\n");

    printf("Press [x] or [X] and then press [Enter] to Exit the Program\n");
    printf("Initializing......"); 
    printf("\n\n");
    
    
    usleep(2000000);   
     
    //API接口函数返回值 
    GX_STATUS status = GX_STATUS_SUCCESS;

    uint32_t device_num = 0;
    uint32_t ret = 0;
    GX_OPEN_PARAM open_param;

    //初始化设备打开参数，默认打开序号为1的设备
    open_param.accessMode = GX_ACCESS_EXCLUSIVE;
    open_param.openMode = GX_OPEN_INDEX;
    open_param.pszContent = "1";

    //初始化库
    status = GXInitLib(); 
    if(status != GX_STATUS_SUCCESS)
    {
        GetErrorString(status);
        return 0;
    }

    //获取枚举设备个数
    status = GXUpdateDeviceList(&device_num, 1000);
    if(status != GX_STATUS_SUCCESS)
    { 
        GetErrorString(status);
        status = GXCloseLib();
        return 0;
    }

    if(device_num <= 0)
    {
        printf("<No device>\n");
        status = GXCloseLib();
        return 0;
    }
    else
    {
        //默认打开第1个设备
        status = GXOpenDevice(&open_param, &g_device);
        if(status == GX_STATUS_SUCCESS)
	{
            printf("<Open device success>\n");
        }
        else
        {
            printf("<Open device fail>\n");
            status = GXCloseLib();
            return 0;			
        }
    }

    //设置采集模式为连续采集
    status = GXSetEnum(g_device, GX_ENUM_ACQUISITION_MODE, GX_ACQ_MODE_CONTINUOUS);
    if(status != GX_STATUS_SUCCESS)
    {
        GetErrorString(status);
        status = GXCloseDevice(g_device);
        if(g_device != NULL)
        {
            g_device = NULL;
        }
        status = GXCloseLib();
        return 0;
    }

    //设置触发开关为OFF
    status = GXSetEnum(g_device, GX_ENUM_TRIGGER_MODE, GX_TRIGGER_MODE_OFF);
    if(status != GX_STATUS_SUCCESS)
    {
        GetErrorString(status);
        status = GXCloseDevice(g_device);
        if(g_device != NULL)
        {
            g_device = NULL;
        }
        status = GXCloseLib();
        return 0;
    }
	
    //为采集做准备    
    ret = PreForImage();
    if(ret != 0)    
    {
        printf("<Failed to prepare for acquire image>\n");
        status = GXCloseDevice(g_device);
        if(g_device != NULL)
        {
            g_device = NULL;
        }
        status = GXCloseLib();
        return 0;
    }

    //启动接收线程
    ret = pthread_create(&g_acquire_thread, 0, ProcGetImage, 0);
    if(ret != 0)
    {
        printf("<Failed to create the collection thread>\n");
        status = GXCloseDevice(g_device);
        if(g_device != NULL)
        {
            g_device = NULL;
        }
        status = GXCloseLib();
        return 0;
    }

    bool run = true;
    while(run == true)
    {
        int c = getchar();

        switch(c)
        {
            //退出程序
            case 'X': 
            case 'x':
                run = false;
                break;
            default:
                break;
        }	
    }

    //为停止采集做准备
    ret = UnPreForImage();
    if(ret != 0)
    {
        status = GXCloseDevice(g_device);
        if(g_device != NULL)
        {
            g_device = NULL;
        }
        status = GXCloseLib();
        return 0;
    }

    //关闭设备
    status = GXCloseDevice(g_device);
    if(status != GX_STATUS_SUCCESS)
    {
        GetErrorString(status);
        if(g_device != NULL)
        {
            g_device = NULL;
        }
        status = GXCloseLib();
        return 0;
    }

    //释放库
    status = GXCloseLib();
    return 0;
}

//-------------------------------------------------
/**
\brief 获取图像大小并申请图像数据空间
\return void
*/
//-------------------------------------------------
int PreForImage()
{
    GX_STATUS status = GX_STATUS_SUCCESS;
    int64_t payload_size = 0;
	
    status = GXGetInt(g_device, GX_INT_PAYLOAD_SIZE, &payload_size);
    if(status != GX_STATUS_SUCCESS)
    {
        GetErrorString(status);
        return status;
    }
	
    g_frame_data.pImgBuf = malloc(payload_size);
    if(g_frame_data.pImgBuf == NULL)
    {
        printf("<Failed to allot memory>\n");
        return MEMORY_ALLOT_ERROR;
    }
 
    return 0;
}

//-------------------------------------------------
/**
\brief 释放资源
\return void
*/
//-------------------------------------------------
int UnPreForImage()
{
    GX_STATUS status = GX_STATUS_SUCCESS;
    uint32_t ret = 0;
   
    //发送停采命令
    status = GXSendCommand(g_device, GX_COMMAND_ACQUISITION_STOP);
    if(status != GX_STATUS_SUCCESS)
    {
        GetErrorString(status);
        return status;
    }

    g_get_image = false;
    ret = pthread_join(g_acquire_thread,NULL);
    if(ret != 0)
    {
        printf("<Failed to release resources>\n");
        return ret;
    }
	

    //释放buffer
    if(g_frame_data.pImgBuf != NULL)
    {
        free(g_frame_data.pImgBuf);
        g_frame_data.pImgBuf = NULL;
    }

    return 0;
}

//-------------------------------------------------
/**
\brief 采集线程函数
\param pParam 线程传入参数
\return void*
*/
//-------------------------------------------------
void *ProcGetImage(void* pParam)
{
    GX_STATUS status = GX_STATUS_SUCCESS;

    //接收线程启动标志
    g_get_image = true;

    //发送开采命令
    status = GXSendCommand(g_device, GX_COMMAND_ACQUISITION_START);
    if(status != GX_STATUS_SUCCESS)
    {
        GetErrorString(status);
    }
	
    while(g_get_image)
    {
        if(g_frame_data.pImgBuf == NULL)
        {
            continue;
        }

        status = GXGetImage(g_device, &g_frame_data, 100);
        if(status == GX_STATUS_SUCCESS)
        {
            if(g_frame_data.nStatus == 0)
            {
               //增加的内容
                Mat src;
                m_rgb_image=new char[g_frame_data.nWidth*g_frame_data.nHeight*3];

                src.create(g_frame_data.nHeight,g_frame_data.nWidth,CV_8UC3);

                memcpy(src.data,g_frame_data.pImgBuf,g_frame_data.nWidth*g_frame_data.nHeight);

                DxRaw8toRGB24(g_frame_data.pImgBuf,m_rgb_image,g_frame_data.nWidth, g_frame_data.nHeight,RAW2RGB_NEIGHBOUR,DX_PIXEL_COLOR_FILTER(BAYERBG),false);

                memcpy(src.data,m_rgb_image,g_frame_data.nWidth*g_frame_data.nHeight*3);
                namedWindow("test",0);
                imshow("test",src);
                waitKey(10); 
                //到这里增加结束
                printf("<Successful acquisition : Width: %d Height: %d >\n", g_frame_data.nWidth, g_frame_data.nHeight);
            }
        }
    }
}

//----------------------------------------------------------------------------------
/**
\brief  获取错误信息描述
\param  emErrorStatus  错误码

\return void
*/
//----------------------------------------------------------------------------------
void GetErrorString(GX_STATUS error_status)
{
    char *error_info = NULL;
    size_t size = 0;
    GX_STATUS status = GX_STATUS_SUCCESS;
	
    // 获取错误描述信息长度
    status = GXGetLastError(&error_status, NULL, &size);
    if(status != GX_STATUS_SUCCESS)
    {
           GetErrorString(status);
	   return;
    }
	
    error_info = new char[size];
    if (error_info == NULL)
    {
        printf("<Failed to allocate memory>\n");
        return ;
    }
	
    // 获取错误信息描述
    status = GXGetLastError(&error_status, error_info, &size);
    if (status != GX_STATUS_SUCCESS)
    {
        printf("<GXGetLastError call fail>\n");
    }
    else
    {
        printf("%s\n", (char*)error_info);
    }

    // 释放资源
    if (error_info != NULL)
    {
        delete []error_info;
        error_info = NULL;
    }
}

显示结果

在这里插入图片描述在这里插入图片描述

Tom Hardy
关注
  • 5
    点赞
  • 踩
  • 47
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
使用ROS驱动大恒相机采集数据
10-06
ROS驱动大恒相机采集数据并转化为opencv格式，然后可以通过opencv进行二次开发，图像处理等操作。前提是先去大恒官网下载Linux相机驱动并安装，不然编译会报错。
Linux下Qt使用OpenCV
06-07
linux下使用Qt调用OpenCV，读取图片，窗口显示图片。
【OpenCV】在Linux上使用OpenCvSharp
最新发布
grape_yan的博客
01-31 1114
OpenCvSharp是一个OpenCV的 .Net wrapper，应用最新的OpenCV库开发，使用习惯比EmguCV更接近原始的OpenCV，该库采用LGPL发行，对商业应用友好。
Qt框架下控制大恒水星相机
12-13
所需环境 系统: win10 64 Qt: 5.12.0 大恒驱动: 官网下载新版驱动即可（最新版本1.11） VS: vs2015 展示大恒水星相机（彩色相机）在QT框架下的基本操作：打开、关闭，开始采集、停止采集。若需要控制黑白相机，只需修改缓存大小。当前工程也可打开黑白相机采图，但画面与安装空间位置相反。对于相机其他如曝光时间、增益、白平衡（彩色相机）的操作，可利用大恒相机驱动安装路径下的例程自行添加。
Java-Linux环境下OpenCV本机库文件
09-14
在Windows操作系统下，本机库文件的扩展名通常是`.dll`（动态链接库），而在Linux操作系统下，本机库文件的扩展名通常是`.so`（共享对象）。这是由于不同操作系统使用不同的二进制格式和加载机制。 原因如下： 1. 操作系统差异：Windows和Linux是两个不同的操作系统，它们使用不同的本机库文件格式。Windows使用`.dll`作为本机库文件的扩展名，而Linux使用`.so`作为本机库文件的扩展名。 2. 二进制格式：Windows和Linux使用不同的二进制格式来编译本机库文件。Windows使用PE（Portable Executable）格式，而Linux使用ELF（Executable and Linkable Format）格式。 3. 加载机制：Windows和Linux使用不同的加载机制来加载本机库文件。Windows使用动态链接库（Dynamic Link Library）的方式加载本机库文件，而Linux使用共享对象（Shared Object）的方式加载本机库文件。 因此，为了在不同的操作系统上使用OpenCV，你需要使用相应操作系统的
MFC项目，大恒图像类封装，Opencv结合使用
11-08
MFC项目，大恒图像类封装，Opencv结合使用，外触发和软触发
大恒水星相机 linux 下使用qt和opencv开发快读入门手册-例程.zip
01-09
大恒相机官方给的qt和opencv的入门例程，简洁有效，可以直接运行；
linux下用opencv读取摄像头数据
阿拉斯攀登
07-21 984
CMakeLists.txt： cmake_minimum_required(VERSION 3.16) project(opencvTest) set(CMAKE_CXX_STANDARD 14) find_package(OpenCV REQUIRED) include_directories(${OpenCV_INCLUDE_DIRS}) add_executable(opencvTest main.cpp) target_link_libraries(opencvTest ${OpenCV_LIBS
大恒相机图像采集 linux+python
Bungehurst
10-21 1596
运行环境： Ubuntu18.04, 大恒相机python库，大恒相机linux驱动，python2.7 代码： import gxipy as gx from PIL import Image import datetime import cv2 """ Author:NoamaNelson Date:2019-11-21 Discription:Secondary development of pythonsdk of Daheng camera. """ def main(): W
linux下运行opencv视频,Linux下使用QT调用opencv读取摄像头视频 调试心得
weixin_35851508的博客
04-30 432
2012FROMhttp://blog.csdn.net/yanzi1225627/article/details/7450088因为做项目要用这，也是白手起家。今天抽空把心得写下，希望大家多顶哈！最初使用v4l2，但发现工作量太大了，而且自己写的代码不如opencv这么专业！参照http://blog.csdn.net/hsl17/article/details/6925876，及http:/...
linux 获取摄像头视频,OpenCV3读取视频或摄像头
weixin_33735910的博客
05-14 551
我们可以利用OpenCV读取视频文件或者摄像头的数据，将其保存为图像，以用于后期处理。下面的实例代码展示了简单的读取和显示操作：// This is a demo introduces you to reading a video and camera#include #include #include using namespace std;// OpenCV includes#include ...
QT+OpenCV调用大恒相机进行实时采集和单帧采集
05-26
QT+OpenCV调用大恒相机进行实时采集和单帧采集，包括Ui设计等，需要提前配置好大恒SDK，网上有教程。
大恒usb相机驱动
01-14
大恒usb相机的驱动，亲测可用，如果需要，还有许多测试代码等
两台大恒相机同时保存图像的MFC小程序
03-16
双目标定实验中，需要同时采集左右两相机图像，本文用于两台大恒相机同时保存图像，同时前缀自动命名left、right； 不过需要配置opencv 和大恒相机。 能在vs2013 x64环境下同时采集。
通过OpenCV打开指定型号大恒相机采集图像并转换成OpenCV图像格式_工业相机图像采集卡
12-22
在VS2017环境下，通过OpenCV和大恒提供的SDK按照IP、MAC地址或序列号打开指定型号的相机，并通过回调和直接采集两种方式获取图像，并将获取的图像保存成OpenCV的Mat格式。对于同一台电脑上连接多台相机的情况，可以避免通过枚举方式打开相机混乱的情况，适合图像处理工程师。
大恒相机QT例程LINUX
01-30
水星系列相机QT开发例程，LINUX系统QT例程，很有参考价值。
OpenCV+大恒相机
05-20
使用OpenCV函数打开大恒GV400UC相机，MFC界面设计、简单易懂
使用国内源来安装pytorch（速度很快）
热门推荐
qq_29462849的博客
05-25 4万+
一、找到合适的安装方式 pytorch官网：https://pytorch.org/ 二、安装命令 pip3 install torch torchvision -i https://pypi.mirrors.ustc.edu.cn/simple 后面的是镜像，当然也可以采用其他源，网上很多，在这里不再陈述。 ...
深度学习实现缺陷检测算法汇总
qq_29462849的博客
02-17 2万+
作者：Tom Hardy Date：2020-1-6 来源：总结|深度学习实现缺陷检测 前言 缺陷检测是工业上非常重要的一个应用，由于缺陷多种多样，传统的机器视觉算法很难做到对缺陷特征完整的建模和迁移，复用性不大，要求区分工况，这会浪费大量的人力成本。深度学习在特征提取和定位上取得了非常好的效果，越来越多的学者和工程人员开始将深度学习算法引入到缺陷检测领域中，下面将会介绍几种深度学习算法在缺陷...
ubuntuopencv调用大恒相机
07-28
你可以按照以下步骤在 Ubuntu 上使用 OpenCV 调用大恒相机： 1. 首先，确保已经安装了 OpenCV 和大恒相机的驱动。你可以通过以下命令安装 OpenCV： ``` sudo apt-get install libopencv-dev ``` 2. 在你的代码中，使用 `VideoCapture` 类来打开相机设备。大恒相机通常会被识别为 `/dev/videoX`，其中 X 是相机设备的编号。你可以尝试不同的编号来找到正确的设备。 ```cpp #include <opencv2/opencv.hpp> int main() { cv::VideoCapture cap("/dev/video0"); // 替换为正确的设备编号 if (!cap.isOpened()) { std::cout << "无法打开相机" << std::endl; return -1; } cv::Mat frame; while (cap.read(frame)) { cv::imshow("Camera", frame); if (cv::waitKey(1) == 'q') { break; } } cap.release(); cv::destroyAllWindows(); return 0; } ``` 3. 构建并运行你的代码。如果一切正常，你应该能够看到从大恒相机捕获到的图像。 请注意，这只是一个简单的示例，你可以根据需要进行修改和扩展。另外，确保你的系统中已经安装了大恒相机的驱动，并且相机设备正确地被识别和连接到了电脑上。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值