OpenCV持久化（二）

如何利用OpenCV持久化自己的数据结构？我们来看看OpenCV中的一个例子。

MyData.hpp定义自己的数据结构MyData如下:

#ifndef MYDATA_HPP
#define MYDATA_HPP

#include <opencv2/core/core.hpp>
#include <iostream>
#include <string>

using namespace std;
using namespace cv;

class MyData
{
public:
    MyData() : A(), X(), id()
    {}
    explicit MyData(int) : A(), X(CV_PI), id("mydata1234") // explicit to avoid implicit conversion
    {}
    void write(FileStorage& fs) const                        //Write serialization for this class
    {
        fs << "{" << "A" << A << "X" << X << "id" << id << "}";
    }
    void read(const FileNode& node)                          //Read serialization for this class
    {
        A = (int)node["A"];
        X = (double)node["X"];
        id = (string)node["id"];
    }
public:   // Data Members
    int A;
    double X;
    string id;
};

//These write and read functions must be defined for the serialization in FileStorage to work
static void write(FileStorage& fs, const std::string&, const MyData& x)
{
    x.write(fs);
}

static void read(const FileNode& node, MyData& x, const MyData& default_value = MyData())
{
    if(node.empty())
        x = default_value;
    else
        x.read(node);
}

// This function will print our custom class to the console
static ostream& operator<<(ostream& out, const MyData& m)
{
    out << "{ id = " << m.id << ", ";
    out << "X = " << m.X << ", ";
    out << "A = " << m.A << "}";
    return out;
}

#endif // MYDATA_HPP

注意，外部静态函数 write 和 read 必须定义，即：

static void write(FileStorage& fs, const std::string&, const MyData& x);

static void read(const FileNode& node, MyData& x, const MyData& default_value = MyData());

原因稍后说明。

主函数main.cpp如下：

 #include <QtCore/QCoreApplication>
 #include "MyData.hpp"

 int main(int argc, char *argv[])
 {
 //    QCoreApplication a(argc, argv);
 //    return a.exec();

       string filename = "../file/test.xml";
       { //write
           Mat R = Mat_<uchar>::eye(, ),
               T = Mat_<double>::zeros(, );
           MyData m();

           FileStorage fs(filename, FileStorage::WRITE);

           fs << "iterationNr" << ;
           fs << "strings" << "[";                              // text - string sequence
           fs << "image1.jpg" << "Awesomeness" << "baboon.jpg";
           fs << "]";                                           // close sequence

           fs << "Mapping";                              // text - mapping
           fs << "{" << "One" << ;
           fs <<        "Two" <<  << "}";

           fs << "R" << R;                                      // cv::Mat
           fs << "T" << T;

           fs << "MyData" << m;                                // your own data structures

           fs.release();                                       // explicit close
           cout << "Write Done." << endl;
       }

       {//read
           cout << endl << "Reading: " << endl;
           FileStorage fs;
           fs.open(filename, FileStorage::READ);

           int itNr;
           //fs["iterationNr"] >> itNr;
           itNr = (int) fs["iterationNr"];
           cout << itNr;
           if (!fs.isOpened())
           {
               cerr << "Failed to open " << filename << endl;
               //help(av);
               return ;
           }

           FileNode n = fs["strings"];                         // Read string sequence - Get node
           if (n.type() != FileNode::SEQ)
           {
               cerr << "strings is not a sequence! FAIL" << endl;
               return ;
           }

           FileNodeIterator it = n.begin(), it_end = n.end(); // Go through the node
           for (; it != it_end; ++it)
               cout << (string)*it << endl;

           n = fs["Mapping"];                                // Read mappings from a sequence
           cout << "Two  " << (int)(n["Two"]) << "; ";
           cout << "One  " << (int)(n["One"]) << endl << endl;

           MyData m;
           Mat R, T;

           fs["R"] >> R;                                      // Read cv::Mat
           fs["T"] >> T;
           fs["MyData"] >> m;                                 // Read your own structure_

           cout << endl
               << "R = " << R << endl;
           cout << "T = " << T << endl << endl;
           cout << "MyData = " << endl << m << endl << endl;

           //Show default behavior for non existing nodes
           cout << "Attempt to read NonExisting (should initialize the data structure with its default).";
           fs["NonExisting"] >> m;
           cout << endl << "NonExisting = " << endl << m << endl;
       }

       cout << endl
           << "Tip: Open up " << filename << " with a text editor to see the serialized data." << endl;

       return ;
 }

可以看到第29行： fs << "MyData" << m; 

当执行到 fs << "MyData" 时，将调用OpenCV源码operations.hpp中的输出操作符：

static inline FileStorage& operator << (FileStorage& fs, const char* str)

返回 FileStorage 的引用，继续输入自定义的数据m时，将调用operations.hpp中的模板函数：

 template<typename _Tp> static inline FileStorage& operator << (FileStorage& fs, const _Tp& value)
 {
     if( !fs.isOpened() )
         return fs;
     if( fs.state == FileStorage::NAME_EXPECTED + FileStorage::INSIDE_MAP )
         CV_Error( CV_StsError, "No element name has been given" );
     write( fs, fs.elname, value );
     if( fs.state & FileStorage::INSIDE_MAP )
         fs.state = FileStorage::NAME_EXPECTED + FileStorage::INSIDE_MAP;
     return fs;
 }

可以看到第7行：write( fs, fs.elname, value );

在operations.hpp中，可以看到两个OpenCV导出函数：

CV_EXPORTS_W void write( FileStorage& fs, const string& name, const Mat& value );
CV_EXPORTS void write( FileStorage& fs, const string& name, const SparseMat& value );

CV_EXPORTS_W void read(const FileNode& node, Mat& mat, const Mat& default_mat=Mat() );
CV_EXPORTS void read(const FileNode& node, SparseMat& mat, const SparseMat& default_mat=SparseMat() );

回到上面的问题，为什么必须要定义外部静态函数write和read：

static void write(FileStorage& fs, const std::string&, const MyData& x);
static void read(const FileNode& node, MyData& x, const MyData& default_value = MyData());

因此，我们在MyData.hpp中定义的外部静态函数write和read重载了OpenCV中operations.hpp的read和write函数。

所以，上述调用第7行：write( fs, fs.elname, value ) 将调用我们自己定义的 write和read 函数。然后如MyData.hpp所示，在MyData类内部定义方法实现自定义数据结构的持久化。

而对外接口用起来就像 fs << "MyData" << m; 这句这么简单。

最后输出结果如下：