MFC中在picture control中显示jpg图像并用opencv对图像进行后台处理

骑猪看日落 2022-05-29 10:08 395阅读 0赞

<一>在MFC的picture control中显示JPG格式的图像

1.借助于CxImage图像库，在MFC自带的图像控件中进行JPG图像的显示；配置环境见之前写的博文。

参考博客：

（1）Cxiamge图像库的使用：[https://www.cnblogs.com/lidabo/p/6923426.html][https_www.cnblogs.com_lidabo_p_6923426.html]

（2）[http://blog.csdn.net/u012273127/article/details/60462710][http_blog.csdn.net_u012273127_article_details_60462710]

（3）[http://blog.csdn.net/friendan/article/details/38358507][http_blog.csdn.net_friendan_article_details_38358507]

自己写的代码：

void CToolsV1Dlg::OnBnClickedOpenimagea() ///对按钮添加的事件处理
    {
    	// TODO: 在此添加控件通知处理程序代码
    	
    	//打开图片选择对话框  
    	LPCTSTR szFilter = _T("BMP(*.bmp)|*.bmp|JPEG(*.jpg)|*.jpg|ALLSUPORTFILE(*.*)|*.*||");
    	CFileDialog dlgBKFile(TRUE, NULL, NULL, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, szFilter, NULL);
    
    	CString strBKFileName;
    	//如果按下OK键  
    	if (dlgBKFile.DoModal() == IDOK)
    	{
    		//读取视频文件  
    		strBKFileName = dlgBKFile.GetPathName();
    	}
    	else
    	{
    		return;
    	}
    
    	//建立CxImage的类指针  
    	CString strExt; //获取文件后缀名  
    	int imageType;  //获取图像类型  
    
    	strExt = FindExtension(strBKFileName);
    	imageType = FindType(strExt);
    
    	//判断指针是否为空  
    	if (m_pImage1 != NULL)
    	{
    		delete m_pImage1;
    		m_pImage1 = NULL;
    	}
    	//开辟内存  
    	m_pImage1 = new CxImage();
    	//打开图片  
    	m_pImage1->Load(strBKFileName, imageType);
    
    	if (!m_pImage1->IsValid())
    	{
    		AfxMessageBox(_T("建立图像指针失败!"));
    		delete m_pImage1;
    		m_pImage1 = NULL;
    		return;
    	}
    
    	//绘制图像到相应的图像控件上  
    	m_pWnd1 = this->GetDlgItem(IDC_IMAGEA); //<span style = "white-space:pre"></span>//这里一定要和picture Control控件的ID对应起来  
    	DrawImgOnCtrl(m_pImage1, m_pWnd1);
    }

2.编写过程中遇到的问题：

（1）关于构造函数和析构函数，代码理解：

#include <iostream>
     
    using namespace std;
     
    class Line
    {
       public:
          void setLength( double len );
          double getLength( void );
          Line();   // 这是构造函数声明
          ~Line();  // 这是析构函数声明
     
       private:
          double length;
    };
     
    // 成员函数定义，包括构造函数
    Line::Line(void)
    {
        cout << "Object is being created" << endl;
    }
    Line::~Line(void)
    {
        cout << "Object is being deleted" << endl;
    }
     
    void Line::setLength( double len )
    {
        length = len;
    }
     
    double Line::getLength( void )
    {
        return length;
    }
    // 程序的主函数
    int main( )
    {
       Line line;
     
       // 设置长度
       line.setLength(6.0); 
       cout << "Length of line : " << line.getLength() <<endl;
     
       return 0;
    }

(2) CxImage类与Mat类之间的转化：

//to Mat
    CxImage img;
    img.Load("C:\\f.jpg");
    uint8_t* buf=NULL;
    int32_t len=0;
    bool rs =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);
    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());

（3）由于显示部分用到的是Cximage类对图像进行存储，而opencv处理的代码中，是用Mat类对图像进行存储，二者之间通过IplImage类进行转化；

Mat和IplImage之间的转化：

/IplImage—>Mat  
    //EXAMPLE：  
    //浅拷贝：  
    IplImage* pBinary=cvLoadImage("c://temp.jpg",0);  
    Mat Img;  
    Img=cvarrToMat(pBinary);  
    //深拷贝只需要再在Mat里创建一个新的Mat对象，然后进行数据的复制，再用上述的函数进行数据头的复制（浅拷贝）：  
    IplImage* pBinary=cvLoadImage("c://temp.jpg", 0);  
    Mat ImgTemp;  
    Img=cvarrToMat(pBinary);  
    Mat Img = ImgTemp.clone();  
      
      
    //Mat—>IplImage  
    //EXAMPLE:  
    //浅拷贝:  
    Mat Img=imread("1.jpg");  
    IplImage* pBinary = &IplImage(Img);  
    //深拷贝只要再加一次复制数据：  
    IplImage *input = cvCloneImage(pBinary);

IplImage和CxImage之间的转化，通过OpenCV2CXimage.h和OpenCV2CXimage.cpp文件进行；

部分代码：

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;
    }

[https_www.cnblogs.com_lidabo_p_6923426.html]: https://www.cnblogs.com/lidabo/p/6923426.html
[http_blog.csdn.net_u012273127_article_details_60462710]: http://blog.csdn.net/u012273127/article/details/60462710
[http_blog.csdn.net_friendan_article_details_38358507]: http://blog.csdn.net/friendan/article/details/38358507