使用 XML / YAML / JSON 文件进行文件输入和输出

目录

• 目标
• 源代码
• 原理解释
• 结果

上一个教程： 离散傅里叶变换
下一个教程： 如何使用 OpenCV parallel_for_ 来并行化你的代码

原作者	Bernát Gábor
兼容性	OpenCV >= 3.0

目标

你将找到以下问题的答案

• 如何使用 YAML、XML 或 JSON 文件在 OpenCV 中向文件打印和读取文本条目？
• 如何对 OpenCV 数据结构执行相同的操作？
• 如何对你的自定义数据结构执行此操作？
• 如何使用 OpenCV 数据结构，例如 cv::FileStorage 、 cv::FileNode 或 cv::FileNodeIterator 。

源代码

C++

你可以点击此处下载，或者在 OpenCV 源代码库的 samples/cpp/tutorial_code/core/file_input_output/file_input_output.cpp 中找到它。

以下是一个示例代码，展示了如何实现目标列表中列出的所有内容。

#include <opencv2/core.hpp>
#include <iostream>
#include <string>
 
using namespace cv;
using namespace std;
 
static void help(char** av)
{
cout << endl
<< av[0] << " 展示了 OpenCV 序列化功能的用法。" << endl << endl
<< "用法： " << endl
<< av[0] << " [输出文件名] (默认 outputfile.yml.gz)" << endl << endl
<< "输出文件可以是 XML (xml)、YAML (yml/yaml) 或 JSON (json)。" << endl
<< "你甚至可以通过在其扩展名中指定来压缩它，例如 xml.gz yaml.gz 等..." << endl
<< "使用 FileStorage，你可以通过使用 << 和 >> 运算符来序列化 OpenCV 中的对象" << endl
<< "例如：- 创建一个类并将其序列化" << endl
<< " - 使用它来读取和写入矩阵。" << endl << endl;
}
 
class MyData
{
public:
MyData() : A(0), X(0), id()
    {}
    explicit MyData(int) : A(97), X(CV_PI), id("mydata1234") // 显式以避免隐式转换
    {}
    void write(FileStorage& fs) const // 写入此类的序列化
    {
fs << "{" << "A" << A << "X" << X << "id" << id << "}";
    }
    void read(const FileNode& node) // 读取此类的序列化
    {
A = (int)node["A"];
X = (double)node["X"];
        id = (string)node["id"];
    }
public: // 数据成员
    int A;
    double X;
    string id;
};
 
// 这些写入和读取函数必须为 FileStorage 中的序列化工作而定义
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);
}
 
// 此函数将我们的自定义类打印到控制台
static ostream& operator<<(ostream& out, const MyData& m)
{
out << "{ id = " << m.id << ", ";
out << "X = " << m.X << ", ";
out << "A = " << m.A << "}";
    return out;
}
 
int main(int ac, char** av)
{
    string filename;
 
    if (ac != 2)
    {
help(av);
filename = "outputfile.yml.gz";
    }
    else
filename = av[1];
 
{ // 写入
        Mat R = Mat_<uchar>::eye(3, 3),
T = Mat_<double>::zeros(3, 1);
MyData m(1);
 
        FileStorage fs(filename, FileStorage::WRITE);
        // 或
        // FileStorage fs;
        // fs.open(filename, FileStorage::WRITE);
 
fs << "iterationNr" << 100;
fs << "strings" << "["; // 文本 - 字符串序列
fs << "image1.jpg" << "Awesomeness" << "../data/baboon.jpg";
fs << "]"; // 关闭序列
 
fs << "Mapping"; // 文本 - 映射
fs << "{" << "One" << 1;
fs << "Two" << 2 << "}";
 
fs << "R" << R; // cv::Mat
fs << "T" << T;
 
fs << "MyData" << m; // 你自己的数据结构
 
fs.release(); // 显式关闭
cout << "文件写入操作：" << filename << " 成功完成。" << endl;
    }
 
{// 读取
cout << endl << "正在读取： " << endl;
        FileStorage fs;
fs.open(filename, FileStorage::READ);
 
        int itNr;
        //fs["iterationNr"] >> itNr;
itNr = (int) fs["iterationNr"];
cout << itNr;
        if (!fs.isOpened())
        {
cerr << "无法打开 " << filename << endl;
help(av);
            return 1;
        }
 
        FileNode n = fs["strings"]; // 读取字符串序列 - 获取节点
        if (n.type() != FileNode::SEQ)
        {
cerr << "strings 不是序列！失败" << endl;
            return 1;
        }
 
        FileNodeIterator it = n.begin(), it_end = n.end(); // 遍历节点
        for (; it != it_end; ++it)
cout << (string)*it << endl;
 
 
n = fs["Mapping"]; // 从序列中读取映射
cout << "Two " << (int)(n["Two"]) << "; ";
cout << "One " << (int)(n["One"]) << endl << endl;
 
 
MyData m;
        Mat R, T;
 
fs["R"] >> R; // 读取 cv::Mat
fs["T"] >> T;
fs["MyData"] >> m; // 读取你自己的结构_
 
cout << endl
<< "R = " << R << endl;
cout << "T = " << T << endl << endl;
cout << "MyData = " << endl << m << endl << endl;
 
        // 显示不存在节点的默认行为
cout << "尝试读取 NonExisting (应该使用其默认值初始化数据结构)。";
fs["NonExisting"] >> m;
cout << endl << "NonExisting = " << endl << m << endl;
    }
 
cout << endl
<< "提示：使用文本编辑器打开 " << filename << " 以查看序列化数据。" << endl;
 
    return 0;
}

Python

你可以点击此处下载，或者在 OpenCV 源代码库的 samples/python/tutorial_code/core/file_input_output/file_input_output.py 中找到它。

以下是一个示例代码，展示了如何实现目标列表中列出的所有内容。

from __future__ import print_function
 
import numpy as np
import cv2 as cv
import sys
 
def help(filename)
    print (
        '''
{0} 展示了 OpenCV 序列化功能的用法。 \n\n
用法：\n
python3 {0} [输出文件名] (默认 outputfile.yml.gz)\n\n
输出文件可以是 XML (xml)、YAML (yml/yaml) 或 JSON (json)。\n
你甚至可以通过在其扩展名中指定来压缩它，例如 xml.gz yaml.gz 等...\n
使用 FileStorage，你可以序列化 OpenCV 中的对象。\n\n
例如：- 创建一个类并将其序列化\n
- 使用它来读取和写入矩阵。\n
 '''.format(filename)
    )
 
class MyData
A = 97
X = np.pi
name = 'mydata1234'
 
    def __repr__(self)
s = '{ name = ' + self.name + ', X = ' + str(self.X)
s = s + ', A = ' + str(self.A) + '}'
        return s
 
    
    def write(self, fs, name)
fs.startWriteStruct(name, cv.FileNode_MAP|cv.FileNode_FLOW)
fs.write('A', self.A)
fs.write('X', self.X)
fs.write('name', self.name)
fs.endWriteStruct()
 
    def read(self, node)
        if (not node.empty())
self.A = int(node.getNode('A').real())
self.X = node.getNode('X').real()
self.name = node.getNode('name').string()
        else:
self.A = self.X = 0
self.name = ''
    
 
def main(argv)
    if len(argv) != 2
help(argv[0])
filename = 'outputfile.yml.gz'
    else :
filename = argv[1]
 
    # 写入
    
R = np.eye(3,3)
T = np.zeros((3,1))
    
m = MyData()
    
 
    
s = cv.FileStorage(filename, cv.FileStorage_WRITE)
    # 或
    # s = cv.FileStorage()
    # s.open(filename, cv.FileStorage_WRITE)
    
 
    
s.write('iterationNr', 100)
    
 
    
s.startWriteStruct('strings', cv.FileNode_SEQ)
    for elem in ['image1.jpg', 'Awesomeness', '../data/baboon.jpg']
s.write('', elem)
s.endWriteStruct()
    
 
    
s.startWriteStruct('Mapping', cv.FileNode_MAP)
s.write('One', 1)
s.write('Two', 2)
s.endWriteStruct()
    
 
    
s.write('R_MAT', R)
s.write('T_MAT', T)
    
 
    
m.write(s, 'MyData')
    
s.release()
    
    print ('文件写入操作：', filename, '成功完成。')
 
    # 读取
    print ('\n正在读取： ')
s = cv.FileStorage()
s.open(filename, cv.FileStorage_READ)
 
    
n = s.getNode('iterationNr')
itNr = int(n.real())
    
    print (itNr)
 
    if (not s.isOpened())
        print ('无法打开 ', filename, file=sys.stderr)
help(argv[0])
exit(1)
 
    
n = s.getNode('strings')
    if (not n.isSeq())
        print ('strings 不是序列！失败', file=sys.stderr)
exit(1)
 
    for i in range(n.size())
        print (n.at(i).string())
    
 
    
n = s.getNode('Mapping')
    print ('Two',int(n.getNode('Two').real()),'; ')
    print ('One',int(n.getNode('One').real()),'\n')
    
 
    
R = s.getNode('R_MAT').mat()
T = s.getNode('T_MAT').mat()
    
m.read(s.getNode('MyData'))
    
 
    print ('\nR =',R)
    print ('T =',T,'\n')
    print ('MyData =','\n',m,'\n')
 
    
    print ('尝试读取 NonExisting (应该初始化数据结构',
            '使用其默认值)。')
m.read(s.getNode('NonExisting'))
    print ('\nNonExisting =','\n',m)
    
 
    print ('\n提示：使用文本编辑器打开',filename,'以查看序列化数据。')
 
if __name__ == '__main__'
    main(sys.argv)

解释

这里我们只讨论 XML、YAML 和 JSON 文件输入。你的输出（及其相应的输入）文件可能只有这些扩展名之一，并且结构也由此而来。你可以序列化两种数据结构：映射（如 STL map 和 Python 字典）和元素序列（如 STL vector）。两者的区别在于，在映射中，每个元素都有一个唯一的名称，你可以通过它访问该元素。对于序列，你需要遍历它们才能查询特定项。

1. XML/YAML/JSON 文件打开和关闭。在向此类文件写入任何内容之前，你需要打开它，并在最后关闭它。OpenCV 中的 XML/YAML/JSON 数据结构是 cv::FileStorage 。要指定此结构绑定到硬盘上的文件，你可以使用其构造函数或此结构的 open() 函数

   C++

           FileStorage fs(filename, FileStorage::WRITE);
           // 或
           // FileStorage fs;
           // fs.open(filename, FileStorage::WRITE);

   Python

   s = cv.FileStorage(filename, cv.FileStorage_WRITE)
       # 或
       # s = cv.FileStorage()
       # s.open(filename, cv.FileStorage_WRITE)

   无论是哪种方式，你使用的第二个参数都是一个常量，指定你将能够对其执行的操作类型：WRITE、READ 或 APPEND。文件名中指定的扩展名也决定了将使用的输出格式。如果你指定一个扩展名（例如 .xml.gz），输出甚至可以被压缩。

   当 cv::FileStorage 对象被销毁时，文件会自动关闭。但是，你可以通过使用 release 函数显式调用此操作

   C++

   fs.release(); // 显式关闭

   Python

   s.release()

2. 文本和数字的输入和输出。在 C++ 中，数据结构使用 STL 库中的 << 输出运算符。在 Python 中，则使用 cv::FileStorage::write() 。要输出任何类型的数据结构，我们首先需要指定其名称。在 C++ 中，我们只需将其名称推送到流中即可。在 Python 中，write 函数的第一个参数是名称。对于基本类型，你可以随后打印值。
   C++

   fs << "iterationNr" << 100;

   Python

   s.write('iterationNr', 100)

   读取是一个简单的寻址（通过 [] 运算符）和类型转换操作，或者通过 >> 运算符读取。在 Python 中，我们使用 getNode() 进行寻址，并使用 real() 。
   C++

           int itNr;
           //fs["iterationNr"] >> itNr;
   itNr = (int) fs["iterationNr"];

   Python

           int itNr;
           //fs["iterationNr"] >> itNr;
   itNr = (int) fs["iterationNr"];

3. OpenCV 数据结构的输入/输出。它们与基本的 C++ 和 Python 类型完全相同。
   C++

           Mat R = Mat_<uchar>::eye(3, 3),
   T = Mat_<double>::zeros(3, 1);

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

   fs["R"] >> R; // 读取 cv::Mat
   fs["T"] >> T;

   Python

   R = np.eye(3,3)
   T = np.zeros((3,1))

   s.write('R_MAT', R)
   s.write('T_MAT', T)

   R = s.getNode('R_MAT').mat()
   T = s.getNode('T_MAT').mat()

4. 向量（数组）和关联映射的输入/输出。正如我前面提到的，我们也可以输出映射和序列（数组、向量）。同样，我们首先打印变量的名称，然后我们必须指定我们的输出是序列还是映射。

   对于序列，在第一个元素之前打印“[”字符，在最后一个元素之后打印“]”字符。在 Python 中，调用 FileStorage.startWriteStruct(structure_name, struct_type)，其中 struct_type 是 cv2.FileNode_MAP 或 cv2.FileNode_SEQ 以开始写入结构。调用 FileStorage.endWriteStruct() 以完成结构。

   C++

   fs << "strings" << "["; // 文本 - 字符串序列
   fs << "image1.jpg" << "Awesomeness" << "../data/baboon.jpg";
   fs << "]"; // 关闭序列

   Python

   s.startWriteStruct('strings', cv.FileNode_SEQ)
       for elem in ['image1.jpg', 'Awesomeness', '../data/baboon.jpg']
   s.write('', elem)
   s.endWriteStruct()

   对于映射，操作相同，但现在我们使用“{”和“}”分隔符。

   C++

   fs << "Mapping"; // 文本 - 映射
   fs << "{" << "One" << 1;
   fs << "Two" << 2 << "}";

   Python

   s.startWriteStruct('Mapping', cv.FileNode_MAP)
   s.write('One', 1)
   s.write('Two', 2)
   s.endWriteStruct()

   要从这些结构中读取，我们使用 cv::FileNode 和 cv::FileNodeIterator 数据结构。cv::FileStorage 类的 [] 运算符（或 Python 中的 getNode() 函数）返回一个 cv::FileNode 数据类型。如果节点是序列，我们可以使用 cv::FileNodeIterator 迭代项。在 Python 中，at() 函数可用于访问序列元素，size() 函数返回序列的长度。

   C++

           FileNode n = fs["strings"]; // 读取字符串序列 - 获取节点
           if (n.type() != FileNode::SEQ)
           {
   cerr << "strings 不是序列！失败" << endl;
               return 1;
           }
    
           FileNodeIterator it = n.begin(), it_end = n.end(); // 遍历节点
           for (; it != it_end; ++it)
   cout << (string)*it << endl;

   Python

   n = s.getNode('strings')
       if (not n.isSeq())
           print ('strings 不是序列！失败', file=sys.stderr)
   exit(1)
    
       for i in range(n.size())
           print (n.at(i).string())

   对于映射，你可以再次使用 [] 运算符（Python 中的 at() 函数）来访问给定项（或 >> 运算符）。

   C++

   n = fs["Mapping"]; // 从序列中读取映射
   cout << "Two " << (int)(n["Two"]) << "; ";
   cout << "One " << (int)(n["One"]) << endl << endl;

   Python

   n = s.getNode('Mapping')
       print ('Two',int(n.getNode('Two').real()),'; ')
       print ('One',int(n.getNode('One').real()),'\n')

5. 读取和写入你自己的数据结构。假设你有一个数据结构，例如

   C++

   class MyData
   {
   public:
   MyData() : A(0), X(0), id() {}
   public: // 数据成员
      int A;
      double X;
      string id;
   };

   Python

   class MyData
       def __init__(self)
   self.A = self.X = 0
   self.name = ''

   在 C++ 中，可以通过在类内部和外部添加读写函数，通过 OpenCV I/O XML/YAML 接口来序列化它（就像 OpenCV 数据结构一样）。在 Python 中，可以通过在类内部实现读写函数来实现类似的功能。对于内部部分

   C++

       void write(FileStorage& fs) const // 写入此类的序列化
       {
   fs << "{" << "A" << A << "X" << X << "id" << id << "}";
       }
       void read(const FileNode& node) // 读取此类的序列化
       {
   A = (int)node["A"];
   X = (double)node["X"];
           id = (string)node["id"];
       }

   Python

       def write(self, fs, name)
   fs.startWriteStruct(name, cv.FileNode_MAP|cv.FileNode_FLOW)
   fs.write('A', self.A)
   fs.write('X', self.X)
   fs.write('name', self.name)
   fs.endWriteStruct()
    
       def read(self, node)
           if (not node.empty())
   self.A = int(node.getNode('A').real())
   self.X = node.getNode('X').real()
   self.name = node.getNode('name').string()
           else:
   self.A = self.X = 0
   self.name = ''

   C++

   在 C++ 中，你需要在类外部添加以下函数定义

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

   在这里你可以观察到，在读取部分我们定义了如果用户尝试读取一个不存在的节点会发生什么。在这种情况下，我们只返回默认的初始化值，但是一个更详细的解决方案是例如为一个对象 ID 返回一个负一值。

   一旦你添加了这四个函数，就使用 >> 运算符进行写入，使用 << 运算符进行读取（或使用 Python 中定义的输入/输出函数）。

   C++

   MyData m(1);

   fs << "MyData" << m; // 你自己的数据结构

   fs["MyData"] >> m; // 读取你自己的结构_

   Python

   m = MyData()

   m.write(s, 'MyData')

   m.read(s.getNode('MyData'))

   或者尝试读取一个不存在的节点

   C++

   cout << "尝试读取 NonExisting (应该使用其默认值初始化数据结构)。";
   fs["NonExisting"] >> m;
   cout << endl << "NonExisting = " << endl << m << endl;

   Python

       print ('尝试读取 NonExisting (应该初始化数据结构',
               '使用其默认值)。')
   m.read(s.getNode('NonExisting'))
       print ('\nNonExisting =','\n',m)

结果

我们主要只是打印出定义的数字。在控制台屏幕上，你可以看到

写入完成。
 
读取中
100image1.jpg
Awesomeness
baboon.jpg
Two 2; One 1
 
 
R = [1, 0, 0;
  0, 1, 0;
  0, 0, 1]
T = [0; 0; 0]
 
MyData =
{ id = mydata1234, X = 3.14159, A = 97}
 
尝试读取 NonExisting (应该使用其默认值初始化数据结构)。
NonExisting =
{ id = , X = 0, A = 0}
 
提示：使用文本编辑器打开 output.xml 以查看序列化数据。

然而，更有趣的是你可能在输出 xml 文件中看到的内容

<?xml version="1.0"?>
<opencv_storage>
<iterationNr>100</iterationNr>
<strings>
  image1.jpg Awesomeness baboon.jpg</strings>
<Mapping>
<One>1</One>
<Two>2</Two></Mapping>
<R type_id="opencv-matrix">
<rows>3</rows>
<cols>3</cols>
<dt>u</dt>
<data>
1 0 0 0 1 0 0 0 1</data></R>
<T type_id="opencv-matrix">
<rows>3</rows>
<cols>1</cols>
<dt>d</dt>
<data>
0. 0. 0.</data></T>
<MyData>
<A>97</A>
<X>3.1415926535897931e+000</X>
<id>mydata1234</id></MyData>
</opencv_storage>

或者 YAML 文件

%YAML:1.0
iterationNr: 100
strings
- "image1.jpg"
- Awesomeness
- "baboon.jpg"
Mapping
One: 1
Two: 2
R: !!opencv-matrix
rows: 3
cols: 3
dt: u
data: [ 1, 0, 0, 0, 1, 0, 0, 0, 1 ]
T: !!opencv-matrix
rows: 3
cols: 1
dt: d
data: [ 0., 0., 0. ]
MyData
A: 97
X: 3.1415926535897931e+000
id: mydata1234

你可以在此处观看其运行时实例。