海康工业相机BayerRG8转BGR8

已于 2024-12-18 21:39:16 修改
阅读量554 收藏
点赞数 2
文章标签： 数码相机
于 2024-12-18 21:36:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xhamigua/article/details/144570200
版权

今天出来冒个泡吧！多话不说，理论也不讲。

海康工业相机BayerRG8转BGR8

开发板找到能用的C++代码：

//海康PixelType_Gvsp_BayerRG8转PixelType_Gvsp_BGR8_Packed格式代码
int Bayer8ToRgb24(unsigned char* pbBayer, int dwWidth, int dwHeight, unsigned char* pbRgb, int iRgbBufLen)
{
    if (nullptr == pbBayer || nullptr == pbRgb)
    {
        return 0;
    }
    if (dwWidth <= 0 || dwHeight <= 0 || iRgbBufLen <= 0)
    {
        return 0;
    }
    if (iRgbBufLen != dwWidth * dwHeight * 3)
    {
        return 0;
    }

    unsigned char* m_pBay = pbBayer;
    unsigned char* m_pRGB24 = pbRgb;
    unsigned long m_ulWidth = dwWidth;
    unsigned long m_ulHeight = dwHeight;

#define R(x,y) m_pRGB24[2 + 3 * ((x) + m_ulWidth * (y))]
#define G(x,y) m_pRGB24[1 + 3 * ((x) + m_ulWidth * (y))]
#define B(x,y) m_pRGB24[0 + 3 * ((x) + m_ulWidth * (y))]
#define Bay(x,y) m_pBay[(x) + m_ulWidth * (y)]

    auto bayer_copy = [&](int x, int y)
        {
            G(x + 0, y + 0) = Bay(x + 0, y + 0);
            G(x + 1, y + 1) = Bay(x + 1, y + 1);
            G(x + 0, y + 1) = G(x + 1, y + 0) = ((unsigned long)Bay(x + 0, y + 0) + (unsigned long)Bay(x + 1, y + 1)) / 2;
            R(x + 0, y + 0) = R(x + 1, y + 0) = R(x + 1, y + 1) = R(x + 0, y + 1) = Bay(x + 0, y + 1);
            B(x + 1, y + 1) = B(x + 0, y + 0) = B(x + 0, y + 1) = B(x + 1, y + 0) = Bay(x + 1, y + 0);
        };

    auto bayer_bilinear = [&](int x, int y)
        {
            R(x + 0, y + 0) = ((unsigned long)Bay(x + 0, y + 1) + (unsigned long)Bay(x + 0, y - 1)) / 2;
            G(x + 0, y + 0) = Bay(x + 0, y + 0);
            B(x + 0, y + 0) = ((unsigned long)Bay(x - 1, y + 0) + (unsigned long)Bay(x + 1, y + 0)) / 2;
            R(x + 0, y + 1) = Bay(x + 0, y + 1);
            G(x + 0, y + 1) = ((unsigned long)Bay(x + 0, y + 0) + (unsigned long)Bay(x + 0, y + 2) + (unsigned long)Bay(x - 1, y + 1) + (unsigned long)Bay(x + 1, y + 1)) / 4;
            B(x + 0, y + 1) = ((unsigned long)Bay(x + 1, y + 0) + (unsigned long)Bay(x - 1, y + 0) + (unsigned long)Bay(x + 1, y + 2) + (unsigned long)Bay(x - 1, y + 2)) / 4;
            R(x + 1, y + 0) = ((unsigned long)Bay(x + 0, y + 1) + (unsigned long)Bay(x + 2, y + 1) + (unsigned long)Bay(x + 0, y - 1) + (unsigned long)Bay(x + 2, y - 1)) / 4;
            G(x + 1, y + 0) = ((unsigned long)Bay(x + 0, y + 0) + (unsigned long)Bay(x + 2, y + 0) + (unsigned long)Bay(x + 1, y - 1) + (unsigned long)Bay(x + 1, y + 1)) / 4;
            B(x + 1, y + 0) = Bay(x + 1, y + 0); R(x + 1, y + 1) = ((unsigned long)Bay(x + 0, y + 1) + (unsigned long)Bay(x + 2, y + 1)) / 2; G(x + 1, y + 1) = Bay(x + 1, y + 1);
            B(x + 1, y + 1) = ((unsigned long)Bay(x + 1, y + 0) + (unsigned long)Bay(x + 1, y + 2)) / 2;
        };

    int i, j;
    for (i = 0; i < m_ulWidth; i += 2)
    {
        for (j = 0; j < m_ulHeight; j += 2)
        {
            if (i == 0 || j == 0 || i == m_ulWidth - 2 || j == m_ulHeight - 2)
            {
                bayer_copy(i, j);
            }
            else
            {
                bayer_bilinear(i, j);
            }
        }
    }
    return 1;
}

用海康SDK搞：

//海康api PixelType_Gvsp_BayerRG8转PixelType_Gvsp_BGR8_Packed格式代码
bool Convert2Mat(void* handle, stImageNode& pstImage, uint8_t** pBgrData)
{
    if (NULL == pstImage.pData)
    {
        return false; //return MV_E_PARAMETER;
    }
    unsigned int nDataSizeForBGR = pstImage.nWidth * pstImage.nHeight * 3;
    *pBgrData = (unsigned char*)malloc(nDataSizeForBGR);
    if (NULL == *pBgrData)
    {
        return false; // return MV_E_BUFOVER;
    }

    // ch:像素格式转换 | en:Convert pixel format 
    MV_CC_PIXEL_CONVERT_PARAM stConvertParam = { 0 };
    memset(&stConvertParam, 0, sizeof(MV_CC_PIXEL_CONVERT_PARAM));

    stConvertParam.nWidth = pstImage.nWidth;                        //ch:图像宽 | en:image width
    stConvertParam.nHeight = pstImage.nHeight;                      //ch:图像高 | en:image height
    stConvertParam.pSrcData = pstImage.pData;                       //ch:输入数据缓存 | en:input data buffer
    stConvertParam.nSrcDataLen = pstImage.nFrameLen;                //ch:输入数据大小 | en:input data size
    stConvertParam.enSrcPixelType = pstImage.enPixelType;           //ch:输入像素格式 | en:input pixel format
    stConvertParam.enDstPixelType = PixelType_Gvsp_BGR8_Packed;     //ch:输出像素格式 | en:output pixel format
    stConvertParam.pDstBuffer = *pBgrData;                          //ch:输出数据缓存 | en:output data buffer
    stConvertParam.nDstBufferSize = nDataSizeForBGR;                //ch:输出缓存大小 | en:output buffer size
    int nRet = MV_CC_ConvertPixelType(handle, &stConvertParam);
    if (MV_OK != nRet)
    {
        free(*pBgrData);
        printf("++++++++++++++++++++++error nFrameNum [%d]  \r\n", pstImage.nFrameNum);
        return false; //return MV_E_UNKNOW;
    }
    return true;
    //注意在外面要free pBgrData
}

完整的全帧率相机抓拍取图程序：


#include <stdio.h>
#ifdef _WIN32
#include <Windows.h>
#include <conio.h>
#include <process.h>
#endif
#include <iostream>
#include <fstream>
#include <sstream>
#include <random>
#include <queue>
#include <thread>
#include <mutex>
#include <atomic>
#include <condition_variable>
#include <opencv2/opencv.hpp>
#include "MvCameraControl.h"


//缓存队列
template<class T>
class DataQueue
{
public:
    DataQueue(void)
    {
    };
    virtual ~DataQueue(void)
    {
        clear();
    };
public:
    bool push(T& data)
    {
        std::unique_lock<std::mutex> lock(m_mutex);
        m_queue.push(std::move(data));
        return true;
    };
    bool pop(T& data)
    {
        std::unique_lock<std::mutex> lock(m_mutex);
        if (m_queue.empty())
            return false;
        data = m_queue.front();
        m_queue.pop();
        return true;
    };
    void clear()
    {
        std::unique_lock<std::mutex> lock(m_mutex);
        while (!m_queue.empty())
        {
            T& data = m_queue.front();
            m_queue.pop();
        }
    };
    int size()
    {
        std::unique_lock<std::mutex> lock(m_mutex);
        return m_queue.size();
    };
protected:
    std::mutex m_mutex;
    std::queue<T> m_queue;
};

//信号量工具
class Semaphore
{
    std::mutex mx;
    std::condition_variable cond;
    long count;
public:
    Semaphore(long count = 0) : count(count) {};
    ~Semaphore(void) { post(); };
    void wait(void)
    {
        std::unique_lock<std::mutex>lock(mx);
        cond.wait(lock, [&]() {return count > 0; });
        --count;
    };
    bool wait(int stime)
    {
        std::unique_lock<std::mutex>lock(mx);
        bool bRet = cond.wait_for(lock, std::chrono::seconds(stime), [&]() {return count > 0; });
        --count;
        return bRet;
    };
    void post(void)
    {
        std::unique_lock<std::mutex>lock(mx);
        ++count;
        cond.notify_one();
    };
};

//中间缓存图像格式
typedef struct _stImageNode_
{
    unsigned char* pData;           //图像数据
    uint64_t  nFrameLen;

    unsigned int nWidth;
    unsigned int nHeight;
    unsigned int nFrameNum;
    enum MvGvspPixelType enPixelType;                //enum MvGvspPixelType
    _stImageNode_()
    {
        pData = 0;
        nFrameLen = nWidth = nHeight = nFrameNum = 0;
        enPixelType = PixelType_Gvsp_BayerGB8;
    }
    ~_stImageNode_()
    {
        if (pData != NULL)
        {
            free(pData);
        }
    }
} stImageNode;

//海康PixelType_Gvsp_BayerRG8转PixelType_Gvsp_BGR8_Packed格式代码
int Bayer8ToRgb24(unsigned char* pbBayer, int dwWidth, int dwHeight, unsigned char* pbRgb, int iRgbBufLen)
{
    if (nullptr == pbBayer || nullptr == pbRgb)
    {
        return 0;
    }
    if (dwWidth <= 0 || dwHeight <= 0 || iRgbBufLen <= 0)
    {
        return 0;
    }
    if (iRgbBufLen != dwWidth * dwHeight * 3)
    {
        return 0;
    }

    unsigned char* m_pBay = pbBayer;
    unsigned char* m_pRGB24 = pbRgb;
    unsigned long m_ulWidth = dwWidth;
    unsigned long m_ulHeight = dwHeight;

#define R(x,y) m_pRGB24[2 + 3 * ((x) + m_ulWidth * (y))]
#define G(x,y) m_pRGB24[1 + 3 * ((x) + m_ulWidth * (y))]
#define B(x,y) m_pRGB24[0 + 3 * ((x) + m_ulWidth * (y))]
#define Bay(x,y) m_pBay[(x) + m_ulWidth * (y)]

    auto bayer_copy = [&](int x, int y)
        {
            G(x + 0, y + 0) = Bay(x + 0, y + 0);
            G(x + 1, y + 1) = Bay(x + 1, y + 1);
            G(x + 0, y + 1) = G(x + 1, y + 0) = ((unsigned long)Bay(x + 0, y + 0) + (unsigned long)Bay(x + 1, y + 1)) / 2;
            R(x + 0, y + 0) = R(x + 1, y + 0) = R(x + 1, y + 1) = R(x + 0, y + 1) = Bay(x + 0, y + 1);
            B(x + 1, y + 1) = B(x + 0, y + 0) = B(x + 0, y + 1) = B(x + 1, y + 0) = Bay(x + 1, y + 0);
        };

    auto bayer_bilinear = [&](int x, int y)
        {
            R(x + 0, y + 0) = ((unsigned long)Bay(x + 0, y + 1) + (unsigned long)Bay(x + 0, y - 1)) / 2;
            G(x + 0, y + 0) = Bay(x + 0, y + 0);
            B(x + 0, y + 0) = ((unsigned long)Bay(x - 1, y + 0) + (unsigned long)Bay(x + 1, y + 0)) / 2;
            R(x + 0, y + 1) = Bay(x + 0, y + 1);
            G(x + 0, y + 1) = ((unsigned long)Bay(x + 0, y + 0) + (unsigned long)Bay(x + 0, y + 2) + (unsigned long)Bay(x - 1, y + 1) + (unsigned long)Bay(x + 1, y + 1)) / 4;
            B(x + 0, y + 1) = ((unsigned long)Bay(x + 1, y + 0) + (unsigned long)Bay(x - 1, y + 0) + (unsigned long)Bay(x + 1, y + 2) + (unsigned long)Bay(x - 1, y + 2)) / 4;
            R(x + 1, y + 0) = ((unsigned long)Bay(x + 0, y + 1) + (unsigned long)Bay(x + 2, y + 1) + (unsigned long)Bay(x + 0, y - 1) + (unsigned long)Bay(x + 2, y - 1)) / 4;
            G(x + 1, y + 0) = ((unsigned long)Bay(x + 0, y + 0) + (unsigned long)Bay(x + 2, y + 0) + (unsigned long)Bay(x + 1, y - 1) + (unsigned long)Bay(x + 1, y + 1)) / 4;
            B(x + 1, y + 0) = Bay(x + 1, y + 0); R(x + 1, y + 1) = ((unsigned long)Bay(x + 0, y + 1) + (unsigned long)Bay(x + 2, y + 1)) / 2; G(x + 1, y + 1) = Bay(x + 1, y + 1);
            B(x + 1, y + 1) = ((unsigned long)Bay(x + 1, y + 0) + (unsigned long)Bay(x + 1, y + 2)) / 2;
        };

    int i, j;
    for (i = 0; i < m_ulWidth; i += 2)
    {
        for (j = 0; j < m_ulHeight; j += 2)
        {
            if (i == 0 || j == 0 || i == m_ulWidth - 2 || j == m_ulHeight - 2)
            {
                bayer_copy(i, j);
            }
            else
            {
                bayer_bilinear(i, j);
            }
        }
    }
    return 1;
}

//海康api PixelType_Gvsp_BayerRG8转PixelType_Gvsp_BGR8_Packed格式代码
bool Convert2Mat(void* handle, stImageNode& pstImage, uint8_t** pBgrData)
{
    if (NULL == pstImage.pData)
    {
        return false; //return MV_E_PARAMETER;
    }
    unsigned int nDataSizeForBGR = pstImage.nWidth * pstImage.nHeight * 3;
    *pBgrData = (unsigned char*)malloc(nDataSizeForBGR);
    if (NULL == *pBgrData)
    {
        return false; // return MV_E_BUFOVER;
    }

    // ch:像素格式转换 | en:Convert pixel format 
    MV_CC_PIXEL_CONVERT_PARAM stConvertParam = { 0 };
    memset(&stConvertParam, 0, sizeof(MV_CC_PIXEL_CONVERT_PARAM));

    stConvertParam.nWidth = pstImage.nWidth;                        //ch:图像宽 | en:image width
    stConvertParam.nHeight = pstImage.nHeight;                      //ch:图像高 | en:image height
    stConvertParam.pSrcData = pstImage.pData;                       //ch:输入数据缓存 | en:input data buffer
    stConvertParam.nSrcDataLen = pstImage.nFrameLen;                //ch:输入数据大小 | en:input data size
    stConvertParam.enSrcPixelType = pstImage.enPixelType;           //ch:输入像素格式 | en:input pixel format
    stConvertParam.enDstPixelType = PixelType_Gvsp_BGR8_Packed;     //ch:输出像素格式 | en:output pixel format
    stConvertParam.pDstBuffer = *pBgrData;                          //ch:输出数据缓存 | en:output data buffer
    stConvertParam.nDstBufferSize = nDataSizeForBGR;                //ch:输出缓存大小 | en:output buffer size
    int nRet = MV_CC_ConvertPixelType(handle, &stConvertParam);
    if (MV_OK != nRet)
    {
        free(*pBgrData);
        printf("++++++++++++++++++++++error nFrameNum [%d]  \r\n", pstImage.nFrameNum);
        return false; //return MV_E_UNKNOW;
    }
    return true;
    //注意在外面要free pBgrData
}

//全局变量
DataQueue<stImageNode*> m_list;
Semaphore m_sem;

int main()
{
#ifdef _WIN32
    system("rd /s /q img");
    system("md img");
#else
    system("rm -rf img");
    system("mkdir img");
#endif

    printf("app start        *********************\n");
    std::atomic_bool m_stated;
    std::thread m_thread;
    MV_CC_DEVICE_INFO_LIST stDeviceList;
    memset(&stDeviceList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));
    int nRet = MV_CC_EnumDevices(MV_GIGE_DEVICE | MV_USB_DEVICE | MV_GENTL_CAMERALINK_DEVICE | MV_GENTL_CXP_DEVICE | MV_GENTL_XOF_DEVICE, &stDeviceList);
    if (MV_OK != nRet || stDeviceList.nDeviceNum < 1)
    {
        return -1;
    }

    int nIndex = 0;
    void* handle = NULL;
    MV_CC_CreateHandle(&handle, stDeviceList.pDeviceInfo[nIndex]);//nIndex=0
    MV_CC_OpenDevice(handle);
    MV_CC_SetIntValueEx(handle, "Width", 1920);
    MV_CC_SetIntValueEx(handle, "Height", 1080);
    MV_CC_SetIntValueEx(handle, "OffsetX", 64);
    MV_CC_SetIntValueEx(handle, "OffsetY", 484);
    MV_CC_SetEnumValueByString(handle, "PixelFormat", "BayerGB8");      //可以实现90fps取图
    //MV_CC_SetEnumValueByString(handle, "PixelFormat", "RGB8Packed");  //只有20多fps 

    MVCC_INTVALUE_EX stIntEx = { 0 };
    MV_CC_GetIntValueEx(handle, "Width", &stIntEx);
    int nWidth = stIntEx.nCurValue;
    memset(&stIntEx, 0, sizeof(MVCC_INTVALUE_EX));
    MV_CC_GetIntValueEx(handle, "Height", &stIntEx);
    int nHeight = stIntEx.nCurValue;
    MV_CC_GetIntValueEx(handle, "PayloadSize", &stIntEx);
    uint64_t m_nImageSize = stIntEx.nCurValue;

    MV_CC_SetEnumValue(handle, "TriggerMode", MV_TRIGGER_MODE_OFF);             //设置触发模式为off
    MV_CC_SetBoolValue(handle, "CCMEnable", false);                             //CCM关闭
    MV_CC_SetBoolValue(handle, "ColorTransformationEnable", false);             //颜色变化关闭
    MV_CC_SetBoolValue(handle, "HueEnable", false);                             //hue关闭
    MV_CC_SetBoolValue(handle, "SaturationEnable", false);                      //饱和度关闭
    MV_CC_SetBoolValue(handle, "BlackLevelEnable", false);                      //关闭黑白电平
    MV_CC_SetIntValueEx(handle, "Brightness", 90);
    MV_CC_SetIntValueEx(handle, "AutoExposureTimeLowerLimit", 30);
    MV_CC_SetIntValueEx(handle, "AutoExposureTimeUpperLimit", 11000);
    MV_CC_SetEnumValueByString(handle, "ExposureAuto", "Continuous");           //Off-手动  Continuous-自动
    MV_CC_SetFloatValue(handle, "ExposureTime", 11111.0000);                    //曝光设置 1000/90约11ms曝光
    MV_CC_SetEnumValueByString(handle, "GainAuto", "Off");                      //Off-手动  Continuous-自动
    MV_CC_SetFloatValue(handle, "Gain", 0.0000);                                //增益0-12 
    //注册抓图回调
    MV_CC_RegisterImageCallBackEx(handle, [](unsigned char* pData, MV_FRAME_OUT_INFO_EX * pFrameInfo, void* pUser) {
        if (NULL == pFrameInfo || NULL == pData)
        {
            printf("ImageCallBackEx Input Param invalid.\n");
            return;
        }
        //相机内存数据存队列
        stImageNode* sImage = new stImageNode();
        sImage->enPixelType = pFrameInfo->enPixelType;
        sImage->nFrameLen = pFrameInfo->nFrameLenEx;
        sImage->nWidth = pFrameInfo->nWidth;
        sImage->nHeight = pFrameInfo->nHeight;
        sImage->nFrameNum = pFrameInfo->nFrameNum + 1;
        sImage->pData = (unsigned char*)malloc(sImage->nHeight * sImage->nWidth * 3);
        memcpy(sImage->pData, pData, sImage->nFrameLen);
        //通知存图
        m_list.push(sImage);
        m_sem.post();
    }, NULL);
    printf("app init ok      *********************\n");

    auto cutstart = [&] {
        //先关线程
        m_stated.store(false);
        if (m_thread.joinable())
            m_thread.join();
        //开始取流API
        MV_CC_StartGrabbing(handle);
        m_stated.store(true);
        //下面建议起多个比如6个线程写会快很多
        m_thread = std::move(std::thread([&]()
            {
                printf("WorkThread Begin . \r\n");
                while (m_stated)
                {
                    m_sem.wait();
                    stImageNode* sImage = NULL;
                    if (!m_list.pop(sImage))
                    {
                        printf("Poll failed, maybe no data. \r\n");
                        std::this_thread::sleep_for(std::chrono::seconds(2));
                        continue;
                    }
                    else
                    {
                        //根据实际场景需求，对图像进行 处理   
#if 1
                        cv::Mat cvImage(sImage->nHeight, sImage->nWidth, CV_8UC3, cv::Scalar(0, 0, 0));
                        //BayerGB8转RGB格式 不过建议用下面方法 SDK的MV_CC_ConvertPixelType做可以节约CPU
                        Bayer8ToRgb24((unsigned char*)(sImage->pData), sImage->nWidth, sImage->nHeight, cvImage.data, cvImage.step * sImage->nHeight);
                        //下面写jpg存图
                        char szFileName[256] = { 0 };
                        sprintf(szFileName, "img/Image_%d_%d_%d.jpg", sImage->nWidth, sImage->nHeight, sImage->nFrameNum);
                        printf("write >>> %s\n", szFileName);
                        cv::imwrite(szFileName, cvImage);   //cv::imshow("cvImage", cvImage);  //cv::waitKey();
#endif
#if 0
                        //SDK库BayerGB8转RGB格式
                        uint8_t* pBgrData = NULL;
                        cv::Mat cvImage;
                        Convert2Mat(handle, *sImage, &pBgrData);
                        cvImage = cv::Mat(sImage->nHeight, sImage->nWidth, CV_8UC3, pBgrData);
                        //下面写jpg存图
                        char szFileName[256] = { 0 };
                        sprintf(szFileName, "img/Image_%d_%d_%d.jpg", Image.nWidth, Image.nHeight, Image.nFrameNum);
                        printf("write >>> %s\n", szFileName);
                        cv::imwrite(szFileName, cvImage);
                        //删除 Convert2Mat里面拷贝的数据
                        if (pBgrData != NULL)
                        {
                            free(pBgrData);
                            pBgrData = NULL;
                        }
#endif
#if 0
                        //原始raw格式
                        FILE* fp = NULL;
                        char szFileName[256] = { 0 };
                        sprintf(szFileName, "img/Image_%d_%d_%d.raw", sImage->nWidth, sImage->nHeight, sImage->nFrameNum);
                        printf("write %s\n", szFileName);
                        fp = fopen(szFileName, "wb+");
                        if (fp == NULL)
                        {
                            //return MV_E_RESOURCE;
                        }
                        fwrite(sImage->pData, 1, sImage->nFrameLen, fp);
                        fclose(fp);
                        fp = NULL;
#endif
                        cvImage.release();
                        //删除释放数据
                        if (sImage->pData)
                        {
                            free(sImage->pData);
                            sImage->pData = NULL;
                        }
                        delete sImage;
                    }
                }
                printf("WorkThread exit . \r\n");
            }));
        };

    auto cutend = [&] {
        MV_CC_StopGrabbing(handle);                         //停止取流
        MV_CC_RegisterImageCallBackEx(handle, NULL, NULL);  //注销抓图回调
        printf("**************************************\n");
        printf("cut end*******************************\n");
        printf("**************************************\n");
        printf("\n\n\n");
        };

    cutstart();
    std::this_thread::sleep_for(std::chrono::seconds(5));
    cutend();

    while (1)
    {
        char c = getchar();             //按键会阻塞
        if ('q' == c)                   //退出程序
            break;
        else if ('b' == c)
        {
            cutstart();
        }
        else if ('e' == c)
        {
            cutend();
        }
        else if ('c' == c)
        {
            m_sem.post();
            m_stated.store(false);
            if (m_thread.joinable())
                m_thread.join();
            MV_CC_CloseDevice(handle);                          //关闭设备
            MV_CC_DestroyHandle(handle);                        //销毁句柄
            MV_CC_Finalize();                                   //反初始化SDK 
        }
        else
        {
            //printf("**************************************\n");
        }
    }
    printf("app end ok       *********************\n");
    //scanf("\n");
    return 0;
}

AGANCUDA
关注
海康工业相机ros程序，可自动调节曝光时间，自动调节增益
三维点云技术探索
07-28 1319
网上 hikrobot_camera HIKROBOT-MVS-CAMERA-ROS 代码无法自动调节曝光，所以我修改原始代码的部分，它其实也是调用了MVS的接口来实现的ros 程序，相当于做了接口接入，然后转发的工作。
机器视觉开发教程——利用C#调用海康机器人工业相机SDK实现回调取图与软触发取图【含免费教程源码】
吾门的博客
09-09 2099
海康机器人工业相机SDK实现回调取图与软触发取图
Bayer 模式图像(bggr ,grbg, gbrg)转rgb888
weixin_42549534的博客
11-07 6302
线性插值是一种简单的插值算法，它通常用于将 Bayer 模式图像转换为 RGB 图像。它通过使用邻近像素的值来计算缺失的值。具体来说，在 BGGR Bayer 模式中，绿色通道的缺失值可以通过使用周围的绿色像素值（左侧、右侧、上方和下方）的平均值进行线性插值。同样的方法也适用于红色和蓝色通道的情况，但需要使用相邻列或相邻行的值进行插值。下面是一个简单的示意图，说明在绿色通道的情况下如何进行线性插值。G * G * G * *（待计算的像素）
Bayer8转RGB并用OpenCV显示
monk1992的博客
09-28 2845
版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/oHanTanYanYing/article/details/81945479 最近做项目用到工业摄像头，其输出最小的数据流是Bayer8，因为带宽有限，只好选用之。 ...
海康彩色工业相机图像格式转换方法(Bayer转RGB)_bayer8
2401_87557104的博客
11-13 2879
虽然可以在相机的内部内置三个图像传感器来分别记录红、绿、蓝三元色，然后将这三种颜色合并得到最终的彩色图像，但是这样做的成本太高。因此，柯达这个公司，提出的解决方案就是，使用一个图像传感器，在图像传感器的前面，放置一个滤光层，滤光层的滤光点与图像传感器的像素一一对应，每个滤光点只能通过红、绿、蓝三种光其中之一；通过规律性的排列不同颜色的滤光点，我们就能在传感器上面有规律的获得不同颜色的光强值，也就是R、G、B的灰度值；
cvt_pic.7z 说明：bayer rg8、bayer gb8像素格式图片资源
09-18
bayer rg8、bayer gb8像素格式图片，及通过ffmpeg命令行将其转换为.bmp查看的方法txt文档
Bayer图像格式转化为标准RGB格式
03-05
Bayer图像奇数行包括green和red颜色的像素，偶数行包括blue和green颜色的像素。奇数列包括green和blue颜色的像素，偶数列包括red和green颜色的像素。采用行缓冲+流水线的处理方式，将前一级抓取到的行数（bayer color pattern），实时转换成标准的30位RGB数据并进行适当的下采样，以便于后继的图像处理及显示。
ffmpeg 查看bayer rg8 \ bg8 像素格式图片方法
weixiao的博客
09-18 2712
１、将bayer rg8像素格式图片转换为.bmp 命令行如下： //ffmpeg转换查看rg8图片命令： ffmpeg -vcodec rawvideo -f rawvideo -pix_fmt bayer_rggb8 -s 2448*2048 -i rg8.raw -f image2 -vcodec bmp rggb8.bmp 参数说明及参考：使用ffmpeg 命令行解码并显示像素格式为.raw图像_xuw_xy的博客-CSDN博客 ...
海康彩色工业相机图像格式转换方法(Bayer转RGB)
热门推荐
qq_23107577的博客
01-29 4万+
海康彩色工业相机图像格式转换方法1.彩色相机是如何变成彩色的-Bayer的由来2.工业相机支持的图像格式3.图像格式转化 1.彩色相机是如何变成彩色的-Bayer的由来 提到工业相机图像格式，尤其是彩色相机的图像格式，不得不先讲一下bayer图像格式，网上有很多介绍这种图像格式的文档，随意引用一篇简单介绍下，引用链接: 图像bayer格式介绍以及bayer插值原理. 大致原理呢，就是相机上面的图像传感器只能感受光强而无法感知光的波长，然而光的颜色却是由波长决定的，因此图像传感器是无法记录颜色的。 虽然可以在
8位Bayer原始数据转换为24位RGB数据
冷却
10-23 8627
BayerToRGB.h //原作者：Vojtech Pavlik //2010-10-23 23:25:16 冷却 整理、封装以及测试 #pragma once typedef unsigned char uint8_t; typedef unsigned short uint16_t; typedef unsigned long uint32_t; #define u8 uint8_
海康（巴斯勒）工业相机图像格式转换OpenCV格式
lpb99的博客
08-28 655
【代码】海康（巴斯勒）工业相机图像格式转换OpenCV格式。
bayer格式图像转成RGB图像
10-22
通用的bayer格式图像转换RGB图像的matlab 程序
Bayer数据转RGB（RGGB格式的纯软件简易快速转换）
07-27
Bayer数据转RGB源码，编译通过，目前只支持1080P并且格式为RGGB，不同平台表现可能不同，本人在zynq7000测试时间23ms，PC端测试5ms，其他平台的转换速度可能有差异，甚至更慢。另外需要说明转换比较简单，对转换效果有要求的请注意。
基于FPGA的Bayer到RGB图像格式转换设计
02-09
一篇关于基于FPGA的Bayer到RGB图像格式转换设计的文章
Qt halcon 混合编程，海康工业相机（二）
05-28 1906
Qt5 海康工业相机使用软触发模式
bayer格式图像
big tiger的博客
05-20 1万+
bayer 格式简介 作者：big tiger    qq：517725908   一、发明人         bayer格式图片是 伊士曼·柯达公司科学家Bryce Bayer发明的，Bryce Bayer所发明的拜耳阵列被广泛运用数字图像。 二、bayer格式图片的优势       对于彩色图像，需要采集多种最基本的颜色，如rgb三种颜色，最简单的方法就是用滤镜的方法，红色的滤镜透
Baumer堡盟工业相机BGAPI SDK联合OpenCV进行Bayer图像转换(C#)
xianzuzhicai的博客
02-03 1180
Baumer堡盟工业相机BGAPI SDK联合OpenCV进行Bayer图像转换(C#)
C# 连接海康威视
weixin_44713908的博客
01-07 1万+
using HalconDotNet; using MvCamCtrl.NET; using System; using System.Collections.Generic; using System.Linq; using System.Runtime.InteropServices; using System.Text; using System.Threading.Tasks; us...
【openCV系列】
zhengjiqingxue的专栏
04-17 233
【openCV系列】 【1、学习方法】 1.学习之路及资料分享：https://blog.csdn.net/shuiyixin/article/details/85648310 【2、学习教程】 1.opencv配置：https://blog.csdn.net/shuiyixin/article/details/80386022 2.图像基本操作：https://blog.csdn.net/shu...
visual studio做主动追踪项目，与海康MVS和arduino串口连接
最新发布
03-09
需要注意的问题包括：海康相机的触发模式是否关闭（引用[4]中提到trigger mode要是off，确保连续采集），SDK的函数调用是否正确，图像处理的延迟是否影响实时性，串口通信的波特率、数据格式是否正确，以及Arduino端...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值