Caffe3——ImageNet数据集创建lmdb类型的数据

ImageNet数据集和cifar,mnist数据集最大的不同,就是数据量特别大;单张图片尺寸大,训练样本个数多;面对如此大的数据集,在转换成lmdb文件时;使用了很多新的类型对象。

1,动态扩容的数组“vector”,动态地添加新元素

2,pair类型数据对,用于存储成对的对象,例如存储文件名和对应标签

3,利用OpenCV中的图像处理函数,来读取和处理大尺寸图像

一:程序开始

由于要向imageNet数据集中设置resize和是否乱序等参数,所以本文使用gflags命令行解析工具;在Create.sh文件中,调用convert_imageset.bin语句为:

[cpp]  view plain  copy
  1. "code" class="cpp">GLOG_logtostderr=1$TOOLS/convert_imageset \  
  2.     --resize_height=$RESIZE_HEIGHT \  
  3.     --resize_width=$RESIZE_WIDTH \  
  4.     --shuffle \  
  5.     $TRAIN_DATA_ROOT \  图像数据集存放的根目录  
  6. $DATA/train.txt \       图像的ID和对应的分类标签数字  
  7. $EXAMPLE/ilsvrc12_train_lmdb  lmdb文件保存的路径  

 
  由于train.txt文件太大,电脑打不开,故打开val.txt一窥之;val.txt中的某个数据为: 
  

65ILSVRC2012_val_00000002.JPEG ,65应该是对应的标签,后面的是图像的编号id。

二:数据转换流程图

Caffe3——ImageNet数据集创建lmdb类型的数据_第1张图片

Caffe3——ImageNet数据集创建lmdb类型的数据_第2张图片

三:convert_imageset.cpp函数分析

1引入必要的头文件和命名空间

[cpp]  view plain  copy
  1. #include//输出数组的内容、对数组进行升幂排序、反转数组内容、复制数组内容等操作,  
  2. #include   // NOLINT(readability/streams)  
  3. #include   
  4. #include//utility头文件定义了一个pair类型,pair类型用于存储一对数据  
  5. #include//会自动扩展容量的数组  
  6. #include "boost/scoped_ptr.hpp"//智能指针头文件  
  7. #include "gflags/gflags.h"  
  8. #include "glog/logging.h"  
  9. #include"caffe/proto/caffe.pb.h"  
  10. #include "caffe/util/db.hpp" //引入包装好的lmdb操作函数  
  11. #include "caffe/util/io.hpp" //引入opencv中的图像操作函数  
  12. #include "caffe/util/rng.hpp"  
头文件和convert_cifar_data.cpp的区别:

1,引入gflags命令行解析工具;

2,引入utility头文件,里面提供了数组洗牌等操作

[cpp]  view plain  copy
  1. using namespace caffe;  // NOLINT(build/namespaces)  
  2. using std::pair;  
  3. using boost::scoped_ptr;  
命名空间区别:

1,引入全部caffe命名空间

2,引入pair对命名空间

2 gflags宏定义参数

//通过gflags宏定义一些程序的参数变量

[cpp]  view plain  copy
  1. DEFINE_bool(gray, false,"When thisoption is on, treat images as grayscale ones");//是否为灰度图片  
  2. DEFINE_bool(shuffle, false,"Randomlyshuffle the order of images and their labels");//定义洗牌变量,是否随机打乱数据集的顺序  
  3. DEFINE_string(backend, "lmdb","The backend {lmdb, leveldb} for storing the result");//默认转换的数据类型  
  4. DEFINE_int32(resize_width, 0, "Width images areresized to");//定义resize的尺寸,默认为0,不转换尺寸  
  5. DEFINE_int32(resize_height, 0, "Height imagesare resized to");  
  6. DEFINE_bool(check_size, false,"When this optionis on, check that all the datum have the samesize");  
  7. DEFINE_bool(encoded, false,"When this option ison, the encoded image will be save in datum");//用于转换数据格式的  
  8. DEFINE_string(encode_type, "","Optional:What type should we encode the image as ('png','jpg',...).");//要转换的数据格式  

3 main()函数

没有想cifar和mnist的main函数,通过调用convert_data()函数来转换数据,而是直接在main函数内完成了所有数据转换代码。

3.1 通过gflags宏定义接收命令行中传入的参数

[cpp]  view plain  copy
  1. const boolis_color = !FLAGS_gray;  //通过gflags把宏定义变量的值,赋值给常值变量  
  2. const boolcheck_size = FLAGS_check_size; //检查图像的size  
  3. const boolencoded = FLAGS_encoded;//是否编译(转换)图像格式  
  4. const stringencode_type = FLAGS_encode_type;//要编译的图像格式  
3.2读取源数据

3.2.1创建读取对象变量

std::ifstream infile(argv[2]);//创建指向train.txt文件的文件读入流

std::vector > lines;//定义向量变量,向量中每个元素为一个pair对,pair对有两个成员变量,一个为string类型,一个为int类型;其中string类型用于存储文件名,int类型,感觉用于存数对应类别的id

如val.txt中前几个字符为“ILSVRC2012_val_00000001.JPEG65ILSVRC2012_val_00000002.JPEG”;感觉这个string= ILSVRC2012_val_00000001.JPEG   int=65

std::stringfilename;

int label;

3.2.2 读取数据

  //下面一条while语句是把train.txt文件中存放的所有文件名和标签,都存放到vextor类型变量lines中;lines中存放图片的名字和对应的标签,不存储真正的图片数据

[cpp]  view plain  copy
  1. while (infile>> filename >> label) {  
  2. nes.push_back(std::make_pair(filename, label));  
//make_pair是pair模板中定义的给pair对象赋值的函数,push_back()函数是vector对象的一个成员函数,用来在末端添加新元素}

3.3判断是否进行洗牌操作

[cpp]  view plain  copy
  1. if(FLAGS_shuffle) {  
  2.   // randomlyshuffle data  
  3.   LOG(INFO)<< "Shuffling data";  
[cpp]  view plain  copy
  1. "font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);">//洗牌函数,使用随机生成器g对元素[first,last)容器内部元素进行随机排列  

 shuffle(lines.begin(), lines.end());//vector.begin() - 回传一个Iterator迭代器,它指向 vector 第一个元素。}

3.4以智能指针的方式创建db::DB类型的对象 db

[cpp]  view plain  copy
  1. scoped_ptrdb(db::GetDB(FLAGS_backend));  
  2. //智能指针的创建方式类似泛型的格式,上面通过db.cpp内定义的命名的子命名空间中db的“成员函数”GetDB函数来初始化db对象  
  3. db->Open(argv[3], db::NEW);//argv[3]的文件夹下创建并打开lmdb的操作环境  
  4. scoped_ptrtxn(db->NewTransaction());//创建lmdb文件的操作句柄  

3.5 源数据中提取图像数据

3.5.1 通过ReadImageToDatum函数把图像数据读取到datum中

//到源数据位置读取每张图片的数据。(../imagenet/xxx.jpeg,65,256,256,true,jpeg,&datum)

[cpp]  view plain  copy
  1. status= ReadImageToDatum(root_folder + lines[line_id].first,lines[line_id].second, resize_height,resize_width, is_color,enc, &datum); //把图像数据读取到datum中  
3.5.2  ReadImageToDatum函数说明

ReadImageToDatum函数为io.cpp文件中定义的函数;io.cpp主要实现了3部分功能:

1,从text文件或者二进制文件中读写proto文件;

2,利用opencv的Mat矩阵,把图像数据读到Mat矩阵中;

3,把Mat矩阵中的值放入到datum中

3.5.3 检查数据尺寸

[cpp]  view plain  copy
  1. if (check_size) {//检查图片尺寸  
  2.       if (!data_size_initialized) {//若data_size_initialized没有初始化  
  3.         data_size = datum.channels() *datum.height() * datum.width();  
  4.         data_size_initialized = true;  
  5.       } else {  
  6.         const std::string& data =datum.data();  
  7.         CHECK_EQ(data.size(), data_size)<< "Incorrect data field size "<< data.size();  
  8.       }  

3.6   序列化键和值并放入临时数据库

[cpp]  view plain  copy
  1. // sequential  
  2. intlength = snprintf(key_cstr, kMaxKeyLength, "%08d_%s", line_id,lines[line_id].first.c_str());//若line_id=1234,lines[line_id].first=“abc.jpeg” 则 key_str=00001234_abc.jpeg,length=00001234_abc.jpeg字符串的长度  
  3.     // Put in db  
  4.  string out;  
  5.     CHECK(datum.SerializeToString(&out));//datum数据,序列化到字符串中  
  6.     txn->Put(string(key_cstr, length), out);//把键值对放入到数据库  
3.7 批量提交到lmdb文件

[cpp]  view plain  copy
  1. if (++count % 1000 == 0) {  
  2.       // Commit db  
  3.       txn->Commit();//保存到lmdb类型的文件  
  4.       txn.reset(db->NewTransaction());//重新初始化操作句柄  
  5.       LOG(ERROR) << "Processed" << count << " files.";  
  6.     }  

四,相关文件

4.1 Convert_imageset.cpp文件

[cpp]  view plain  copy
  1. // This program converts a set of images to a lmdb/leveldb by storing them  
  2. // as Datum proto buffers.  
  3. // Usage:  
  4. //   convert_imageset [FLAGS] ROOTFOLDER/ LISTFILE DB_NAME  
  5. //  
  6. // where ROOTFOLDER is the root folder that holds all the images, and LISTFILE  
  7. // should be a list of files as well as their labels, in the format as  
  8. //   subfolder1/file1.JPEG 7  
  9. //   ....  
  10.   
  11. #include //输出数组的内容、对数组进行升幂排序、反转数组内容、复制数组内容等操作,  
  12. #include   // NOLINT(readability/streams)  
  13. #include   
  14. #include //utility头文件定义了一个pair类型  
  15. #include //会自动扩展容量的数组  
  16.   
  17. #include "boost/scoped_ptr.hpp"  
  18. #include "gflags/gflags.h"  
  19. #include "glog/logging.h"  
  20.   
  21. #include "caffe/proto/caffe.pb.h"  
  22. #include "caffe/util/db.hpp"  
  23. #include "caffe/util/io.hpp"  
  24. #include "caffe/util/rng.hpp"  
  25.   
  26. using namespace caffe;  // NOLINT(build/namespaces)  
  27. using std::pair;  
  28. using boost::scoped_ptr;  
  29.   
  30.   
  31. //通过gflags宏定义一些程序的参数变量  
  32. DEFINE_bool(gray, false,  
  33.     "When this option is on, treat images as grayscale ones");  
  34. DEFINE_bool(shuffle, false,  
  35.     "Randomly shuffle the order of images and their labels");//洗牌,随机打乱数据集的顺序  
  36. DEFINE_string(backend, "lmdb",  
  37.         "The backend {lmdb, leveldb} for storing the result");  
  38. DEFINE_int32(resize_width, 0, "Width images are resized to");  
  39. DEFINE_int32(resize_height, 0, "Height images are resized to");  
  40. DEFINE_bool(check_size, false,  
  41.     "When this option is on, check that all the datum have the same size");  
  42. DEFINE_bool(encoded, false,  
  43.     "When this option is on, the encoded image will be save in datum");//用于转换数据格式的  
  44. DEFINE_string(encode_type, "",  
  45.     "Optional: What type should we encode the image as ('png','jpg',...).");//要转换的数据格式  
  46.   
  47. int main(int argc, char** argv) {  
  48.   ::google::InitGoogleLogging(argv[0]);  
  49.   
  50. #ifndef GFLAGS_GFLAGS_H_  
  51.   namespace gflags = google;  
  52. #endif  
  53.   
  54.   gflags::SetUsageMessage("Convert a set of images to the leveldb/lmdb\n"  
  55.         "format used as input for Caffe.\n"  
  56.         "Usage:\n"  
  57.         "    convert_imageset [FLAGS] ROOTFOLDER/ LISTFILE DB_NAME\n"  
  58.         "The ImageNet dataset for the training demo is at\n"  
  59.         "    http://www.image-net.org/download-images\n");  
  60.   gflags::ParseCommandLineFlags(&argc, &argv, true);  
  61.   
  62.   if (argc < 4) {  
  63.     gflags::ShowUsageWithFlagsRestrict(argv[0], "tools/convert_imageset");  
  64.     return 1;  
  65.   }  
  66.   //arg[1] 训练集存放的地址,arg[2] train.txt(估计是训练集中所有图片的文件名称),arg[3] 要保存的文件名称xxlmdb  
  67.   const bool is_color = !FLAGS_gray;  //通过gflags把宏定义变量的值,赋值给常值变量  
  68.   const bool check_size = FLAGS_check_size; //检查图像的size  
  69.   const bool encoded = FLAGS_encoded;//是否编译(转换)图像格式  
  70.   const string encode_type = FLAGS_encode_type;//要编译的图像格式  
  71.   
  72.   std::ifstream infile(argv[2]);//定义指向train.txt数据文件的文件读入流  
  73.   std::vectorint> > lines;//定义向量变量,向量中每个元素为一个pair对,pair对有两个成员变量,一个为string类型,一个为int类型  
  74.   std::string filename;  
  75.   int label;  
  76.   //下面一条while语句是把train.txt文件中存数的数据和标签,都存放到vextor类型变量中lines中;lines中存放图片的名字和对应的标签,不存储真正的图片数据  
  77.   while (infile >> filename >> label) {  
  78.     lines.push_back(std::make_pair(filename, label));//make_pair是pair模板中定义的给pair对象赋值的函数,push_back()函数是vector对象的一个成员函数,用来在末端添加新元素  
  79.   }  
  80.   if (FLAGS_shuffle) {  
  81.     // randomly shuffle data  
  82.     LOG(INFO) << "Shuffling data";  
  83.     //洗牌函数,使用随机生成器g对元素[first, last)容器内部元素进行随机排列  
  84.     shuffle(lines.begin(), lines.end());//vector.begin() - 回传一个Iterator迭代器,它指向 vector 第一个元素。  
  85.   }  
  86.   LOG(INFO) << "A total of " << lines.size() << " images.";  
  87.   
  88.   if (encode_type.size() && !encoded)  
  89.     LOG(INFO) << "encode_type specified, assuming encoded=true.";  
  90.   
  91.   int resize_height = std::max<int>(0, FLAGS_resize_height);  
  92.   int resize_width = std::max<int>(0, FLAGS_resize_width);  
  93.   
  94.   // Create new DB  
  95.   scoped_ptr db(db::GetDB(FLAGS_backend));  
  96.   db->Open(argv[3], db::NEW);//argv[3]的文件夹下打开创建lmdb的操作环境  
  97.   scoped_ptr txn(db->NewTransaction());//创建lmdb文件的操作句柄  
  98.   
  99.   // Storing to db  
  100.   std::string root_folder(argv[1]);//把源数据文件的地址复制给root_folder  
  101.   Datum datum;//声明数据“转换”对象  
  102.   int count = 0;  
  103.   const int kMaxKeyLength = 256;  
  104.   char key_cstr[kMaxKeyLength];  
  105.   int data_size = 0;  
  106.   bool data_size_initialized = false;  
  107.   
  108.   for (int line_id = 0; line_id < lines.size(); ++line_id) {  
  109.     bool status;  
  110.     std::string enc = encode_type; //enc为空串,则enc.size()=false;否则为true  
  111.     if (encoded && !enc.size()) {  
  112.       // Guess the encoding type from the file name  
  113.       string fn = lines[line_id].first;//把图像的文件名赋值给fn(filename)  
  114.       size_t p = fn.rfind('.');//rfind函数的返回值是一个整形的索引值,直线要查找的字符在字符串中的位置;若没有找到,返回string::npos  
  115.       if ( p == fn.npos )  
  116.         LOG(WARNING) << "Failed to guess the encoding of '" << fn << "'";  
  117.       enc = fn.substr(p);//找到了,就截取文件名”.“后面的字符串,以获得图像格式字符串  
  118.       std::transform(enc.begin(), enc.end(), enc.begin(), ::tolower);//将enc字符串转换成小写  
  119.     }  
  120.     //到源数据位置,以此读取每张图片的数据。(../imagenet/xxx.jpeg,65,256,256,true,jpeg,&datum)  
  121.     status = ReadImageToDatum(root_folder + lines[line_id].first,  
  122.         lines[line_id].second, resize_height, resize_width, is_color,enc, &datum);  //把图像数据读取到datum中  
  123.     if (status == falsecontinue;//status=false,说明此张图片读取错误;“跳过”继续下一张  
  124.     if (check_size) {//检查图片尺寸  
  125.       if (!data_size_initialized) {//若data_size_initialized没有初始化  
  126.         data_size = datum.channels() * datum.height() * datum.width();  
  127.         data_size_initialized = true;  
  128.       } else {  
  129.         const std::string& data = datum.data();  
  130.         CHECK_EQ(data.size(), data_size) << "Incorrect data field size "  
  131.             << data.size();  
  132.       }  
  133.     }  
  134.     // sequential  
  135.     int length = snprintf(key_cstr, kMaxKeyLength, "%08d_%s", line_id,   
  136.         lines[line_id].first.c_str());//若line_id=1234,lines[line_id].first=“abc.jpeg” 则 key_str=00001234_abc.jpeg,length=00001234_abc.jpeg字符串的长度  
  137.   
  138.     // Put in db  
  139.     string out;  
  140.     CHECK(datum.SerializeToString(&out));//datum数据,序列化到字符串中  
  141.     txn->Put(string(key_cstr, length), out);//把键值对放入到数据库  
  142.   
  143.     if (++count % 1000 == 0) {  
  144.       // Commit db  
  145.       txn->Commit();//保存到lmdb类型的文件  
  146.       txn.reset(db->NewTransaction());//重新初始化操作句柄  
  147.       LOG(ERROR) << "Processed " << count << " files.";  
  148.     }  
  149.   }  
  150.   // write the last batch  
  151.   if (count % 1000 != 0) {  
  152.     txn->Commit();  
  153.     LOG(ERROR) << "Processed " << count << " files.";  
  154.   }  
  155.   return 0;  
  156. }  
4.2 io.cpp文件

[cpp]  view plain  copy
  1. #include   
  2. #include   
  3. #include   
  4. #include   
  5. #include   
  6. #include   
  7. #include   
  8. #include   
  9. #include   
  10.   
  11. #include   
  12. #include   // NOLINT(readability/streams)  
  13. #include   
  14. #include   
  15.   
  16. #include "caffe/common.hpp"  
  17. #include "caffe/proto/caffe.pb.h"  
  18. #include "caffe/util/io.hpp"  
  19.   
  20. const int kProtoReadBytesLimit = INT_MAX;  // Max size of 2 GB minus 1 byte.  
  21.   
  22. namespace caffe {  
  23.   
  24. using google::protobuf::io::FileInputStream;//文件输入流  
  25. using google::protobuf::io::FileOutputStream;//文件输出流  
  26. using google::protobuf::io::ZeroCopyInputStream;//These interfaces are different from classic I/O streams in that they try to minimize the amount of data copying that needs to be done  
  27. using google::protobuf::io::CodedInputStream;  
  28. using google::protobuf::io::ZeroCopyOutputStream;  
  29. using google::protobuf::io::CodedOutputStream;  
  30. using google::protobuf::Message;  
  31.   
  32. bool ReadProtoFromTextFile(const char* filename, Message* proto) {//从文本文件中读入proto文件  
  33.   int fd = open(filename, O_RDONLY);  
  34.   CHECK_NE(fd, -1) << "File not found: " << filename;  
  35.   FileInputStream* input = new FileInputStream(fd);  
  36.   bool success = google::protobuf::TextFormat::Parse(input, proto);  
  37.   delete input;  
  38.   close(fd);  
  39.   return success;  
  40. }  
  41.   
  42. void WriteProtoToTextFile(const Message& proto, const char* filename) {//想文本文件中写入proto文件  
  43.   int fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0644);  
  44.   FileOutputStream* output = new FileOutputStream(fd);  
  45.   CHECK(google::protobuf::TextFormat::Print(proto, output));  
  46.   delete output;  
  47.   close(fd);  
  48. }  
  49.   
  50. bool ReadProtoFromBinaryFile(const char* filename, Message* proto) {//从二进制文件读入proto  
  51.   int fd = open(filename, O_RDONLY);  
  52.   CHECK_NE(fd, -1) << "File not found: " << filename;  
  53.   ZeroCopyInputStream* raw_input = new FileInputStream(fd);  
  54.   CodedInputStream* coded_input = new CodedInputStream(raw_input);  
  55.   coded_input->SetTotalBytesLimit(kProtoReadBytesLimit, 536870912);  
  56.   
  57.   bool success = proto->ParseFromCodedStream(coded_input);  
  58.   
  59.   delete coded_input;  
  60.   delete raw_input;  
  61.   close(fd);  
  62.   return success;  
  63. }  
  64.   
  65. void WriteProtoToBinaryFile(const Message& proto, const char* filename) {//把proto写入二进制文件中  
  66.   fstream output(filename, ios::out | ios::trunc | ios::binary);  
  67.   CHECK(proto.SerializeToOstream(&output));  
  68. }  
  69.   
  70.   
  71. //基本上讲 Mat 是一个类,由两个数据部分组成:矩阵头(包含矩阵尺寸,存储方法,存储地址等信息)和  
  72. //一个指向存储所有像素值的矩阵的指针(根据所选存储方法的不同矩阵可以是不同的维数)。  
  73. //矩阵头的尺寸是常数值,但矩阵本身的尺寸会依图像的不同而不同,通常比矩阵头的尺寸大数个数量级。因此,当在程序中传递图像并创建拷贝时,  
  74. //大的开销是由矩阵造成的,而不是信息头。OpenCV是一个图像处理库,囊括了大量的图像处理函数,为了解决问题通常要使用库中的多个函数,  
  75. //因此在函数中传递图像是家常便饭。同时不要忘了我们正在讨论的是计算量很大的图像处理算法,因此,除非万不得已,我们不应该拷贝 大 的图像,因为这会降低程序速度。  
  76. cv::Mat ReadImageToCVMat(const string& filename,  
  77.     const int height, const int width, const bool is_color) {//读取图片到CVMat中,cv::Mat ,Mat数据结构式opencv2.0以后的特定的数据类型  
  78.   cv::Mat cv_img;  
  79.   int cv_read_flag = (is_color ? CV_LOAD_IMAGE_COLOR :  
  80.     CV_LOAD_IMAGE_GRAYSCALE);  
  81.   cv::Mat cv_img_origin = cv::imread(filename, cv_read_flag);//读取图片内容  
  82.   if (!cv_img_origin.data) {  
  83.     LOG(ERROR) << "Could not open or find file " << filename;  
  84.     return cv_img_origin;  
  85.   }  
  86.   if (height > 0 && width > 0) {  
  87.     cv::resize(cv_img_origin, cv_img, cv::Size(width, height));  
  88.   } else {  
  89.     cv_img = cv_img_origin;  
  90.   }  
  91.   return cv_img;  
  92. }  
  93.   
  94. cv::Mat ReadImageToCVMat(const string& filename,//读取图片到CVMat中,重载1  
  95.     const int height, const int width) {  
  96.   return ReadImageToCVMat(filename, height, width, true);  
  97. }  
  98.   
  99. cv::Mat ReadImageToCVMat(const string& filename,//读取图片到CVMat中,重载2  
  100.     const bool is_color) {  
  101.   return ReadImageToCVMat(filename, 0, 0, is_color);  
  102. }  
  103.   
  104. cv::Mat ReadImageToCVMat(const string& filename) {//读取图片到CVMat中,重载3  
  105.   return ReadImageToCVMat(filename, 0, 0, true);  
  106. }  
  107. // Do the file extension and encoding match?  
  108. static bool matchExt(const std::string & fn, //匹配拓展名称?  
  109.                      std::string en) {  
  110.   size_t p = fn.rfind('.');//查找"."字符,若找到则返回“.”在字符串中的位置,找不到则返回npos  
  111.   std::string ext = p != fn.npos ? fn.substr(p) : fn;//如果字符串fn中存在".“,则截取字符串p  
  112.   std::transform(ext.begin(), ext.end(), ext.begin(), ::tolower);//把ext变成小写  
  113.   std::transform(en.begin(), en.end(), en.begin(), ::tolower);  
  114.   if ( ext == en )  
  115.     return true;  
  116.   if ( en == "jpg" && ext == "jpeg" )  
  117.     return true;  
  118.   return false;  
  119. }  
  120.   
  121. bool ReadImageToDatum(const string& filename, const int label,//把图片读到 Datum中  
  122.     const int height, const int width, const bool is_color,  
  123.     const std::string & encoding, Datum* datum) {  
  124.   cv::Mat cv_img = ReadImageToCVMat(filename, height, width, is_color);//先把数据读到cv::Mat类型矩阵中  
  125.   if (cv_img.data) {//Mat矩阵中数据指针Mat.data是uchar类型指针,矩阵中的元素应该是uchar类型;该语句是判断cv_img中是否有数据  
  126.     if (encoding.size()) {//是否需要编码  
  127.       if ( (cv_img.channels() == 3) == is_color && !height && !width &&  
  128.           matchExt(filename, encoding) )  
  129.         return ReadFileToDatum(filename, label, datum);  
  130.   
  131.       std::vector buf;  
  132.       cv::imencode("."+encoding, cv_img, buf);//感觉这行代码的作用是把cv_img中的值赋值给buf  
  133.       datum->set_data(std::string(reinterpret_cast<char*>(&buf[0]),  
  134.                       buf.size()));  
  135.       datum->set_label(label);  
  136.       datum->set_encoded(true);//感觉是一种编码函数  
  137.       return true;  
  138.     }  
  139.     CVMatToDatum(cv_img, datum);  
  140.     datum->set_label(label);  
  141.     return true;  
  142.   } else {  
  143.     return false;  
  144.   }  
  145. }  
  146.   
  147. bool ReadFileToDatum(const string& filename, const int label,  
  148.     Datum* datum) {  
  149.   std::streampos size;  
  150.   
  151.   fstream file(filename.c_str(), ios::in|ios::binary|ios::ate);  
  152.   if (file.is_open()) {  
  153.     size = file.tellg();  
  154.     std::string buffer(size, ' ');  
  155.     file.seekg(0, ios::beg);  
  156.     file.read(&buffer[0], size);  
  157.     file.close();  
  158.     datum->set_data(buffer);  
  159.     datum->set_label(label);  
  160.     datum->set_encoded(true);  
  161.     return true;  
  162.   } else {  
  163.     return false;  
  164.   }  
  165. }  
  166.   
  167. cv::Mat DecodeDatumToCVMatNative(const Datum& datum) {  
  168.   cv::Mat cv_img;  
  169.   CHECK(datum.encoded()) << "Datum not encoded";  
  170.   const string& data = datum.data();  
  171.   std::vector<char> vec_data(data.c_str(), data.c_str() + data.size());  
  172.   cv_img = cv::imdecode(vec_data, -1);  
  173.   if (!cv_img.data) {  
  174.     LOG(ERROR) << "Could not decode datum ";  
  175.   }  
  176.   return cv_img;  
  177. }  
  178. cv::Mat DecodeDatumToCVMat(const Datum& datum, bool is_color) {  
  179.   cv::Mat cv_img;  
  180.   CHECK(datum.encoded()) << "Datum not encoded";  
  181.   const string& data = datum.data();  
  182.   std::vector<char> vec_data(data.c_str(), data.c_str() + data.size());  
  183.   int cv_read_flag = (is_color ? CV_LOAD_IMAGE_COLOR :  
  184.     CV_LOAD_IMAGE_GRAYSCALE);  
  185.   cv_img = cv::imdecode(vec_data, cv_read_flag);  
  186.   if (!cv_img.data) {  
  187.     LOG(ERROR) << "Could not decode datum ";  
  188.   }  
  189.   return cv_img;  
  190. }  
  191.   
  192. // If Datum is encoded will decoded using DecodeDatumToCVMat and CVMatToDatum  
  193. // If Datum is not encoded will do nothing  
  194. bool DecodeDatumNative(Datum* datum) {  
  195.   if (datum->encoded()) {  
  196.     cv::Mat cv_img = DecodeDatumToCVMatNative((*datum));  
  197.     CVMatToDatum(cv_img, datum);  
  198.     return true;  
  199.   } else {  
  200.     return false;  
  201.   }  
  202. }  
  203. bool DecodeDatum(Datum* datum, bool is_color) {  
  204.   if (datum->encoded()) {  
  205.     cv::Mat cv_img = DecodeDatumToCVMat((*datum), is_color);  
  206.     CVMatToDatum(cv_img, datum);  
  207.     return true;  
  208.   } else {  
  209.     return false;  
  210.   }  
  211. }  
  212.   
  213. void CVMatToDatum(const cv::Mat& cv_img, Datum* datum) {  
  214.   CHECK(cv_img.depth() == CV_8U) << "Image data type must be unsigned byte";  
  215.   datum->set_channels(cv_img.channels());  
  216.   datum->set_height(cv_img.rows);  
  217.   datum->set_width(cv_img.cols);  
  218.   datum->clear_data();  
  219.   datum->clear_float_data();  
  220.   datum->set_encoded(false);  
  221.   int datum_channels = datum->channels();  
  222.   int datum_height = datum->height();  
  223.   int datum_width = datum->width();  
  224.   int datum_size = datum_channels * datum_height * datum_width;  
  225.   std::string buffer(datum_size, ' ');  
  226.   for (int h = 0; h < datum_height; ++h) {  
  227.     const uchar* ptr = cv_img.ptr(h);  
  228.     int img_index = 0;  
  229.     for (int w = 0; w < datum_width; ++w) {  
  230.       for (int c = 0; c < datum_channels; ++c) {  
  231.         int datum_index = (c * datum_height + h) * datum_width + w;  
  232.         buffer[datum_index] = static_cast<char>(ptr[img_index++]);  
  233.       }  
  234.     }  
  235.   }  
  236.   datum->set_data(buffer);  
  237. }  
  238. 。。。。。  
五, 以上代码注释为个人理解,如有遗漏,错误还望大家多多交流,指正,以便共同学习,进步!!

你可能感兴趣的:(Caffe3——ImageNet数据集创建lmdb类型的数据)