图像处理程序的序列化和反序列化

      所谓序列化，就是讲内存数据保存为磁盘数据的过程，反序列化就是反过来理解。对于图像处理程序来说，最主要的变量是图片，然后还有相关的参数或运算结果。这里区分4个部分、由简单到复杂，分享一下自己的研究成果，希望能够给需要的工程师提供一些帮助。

  

一、基本操作

        OpenCV本身提供了FileStorage的序列化保存方法，这对于保存参数来说非常适合；但是如果用来保存图片，会将原始图片的体积多倍增大，速度也比较慢。Mfc本身也提供了序列化的操作，但是使用起来的话，需要注意的地方比较多，比不上OpenCV来的直接。

        我们最终想要通过保存得到，并且能够被图像处理程序读取的，是一个单一的文件。这个文件不仅包含了图片数据，而且包括相关的参数和运算结果，同时这个文件不能太大。所以我想到采用zip压缩/解压的方式来打包原始图片和运算结果。实验证明，效果是能够符合要求的。

        在打包代码的选择上，找到了比较好的实现。zip.c++/unzip.c++中提供了稳定并且便于使用的压缩解压过程（具体使用参考对应的.h文件，压缩文件可以设定密码）。实际使用中，保存的时候参数保存为.xml文件，图片保存为.jpg图片，而后统一压缩成.go文件；读取的时候反过来操作。

        为了说明问题，编写例程。现在把使用说明一下，具体细节可以参考代码。

1、点击读取图片，可以读入jpg或bmp图片，同时手工设置参数一到三

2、点击保存，保存为.go文件

3、点击打开，打开相应的.go文件，同时解压缩后，图片和参数分别显示出来。

        本例程主要展现的是“图像处理程序的序列化和反序列化”，而后结合实际使用过程中发现的问题进行衍生。希望能够有类似需求的工程师提供一些帮助。

    

主要代码： //保存序列化结果

void CGOsaveView : : OnButtonSave()
{
    CString str1;string s1;
    CString str2;string s2;
    CString str3;string s3;

    CString szFilters = _T( "go(*.go)|*.go|*(*.*)|*.*||" );
    CString FilePathName = "" ;
    CFileDialog dlg(FALSE,NULL,NULL, 0 ,szFilters, this );
    if (dlg.DoModal() == IDOK){
        FilePathName = dlg.GetPathName();
    }   

    if (m_fimage.rows < = 0 )
    {
        AfxMessageBox( "m_fimage为空!" );
        return ;
    }
   
    GetDlgItemText(IDC_EDIT1,str1);
    GetDlgItemText(IDC_EDIT2,str2);
    GetDlgItemText(IDC_EDIT3,str3);
    s1 = str1.GetBuffer( 0 );
    s2 = str2.GetBuffer( 0 );
    s3 = str3.GetBuffer( 0 );

    string filename = "params.xml" ;
    FileStorage fs(filename, FileStorage : : WRITE);
    fs << "str1" << s1;
    fs << "str2" << s2;
    fs << "str3" << s3;
    fs.release();

    imwrite( "m_fimage.jpg" ,m_fimage);

    AfxMessageBox( "数据保存成功！" );


    HZIP hz = CreateZip(FilePathName, "GreenOpen" ); //可以设定密码
    ZipAdd(hz, "params.xml" , "params.xml" );
    ZipAdd(hz, "m_fimage.jpg" , "m_fimage.jpg" );
    CloseZip(hz);
    AfxMessageBox( "数据压缩成功！" );

  
}

//打开序列化结果
void CGOsaveView : : OnButtonOpen()
{
    string s1;
    string s2;
    string s3;

    CString szFilters = _T( "*(*.*)|*.*|go(*.go)|*.go||" );
    CString FilePathName = "" ;
    CFileDialog dlg(TRUE,NULL,NULL, 0 ,szFilters, this );
    if (dlg.DoModal() == IDOK){
        FilePathName = dlg.GetPathName();
    }   
    HZIP hz = OpenZip(FilePathName, "GreenOpen" );
    ZIPENTRY ze; GetZipItem(hz, - 1 , & ze); int numitems = ze.index;
    if (numitems < = 0 )
    {
        AfxMessageBox( "文件读取错误!" );
        return ;
    }
    for ( int i = 0 ; i < numitems; i ++ )
    { 
        GetZipItem(hz,i, & ze);
        UnzipItem(hz,i,ze.name);
    }
    CloseZip(hz);
    AfxMessageBox( "数据解压缩成功" );
    m_fimage = imread( "m_fimage.jpg" );
    if (m_fimage.rows < = 0 )
    {
        AfxMessageBox( "文件读取错误!" );
        return ;
    }
    string filename = "params.xml" ;
    FileStorage fs(filename, FileStorage : : READ);
    fs[ "str1" ] >> s1;
    fs[ "str2" ] >> s2;
    fs[ "str3" ] >> s3;

    SetDlgItemText(IDC_EDIT1,s1.c_str());
    SetDlgItemText(IDC_EDIT2,s2.c_str());
    SetDlgItemText(IDC_EDIT3,s3.c_str());
    AfxMessageBox( "数据反序列成功" );
    SOURSHOW;
}

 

         我们需要注意到的是这里的Mat是可以直接序列化的，这种方法对于存储OpenCV一类的变量来说，非常方便。但是如果是自己设定的结构体了？

二、存储自己的结构体

          这里给出一个新的例子，值得参考：

//另存当前模板数据
BOOL CGOImageShopDoc : :OutPutElementItems(string filename)
{
    FileStorage fs(filename, FileStorage : :WRITE);
     具体写下内容,注意OpenCV支持Rect等基础结构的序列化
     int iElementStruct  = m_rctTracker.size(); //数量
    fs  <<  "iElementStruct"  << iElementStruct;
     //按照openCV推荐的方法来写入和读取数据。
    fs  <<  "ElementContent"  <<  "[";
     for ( int i  =  0; i  < iElementStruct; i ++)
    {
        string strName(CW2A(m_rctTracker[i].name.GetString()));
        string strTypeName(CW2A(m_rctTracker[i].typeName.GetString()));
         int iLeft  = m_rctTracker[i].AreaTracker.m_rect.left;
         int iTop  = m_rctTracker[i].AreaTracker.m_rect.top;
         int iWidth  = m_rctTracker[i].AreaTracker.m_rect.Width();
         int iHeight  = m_rctTracker[i].AreaTracker.m_rect.Height();
         fs << "{:" << "strName" <<strName << "strTypeName" <<strTypeName << "rectLeft" <<iLeft << "rectTop" <<iTop << "rectWidth" <<iWidth << "rectHeight" <<iHeight << "}";    
    }
    fs  <<  "]";
     书写内容结束
    fs.release();
     return TRUE;
}

 

//读取模板书
BOOL CGOImageShopDoc : :ReadElementsItems(string filename)
{
     //读取数据
    FileStorage fs(filename, FileStorage : :READ);
     if (fs.isOpened())
    {
         //清空现有数据
        m_rctTracker.clear();
         //具体业务
         int iElementStruct  =  - 1;
        Rect rect;
        fs[ "iElementStruct"]  >> iElementStruct;
        cv : :FileNode features  = fs[ "ElementContent"];
        cv : :FileNodeIterator it  = features.begin(), it_end  = features.end();
         int idx  =  0;
         for (; it  != it_end;  ++it, idx ++)
        {
            string strName;string strTypeName;
             int iLeft;
             int iTop;
             int iWidth;
             int iHeight;
            strName  = (string)( *it)[ "strName"];  //获得strName
            strTypeName =(string)( *it)[ "strTypeName"];
            iLeft  = ( int)( *it)[ "rectLeft"];
            iTop  = ( int)( *it)[ "rectTop"];
            iWidth  = ( int)( *it)[ "rectWidth"];
            iHeight  = ( int)( *it)[ "rectHeight"];
            CRect rect  = CRect(iLeft, iTop, iLeft +iWidth, iTop +iHeight); //获得rect
             //生成识别区域
            Mat matROI  = m_imageRaw(Rect(iLeft,iTop,iWidth,iHeight));
            vector <CRect > vecFindRect ;
             if (strTypeName  ==  "定位")
            {
                vecFindRect  = findRect(matROI);
            }
           ……
        }
    }
    fs.release();
    
     return TRUE;
}

如果我们打开这里保存的文件，可以发现这种模式：

%YAML : 1. 0
-- -
iElementStruct : 15
ElementContent :
    - { strName : "定位", rectLeft : 37, rectTop : 73, rectWidth : 241,
       rectHeight : 120 }
    - { strName : "定位", rectLeft : 1556, rectTop : 107, rectWidth : 130,
       rectHeight : 70 }
    - { strName : "定位", rectLeft : 3127, rectTop : 99, rectWidth : 93,
       rectHeight : 70 }
    - { strName : "定位", rectLeft : 19, rectTop : 2187, rectWidth : 95,
       rectHeight : 77 }
    - { strName : "定位", rectLeft : 1592, rectTop : 2203, rectWidth : 95,
       rectHeight : 44 }
    - { strName : "定位", rectLeft : 3151, rectTop : 2184, rectWidth : 84,
       rectHeight : 68 }
    - { strName : "考号", rectLeft : 1042, rectTop : 419, rectWidth : 300,
       rectHeight : 121 }
    - { strName : "主观分数", rectLeft : 161, rectTop : 678, rectWidth : 929,
       rectHeight : 63 }
    - { strName : "主观分数", rectLeft : 1789, rectTop : 203, rectWidth : 869,
       rectHeight : 76 }
    - { strName : "主观分数", rectLeft : 1777, rectTop : 717, rectWidth : 868,
       rectHeight : 64 }
    - { strName : "主观分数", rectLeft : 1785, rectTop : 1713, rectWidth : 388,
       rectHeight : 66 }
    - { strName : "主观题", rectLeft : 76, rectTop : 825, rectWidth : 1450,
       rectHeight : 1246 }
    - { strName : "主观题", rectLeft : 1692, rectTop : 367, rectWidth : 1524,
       rectHeight : 323 }
    - { strName : "主观题", rectLeft : 1696, rectTop : 864, rectWidth : 1518,
       rectHeight : 749 }
    - { strName : "主观题", rectLeft : 1696, rectTop : 1787, rectWidth : 1534,
       rectHeight : 307 }

 

那么，这种方式是OpenCV支持的结构保存方式，每一个

- { strName : "主观题", rectLeft : 1696, rectTop : 1787, rectWidth : 1534,
       rectHeight : 307 }

是一个可以存储读取的结构。

 

三、FileNode支持哪些结构

          在这个例子中，我们非常丑陋地使用了4个int值来定义一个Rect。为什么不能直接定义？

         比如编写代码

     string filename  =   "序列化.yml" ;

    FileStorage fs(filename, FileStorage : :WRITE);
    fs  <<  "str1"  << 1;
    cv : :Rect cvRect( 10, 10, 10, 10);
    fs << "cvRect" <<cvRect;
    fs.release();
     return  0;

         生成这样的结果：

%YAML : 1. 0
-- -
str1 : 1
cvRect : [ 10, 10, 10, 10 ]

 

但是，如果我们读取这个Rect，并且编写这样的代码

则会报错：

          为了进一步解析这个问题，翻看OpenCV的代码：

class CV_EXPORTS_W_SIMPLE FileNode
{
public :
    //! type of the file storage node
    enum Type
    {
        NONE       = 0, //!< empty node
        INT       = 1, //!< an integer
        REAL       = 2, //!< floating-point number
        FLOAT     = REAL, //!< synonym or REAL
        STR       = 3, //!< text string in UTF-8 encoding
        STRING     = STR, //!< synonym for STR
        REF       = 4, //!< integer of size size_t. Typically used for storing complex dynamic structures where some elements reference the others
        SEQ       = 5, //!< sequence
        MAP       = 6, //!< mapping
        TYPE_MASK = 7,
        FLOW       = 8,   //!< compact representation of a sequence or mapping. Used only by YAML writer
        USER       = 16, //!< a registered object (e.g. a matrix)
        EMPTY     = 32, //!< empty structure (sequence or mapping)
        NAMED     = 64   //!< the node has a name (i.e. it is element of a mapping)
    };

         那么的确是不可能直接转换为所有的OpenCV类型，这里只是保存为了其他节点的序列，通过代码测试也的确是这样。

 

               在这种情况下，我们可以首先将序列读入vector中，非常有用。

而后再根据实际情况进行封装。

         

四、更进一步，进行类封装

         如果想更进一步，自然需要采用类的方法，这里是一个很好的例子。

# include  <opencv2\opencv.hpp >
# include  "opencv2/imgproc/imgproc.hpp"
# include  "opencv2/highgui/highgui.hpp"
# include  "opencv2/core/core.hpp"
# include  <iostream >
# include  <fstream >
 
using  namespace std;
using  namespace cv;
 
class ColletorMat
{
private :
     int indexFrame;
     bool found;
    Mat frame;
 
public :
 
    ColletorMat( int index,  bool found, Mat frame)
    {
         this - >indexFrame  = index;
         this - >found  = found;
         this - >frame  = frame;
    }
 
     ~ColletorMat()
    {
 
    }
 
     // settors
     void set_indexFrame( int index)
    {
         this - >indexFrame  = index;
    }
 
     void set_found( bool found)
    {
         this - >found  = found;
    }
 
     void set_frame(Mat frame)
    {
         this - >frame  = frame;
    }
 
     // accessors
     int get_indexFrame()
    {
         return  this - >indexFrame;
    }
 
     bool get_found()
    {
         return  this - >found;
    }
 
    Mat get_frame()
    {
         return  this - >frame;
    }
 
};
 
void matwrite(ofstream & fs,  const Mat & mat,  int index,  bool checking)
{
     // Data Object
     int indexFrame  = index;
     bool found  = checking;
    fs.write(( char *) &indexFrame,  sizeof( int));     // indexFrame
    fs.write(( char *) &found,  sizeof( bool));     // bool checking
 
     // Header
     int type  = mat.type();
     int channels  = mat.channels();
    fs.write(( char *) &mat.rows,  sizeof( int));     // rows
    fs.write(( char *) &mat.cols,  sizeof( int));     // cols
    fs.write(( char *) &type,  sizeof( int));         // type
    fs.write(( char *) &channels,  sizeof( int));     // channels
 
     // Data
     if (mat.isContinuous())
    {
        fs.write(mat.ptr < char >( 0), (mat.dataend  - mat.datastart));
    }
     else
    {
         int rowsz  = CV_ELEM_SIZE(type)  * mat.cols;
         for ( int r  =  0; r  < mat.rows;  ++r)
        {
            fs.write(mat.ptr < char >(r), rowsz);
        }
    }
}
 
ColletorMat matread(ifstream & fs)
{
     // Data Object
     int indexFrame;
     bool found;
    fs.read(( char *) &indexFrame,  sizeof( int));      //
    fs.read(( char *) &found,  sizeof( bool));          //
 
     // Header
     int rows, cols, type, channels;
    fs.read(( char *) &rows,  sizeof( int));          // rows
    fs.read(( char *) &cols,  sizeof( int));          // cols
    fs.read(( char *) &type,  sizeof( int));          // type
    fs.read(( char *) &channels,  sizeof( int));      // channels
 
     // Data
    Mat mat(rows, cols, type);
    fs.read(( char *)mat.data, CV_ELEM_SIZE(type)  * rows  * cols);
 
    ColletorMat ojbectMat(indexFrame, found, mat);
     return ojbectMat;
}
 
int main()
{
     // Save the random generated data
    {
        Mat image1, image2, image3;
        image1  = imread( "C:\\opencvVid\\data_seq\\Human3\\0001.jpg");
        image2  = imread( "C:\\opencvVid\\data_seq\\Human3\\0002.jpg");
        image3  = imread( "C:\\opencvVid\\data_seq\\Human3\\0003.jpg");
 
         if (image1.empty()  || image2.empty()  || image3.empty()) {
            std : :cout  <<  "error: image not readed from file\n";
             return( 0);
        }
 
        imshow( "M1",image1);
        imshow( "M2",image2);
        imshow( "M3",image3);
 
        ( char)cvWaitKey( 0);
 
        ofstream fs( "azdoudYoussef.bin", fstream : :binary);
        matwrite(fs, image1,  100,  true);
        matwrite(fs, image2,  200,  true);
        matwrite(fs, image3,  300,  true);
        fs.close();
 
         double tic  =  double(getTickCount());
        ifstream loadFs( "azdoudYoussef.bin", ios : :binary);
 
         if( !loadFs.is_open()){
            cout  <<  "error while opening the binary file"  << endl;
        }
 
        ColletorMat lcolletorMat1  = matread(loadFs);
        ColletorMat lcolletorMat2  = matread(loadFs);
        ColletorMat lcolletorMat3  = matread(loadFs);
 
        cout  <<  "frames loaded up "  << endl;
 
        vector <ColletorMat > setFrames;
        setFrames.push_back(lcolletorMat1);
        setFrames.push_back(lcolletorMat2);
        setFrames.push_back(lcolletorMat3);
 
        imshow( "1", lcolletorMat1.get_frame());
        imshow( "2", lcolletorMat2.get_frame());
        imshow( "3", lcolletorMat3.get_frame());
        ( char)cvWaitKey( 0);
 
        cout  <<  "indexFrame"  <<lcolletorMat1.get_indexFrame()  <<  "found"  << lcolletorMat1.get_found();
         double toc  = ( double(getTickCount())  - tic)  *  1000.  / getTickFrequency();
        cout  <<  "Using Raw: "  << toc  << endl;
        loadFs.close();
 
    }
     return  0;
}