Add readNet* functions which parse models from byte arrays

modules/dnn/src/caffe/caffe_importer.cpp

@@ -453,6 +453,12 @@ Net readNetFromCaffe(const char *bufferProto, size_t lenProto,
     return net;
 }
 
+Net readNetFromCaffe(const std::vector<char>& bufferProto, const std::vector<char>& bufferModel)
+{
+    return readNetFromCaffe(&bufferProto[0], bufferProto.size(),
+                            bufferModel.empty() ? NULL : &bufferModel[0], bufferModel.size());
+}
+
 #endif //HAVE_PROTOBUF
 
 CV__DNN_EXPERIMENTAL_NS_END

modules/dnn/src/darknet/darknet_importer.cpp

@@ -181,45 +181,71 @@ public:
     }
 };
 
+static Net readNetFromDarknet(std::istream &cfgFile, std::istream &darknetModel)
+{
+    Net net;
+    DarknetImporter darknetImporter(cfgFile, darknetModel);
+    darknetImporter.populateNet(net);
+    return net;
+}
+
+static Net readNetFromDarknet(std::istream &cfgFile)
+{
+    Net net;
+    DarknetImporter darknetImporter(cfgFile);
+    darknetImporter.populateNet(net);
+    return net;
+}
+
 }
 
 Net readNetFromDarknet(const String &cfgFile, const String &darknetModel /*= String()*/)
 {
-    Net net;
     std::ifstream cfgStream(cfgFile.c_str());
-    if(!cfgStream.is_open()) {
+    if (!cfgStream.is_open())
+    {
         CV_Error(cv::Error::StsParseError, "Failed to parse NetParameter file: " + std::string(cfgFile));
-        return net;
     }
-    DarknetImporter darknetImporter;
-    if (darknetModel != String()) {
-        std::ifstream darknetModelStream(darknetModel.c_str());
-        if(!darknetModelStream.is_open()){
+    if (darknetModel != String())
+    {
+        std::ifstream darknetModelStream(darknetModel.c_str(), std::ios::binary);
+        if (!darknetModelStream.is_open())
+        {
             CV_Error(cv::Error::StsParseError, "Failed to parse NetParameter file: " + std::string(darknetModel));
-            return net;
         }
-        darknetImporter = DarknetImporter(cfgStream, darknetModelStream);
-    } else {
-        darknetImporter = DarknetImporter(cfgStream);
+        return readNetFromDarknet(cfgStream, darknetModelStream);
     }
-    darknetImporter.populateNet(net);
-    return net;
+    else
+        return readNetFromDarknet(cfgStream);
 }
 
-Net readNetFromDarknet(const FileNode &cfgFile, const FileNode &darknetModel /*= FileNode()*/)
+struct BufferStream : public std::streambuf
 {
-    DarknetImporter darknetImporter;
-    if(darknetModel.empty()){
-        std::istringstream cfgStream((std::string)cfgFile);
-        darknetImporter = DarknetImporter(cfgStream);
-    }else{
-        std::istringstream cfgStream((std::string)cfgFile);
-        std::istringstream darknetModelStream((std::string)darknetModel);
-        darknetImporter = DarknetImporter(cfgStream, darknetModelStream);
+    BufferStream(const char* s, std::size_t n)
+    {
+        char* ptr = const_cast<char*>(s);
+        setg(ptr, ptr, ptr + n);
     }
-    Net net;
-    darknetImporter.populateNet(net);
-    return net;
+};
+
+Net readNetFromDarknet(const char *bufferCfg, size_t lenCfg, const char *bufferModel, size_t lenModel)
+{
+    BufferStream cfgBufferStream(bufferCfg, lenCfg);
+    std::istream cfgStream(&cfgBufferStream);
+    if (lenModel)
+    {
+        BufferStream weightsBufferStream(bufferModel, lenModel);
+        std::istream weightsStream(&weightsBufferStream);
+        return readNetFromDarknet(cfgStream, weightsStream);
+    }
+    else
+        return readNetFromDarknet(cfgStream);
+}
+
+Net readNetFromDarknet(const std::vector<char>& bufferCfg, const std::vector<char>& bufferModel)
+{
+    return readNetFromDarknet(&bufferCfg[0], bufferCfg.size(),
+                              bufferModel.empty() ? NULL : &bufferModel[0], bufferModel.size());
 }
 
 CV__DNN_EXPERIMENTAL_NS_END

modules/dnn/src/dnn.cpp

@@ -3047,6 +3047,23 @@ Net readNet(const String& _model, const String& _config, const String& _framewor
                                       model + (config.empty() ? "" : ", " + config));
 }
 
+Net readNet(const String& _framework, const std::vector<char>& bufferModel,
+            const std::vector<char>& bufferConfig)
+{
+    String framework = _framework.toLowerCase();
+    if (framework == "caffe")
+        return readNetFromCaffe(bufferConfig, bufferModel);
+    else if (framework == "tensorflow")
+        return readNetFromTensorflow(bufferModel, bufferConfig);
+    else if (framework == "darknet")
+        return readNetFromDarknet(bufferConfig, bufferModel);
+    else if (framework == "torch")
+        CV_Error(Error::StsNotImplemented, "Reading Torch models from buffers");
+    else if (framework == "dldt")
+        CV_Error(Error::StsNotImplemented, "Reading Intel's Model Optimizer models from buffers");
+    CV_Error(Error::StsError, "Cannot determine an origin framework with a name " + framework);
+}
+
 Net readNetFromModelOptimizer(const String &xml, const String &bin)
 {
     return Net::readFromModelOptimizer(xml, bin);

modules/dnn/src/tensorflow/tf_importer.cpp

@@ -1856,5 +1856,11 @@ Net readNetFromTensorflow(const char* bufferModel, size_t lenModel,
     return net;
 }
 
+Net readNetFromTensorflow(const std::vector<char>& bufferModel, const std::vector<char>& bufferConfig)
+{
+    return readNetFromCaffe(&bufferModel[0], bufferModel.size(),
+                            bufferConfig.empty() ? NULL : &bufferConfig[0], bufferConfig.size());
+}
+
 CV__DNN_EXPERIMENTAL_NS_END
 }} // namespace