Chiebot-Mirror
/
opencv_contrib
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Added binary .caffemodel import support.

Browse Source 
Some changes in API.
Caffe source files was cleared from unnecessary code.
pull/265/head
Vitaliy Lyudvichenko 10 years ago
parent 6e23d93b39
commit 77321e3ad6
10 changed files with 261 additions and 349 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 42
      modules/dnn/include/opencv2/dnn.hpp
  2. 0
      modules/dnn/include/opencv2/dnn/dict.hpp
  3. 37
      modules/dnn/include/opencv2/dnn/dnn.inl.hpp
  4. 134
      modules/dnn/src/caffe/common.hpp
  5. 59
      modules/dnn/src/caffe/glog_emulator.hpp
  6. 165
      modules/dnn/src/caffe/io.cpp
  7. 12
      modules/dnn/src/caffe/util/io.hpp
  8. 101
      modules/dnn/src/caffe_importer.cpp
  9. 43
      modules/dnn/src/dnn.cpp
  10. 17
      modules/dnn/test/test_caffe_importer.cpp

42
modules/dnn/include/opencv2/dnn.hpp
Unescape View File

@ -4,7 +4,7 @@
#include <opencv2/core.hpp>
#include <map>
#include <vector>
#include "dict.hpp"
#include "dnn/dict.hpp"
namespace cv
{
@ -25,29 +25,37 @@ namespace dnn
Blob();
Blob(InputArray in);
void fill(InputArray in);
void fill(int ndims, const int *sizes, int type, void *data, bool deepCopy = true);
void create(int ndims, const int *sizes, int type = CV_32F);
bool empty() const;
int width() const; //cols
int height() const; //rows
Mat& getMatRef();
const Mat& getMatRef() const;
Mat getMat();
Mat getMat(int num, int channel);
int cols() const;
int rows() const;
Size size() const;
int channels() const;
int num() const;
Vec4i size() const;
Vec4i shape() const;
};
CV_EXPORTS class LayerParams : public Dict
{
public:
std::vector<Blob> learnedWeights;
std::vector<Blob> learnedBlobs;
};
//this class allows to build new Layers
CV_EXPORTS class Layer
CV_EXPORTS class LayerRegister
{
public:
//Layer registration routines
typedef Layer* (*Constuctor)();
@ -57,6 +65,16 @@ namespace dnn
static Ptr<Layer> createLayerInstance(const String &type);
private:
LayerRegister();
LayerRegister(const LayerRegister &lr);
static std::map<String, Constuctor> registeredLayers;
};
//this class allows to build new Layers
CV_EXPORTS class Layer
{
public:
//TODO: this field must be declared as public if we want support possibility to change these params in runtime
@ -79,10 +97,6 @@ namespace dnn
virtual void adjustShape(const std::vector<Blob> &inputs, std::vector<Blob> &outputs);
virtual void forward(std::vector<Blob> &inputs, std::vector<Blob> &outputs);
private:
static std::map<String, Constuctor> registeredLayers;
};
//TODO: divide NetConfiguration interface and implementation, hide internal data
@ -157,4 +171,6 @@ namespace dnn
}
}
#include "dnn/dnn.inl.hpp"
#endif

0
modules/dnn/include/opencv2/dict.hpp → modules/dnn/include/opencv2/dnn/dict.hpp
Unescape View File

37
modules/dnn/include/opencv2/dnn/dnn.inl.hpp
Unescape View File

@ -0,0 +1,37 @@
#ifndef __OPENCV_DNN_INL_HPP__
#define __OPENCV_DNN_INL_HPP__
#include <opencv2/dnn.hpp>
namespace cv
{
namespace dnn
{
inline
Mat& Blob::getMatRef()
{
return m;
}
inline
const Mat& Blob::getMatRef() const
{
return m;
}
inline
Mat Blob::getMat()
{
return m;
}
Mat Blob::getMat(int num, int channel)
{
CV_Assert(false);
return Mat();
}
}
}
#endif

134
modules/dnn/src/caffe/common.hpp
Unescape View File

@ -3,10 +3,8 @@
#include <opencv2/core.hpp>
#include <iostream>
#define CHECK CV_Assert
#define LOG(WHERE) std::cerr
//#include <boost/shared_ptr.hpp>
#include "glog_emulator.hpp"
//#include <gflags/gflags.h>
//#include <glog/logging.h>
@ -21,63 +19,18 @@
#include <utility> // pair
#include <vector>
//#include "caffe/util/device_alternate.hpp"
//
//// gflags 2.1 issue: namespace google was changed to gflags without warning.
//// Luckily we will be able to use GFLAGS_GFLAGS_H_ to detect if it is version
//// 2.1. If yes, we will add a temporary solution to redirect the namespace.
//// TODO(Yangqing): Once gflags solves the problem in a more elegant way, let's
//// remove the following hack.
//#ifndef GFLAGS_GFLAGS_H_
//namespace gflags = google;
//#endif // GFLAGS_GFLAGS_H_
//
//// Disable the copy and assignment operator for a class.
//#define DISABLE_COPY_AND_ASSIGN(classname) \
//private:\
// classname(const classname&);\
// classname& operator=(const classname&)
//
//// Instantiate a class with float and double specifications.
//#define INSTANTIATE_CLASS(classname) \
// char gInstantiationGuard##classname; \
// template class classname<float>; \
// template class classname<double>
//
//#define INSTANTIATE_LAYER_GPU_FORWARD(classname) \
// template void classname<float>::Forward_gpu( \
// const std::vector<Blob<float>*>& bottom, \
// const std::vector<Blob<float>*>& top); \
// template void classname<double>::Forward_gpu( \
// const std::vector<Blob<double>*>& bottom, \
// const std::vector<Blob<double>*>& top);
//
//#define INSTANTIATE_LAYER_GPU_BACKWARD(classname) \
// template void classname<float>::Backward_gpu( \
// const std::vector<Blob<float>*>& top, \
// const std::vector<bool>& propagate_down, \
// const std::vector<Blob<float>*>& bottom); \
// template void classname<double>::Backward_gpu( \
// const std::vector<Blob<double>*>& top, \
// const std::vector<bool>& propagate_down, \
// const std::vector<Blob<double>*>& bottom)
//
//#define INSTANTIATE_LAYER_GPU_FUNCS(classname) \
// INSTANTIATE_LAYER_GPU_FORWARD(classname); \
// INSTANTIATE_LAYER_GPU_BACKWARD(classname)
//
//// A simple macro to mark codes that are not implemented, so that when the code
//// is executed we will see a fatal log.
//#define NOT_IMPLEMENTED LOG(FATAL) << "Not Implemented Yet"
//
//// See PR #1236
//namespace cv { class Mat; }
//
//namespace caffe {
//
//// We will use the boost shared_ptr instead of the new C++11 one mainly
//// because cuda does not work (at least now) well with C++11 features.
//using boost::shared_ptr;
namespace caffe {
// Common functions and classes from std that caffe often uses.
using std::fstream;
@ -94,84 +47,5 @@ using std::string;
using std::stringstream;
using std::vector;
//// A global initialization function that you should call in your main function.
//// Currently it initializes google flags and google logging.
//void GlobalInit(int* pargc, char*** pargv);
//
//// A singleton class to hold common caffe stuff, such as the handler that
//// caffe is going to use for cublas, curand, etc.
//class Caffe {
// public:
// ~Caffe();
// inline static Caffe& Get() {
// if (!singleton_.get()) {
// singleton_.reset(new Caffe());
// }
// return *singleton_;
// }
// enum Brew { CPU, GPU };
//
// // This random number generator facade hides boost and CUDA rng
// // implementation from one another (for cross-platform compatibility).
// class RNG {
// public:
// RNG();
// explicit RNG(unsigned int seed);
// explicit RNG(const RNG&);
// RNG& operator=(const RNG&);
// void* generator();
// private:
// class Generator;
// shared_ptr<Generator> generator_;
// };
//
// // Getters for boost rng, curand, and cublas handles
// inline static RNG& rng_stream() {
// if (!Get().random_generator_) {
// Get().random_generator_.reset(new RNG());
// }
// return *(Get().random_generator_);
// }
//#ifndef CPU_ONLY
// inline static cublasHandle_t cublas_handle() { return Get().cublas_handle_; }
// inline static curandGenerator_t curand_generator() {
// return Get().curand_generator_;
// }
//#endif
//
// // Returns the mode: running on CPU or GPU.
// inline static Brew mode() { return Get().mode_; }
// // The setters for the variables
// // Sets the mode. It is recommended that you don't change the mode halfway
// // into the program since that may cause allocation of pinned memory being
// // freed in a non-pinned way, which may cause problems - I haven't verified
// // it personally but better to note it here in the header file.
// inline static void set_mode(Brew mode) { Get().mode_ = mode; }
// // Sets the random seed of both boost and curand
// static void set_random_seed(const unsigned int seed);
// // Sets the device. Since we have cublas and curand stuff, set device also
// // requires us to reset those values.
// static void SetDevice(const int device_id);
// // Prints the current GPU status.
// static void DeviceQuery();
//
// protected:
//#ifndef CPU_ONLY
// cublasHandle_t cublas_handle_;
// curandGenerator_t curand_generator_;
//#endif
// shared_ptr<RNG> random_generator_;
//
// Brew mode_;
// static shared_ptr<Caffe> singleton_;
//
// private:
// // The private constructor to avoid duplicate instantiation.
// Caffe();
//
// DISABLE_COPY_AND_ASSIGN(Caffe);
//};
//
//} // namespace caffe
//
} // namespace caffe
#endif // CAFFE_COMMON_HPP_

59
modules/dnn/src/caffe/glog_emulator.hpp
Unescape View File

@ -0,0 +1,59 @@
#pragma once
#include <stdlib.h>
#include <iostream>
#include <opencv2/core.hpp>
#define CHECK(cond) cv::GLogWrapper(__FILE__, CV_Func, __LINE__, "CHECK", #cond, cond)
#define CHECK_EQ(a, b) cv::GLogWrapper(__FILE__, CV_Func, __LINE__, "CHECK", #a #b, ((a) == (b)))
#define LOG(TYPE) cv::GLogWrapper(__FILE__, CV_Func, __LINE__, #TYPE)
namespace cv
{
class GLogWrapper
{
const char *type, *cond_str, *file, *func;
int line;
bool cond_staus;
std::ostream &stream;
static std::ostream &selectStream(const char *type)
{
if (!strcmp(type, "INFO"))
return std::cout;
else
return std::cerr;
}
public:
GLogWrapper(const char *_file, const char *_func, int _line,
const char *_type,
const char *_cond_str = NULL, bool _cond_status = true
) :
stream(selectStream(_type)),
file(_file), func(_func), line(_line),
type(_type), cond_str(_cond_str), cond_staus(_cond_status) {}
template<typename T>
GLogWrapper &operator<<(const T &v)
{
if (!cond_str || cond_str && !cond_staus)
stream << v;
return *this;
}
~GLogWrapper()
{
if (cond_str && !cond_staus)
{
cv::error(cv::Error::StsAssert, cond_str, func, file, line);
}
//else if (!cond_str && strcmp(type, "INFO"))
//{
// cv::error(cv::Error::StsAssert, type, func, file, line);
//}
}
};
}

165
modules/dnn/src/caffe/io.cpp
Unescape View File

@ -1,11 +1,7 @@
//#include <fcntl.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/io/zero_copy_stream_impl.h>
#include <google/protobuf/text_format.h>
#include <opencv2/core.hpp>
//#include <opencv2/highgui/highgui.hpp>
//#include <opencv2/highgui/highgui_c.h>
//#include <opencv2/imgproc/imgproc.hpp>
//#include <stdint.h>
//
//#include <algorithm>
@ -67,166 +63,5 @@ bool ReadProtoFromBinaryFile(const char* filename, Message* proto) {
// fstream output(filename, ios::out | ios::trunc | ios::binary);
// CHECK(proto.SerializeToOstream(&output));
//}
//
//cv::Mat ReadImageToCVMat(const string& filename,
// const int height, const int width, const bool is_color) {
// cv::Mat cv_img;
// int cv_read_flag = (is_color ? CV_LOAD_IMAGE_COLOR :
// CV_LOAD_IMAGE_GRAYSCALE);
// cv::Mat cv_img_origin = cv::imread(filename, cv_read_flag);
// if (!cv_img_origin.data) {
// LOG(ERROR) << "Could not open or find file " << filename;
// return cv_img_origin;
// }
// if (height > 0 && width > 0) {
// cv::resize(cv_img_origin, cv_img, cv::Size(width, height));
// } else {
// cv_img = cv_img_origin;
// }
// return cv_img;
//}
//
//cv::Mat ReadImageToCVMat(const string& filename,
// const int height, const int width) {
// return ReadImageToCVMat(filename, height, width, true);
//}
//
//cv::Mat ReadImageToCVMat(const string& filename,
// const bool is_color) {
// return ReadImageToCVMat(filename, 0, 0, is_color);
//}
//
//cv::Mat ReadImageToCVMat(const string& filename) {
// return ReadImageToCVMat(filename, 0, 0, true);
//}
//// Do the file extension and encoding match?
//static bool matchExt(const std::string & fn,
// std::string en) {
// size_t p = fn.rfind('.');
// std::string ext = p != fn.npos ? fn.substr(p) : fn;
// std::transform(ext.begin(), ext.end(), ext.begin(), ::tolower);
// std::transform(en.begin(), en.end(), en.begin(), ::tolower);
// if ( ext == en )
// return true;
// if ( en == "jpg" && ext == "jpeg" )
// return true;
// return false;
//}
//bool ReadImageToDatum(const string& filename, const int label,
// const int height, const int width, const bool is_color,
// const std::string & encoding, Datum* datum) {
// cv::Mat cv_img = ReadImageToCVMat(filename, height, width, is_color);
// if (cv_img.data) {
// if (encoding.size()) {
// if ( (cv_img.channels() == 3) == is_color && !height && !width &&
// matchExt(filename, encoding) )
// return ReadFileToDatum(filename, label, datum);
// std::vector<uchar> buf;
// cv::imencode("."+encoding, cv_img, buf);
// datum->set_data(std::string(reinterpret_cast<char*>(&buf[0]),
// buf.size()));
// datum->set_label(label);
// datum->set_encoded(true);
// return true;
// }
// CVMatToDatum(cv_img, datum);
// datum->set_label(label);
// return true;
// } else {
// return false;
// }
//}
//
//bool ReadFileToDatum(const string& filename, const int label,
// Datum* datum) {
// std::streampos size;
//
// fstream file(filename.c_str(), ios::in|ios::binary|ios::ate);
// if (file.is_open()) {
// size = file.tellg();
// std::string buffer(size, ' ');
// file.seekg(0, ios::beg);
// file.read(&buffer[0], size);
// file.close();
// datum->set_data(buffer);
// datum->set_label(label);
// datum->set_encoded(true);
// return true;
// } else {
// return false;
// }
//}
//
//cv::Mat DecodeDatumToCVMatNative(const Datum& datum) {
// cv::Mat cv_img;
// CHECK(datum.encoded()) << "Datum not encoded";
// const string& data = datum.data();
// std::vector<char> vec_data(data.c_str(), data.c_str() + data.size());
// cv_img = cv::imdecode(vec_data, -1);
// if (!cv_img.data) {
// LOG(ERROR) << "Could not decode datum ";
// }
// return cv_img;
//}
//cv::Mat DecodeDatumToCVMat(const Datum& datum, bool is_color) {
// cv::Mat cv_img;
// CHECK(datum.encoded()) << "Datum not encoded";
// const string& data = datum.data();
// std::vector<char> vec_data(data.c_str(), data.c_str() + data.size());
// int cv_read_flag = (is_color ? CV_LOAD_IMAGE_COLOR :
// CV_LOAD_IMAGE_GRAYSCALE);
// cv_img = cv::imdecode(vec_data, cv_read_flag);
// if (!cv_img.data) {
// LOG(ERROR) << "Could not decode datum ";
// }
// return cv_img;
//}
//
//// If Datum is encoded will decoded using DecodeDatumToCVMat and CVMatToDatum
//// If Datum is not encoded will do nothing
//bool DecodeDatumNative(Datum* datum) {
// if (datum->encoded()) {
// cv::Mat cv_img = DecodeDatumToCVMatNative((*datum));
// CVMatToDatum(cv_img, datum);
// return true;
// } else {
// return false;
// }
//}
//bool DecodeDatum(Datum* datum, bool is_color) {
// if (datum->encoded()) {
// cv::Mat cv_img = DecodeDatumToCVMat((*datum), is_color);
// CVMatToDatum(cv_img, datum);
// return true;
// } else {
// return false;
// }
//}
//
//void CVMatToDatum(const cv::Mat& cv_img, Datum* datum) {
// CHECK(cv_img.depth() == CV_8U) << "Image data type must be unsigned byte";
// datum->set_channels(cv_img.channels());
// datum->set_height(cv_img.rows);
// datum->set_width(cv_img.cols);
// datum->clear_data();
// datum->clear_float_data();
// datum->set_encoded(false);
// int datum_channels = datum->channels();
// int datum_height = datum->height();
// int datum_width = datum->width();
// int datum_size = datum_channels * datum_height * datum_width;
// std::string buffer(datum_size, ' ');
// for (int h = 0; h < datum_height; ++h) {
// const uchar* ptr = cv_img.ptr<uchar>(h);
// int img_index = 0;
// for (int w = 0; w < datum_width; ++w) {
// for (int c = 0; c < datum_channels; ++c) {
// int datum_index = (c * datum_height + h) * datum_width + w;
// buffer[datum_index] = static_cast<char>(ptr[img_index++]);
// }
// }
// }
// datum->set_data(buffer);
//}
} // namespace caffe

12
modules/dnn/src/caffe/util/io.hpp
Unescape View File

@ -1,26 +1,18 @@
#ifndef CAFFE_UTIL_IO_H_
#define CAFFE_UTIL_IO_H_
#include <opencv2/core.hpp>
#include <iostream>
#define CHECK(cond) if (!(cond)) std::cerr << #cond
#define CHECK_EQ(a, b) if (!((a) == (b))) std::cerr << #a << "!=" << #b
#define LOG(WHERE) std::cerr
//instead of GLOG
#include "glog_emulator.hpp"
//#include <unistd.h>
#include <string>
#include <stdio.h>
#include <google/protobuf/message.h>
//#include "hdf5.h"
//#include "hdf5_hl.h"
//#include "caffe/blob.hpp"
#include "caffe/common.hpp"
#include "caffe.pb.h"
#define HDF5_NUM_DIMS 4
namespace caffe {
using ::google::protobuf::Message;

101
modules/dnn/src/caffe_importer.cpp
Unescape View File

@ -3,6 +3,7 @@
#include <iostream>
#include <fstream>
#include <algorithm>
#include <google/protobuf/message.h>
#include <google/protobuf/text_format.h>
#include <google/protobuf/io/zero_copy_stream_impl.h>
@ -20,35 +21,19 @@ using ::google::protobuf::Reflection;
namespace
{
void walk(const Descriptor *desc)
{
if (desc == NULL)
return;
std::cout << "* " << desc->full_name() << std::endl;
for (int i = 0; i < desc->field_count(); i++)
{
const FieldDescriptor *fdesc = desc->field(i);
if (fdesc->message_type())
walk(fdesc->message_type());
else;
//std::cout << "f " << desc->field(i)->full_name() << std::endl;
}
}
class CaffeImporter : public Importer
{
caffe::NetParameter net;
cv::dnn::LayerParams params;
caffe::NetParameter netBinary;
public:
CaffeImporter(const char *pototxt, const char *caffeModel)
{
ReadNetParamsFromTextFileOrDie(std::string(pototxt), &net);
if (caffeModel && caffeModel[0])
ReadNetParamsFromBinaryFileOrDie(caffeModel, &netBinary);
}
inline bool skipCaffeLayerParam(const FieldDescriptor *fd)
@ -144,11 +129,52 @@ namespace
}
}
void blobFromProto(const caffe::BlobProto &protoBlob, cv::dnn::Blob &dstBlob)
{
AutoBuffer<int, 4> shape;
if (protoBlob.has_num() || protoBlob.has_channels() || protoBlob.has_height() || protoBlob.has_width())
{
shape.resize(4);
shape[0] = protoBlob.num();
shape[1] = protoBlob.channels();
shape[2] = protoBlob.height();
shape[3] = protoBlob.width();
}
else if (protoBlob.has_shape())
{
const caffe::BlobShape &_shape = protoBlob.shape();
shape.resize(_shape.dim_size());
for (int i = 0; i < _shape.dim_size(); i++)
shape[i] = _shape.dim(i);
}
else
{
CV_Error(cv::Error::StsAssert, "Unknown shape of input blob");
}
size_t declaredBlobSize = 1;
for (int i = 0; i < shape.size(); i++)
declaredBlobSize *= shape[i];
CV_Assert(declaredBlobSize == protoBlob.data_size());
dstBlob.create(shape.size(), shape, CV_32F);
CV_DbgAssert(protoBlob.GetDescriptor()->FindFieldByLowercaseName("data")->cpp_type() == FieldDescriptor::CPPTYPE_FLOAT);
float *dstData = dstBlob.getMatRef().ptr<float>();
for (size_t i = 0; i < protoBlob.data_size(); i++)
dstData[i] = protoBlob.data(i);
}
void populateNetConfiguration(Ptr<NetConfiguration> config)
{
const Descriptor *layerDescriptor = caffe::LayerParameter::descriptor();
int layersSize = net.layer_size();
for (int li = 0; li < net.layer_size(); li++)
std::vector<String> layersName(layersSize);
std::vector<LayerParams> layersParam(layersSize);
for (int li = 0; li < layersSize; li++)
{
const caffe::LayerParameter layer = net.layer(li);
String name = layer.name();
@ -160,13 +186,38 @@ namespace
std::cout << std::endl << "LAYER: " << name << std::endl;
cv::dnn::LayerParams params;
extractLayerParams(layer, params);
extractLayerParams(layer, layersParam[li]);
layersName[li] = name;
//SetUp
//int id = config->addLayer(name, type);
//config->setLayerOutputLabels(id, bottoms);
}
for (int li = 0; li < netBinary.layer_size(); li++)
{
const caffe::LayerParameter layer = netBinary.layer(li);
if (layer.blobs_size() == 0)
continue;
String name = layer.name();
int index = std::find(layersName.begin(), layersName.end(), name) - layersName.begin();
if (index < layersName.size())
{
std::vector<Blob> &layerBlobs = layersParam[index].learnedBlobs;
layerBlobs.resize(layer.blobs_size());
for (int bi = 0; bi < layer.blobs_size(); bi++)
{
blobFromProto(layer.blobs(bi), layerBlobs[bi]);
}
}
else
{
std::cerr << "Unknown layer name " << name << " into" << std::endl;
}
}
}
~CaffeImporter()

43
modules/dnn/src/dnn.cpp
Unescape View File

@ -1,6 +1,7 @@
#include "opencv2/dnn.hpp"
using namespace cv;
using namespace cv::dnn;
#include <algorithm>
namespace cv
{
@ -18,6 +19,48 @@ Blob::Blob(InputArray in)
m = in.getMat();
}
static Vec4i blobNormalizeShape(int ndims, const int *sizes)
{
Vec4i shape = Vec4i::all(1);
for (int i = 0; i < std::min(3, ndims); i++)
shape[3 - i] = sizes[ndims-1 - i];
for (int i = 3; i < ndims; i++)
shape[0] *= sizes[ndims-1 - i];
return shape;
}
void Blob::fill(int ndims, const int *sizes, int type, void *data, bool deepCopy)
{
CV_Assert(type == CV_32F || type == CV_64F);
Vec4i shape = blobNormalizeShape(ndims, sizes);
if (deepCopy)
{
m.create(3, &shape[0], type);
size_t dataSize = m.total() * m.elemSize();
memcpy(m.data, data, dataSize);
}
else
{
m = Mat(shape.channels, &shape[0], type, data);
}
}
void Blob::fill(InputArray in)
{
CV_Assert(in.isMat() || in.isMatVector());
}
void Blob::create(int ndims, const int *sizes, int type /*= CV_32F*/)
{
Vec4i shape = blobNormalizeShape(ndims, sizes);
m.create(shape.channels, &shape[0], type);
}
Net::~Net()
{

17
modules/dnn/test/test_caffe_importer.cpp
Unescape View File

@ -14,18 +14,23 @@ static std::string getOpenCVExtraDir()
return cvtest::TS::ptr()->get_data_path();
}
TEST(ReadCaffePrototxt_gtsrb, Accuracy)
static std::string getTestFile(const char *filename)
{
Ptr<Importer> importer = createCaffeImporter(getOpenCVExtraDir() + "/dnn/gtsrb.prototxt", "");
Ptr<NetConfiguration> config = NetConfiguration::create();
importer->populateNetConfiguration(config);
return (getOpenCVExtraDir() + "/dnn/") + filename;
}
TEST(ReadCaffePrototxt_GoogleNet, Accuracy)
TEST(ReadCaffePrototxt_gtsrb, Accuracy)
{
Ptr<Importer> importer = createCaffeImporter(getOpenCVExtraDir() + "/dnn/googlenet_deploy.prototxt", "");
Ptr<Importer> importer = createCaffeImporter(getTestFile("gtsrb.prototxt"), getTestFile("gtsrb_iter_36000.caffemodel") );
Ptr<NetConfiguration> config = NetConfiguration::create();
importer->populateNetConfiguration(config);
}
//TEST(ReadCaffePrototxt_GoogleNet, Accuracy)
//{
// Ptr<Importer> importer = createCaffeImporter(getOpenCVExtraDir() + "/dnn/googlenet_deploy.prototxt", "");
// Ptr<NetConfiguration> config = NetConfiguration::create();
// importer->populateNetConfiguration(config);
//}
}
Write Preview
Loading…
Cancel
Save