opencv 图像类型（Mat、图像字节流、Bitmap、BITMAPINFO、CxImage、AVFrame）之间的转换

byxdaz

已于 2023-02-10 09:07:43 修改

阅读量8.1k

点赞数 4

分类专栏： OpenCV 音视频文章标签： opencv 人工智能计算机视觉

于 2019-11-17 13:27:56 首次发布

本文链接：https://blog.csdn.net/byxdaz/article/details/103107878

版权

音视频同时被 2 个专栏收录

55 篇文章 25 订阅

订阅专栏

OpenCV

26 篇文章 5 订阅

订阅专栏

一、Mat与Iplimage
Mat<-----> Iplimage ：直接赋值

IplImage *iplImg = cvLoadImage("greatwave.jpg", 1);
Mat mtx(iplImg); // IplImage* ->Mat 共享数据
// or : Mat mtx = iplImg;
cvReleaseImage(&iplImg);

Iplimage ---> CvvImage ：用“Copyof ”

CvvImage cImg;
Iplimage myimg;
cImg.Copyof(myimg, -1);

Opencv2.2版本以上CvvImage类的使用，参考这篇文章Opencv2.2版本以上CvvImage类的使用 - 我自逍遥笑 - 博客园

二、Mat与图像数据

std::vector<unsigned char> Mat2ImageData(const cv::Mat &img, std::string imgType="jpg")
{
    std::vector<unsigned char> vecImgData;
    std::vector<int> vecCompression_params;
    vecCompression_params.push_back(CV_IMWRITE_JPEG_QUALITY);
    vecCompression_params.push_back(100);
    imgType = "." + imgType;
    cv::imencode(imgType, img, vecImgData, vecCompression_params);
    return vecImgData;
}

cv::Mat ImageData2Mat(std::vector<unsigned char> vecImageData)
{
    cv::Mat img;
    img = cv::imdecode(vecImageData, CV_LOAD_IMAGE_COLOR);
    return img;
}

三、Mat转Bitmap

//获取图片宽度。绘制图片时，一定要保证Mat图片符合window图片要求(即每行字节数为4的倍数)，如果不满足则要进行适当的转化，否则画出的图像会出现问题(图像不是标准图像，反而是斜的)。
int GetSuiteableWidth(const int prewidth)
{
    int nwidth = 0;
    int nremainder = prewidth % 4;
    if (nremainder == 0)
    {
        return prewidth;//宽度 pix
    }
    else
    {
        return (prewidth / 4 + 1) * 4;//宽度 pix
    }
    return 0;
}

void FillBitmapInfo(BITMAPINFO* bmi, int width, int height, int bpp, int origin)
{
    BITMAPINFOHEADER* bmih = &(bmi->bmiHeader);
 
    memset(bmih, 0, sizeof(*bmih));
    bmih->biSize = sizeof(BITMAPINFOHEADER);//指定文件大小，包括这14个字节
    /*32位的Windows操作系统处理4个字节(32位)的速度比较快，所以BMP的每一行颜色占用的字节数规定为4的整数倍。MyBmp.bmp中一行颜色有两个像素，共占用6字节，如果要补齐4*2=8字节，就要再加两个0字节。
行补位的公式为：widthBytes = (width*biBitCount+31)/32*4 */
    //width = (width*bpp + width) / 32 * 4;
    bmih->biWidth = GetSuiteableWidth(width);//宽度 pix
    bmih->biHeight = origin ? abs(height) : -abs(height); // 高度  .bMP文件的数据从下到上，从左到右的。也就是说，从文件中最先读到的是图象最下面一行的左边第一个象素，然后是左边第二个象素……接下来是倒数第二行左边第一个象素，左边第二个象素……依次类推 ，最后得到的是最上面一行的最右一个象素。
    bmih->biPlanes = 1; // 目标设备的级别，必须为1
    bmih->biBitCount = (unsigned short)bpp;// 每个像素所需的位数，必须是1(双色), 每个像素的位数
    // 1 - 黑白图，4 - 16色，8 - 256色，24 - 真彩色 4(16色)，8(256色)或24(真彩色)之一
    bmih->biCompression = BI_RGB;// 位图压缩类型，必须是 0(不压缩), 1(BI_RLE8压缩类型)或2(BI_RLE4压缩类型)之一
//    bmih->biSizeImage = bmih->biHeight * 8 *height;
    /*biSizeImage
    指定实际的位图数据占用的字节数，其实也可以从以下的公式中计算出来：
    biSizeImage=biWidth’ × biHeight
    要注意的是：上述公式中的biWidth’必须是4的整倍数(所以不是biWidth，而是biWidth’，
    表示大于或等于biWidth的，最接近4的整倍数。举个例子，如果biWidth=240，则biWidth’=240；
    如果biWidth=241，biWidth’=244)。*/
}

CBitmap * Mat2CBitmap(const cv::Mat imgTmp)
{
    HDC hDC = this->GetDC()->GetSafeHdc();
    uchar buffer[sizeof(BITMAPINFOHEADER) + 1024];
    BITMAPINFO* bmi = (BITMAPINFO*)buffer;
    int bmp_w = imgTmp.cols, bmp_h = imgTmp.rows;
    int nchannels = imgTmp.channels();
    int bpp = (imgTmp.depth()+1)*nchannels;
    FillBitmapInfo(bmi, bmp_w, bmp_h, bpp*8, 0);
    /*
    DWORD biSizeImage; // 位图的大小，以字节为单位
    LONG biXPelsPerMeter; // 位图水平分辨率，每米像素数
    LONG biYPelsPerMeter; // 位图垂直分辨率，每米像素数
    DWORD biClrUsed;// 位图实际使用的颜色表中的颜色数
    DWORD biClrImportant;// 位图显示过程中重要的颜色数72*8
    */
    char *pBits = NULL;
    HBITMAP hBitmap = CreateDIBSection(hDC, bmi, DIB_RGB_COLORS, (void**)&pBits, NULL, 0);
    int pixelBytes = imgTmp.channels()*(imgTmp.depth()+1); // 计算一个像素多少个字节
    
    if (bmp_w%4==0)
    {
        memcpy(pBits , imgTmp.data, pixelBytes*bmp_w*bmp_h);
    }
    else
    {
        // 原始图像宽度不是 4 的倍数，将实际图片数据一行一行拷贝过去 
        int ntempW = GetSuiteableWidth(bmp_w);
        for (size_t i = 0; i < bmp_h; i++)
        {
            memcpy(pBits + pixelBytes * ntempW * i, imgTmp.data + pixelBytes * bmp_w * i, pixelBytes*bmp_w);
        }
    }
 
    CBitmap *pBitmap = new CBitmap;
    pBitmap->Attach(hBitmap);
    return pBitmap;
}

四、Mat转BITMAPINFO

void Mat2BITMAPINFO(const cv::Mat image,BITMAPINFO *imgInfo)
{
    //根据图像通道数建立图像信息（这里假定图像像素为24与32位或者8位(有颜色表的类似)）
    if(image.channels() == 3 || image.channels() == 4)
    {
        imgInfo = (BITMAPINFO*) new BYTE[sizeof(BITMAPINFOHEADER)];
    }
    else    //8位，有颜色表
    {
        imgInfo = (BITMAPINFO*) new BYTE[sizeof(BITMAPINFOHEADER) + 256*sizeof(RGBQUAD)];
        //颜色表赋值
        for (int i(0); i < 256; ++i)
        {
            imgInfo ->bmiColors[i].rgbBlue = i;
            imgInfo ->bmiColors[i].rgbGreen = i;
            imgInfo ->bmiColors[i].rgbRed = i;
            imgInfo ->bmiColors[i].rgbReserved = 0;
        }
    }

    //头文件信息(注意由实际显示情况可得出图像原点显示在空间左下角)
    imgInfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    imgInfo->bmiHeader.biBitCount = 8 * image .channels();
    imgInfo->bmiHeader.biHeight = -image .rows;
    imgInfo->bmiHeader.biWidth = image .cols;
    imgInfo->bmiHeader.biPlanes = 1;
    imgInfo->bmiHeader.biCompression = BI_RGB;
    imgInfo->bmiHeader.biSizeImage = image .channels() * image .cols * image .rows;
    imgInfo->bmiHeader.biXPelsPerMeter = 0;
    imgInfo->bmiHeader.biYPelsPerMeter = 0;
    imgInfo->bmiHeader.biClrUsed = 0;
    imgInfo->bmiHeader.biClrImportant = 0;
}

//测试代码
void CPointMatchDlg::OnPaint()
{
    CDC *pDC;
    pDC = GetDlgItem(IDC_MATCH_PICTURE_CONTROL)->GetDC();
    CRecr imgCtrlRect;
    GetDlgItem(IDC_MATCH_PICTURE_CONTROL)->GetClientRect(&imgCtrlRect);
    
    pDC->SetStretchBltMode(COLORONCOLOR);
    ::StretchDIBits(pDC->GetSafeHdc(), 
                0, 0, 
                imgCtrlRect.Width(), m_imgCtrlRect.Height(), 
                0, 0, 
                m_image.cols, m_image.rows, 
                m_image.data, 
                m_imgInfo, 
                DIB_RGB_COLORS, 
                SRCCOPY);

    ReleaseDC(pDC);
}

注意：
　　这里绘制图片时，一定要保证Mat图片符合window图片要求(即每行字节数为4的倍数)，如果不满足则要进行适当的转化，否则画出的图像会出现问题(图像不是标准图像，反而是斜的)。
　　如果图片行字节数不是4的倍数，修改为如下语句：

cv::Mat tempImg =  cv::imread("d:\\test.jpeg", cv::IMREAD_UNCHANGED); 
m_image = cv::Mat::zeros(tempImg.rows, (tempImg.cols + 3) / 4 * 4, m_image.type());   //转化行字节数为4的倍数
tempImage.copyTo(m_image(cv::Rect(0, 0, tempImg.cols, tempImg.rows)));

五、Mat与CxImage

CxImage img;
img.Load("C:\\f.jpg");
uint8_t *buf=NULL;
int32_t len=0;
boolrs =img.Encode(buf,len,CXIMAGE_FORMAT_BMP);
cv::Mat temp2;
vector<uchar> buff2;
buff2.resize(len);
memcpy(&buff2[0],buf,len);
temp2= cv::imdecode(buff2,1);
delete []buf; //要释放buf，这个buf在函数里分配了内存

cv::imshow("111",temp2);
cv::waitKey();
 
//to Cximage
vector<uchar> buff;
cv::imencode(".bmp",temp2,buff);
CxImage img2(&buff[0],buff.size(),CXIMAGE_FORMAT_BMP);
img2.Blt(GetDlgItem(IDC_STATIC_P)->GetDC()->GetSafeHdc());

六、Mat与AVFrame

Mat是opencv的图像格式，颜色空间为BGR，对应FFmpeg格式为AV_PIX_FMT_BGR24。AVFrame一般为YUV420P，以此格式为例。这个通过FFmpeg的格式转换函数就可以解决。

extern "C" {  
#include "libavutil/avutil.h"  
#include "libavcodec/avcodec.h"  
#include "libavformat/avformat.h"  
#include "libswscale/swscale.h"  
#include <libavutil/imgutils.h>  
}  
#include <opencv2/core.hpp>  
 
 
//AVFrame 转 cv::mat  
cv::Mat avframeToCvmat(const AVFrame * frame)  
{  
    int width = frame->width;  
    int height = frame->height;  
    cv::Mat image(height, width, CV_8UC3);  
    int cvLinesizes[1];  
    cvLinesizes[0] = image.step1();  
    SwsContext* conversion = sws_getContext(width, height, (AVPixelFormat) frame->format, width, height, AVPixelFormat::AV_PIX_FMT_BGR24, SWS_FAST_BILINEAR, NULL, NULL, NULL);  
    sws_scale(conversion, frame->data, frame->linesize, 0, height, &image.data, cvLinesizes);  
    sws_freeContext(conversion);  
    return image;  
}  
 
//cv::Mat 转 AVFrame  
AVFrame* cvmatToAvframe(cv::Mat* image, AVFrame * frame){  
    int width = image->cols;  
    int height = image->rows;  
    int cvLinesizes[1];  
    cvLinesizes[0] = image->step1();  
    if (frame == NULL){  
        frame = av_frame_alloc();  
        av_image_alloc(frame->data, frame->linesize, width, height, AVPixelFormat::AV_PIX_FMT_YUV420P, 1);  
    }  
    SwsContext* conversion = sws_getContext(width, height, AVPixelFormat::AV_PIX_FMT_BGR24, width, height, (AVPixelFormat) frame->format, SWS_FAST_BILINEAR, NULL, NULL, NULL);  
    sws_scale(conversion, &image->data, cvLinesizes , 0, height, frame->data, frame->linesize);  
    sws_freeContext(conversion);  
    return  frame;  
}

cv::Mat avframeToCvmat2(AVFrame *yuv420Frame)
{
	//得到AVFrame信息
    int srcW = yuv420Frame->width;
    int srcH = yuv420Frame->height;
    SwsContext *swsCtx = sws_getContext(srcW, srcH, (AVPixelFormat)yuv420Frame->format, srcW, srcH, (AVPixelFormat)AV_PIX_FMT_BGR24, SWS_BICUBIC, NULL, NULL, NULL);

	//生成Mat对象
    cv::Mat mat;
    mat.create(cv::Size(srcW, srcH), CV_8UC3);

	//格式转换，直接填充Mat的数据data
    AVFrame *bgr24Frame = av_frame_alloc();
    av_image_fill_arrays(bgr24Frame->data, bgr24Frame->linesize, (uint8_t *)mat.data, (AVPixelFormat)AV_PIX_FMT_BGR24, srcW, srcH, 1);
    sws_scale(swsCtx,(const uint8_t* const*)yuv420Frame->data, yuv420Frame->linesize, 0, srcH, bgr24Frame->data, bgr24Frame->linesize);

	//释放
    av_frame_free(bgr24Frame);
    sws_freeContext(swsCtx);

    return mat;
}

AVFrame *cvmatToAvframe2(cv::Mat &inMat)
{
	//得到Mat信息
    AVPixelFormat dstFormat = AV_PIX_FMT_YUV420P;
    int width = inMat.cols;
    int height = inMat.rows;

	//创建AVFrame填充参数 注：调用者释放该frame
    AVFrame *frame = av_frame_alloc();
    frame->width = width;
    frame->height = height;
    frame->format = dstFormat;

	//初始化AVFrame内部空间
    int ret = av_frame_get_buffer(frame, 32);
    if (ret < 0)
    {
        qDebug() << "Could not allocate the video frame data" ;
        return nullptr;
    }
    ret = av_frame_make_writable(frame);
    if (ret < 0)
    {
        qDebug() << "Av frame make writable failed.";
        return nullptr;
    }

    //转换颜色空间为YUV420
    cv::cvtColor(inMat, inMat, cv::COLOR_BGR2YUV_I420);

	//按YUV420格式，设置数据地址
    int frame_size = width * height;
    unsigned char *data = inMat.data;
    memcpy(frame->data[0], data, frame_size);
    memcpy(frame->data[1], data + frame_size, frame_size/4);
    memcpy(frame->data[2], data + frame_size * 5/4, frame_size/4);

    return frame;
}