【转】OpenCV与CxImage转换(IplImage)、IplImage QImage Mat 格式互转

最近由于在项目中用到了Opencv库，但是为了更好的显示图像还是使用了Cximage库，它可以快捷地存取、显示、转换各种图像。Opencv库用于高级图像处理与识别。为了使Cximage图像与Opencv图像交互，写了个Cximage转换到IplImage的类。

OpenCV2CXimage.h

#pragma once
/*
* 类说明：OpenCV图像与CXimage图像互转
* 用于OpenCV的图像与CXimage图像格式互转进行封装。 OpenCV的图像位数必须是大等于8的整数倍，支持BMP，JPG图像格式；CXimage的图像位数可以是1、2、4、8、16、24，支持BMP，JPG，TIF，PNG，GIF图像格式。
*/

#include "unicode//ximage.h"
#pragma comment(lib, "cximage_unicode.lib")
//#pragma comment(lib, "j2k_unicode.lib")
#pragma comment(lib, "jasper_unicode.lib")
#pragma comment(lib, "jbig_unicode.lib")
#pragma comment(lib, "Jpeg_unicode.lib")
#pragma comment(lib, "png_unicode.lib")
#pragma comment(lib, "Tiff_unicode.lib")
#pragma comment(lib, "zlib_unicode.lib")
#pragma comment(lib, "mng_unicode.lib")
#pragma comment(lib, "libdcr_unicode.lib")

#include "cv.h"
#include "cxcore.h"
#include "highgui.h"
#ifdef _DEBUG
    #pragma comment(lib, "cxcore200d.lib")
    #pragma comment(lib, "cv200d.lib")
    #pragma comment(lib, "highgui200d.lib")
#else
    #pragma comment(lib, "cxcore200.lib")
    #pragma comment(lib, "cv200.lib")
    #pragma comment(lib, "highgui200.lib")
#endif

class OpenCV2CXimage
{
public:
    OpenCV2CXimage(void);
    ~OpenCV2CXimage(void);

    /*
    功能说明: 获取黑点标记的方式
    参数说明:  cxImage 图像处理类
    返回值: 黑点标记
    */
    static int OpenCV2CXimage::GetBlackColor(CxImage cxImage);

    /*
    功能说明: 获取白点标记的方式
    参数说明:  cxImage 图像处理类
    返回值: 黑点标记
    */
    static int OpenCV2CXimage::GetWhiteColor(CxImage cxImage);

    /*
    *功能说明：转换Cximage到IplImage(注：由于IplImage结构不支持图像像数非8位格式，所以强制转换成8位整数倍)
    *参数说明：src，表示原始Cximage图像；dst，[out] 表示Opencv图像IplImage结构
    *返回值：bool类型。true，表示成功；flase,表示失败。
    */
    bool Cximage2IplImage(CxImage *src,IplImage **dst);

    /*
    *功能说明：转换IplImage到Cximage
    *参数说明：src，表示Opencv图像IplImage结构；dst，[out] 表示输出Cximage图像;nBpp,表示输出Cximage图像位数占多少位[一个像数占多少位](1,8,24);
    *返回值：bool类型。true，表示成功；flase,表示失败。
    */
    bool IplImage2Cximage(IplImage *src,CxImage *dst,long nBpp=8);

    /*
    *功能说明：图象格式转换
    *参数说明：src，表示输入Cximage图像；dst，[out] 表示输出Cximage图像；imagetype,表示图象类型
    *返回值：bool类型。true，表示成功；flase,表示失败。
    */
    bool CxImageFormatConvert(CxImage *src,CxImage *dst,long imagetype = CXIMAGE_FORMAT_BMP);

protected:
    RGBQUAD *m_pPal;//调色版
    int m_nPalatteCount;
};

OpenCV2CXimage.cpp

#include "StdAfx.h"
#include "OpenCV2CXimage.h"
#include <map>
using namespace std;

OpenCV2CXimage::OpenCV2CXimage(void)
{
    m_pPal = NULL;
    m_nPalatteCount = 0;
}

OpenCV2CXimage::~OpenCV2CXimage(void)
{
    if(m_pPal!=NULL)
    {
        delete []m_pPal;
        m_pPal = NULL;
    }
}

//函数名: GetBlackColor
//功能:  获取黑点标记的方式
//参数:  cxImage 图像处理类
//返回值: 黑点标记
int OpenCV2CXimage::GetBlackColor(CxImage cxImage)
{
    long i;
    int iBlackFlag = 0;
    RGBQUAD *pData = cxImage.GetPalette();
    long nPaletteSize = cxImage.GetPaletteSize()/sizeof(RGBQUAD);
    for(i=0;i<nPaletteSize;i++)
    {
        if(pData[i].rgbBlue==0 && pData[i].rgbGreen==0 && pData[i].rgbRed==0)
        {
            iBlackFlag = i;
            break;
        }
    }
    return iBlackFlag;
}

//函数名: GetWhiteColor
//功能:  获取白点标记的方式
//参数:  cxImage 图像处理类
//返回值: 黑点标记
int OpenCV2CXimage::GetWhiteColor(CxImage cxImage)
{
    long i;
    int iWhiteFlag = 255;
    RGBQUAD *pData = cxImage.GetPalette();
    long nPaletteSize = cxImage.GetPaletteSize()/sizeof(RGBQUAD);
    for(i=0;i<nPaletteSize;i++)
    {
        if(pData[i].rgbBlue==255 && pData[i].rgbGreen==255 && pData[i].rgbRed==255)
        {
            iWhiteFlag = i;
            break;
        }
    }
    return iWhiteFlag;
}

/*
*功能说明：转换Cximage到IplImage
*参数说明：src，表示原始Cximage图像；dst，[out] 表示Opencv图像IplImage结构
*返回值：bool类型。true，表示成功；flase,表示失败。
*/
bool OpenCV2CXimage::Cximage2IplImage(CxImage *src,IplImage **dst)
{
    bool bRet = true;
    if(!src || !src->IsValid())
    {
        bRet = false;
        return bRet;
    }
    m_nPalatteCount = src->GetPaletteSize()/sizeof(RGBQUAD);;
    m_pPal = src->GetPalette();
    int iBackColor = GetBlackColor(*src);
    long i = 0,j = 0;
    long nImageWidth = 0,nImageHeight = 0;
    nImageWidth = src->GetWidth();
    nImageHeight = src->GetHeight();
    long nBitCunt = src->GetBpp();
    if(nBitCunt<=1)
    {
        *dst = cvCreateImage(cvSize(nImageWidth,nImageHeight),IPL_DEPTH_8U,1);
        cvZero(*dst);
        //转换Cximage to IplImage
        for(j=0;j<nImageHeight;j++)
        {
            for(i=0;i<nImageWidth;i++)
            {
                if(src->GetPixelIndex(i,j)==iBackColor)
                {
                    CV_IMAGE_ELEM(*dst,uchar,nImageHeight-1-j,i) = 0;
                }
                else
                {
                    CV_IMAGE_ELEM(*dst,uchar,nImageHeight-1-j,i) = 255;
                }
            }
        }
    }
    else if(nBitCunt<=8)
    {
        *dst = cvCreateImage(cvSize(nImageWidth,nImageHeight),IPL_DEPTH_8U,1);
        cvZero(*dst);
        //对应图像调色版与标准调色版的关系
        map<int,int> mapPalatte;
        RGBQUAD szSystemPal[256];
        int k = 0;
        for(k=0;k<256;k++)
        {
            szSystemPal[k].rgbBlue = k;
            szSystemPal[k].rgbGreen = k;
            szSystemPal[k].rgbRed = k;
            szSystemPal[k].rgbReserved = 0;
        }
        int m = 0;
        for(m=0;m<m_nPalatteCount;m++)
        {
            for(k=0;k<256;k++)
            {
                if(m_pPal[m].rgbBlue==szSystemPal[k].rgbBlue && m_pPal[m].rgbGreen==szSystemPal[k].rgbGreen && m_pPal[m].rgbRed==szSystemPal[k].rgbRed)
                {
                    mapPalatte.insert(make_pair(m,k));
                    break;
                }
            }
        }
        //////////////////////////////////////////////////////////////////////////

        //转换Cximage to IplImage
        map<int,int>::iterator iter;
        BYTE btIndex = 0;
        for(j=0;j<nImageHeight;j++)
        {
            for(i=0;i<nImageWidth;i++)
            {
                btIndex = src->GetPixelIndex(i,j);
                iter = mapPalatte.find(btIndex);
                if(iter!=mapPalatte.end())
                {
                    btIndex = iter->second;
                }
                CV_IMAGE_ELEM(*dst,uchar,nImageHeight-1-j,i) = btIndex;
            }
        }
    }
    else if(nBitCunt<=16)
    {
        *dst = cvCreateImage(cvSize(nImageWidth,nImageHeight),IPL_DEPTH_16U,1);
        (*dst)->origin = 1;//底—左结构 (Windows bitmaps 风格)
        cvZero(*dst);
        //转换Cximage to IplImage
        for(j=0;j<nImageHeight;j++)
        {
            for(i=0;i<nImageWidth;i++)
            {
                BYTE *pSrc = src->GetBits(j) + 2*i;
                CV_IMAGE_ELEM(*dst,ushort,j,i) = (*pSrc) + (*(pSrc+1))*256;
            }
        }
    }
    else //24色
    {
        *dst = cvCreateImage(cvSize(nImageWidth,nImageHeight),IPL_DEPTH_8U,3);
        (*dst)->origin = 1;//底—左结构 (Windows bitmaps 风格)
        cvZero(*dst);
        //转换Cximage to IplImag
        memcpy((*dst)->imageData,src->GetBits(0),src->GetSize());
    }
    return bRet;
}

/*
*功能说明：转换IplImage到Cximage
*参数说明：src，表示Opencv图像IplImage结构；dst，[out] 表示输出Cximage图像;nBpp,表示输出Cximage图像位数占多少位[一个像数占多少位]
*返回值：bool类型。true，表示成功；flase,表示失败。
*/
bool OpenCV2CXimage::IplImage2Cximage(IplImage *src,CxImage *dst,long nBpp)
{
    bool bRet = true;
    if(src==NULL || dst==NULL)
    {
        return false;
    }
    if(!(nBpp==1 || nBpp==8 || nBpp==24))
    {
        return false;
    }
    long i = 0,j = 0;
    CvSize csImageSize = cvGetSize(src);
    CxImage ciTmp;
    ciTmp.Create(csImageSize.width,csImageSize.height,src->depth,CXIMAGE_FORMAT_BMP);
    if(src->depth== IPL_DEPTH_8U)//灰度
    {
        ciTmp.SetStdPalette();
        BYTE btIndex = 0;
        for(j=0;j<csImageSize.height;j++)
        {
            for(i=0;i<csImageSize.width;i++)
            {
                btIndex = CV_IMAGE_ELEM(src,uchar,csImageSize.height-1-j,i);
                ciTmp.SetPixelIndex(i,j,btIndex);
            }
        }
    }
    else //彩色
    {
        //转换IplImag to Cximage
        memcpy(ciTmp.GetBits(0),src->imageData,src->imageSize);
    }

    //转换成需要的目标图像
    dst->Create(csImageSize.width,csImageSize.height,nBpp,CXIMAGE_FORMAT_BMP);
    if(nBpp==ciTmp.GetBpp())
    {
        dst->Copy(ciTmp);
    }
    else
    {
        if(nBpp==1)//二值
        {
            //对应图像调色版与标准调色版的关系
            map<int,int> mapPalatte;
            RGBQUAD szSystemPal[256];
            int k = 0;
            for(k=0;k<256;k++)
            {
                szSystemPal[k].rgbBlue = k;
                szSystemPal[k].rgbGreen = k;
                szSystemPal[k].rgbRed = k;
                szSystemPal[k].rgbReserved = 0;
            }
            int m = 0;
            for(k=0;k<256;k++)
            {
                for(m=0;m<m_nPalatteCount;m++)
                {
                    if(m_pPal[m].rgbBlue==szSystemPal[k].rgbBlue && m_pPal[m].rgbGreen==szSystemPal[k].rgbGreen && m_pPal[m].rgbRed==szSystemPal[k].rgbRed)
                    {
                        mapPalatte.insert(make_pair(k,m));
                        break;
                    }
                }
            }
            //////////////////////////////////////////////////////////////////////////
            byte btValue = 0;
            map<int,int>::iterator iter;
            long nImageWidth = 0;
            long nImageHeight = 0;
            if(ciTmp.GetBpp()>8)
            {
                ciTmp.GrayScale();
            }
            if(m_nPalatteCount==2) //表示原始的图象为二值图象
            {
                dst->SetPalette(m_pPal,m_nPalatteCount);
                btValue = 0;
                nImageWidth = ciTmp.GetWidth();
                nImageHeight = ciTmp.GetHeight();
                for(j=0;j<nImageHeight;j++)
                {
                    for(i=0;i<nImageWidth;i++)
                    {
                        btValue = ciTmp.GetPixelIndex(i,j);
                        iter = mapPalatte.find(btValue);
                        if(iter!=mapPalatte.end())
                        {
                            btValue = iter->second;
                        }
                        dst->SetPixelIndex(i,j,btValue);
                    }
                }
            }
            else
            {
                ciTmp.Threshold(128);
                dst->Copy(ciTmp);
            }
        }
        else if(nBpp==8)
        {
            //对应图像调色版与标准调色版的关系
            map<int,int> mapPalatte;
            RGBQUAD szSystemPal[256];
            int k = 0;
            for(k=0;k<256;k++)
            {
                szSystemPal[k].rgbBlue = k;
                szSystemPal[k].rgbGreen = k;
                szSystemPal[k].rgbRed = k;
                szSystemPal[k].rgbReserved = 0;
            }
            int m = 0;
            for(k=0;k<256;k++)
            {
                for(m=0;m<m_nPalatteCount;m++)
                {
                    if(m_pPal[m].rgbBlue==szSystemPal[k].rgbBlue && m_pPal[m].rgbGreen==szSystemPal[k].rgbGreen && m_pPal[m].rgbRed==szSystemPal[k].rgbRed)
                    {
                        mapPalatte.insert(make_pair(k,m));
                        break;
                    }
                }
            }
            //////////////////////////////////////////////////////////////////////////
            byte btValue = 0;
            map<int,int>::iterator iter;
            long nImageWidth = 0;
            long nImageHeight = 0;
            if(ciTmp.GetBpp()!=8)
            {
                ciTmp.GrayScale();
            }
            if(m_nPalatteCount==8) //表示原始的图象为灰度图象
            {
                dst->SetPalette(m_pPal,m_nPalatteCount);
                btValue = 0;
                nImageWidth = ciTmp.GetWidth();
                nImageHeight = ciTmp.GetHeight();
                for(j=0;j<nImageHeight;j++)
                {
                    for(i=0;i<nImageWidth;i++)
                    {
                        btValue = ciTmp.GetPixelIndex(i,j);
                        iter = mapPalatte.find(btValue);
                        if(iter!=mapPalatte.end())
                        {
                            btValue = iter->second;
                        }
                        dst->SetPixelIndex(i,j,btValue);
                    }
                }
            }
            else
            {
                dst->Copy(ciTmp);
            }
        }
        else
        {
            if(ciTmp.GetBpp()==24)
            {
                dst->Copy(ciTmp);
            }
            else
            {
                byte btValue = 0;
                COLORREF clValue;
                map<int,int>::iterator iter;
                long nImageWidth = 0;
                long nImageHeight = 0;
                bRet = ciTmp.IncreaseBpp(24);
                dst->Copy(ciTmp);
            }
        }
    }
    return bRet;
}

//图象格式转换
bool OpenCV2CXimage::CxImageFormatConvert(CxImage *src,CxImage *dst,long imagetype)
{
    bool bRet = true;
    if(src==NULL || dst==NULL)
    {
        return false;
    }
    if(!(imagetype>0 && imagetype<=19))
    {
        return false;
    }
    if(src->GetType()==imagetype)
    {
        dst->Copy(*src);
    }
    else
    {
        dst->Create(src->GetWidth(),src->GetHeight(),src->GetBpp(),imagetype);
        src->SetType(imagetype);
        dst->Copy(*src);
    }
    return true;
}
//QImage->IplImage *
static IplImage *ConvertToIplImage(const QImage &img)
{
    int nChannel=0;
    if(img.format()==QImage::Format_RGB888)nChannel=3;
    if(img.format()==QImage::Format_ARGB32)nChannel=4;
    if( nChannel==0 )return false;

    IplImage *iplImg=cvCreateImageHeader( cvSize(img.width(), img.height()),8,nChannel );
    iplImg->imageData=(char*)img.bits();

    if(nChannel==3)
        cvConvertImage(iplImg,iplImg,CV_CVTIMG_SWAP_RB);

    return iplImg;
}

//Mat->QImage
static QImage ConvertToQImage(cv::Mat &mat)
{
    QImage img;
    int nChannel=mat.channels();
    if(nChannel==3)
    {
        cv::cvtColor(mat,mat,CV_BGR2RGB);
        img = QImage((const unsigned char*)mat.data,mat.cols,mat.rows,QImage::Format_RGB888);
    }
    else if(nChannel==4||nChannel==1)
    {
        img = QImage((const unsigned char*)mat.data,mat.cols,mat.rows,QImage::Format_ARGB32);
    }

    return img;
}

//IplImage *->QImage
static QImage ConvertToQImage(IplImage *iplImg)
{
    QImage img;
    int nChannel=iplImg->nChannels;
    if(nChannel==3)
    {
        cvConvertImage(iplImg,iplImg,CV_CVTIMG_SWAP_RB);
        img = QImage((const unsigned char*)iplImg->imageData,iplImg->width,iplImg->height,QImage::Format_RGB888);
    }
    else if(nChannel==4||nChannel==1)
    {
        img = QImage((const unsigned char*)iplImg->imageData,iplImg->width,iplImg->height,QImage::Format_ARGB32);
    }

    return img;
}

本文转自：http://blog.csdn.net/augusdi/article/details/8865668

　　　　  http://www.cnblogs.com/emouse/archive/2013/03/29/2988807.html

时间： 2024-10-12 07:39:05

【转】OpenCV与CxImage转换(IplImage)、IplImage QImage Mat 格式互转的相关文章

IplImage 与 QImage 相互转换

在使用Qt和OpenCV编程时,对于它们各自的图像类QImage和IplImage难以避免的需要互相之间的转换,下面我们就来看它们的相互转换. 1. QImage 转换为 IplImage IplImage *QImageToIplImage(const QImage * qImage) { int width = qImage->width(); int height = qImage->height(); CvSize Size; Size.height = height; Size.wi

OpenCV数据结构：CvMat，IplImage，CvArr的应用

最近看HS算法时,发现在新的OpenCV3.0已经移除了该算法,于是不得不看老版的.这其中涉及到了CvMat,CvArr,IplImage的使用.关于这三个结构与Mat的转换关系,总结如下: (1)派生关系:CvArr->CvMat->IplImage 传参问题:CvArr作为函数参数,可传入CvMat或IplImage,但内部都按CvMat处理. (2)Mat转IplImage和CvMat IplImage img=IplImage(mat) CvMat cvmat=mat (3)CvMat

OpenCV 3.0中IplImage* 转cv::Mat

在OpenCV 2.0中使用: IplImage * ipl1, *ipl2; // ... const cv::Mat m = cv::Mat(ipl,false); cv::Mat m2 = ipl2; 在OpenCV 3.0中: IplImage * ipl = ...; cv::Mat m = cv::cvarrToMat(ipl);

IplImage* 格式与Mat 格式的转换

IplImage * img: Mat temp = cvarrToMat(img);    //     IplImage*  格式    ==>    Mat 格式 img = (IplImage *)&temp;       //       IplImage*  格式    <==     Mat 格式 原文地址:https://www.cnblogs.com/roscangjie/p/12148181.html

opencv中Mat格式的数据访问.at

opencv3中图形存储基本为Mat格式,如果我们想获取像素点的灰度值或者RGB值,可以通过image.at<uchar>(i,j)的方式轻松获取. Mat类中的at方法对于获取图像矩阵某点的RGB值或者改变某点的值很方便,对于单通道的图像,则可以使用: image.at<uchar>(i, j) 其中有一个要注意的地方是i对应的是点的y坐标,j对应的是点的x坐标,而不是我们习惯的(x,y) 来获取或改变该点的值,而RGB通道的则可以使用: image.at<Vec3b>

转：如何转换Android打包用jks格式keystore证书为Air用pkcs12格式p12证书

转自:http://blog.k-res.net/archives/1539.html 如何转换Android打包用jks格式keystore证书为Air用pkcs12格式p12证书 六月 11, 2013  |  Posted by K-Res 由于受到Flash先进的Stage3D技术以及Unreal Epic Citadel演示的诱惑,决定试用一下Flash Builder的跨平台性能,顺利运行Starling 2D框架demo后决定打包上设备一试,遂即发现Air的跨平台导出Android

将json的时间格式转换成正常的时间格式

/** * 对Date的扩展,将 Date 转化为指定格式的String * 月(M).日(d).12小时(h).24小时(H).分(m).秒(s).周(E).季度(q) 可以用 1-2 个占位符 * 年(y)可以用 1-4 个占位符,毫秒(S)只能用 1 个占位符(是 1-3 位的数字) * eg: * (new Date()).pattern("yyyy-MM-dd hh:mm:ss.S") ==> 2006-07-02 08:09:04.423 * (new Date())

DDSM数据库转换图像格式——LJPEG转为PNG格式

Digital Database for Screening Mammography (DDSM)数据库是一个非常大的乳腺图像数据库,有一万多张图像,但是图像格式是LJPEG,现有的图像软件(如photoshop.ACCDsee.windows自带的图像查看软件)以及编程软件(如matlab)都无法读取,需要将其转换成其他常见的格式才能使用.我从网上搜到了很多方法,试过之后都不成功,其中包括该数据库的创建者--南佛罗里达大学自己写的一个程序[1],一个医学图像格式转换软件XMedCon[2].最

土办法解决日期转换问题，转出格式为。。。 贰零壹陆年零壹月零捌日

/** * 参数名称:@param dateStr 待转换的日期(String格式,结构为yyyy-MM-dd) * 返回值:String 小写汉字的日期 * 方法描述:土办法解决日期转换问题,转出格式为... 贰零壹陆年零壹月零捌日 * @author:zhouzhiwei * 创建时间:2014-5-23 下午05:59:20 */ public static String stringToChineseSmallRMB(String dateStr) { // 传参数的格式为 2011-1