海康（巴斯勒）工业相机图像格式转换OpenCV格式

于 2024-08-28 16:22:53 发布
阅读量320 收藏
点赞数 2
文章标签： 数码相机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lpb99/article/details/141643379
版权 
#include <stdio.h>
#include <Windows.h>
#include <conio.h>
#include "MvCameraControl.h"
#include "opencv2/core/core_c.h"
#include "opencv2/imgcodecs.hpp"
#include "opencv2/highgui.hpp"
#include "opencv2/imgproc.hpp"



// ch:等待按键输入 | en:Wait for key press
void WaitForKeyPress(void)
{
    while (!_kbhit())
    {
        Sleep(10);
    }
    _getch();
}

bool PrintDeviceInfo(MV_CC_DEVICE_INFO* pstMVDevInfo)
{
    if (NULL == pstMVDevInfo)
    {
        printf("The Pointer of pstMVDevInfo is NULL!\n");
        return false;
    }
    if (pstMVDevInfo->nTLayerType == MV_GIGE_DEVICE)
    {
        int nIp1 = ((pstMVDevInfo->SpecialInfo.stGigEInfo.nCurrentIp & 0xff000000) >> 24);
        int nIp2 = ((pstMVDevInfo->SpecialInfo.stGigEInfo.nCurrentIp & 0x00ff0000) >> 16);
        int nIp3 = ((pstMVDevInfo->SpecialInfo.stGigEInfo.nCurrentIp & 0x0000ff00) >> 8);
        int nIp4 = (pstMVDevInfo->SpecialInfo.stGigEInfo.nCurrentIp & 0x000000ff);

        // ch:打印当前相机ip和用户自定义名字 | en:print current ip and user defined name
        printf("CurrentIp: %d.%d.%d.%d\n", nIp1, nIp2, nIp3, nIp4);
        printf("UserDefinedName: %s\n\n", pstMVDevInfo->SpecialInfo.stGigEInfo.chUserDefinedName);
    }
    else if (pstMVDevInfo->nTLayerType == MV_USB_DEVICE)
    {
        printf("UserDefinedName: %s\n", pstMVDevInfo->SpecialInfo.stUsb3VInfo.chUserDefinedName);
        printf("Serial Number: %s\n", pstMVDevInfo->SpecialInfo.stUsb3VInfo.chSerialNumber);
        printf("Device Number: %d\n\n", pstMVDevInfo->SpecialInfo.stUsb3VInfo.nDeviceNumber);
    }
    else
    {
        printf("Not support.\n");
    }

    return true;
}

bool IsColor(MvGvspPixelType enType)
{
    switch (enType)
    {
    case PixelType_Gvsp_BGR8_Packed:
    case PixelType_Gvsp_YUV422_Packed:
    case PixelType_Gvsp_YUV422_YUYV_Packed:
    case PixelType_Gvsp_BayerGR8:
    case PixelType_Gvsp_BayerRG8:
    case PixelType_Gvsp_BayerGB8:
    case PixelType_Gvsp_BayerBG8:
    case PixelType_Gvsp_BayerGB10:
    case PixelType_Gvsp_BayerGB10_Packed:
    case PixelType_Gvsp_BayerBG10:
    case PixelType_Gvsp_BayerBG10_Packed:
    case PixelType_Gvsp_BayerRG10:
    case PixelType_Gvsp_BayerRG10_Packed:
    case PixelType_Gvsp_BayerGR10:
    case PixelType_Gvsp_BayerGR10_Packed:
    case PixelType_Gvsp_BayerGB12:
    case PixelType_Gvsp_BayerGB12_Packed:
    case PixelType_Gvsp_BayerBG12:
    case PixelType_Gvsp_BayerBG12_Packed:
    case PixelType_Gvsp_BayerRG12:
    case PixelType_Gvsp_BayerRG12_Packed:
    case PixelType_Gvsp_BayerGR12:
    case PixelType_Gvsp_BayerGR12_Packed:
        return true;
    default:
        return false;
    }
}

bool IsMono(MvGvspPixelType enType)
{
    switch (enType)
    {
    case PixelType_Gvsp_Mono10:
    case PixelType_Gvsp_Mono10_Packed:
    case PixelType_Gvsp_Mono12:
    case PixelType_Gvsp_Mono12_Packed:
        return true;
    default:
        return false;
    }
}

// ch:像素排列由RGB转为BGR | en:Convert pixel arrangement from RGB to BGR
void RGB2BGR(unsigned char* pRgbData, unsigned int nWidth, unsigned int nHeight)
{
    if (NULL == pRgbData)
    {
        return;
    }

    // red和blue数据互换
    for (unsigned int j = 0; j < nHeight; j++)
    {
        for (unsigned int i = 0; i < nWidth; i++)
        {
            unsigned char red = pRgbData[j * (nWidth * 3) + i * 3];
            pRgbData[j * (nWidth * 3) + i * 3] = pRgbData[j * (nWidth * 3) + i * 3 + 2];
            pRgbData[j * (nWidth * 3) + i * 3 + 2] = red;
        }
    }
}


int main()
{
    int nRet = MV_OK;
    void* handle = NULL;
    unsigned char* pConvertData = NULL;
    unsigned int nConvertDataSize = 0;
    cv::Mat srcImage;
    do
    {
        // ch:枚举设备 | en:Enum device
        MV_CC_DEVICE_INFO_LIST stDeviceList;
        memset(&stDeviceList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));
        nRet = MV_CC_EnumDevices(MV_GIGE_DEVICE | MV_USB_DEVICE, &stDeviceList);
        if (MV_OK != nRet)
        {
            printf("Enum Devices fail! nRet [0x%x]\n", nRet);
            break;
        }

        if (stDeviceList.nDeviceNum > 0)
        {
            for (unsigned int i = 0; i < stDeviceList.nDeviceNum; i++)
            {
                printf("[device %d]:\n", i);
                MV_CC_DEVICE_INFO* pDeviceInfo = stDeviceList.pDeviceInfo[i];
                if (NULL == pDeviceInfo)
                {
                    break;
                }
                PrintDeviceInfo(pDeviceInfo);
            }
        }
        else
        {
            printf("Find No Devices!\n");
            break;
        }

        printf("Please Input camera index(0-%d):", stDeviceList.nDeviceNum - 1);
        unsigned int nIndex = 0;
        scanf_s("%d", &nIndex);

        if (nIndex >= stDeviceList.nDeviceNum)
        {
            printf("Input error!\n");
            break;
        }

        // ch:选择设备并创建句柄 | en:Select device and create handle
        nRet = MV_CC_CreateHandle(&handle, stDeviceList.pDeviceInfo[nIndex]);
        if (MV_OK != nRet)
        {
            printf("Create Handle fail! nRet [0x%x]\n", nRet);
            break;
        }

        // ch:打开设备 | en:Open device
        nRet = MV_CC_OpenDevice(handle);
        if (MV_OK != nRet)
        {
            printf("Open Device fail! nRet [0x%x]\n", nRet);
            break;
        }

        // ch:探测网络最佳包大小(只对GigE相机有效) | en:Detection network optimal package size(It only works for the GigE camera)
        if (stDeviceList.pDeviceInfo[nIndex]->nTLayerType == MV_GIGE_DEVICE)
        {
            int nPacketSize = MV_CC_GetOptimalPacketSize(handle);
            if (nPacketSize > 0)
            {
                nRet = MV_CC_SetIntValue(handle, "GevSCPSPacketSize", nPacketSize);
                if (nRet != MV_OK)
                {
                    printf("Warning: Set Packet Size fail nRet [0x%x]!", nRet);
                }
            }
            else
            {
                printf("Warning: Get Packet Size fail nRet [0x%x]!", nPacketSize);
            }
        }

        nRet = MV_CC_SetEnumValue(handle, "TriggerMode", MV_TRIGGER_MODE_OFF);
        if (MV_OK != nRet)
        {
            printf("Set Trigger Mode fail! nRet [0x%x]\n", nRet);
            break;
        }

        // ch:开始取流 | en:Start grab image
        nRet = MV_CC_StartGrabbing(handle);
        if (MV_OK != nRet)
        {
            printf("Start Grabbing fail! nRet [0x%x]\n", nRet);
            break;
        }

        MV_FRAME_OUT stImageInfo = { 0 };

        nRet = MV_CC_GetImageBuffer(handle, &stImageInfo, 1000);
        if (nRet == MV_OK)
        {
            printf("Get One Frame: Width[%d], Height[%d], nFrameNum[%d]\n",
                stImageInfo.stFrameInfo.nWidth, stImageInfo.stFrameInfo.nHeight, stImageInfo.stFrameInfo.nFrameNum);

            MvGvspPixelType enDstPixelType = PixelType_Gvsp_Undefined;
            unsigned int nChannelNum = 0;
            char chFileName[MAX_PATH] = { 0 };
            //如果是彩色则转成RGB8
            if (IsColor(stImageInfo.stFrameInfo.enPixelType))
            {
                nChannelNum = 3;
                enDstPixelType = PixelType_Gvsp_RGB8_Packed;
                sprintf_s(chFileName, "AfterConvert.rgb");
            }
            //如果是黑白则转换成Mono8
            else if (IsMono(stImageInfo.stFrameInfo.enPixelType))
            {
                nChannelNum = 1;
                enDstPixelType = PixelType_Gvsp_Mono8;
                sprintf_s(chFileName, "AfterConvert.gray");
            }
            else
            {
                printf("Don't need to convert!\n");
            }

            if (enDstPixelType != PixelType_Gvsp_Undefined)
            {
                pConvertData = (unsigned char*)malloc(stImageInfo.stFrameInfo.nWidth * stImageInfo.stFrameInfo.nHeight * nChannelNum);
                if (NULL == pConvertData)
                {
                    printf("malloc pConvertData fail!\n");
                    nRet = MV_E_RESOURCE;
                    break;
                }
                nConvertDataSize = stImageInfo.stFrameInfo.nWidth * stImageInfo.stFrameInfo.nHeight * nChannelNum;

                // ch:像素格式转换 | en:Convert pixel format 
                MV_CC_PIXEL_CONVERT_PARAM_EX stConvertParam = { 0 };

                stConvertParam.nWidth = stImageInfo.stFrameInfo.nWidth;                 //ch:图像宽 | en:image width
                stConvertParam.nHeight = stImageInfo.stFrameInfo.nHeight;               //ch:图像高 | en:image height
                stConvertParam.pSrcData = stImageInfo.pBufAddr;                         //ch:输入数据缓存 | en:input data buffer
                stConvertParam.nSrcDataLen = stImageInfo.stFrameInfo.nFrameLen;         //ch:输入数据大小 | en:input data size
                stConvertParam.enSrcPixelType = stImageInfo.stFrameInfo.enPixelType;    //ch:输入像素格式 | en:input pixel format
                stConvertParam.enDstPixelType = enDstPixelType;                         //ch:输出像素格式 | en:output pixel format
                stConvertParam.pDstBuffer = pConvertData;                               //ch:输出数据缓存 | en:output data buffer
                stConvertParam.nDstBufferSize = nConvertDataSize;                       //ch:输出缓存大小 | en:output buffer size
                nRet = MV_CC_ConvertPixelTypeEx(handle, &stConvertParam);
                if (MV_OK != nRet)
                {
                    printf("Convert Pixel Type fail! nRet [0x%x]\n", nRet);
                    break;
                }

                FILE* fp = NULL;
                errno_t err = fopen_s(&fp, chFileName, "wb");
                if (0 != err || NULL == fp)
                {
                    printf("Open file failed\n");
                    nRet = MV_E_RESOURCE;
                    break;
                }
                fwrite(stConvertParam.pDstBuffer, 1, stConvertParam.nDstLen, fp);
                fclose(fp);
                
                
                if (PixelType_Gvsp_RGB8_Packed == enDstPixelType)
                {
                    RGB2BGR(pConvertData, stConvertParam.nWidth, stConvertParam.nHeight);
                    srcImage = cv::Mat(stConvertParam.nHeight, stConvertParam.nWidth, CV_8UC3, pConvertData);
                    cv::imwrite("Image.bmp", srcImage);
                }


                printf("Convert pixeltype succeed\n");
            }
            MV_CC_FreeImageBuffer(handle, &stImageInfo);
        }
        else
        {
            printf("Get Image fail! nRet [0x%x]\n", nRet);
        }

        // ch:停止取流 | en:Stop grab image
        nRet = MV_CC_StopGrabbing(handle);
        if (MV_OK != nRet)
        {
            printf("Stop Grabbing fail! nRet [0x%x]\n", nRet);
            break;
        }

        // ch:关闭设备 | en:Close device
        nRet = MV_CC_CloseDevice(handle);
        if (MV_OK != nRet)
        {
            printf("Close Device fail! nRet [0x%x]\n", nRet);
            break;
        }

        // ch:销毁句柄 | en:Destroy handle
        nRet = MV_CC_DestroyHandle(handle);
        if (MV_OK != nRet)
        {
            printf("Destroy Handle fail! nRet [0x%x]\n", nRet);
            break;
        }
    } while (0);

    if (pConvertData)
    {
        free(pConvertData);
        pConvertData = NULL;
    }

    if (nRet != MV_OK)
    {
        if (handle != NULL)
        {
            MV_CC_DestroyHandle(handle);
            handle = NULL;
        }
    }

    printf("Press a key to exit.\n");
    WaitForKeyPress();

    return 0;
}

糅合两个cpp文件，ConvertPixelType.cpp，RawDataFormatConvert.cpp，路径如下：

C:\Program Files (x86)\MVS\Development\Samples\VC\VS\SimpleSamples\ConvertPixelType\ConvertPixelType.cpp
C:\Program Files (x86)\MVS\Development\Samples\OpenCV\VC\RawDataFormatConvert_OpenCV4\RawDataFormatConvert.cpp

lpb99
关注
QT版本华睿相机的Demo程序实现
追赶时代的博客
07-01 765
QT 华睿相机 SDK实现
Basler相机采集的彩色图像转换到opencv中Mat的问题
cai747的博客
08-22 3674
之前使用的都是黑白相机，采集的也是灰度图像，直接用pylon中的示例代码就可以完成图像的转换。 // Create an instant camera object with the camera device found first. CInstantCamera camera( CTlFactory::GetInstance().CreateFirstDevice()); // Print
海康彩色工业相机图像格式转换方法(Bayer转RGB)
热门推荐
qq_23107577的博客
01-29 3万+
海康彩色工业相机图像格式转换方法1.彩色相机是如何变成彩色的-Bayer的由来2.工业相机支持的图像格式3.图像格式转化 1.彩色相机是如何变成彩色的-Bayer的由来 提到工业相机图像格式，尤其是彩色相机的图像格式，不得不先讲一下bayer图像格式，网上有很多介绍这种图像格式的文档，随意引用一篇简单介绍下，引用链接: 图像bayer格式介绍以及bayer插值原理. 大致原理呢，就是相机上面的图像传感器只能感受光强而无法感知光的波长，然而光的颜色却是由波长决定的，因此图像传感器是无法记录颜色的。 虽然可以在
basler多相机拍照，通过opencv(3.4.1) svm 实时颜色分类（基于C++）
二二小少年的博客
08-16 4698
第一次写博客还是挺激动的，哈哈哈，先来一波干货吧，没写过博客，也不知道什么格式合适，大家先凑合看吧（笔芯） 一、背景及实现效果介绍： 1.1背景简介 该示例基于工业4.0的项目，具体产线技术，流程这里就不多说了，主要说一下我负责的视觉那一块。视觉主要识别乐高积木，识别是否有积木，是什么颜色？（说到这里，估计有的人应该知道了我们这个工业4.0的东西了。）视觉这一部分主要工作是接收上位机给我的拍...
Qt+BASLER相机+OpenCV
ZONGXP的博客
12-13 9899
参考： http://www.ilovematlab.cn/thread-106077-1-1.html http://blog.csdn.net/u013351270/article/details/54345855 http://blog.csdn.net/wt881010/article/details/53483813 https://imaginghub.com/projects...
海康工业相机SDK+OpenCV实例(2)：RawDataFormatConvert详解
分享学习经验，欢迎交流！
04-25 7799
海康工业相机SDK+OpenCV实例(2)：RawDataFormatConvert详解
海康威视工业相机 +Opencv+C#+WPF
12-30
在海康工业相机获取到图像后，我们可以通过OpenCV进行图像预处理，例如灰度转换、直方图均衡化、二值化等阈值处理。这些步骤有助于提高后续分析的准确性和效率。 阈值处理是计算机视觉中常用的一种技术，用于将图像...
C#中实现海康相机取的图像格式与VisionPro图像格式的转换.rar
07-31
在本文中，我们将深入探讨如何在C#编程环境中实现海康相机获取的图像格式与National Instruments的VisionPro图像格式之间的转换。海康威视是一家知名的安防监控设备制造商，其相机可提供多种图像格式，而VisionPro是...
QT + OPENCV + 海康工业相机显示不同处理阶段9宫格图像
10-11
QT + OpenCV + 海康工业相机显示不同处理阶段9宫格图像是一种常见的计算机视觉应用场景，主要用于实时监控和分析来自多个摄像机的图像数据。在这个项目中，我们使用QT作为图形用户界面（GUI）框架，OpenCV作为图像...
Qt调用海康、巴斯勒工业相机代码
09-29
工业相机，如海康和巴斯勒的产品，通常用于自动化、质量控制、机器视觉等领域，需要与软件紧密结合以实现高精度的图像捕捉和处理。 首先，让我们理解Qt如何与硬件设备交互。Qt提供了QIODevice类，它是所有输入/输出...
海康机器人工业视觉相机SDK的CImage图像转VM算子CMvdImage图像封装函数 C#
最新发布
04-11
标题中提到的“海康机器人工业视觉相机SDK”指的是海康威视为开发者提供的软件开发工具包，用于开发与海康工业相机配合使用的应用程序。SDK中通常包含了一系列的API函数和接口，允许开发者能够更加方便地与工业相机...
如何将海康高清摄像机转成opencv可以处理的格式？
大浪的专栏
04-18 4423
环境：Red Hat Enterprise linux As5 SDK版本： CH-HCNetSDK(Linux)4.0.2.7 OpenCv：2.2.0 将控制台演示代码的 GetStream.cpp 覆盖为以下，就能转换成 IplImage 内存数据，IplImage *img 是YUV格式，IplImage *imgBgr 是BGR格式： /* * Copyright(C) 2
海康工业相机SDK + OpenCV实例(4)：相机参数设置详解
分享学习经验，欢迎交流！
04-28 1万+
海康工业相机SDK + OpenCV实例(4)：相机参数设置详解
OpenCV处理工业相机Bayer格式数据
winyio8的博客
03-05 2415
将工业相机的Raw格式转换成OpenCV识别的Mat格式，两个步骤，先Raw转BGR，再保证成Mat格式
海康工业相机排雷笔记02-像素格式解析
yonghuming_66的博客
03-03 7131
工业相机使用过程记录 02-像素格式解析 通过将相机输出图像裸数据raw格式直接存图查看 一、黑白/Mono 直接使用相机测试图像存图： 图像中各部分灰度分别为：0、36、73、109、146、182、219、255，以灰度73列为例 (1)Mono 8 该列图像数据为十六进制49，十进制为73，那么Mono 8就是每个像素点占8bit，依次排列。 (2)Mono 10 该列图像数据为十六进制2401，由于相机均为小端数据，实际数据应解析为0124，十进制为292=73*4，那么Mono 10格式为每
QT基本格式转换
Happinessคิดถึง的博客
07-29 419
** 更新时间：2020-07-29 ** 16进制在线转换网站 16进制字符串 转 QString （这个我找了好久，噗） QByteArray aa = QByteArray::fromHex("4154"); QString bb=aa.data(); qDebug()<<"aa"<<bb; 结果输出为: aa “AT” ~持续更新 今晚我会把所有常用的格式互转总结上来。 ...
海康相机采集图像 data (unsigned char*) 转QImage、Hobject、Mat
love_android_hehe的专栏
03-30 1695
qt、c++工业相机数据转QImage、HObject、Mat
Basler sdk 图像数据转换Opencv、Halcon方式
lighter
08-25 2437
1.转Opencv Mat参考代码如下： //Open cv 2.4.10 //for Mono Mat Img; uchar* test = (uchar *)(ptrGrabResult->GetBuffer()); Mat mat(ptrGrabResult->GetHeight(), ptrGrabResult->GetWidth(), CV_8UC1, test); //for Color Mat BayerImg; uchar* test = (uchar *)(ptrG
海康 工业相机 获取 图像 opencv显示 c++
05-15
海康工业相机是一种专业的高清图像采集设备，能够实时获取高清、清晰、稳定的图像数据。要在opencv中显示这些图像，需要通过C语言来编写程序实现。首先需要使用相应的SDK库将工业相机与计算机进行连接，在程序中调用SDK库可以获得相机的实时数据流，通过opencv库的函数实现图像的显示。 具体实现步骤如下： 1. 安装相应的海康相机SDK，确保相机已经成功连接计算机。 2. 在C语言程序中引用SDK库文件，并初始化相机。 3. 通过SDK库提供的函数，获取相机的实时图像数据流。 4. 将相机图像数据流转换为opencv格式的图像数据。 5. 使用opencv库的图像显示函数将图像显示出来。 6. 实时刷新相机图像数据流，并持续更新图像数据来实现实时显示。 总之，通过海康工业相机和opencv库的结合，可以获取到高质量的图像，并通过编写C语言程序实现实时图像的获取和显示。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值