OpenCV 如何使用 XML 和 YAML 文件的文件输入和输出

 返回：OpenCV系列文章目录（持续更新中......）

上一篇：如何利用OpenCV4.9离散傅里叶变换

下一篇:如何使用 OpenCV parallel_for_并行化代码

目标

本文内容主要介绍：

• 如何使用 YAML 或 XML 文件打印和读取文件和 OpenCV 的文本条目？
• 如何对 OpenCV 数据结构做同样的事情？
• 如何为您的数据结构执行此操作？
• 使用 OpenCV 数据结构，例如 cv::FileStorage , cv::FileNode or cv::FileNodeIterator .

源代码
 

需要源码的朋友可以前往官网下载：

下面是一个示例代码，说明如何实现目标列表中列举的所有内容。

#include <opencv2/core.hpp>
#include <iostream>
#include <string> 
using namespace cv;
using namespace std; 
static void help(char** av)
{
 cout << endl
 << av[0] << " shows the usage of the OpenCV serialization functionality." << endl
 << "usage: " << endl
 << av[0] << " outputfile.yml.gz" << endl
 << "The output file may be either XML (xml) or YAML (yml/yaml). You can even compress it by "
 << "specifying this in its extension like xml.gz yaml.gz etc... " << endl
 << "With FileStorage you can serialize objects in OpenCV by using the << and >> operators" << endl
 << "For example: - create a class and have it serialized" << endl
 << " - use it to read and write matrices." << endl;
} 
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;
} 
int main(int ac, char** av)
{
 if (ac != 2)
 {
 help(av);
 return 1;
 } 
 string filename = av[1];
 { //write
 Mat R = Mat_<uchar>::eye(3, 3),
 T = Mat_<double>::zeros(3, 1);
 MyData m(1); 
 FileStorage fs(filename, FileStorage::WRITE);
 // or:
 // FileStorage fs;
 // fs.open(filename, FileStorage::WRITE); 
 fs << "iterationNr" << 100;
 fs << "strings" << "["; // text - string sequence
 fs << "image1.jpg" << "Awesomeness" << "../data/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;
}

C++Python

from __future__ import print_function 
import numpy as np
import cv2 as cv
import sys 
def help(filename):
 print (
 '''
 {0} shows the usage of the OpenCV serialization functionality. \n\n
 usage:\n
 python3 {0} outputfile.yml.gz\n\n
 The output file may be either in XML, YAML or JSON. You can even compress it\n
 by specifying this in its extension like xml.gz yaml.gz etc... With\n
 FileStorage you can serialize objects in OpenCV.\n\n
 For example: - create a class and have it serialized\n
 - use it to read and write matrices.\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])
 exit(1) 
 # write 
 R = np.eye(3,3)
 T = np.zeros((3,1)) 
 m = MyData() 
 filename = argv[1] 
 s = cv.FileStorage(filename, cv.FileStorage_WRITE)
 # or:
 # 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 ('Write Done.') 
 # read
 print ('\nReading: ')
 s = cv.FileStorage()
 s.open(filename, cv.FileStorage_READ) 
 n = s.getNode('iterationNr')
 itNr = int(n.real()) 
 print (itNr) 
 if (not s.isOpened()):
 print ('Failed to open ', filename, file=sys.stderr)
 help(argv[0])
 exit(1) 
 n = s.getNode('strings')
 if (not n.isSeq()):
 print ('strings is not a sequence! FAIL', 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 ('Attempt to read NonExisting (should initialize the data structure',
 'with its default).')
 m.read(s.getNode('NonExisting'))
 print ('\nNonExisting =','\n',m) 
 print ('\nTip: Open up',filename,'with a text editor to see the serialized data.') 
if __name__ == '__main__':
 main(sys.argv)

解释

这里我们只讨论 XML 和 YAML 文件输入。您的输出（及其各自的输入）文件可能只有这些扩展名之一，并且结构来自此。它们是可以序列化的两种数据结构：映射（如 STL 映射和 Python 字典）和元素序列（如 STL 向量）。它们之间的区别在于，在地图中，每个元素都有一个唯一的名称，您可以通过访问它的内容。对于序列，您需要遍历它们以查询特定项目。

XML/YAML 文件打开和关闭：

在将任何内容写入此类文件之前，您需要打开它，最后关闭它。OpenCV 中的 XML/YAML 数据结构是 cv：：FileStorage 。要指定文件绑定到硬盘上的此结构，您可以使用其构造函数或以下函数的 open（） 函数：

C++:

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

Python: 

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

您使用的第二个参数中的任何一个都是一个常量，指定您可以对它们执行的操作类型：WRITE、READ 或 APPEND。文件名中指定的扩展名还决定了将使用的输出格式。如果指定扩展名（如 *.xml.gz*），输出甚至可能会被压缩。

当 cv::FileStorage 对象被销毁时，该文件将自动关闭。但是，您可以使用 release 函数显式调用此函数：

C++:

 fs.release(); // explicit close

Python:

 s.release()

文本和数字的输入和输出：

在C++中，数据结构使用 STL 库中的<<输出运算符。在 Python 中，改用 cv：：FileStorage：：write（）。要输出任何类型的数据结构，我们首先需要指定其名称。我们只需将它的名称推送到 C++ 中的流即可做到这一点。在 Python 中，写函数的第一个参数是名称。对于基本类型，您可以按照以下值打印：

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"];

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; // Read 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()

向量（数组）和关联映射的输入/输出：

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

对于第一个元素之前的序列，请打印“[”字符，在最后一个元素之后打印“]”字符。使用 Python 时，调用 where is 或开始编写结构。调用以完成结构：

FileStorage.startWriteStruct(structure_name, struct_type)struct_typecv2.FileNode_MAPcv2.FileNode_SEQFileStorage.endWriteStruct()

c++: 

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

Python: 

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

对于映射，键值是相同的，但是现在我们使用“{”和“}”分隔符：

c++： 

 fs << "Mapping"; // text - 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"]; // 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;

Python: 

 n = s.getNode('strings')
 if (not n.isSeq()):
 print ('strings is not a sequence! FAIL', file=sys.stderr)
 exit(1) 
 for i in range(n.size()):
 print (n.at(i).string())

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

c++：

 n = fs["Mapping"]; // Read mappings from a sequence
 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')

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

C++：

class MyData
{
public:
 MyData() : A(0), X(0), id() {}
public: // Data Members
 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 //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"];
 }

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++ 和python中，需要在类之外添加以下函数定义：

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 的减 1 值。

添加这四个函数后，使用 >> 运算符进行写入，使用 << 运算符进行读取（或为 Python 定义的输入/输出函数）：

C++:

 MyData m(1);
 fs << "MyData" << m; // your own data structures
 fs["MyData"] >> m; // Read your own structure_

Python: 

 m = MyData()
 m.write(s, 'MyData')
 m.read(s.getNode('MyData'))

 或者尝试阅读不存在的读取：

c++:

 cout << "Attempt to read NonExisting (should initialize the data structure with its default).";
 fs["NonExisting"] >> m;
 cout << endl << "NonExisting = " << endl << m << endl;

 Python:

 print ('Attempt to read NonExisting (should initialize the data structure',
 'with its default).')
 m.read(s.getNode('NonExisting'))
 print ('\nNonExisting =','\n',m)

我们可以看到结果：

大多数情况下，我们只是打印出定义的数字。在主机的屏幕上，您可以看到：

Write Done. 
Reading:
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}
 
Attempt to read NonExisting (should initialize the data structure with its default).
NonExisting =
{ id = , X = 0, A = 0} 
Tip: Open up output.xml with a text editor to see the serialized data.

在输出 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

You may observe a runtime instance of this on the YouTube here .

参考文章：

1、《File Input and Output using XML and YAML files》----Bernát Gábor