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(0), X(0), id()
    {}
    explicit MyData(int) : A(97), 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(3, 3),
              T = Mat_<double>::zeros(3, 1);
          MyData m(1);

          FileStorage fs(filename, FileStorage::WRITE);

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

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

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

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

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

可以看到第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; 这句这么简单。

最后输出结果如下：