windows下用c++调用caffe做前向

参考博客：

https://blog.csdn.net/muyouhang/article/details/54773265

https://blog.csdn.net/hhh0209/article/details/79830988

新建caffe的属性表，caffe_gpu_x64_release.props

将NugetPackages，caffe，CUDA中的头文件加进去

属性-C/C++-附加包含目录：

D:\caffe20190311\NugetPackages\OpenCV.2.4.10\build\native\include

D:\caffe20190311\NugetPackages\OpenBLAS.0.2.14.1\lib\native\include

D:\caffe20190311\NugetPackages\protobuf-v120.2.6.1\build\native\include

D:\caffe20190311\NugetPackages\glog.0.3.3.0\build\native\include

D:\caffe20190311\NugetPackages\gflags.2.1.2.1\build\native\include

D:\caffe20190311\NugetPackages\boost.1.59.0.0\lib\native\include

D:\caffe20190311\caffe-master\include

D:\caffe20190311\caffe-master\include\caffe

C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v8.0\include

将NugetPackages，caffe生成的，CUDA中静态库加入进去

属性-链接器-常规-附加库目录：

D:\caffe20190311\NugetPackages\OpenCV.2.4.10\build\native\lib\x64\v120\Release

D:\caffe20190311\NugetPackages\hdf5-v120-complete.1.8.15.2\lib\native\lib\x64

D:\caffe20190311\NugetPackages\OpenBLAS.0.2.14.1\lib\native\lib\x64

D:\caffe20190311\NugetPackages\gflags.2.1.2.1\build\native\x64\v120\dynamic\Lib

D:\caffe20190311\NugetPackages\glog.0.3.3.0\build\native\lib\x64\v120\Release\dynamic

D:\caffe20190311\NugetPackages\protobuf-v120.2.6.1\build\native\lib\x64\v120\Release

D:\caffe20190311\NugetPackages\boost_chrono-vc120.1.59.0.0\lib\native\address-model-64\lib

D:\caffe20190311\NugetPackages\boost_system-vc120.1.59.0.0\lib\native\address-model-64\lib

D:\caffe20190311\NugetPackages\boost_thread-vc120.1.59.0.0\lib\native\address-model-64\lib

D:\caffe20190311\NugetPackages\boost_filesystem-vc120.1.59.0.0\lib\native\address-model-64\lib

D:\caffe20190311\NugetPackages\boost_date_time-vc120.1.59.0.0\lib\native\address-model-64\lib

D:\caffe20190311\caffe-master\Build\x64\Release

C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v8.0\lib\x64

将一些动态库加入进去

属性-链接器-输入-附加依赖项：

libcaffe.lib

libprotobuf.lib

libglog.lib

gflags.lib

libopenblas.dll.a

hdf5.lib

hdf5_hl.lib

cublas.lib

cublas_device.lib

cuda.lib

cudadevrt.lib

cudnn.lib

cudart.lib

cufft.lib

cudart_static.lib

cufftw.lib

cusparse.lib

cusolver.lib

curand.lib

nppc.lib

opencv_highgui2410.lib

opencv_core2410.lib

opencv_imgproc2410.lib

kernel32.lib

user32.lib

gdi32.lib

winspool.lib

comdlg32.lib

advapi32.lib

shell32.lib

ole32.lib

oleaut32.lib

uuid.lib

odbc32.lib

odbccp32.lib

若在没有GPU的电脑，用cpu调用caffe

将头文件，静态库目录，动态库，去掉和cuda相关的就行

caffe_cpu_x64_release.props

附加包含目录，去掉最后一排与CUDA相关的头文件目录

附加库目录，去掉最后一排与CUDA相关的静态库目录

附加依赖项：

libcaffe.lib

libprotobuf.lib

libglog.lib

gflags.lib

libopenblas.dll.a

hdf5.lib

hdf5_hl.lib

opencv_highgui2410.lib

opencv_core2410.lib

opencv_imgproc2410.lib

kernel32.lib

user32.lib

gdi32.lib

winspool.lib

comdlg32.lib

advapi32.lib

shell32.lib

ole32.lib

oleaut32.lib

uuid.lib

odbc32.lib

odbccp32.lib

即可配置好caffe_x64_release.props的属性表　　

调用caffe，输入prototxt和caffemodel文件，输出每个层的名字：

caffe_layer.h

#include<caffe/common.hpp>

#include<caffe/proto/caffe.pb.h>

#include<caffe/layers/batch_norm_layer.hpp>

#include<caffe/layers/bias_layer.hpp>

#include <caffe/layers/concat_layer.hpp>

#include <caffe/layers/conv_layer.hpp>

#include <caffe/layers/dropout_layer.hpp>

#include<caffe/layers/input_layer.hpp>

#include <caffe/layers/inner_product_layer.hpp>

#include "caffe/layers/lrn_layer.hpp"

#include <caffe/layers/pooling_layer.hpp>

#include <caffe/layers/relu_layer.hpp>

#include "caffe/layers/softmax_layer.hpp"

#include<caffe/layers/scale_layer.hpp>

#include<caffe/layers/prelu_layer.hpp>

namespace caffe

{

	extern INSTANTIATE_CLASS(BatchNormLayer);

	extern INSTANTIATE_CLASS(BiasLayer);

	extern INSTANTIATE_CLASS(InputLayer);

	extern INSTANTIATE_CLASS(InnerProductLayer);

	extern INSTANTIATE_CLASS(DropoutLayer);

	extern INSTANTIATE_CLASS(ConvolutionLayer);

	REGISTER_LAYER_CLASS(Convolution);

	extern INSTANTIATE_CLASS(ReLULayer);

	REGISTER_LAYER_CLASS(ReLU);

	extern INSTANTIATE_CLASS(PoolingLayer);

	REGISTER_LAYER_CLASS(Pooling);

	extern INSTANTIATE_CLASS(LRNLayer);

	REGISTER_LAYER_CLASS(LRN);

	extern INSTANTIATE_CLASS(SoftmaxLayer);

	REGISTER_LAYER_CLASS(Softmax);

	extern INSTANTIATE_CLASS(ScaleLayer);

	extern INSTANTIATE_CLASS(ConcatLayer);

	extern INSTANTIATE_CLASS(PReLULayer);

}

main.cpp　　

#include<caffe.hpp>

#include <string>

#include <vector>

#include "caffe_layer.h"

using namespace caffe;

using namespace std;

int main() {

	string net_file = "./infrared_mbfnet/antispoof-infrared.prototxt";		//prototxt文件

	string weight_file = "./infrared_mbfnet/antispoof-infrared.caffemodel";		//caffemodel文件

	Caffe::set_mode(Caffe::CPU);

	//Caffe::SetDevice(0);

	Phase phase = TEST;

	boost::shared_ptr<Net<float>> net(new caffe::Net<float>(net_file, phase));

	net->CopyTrainedLayersFrom(weight_file);

	vector<string> blob_names = net->blob_names();

	for (int i = 0; i < blob_names.size(); i++){

		cout << blob_names.at(i) << endl;

	}

	system("pause");

	return 0;

}

注意：若模型中用到了，prelu层，需要在caffe_layer.h中加入prelu_layer.hpp的头文件，并在代码中声明一下，extern INSTANTIATE_CLASS(PReLULayer)，否则，会报错，找不到该层。

运行结果：

用c++调用caffe做前向：

在caffe目录中，./caffe-master/examples/cpp_classification/classification.cpp 将该文件添加到vs2013工程中，配置caffe_x64_release属性表

在原始的classification.cpp文件中，main函数的输入项有4个，model_file，trained_file，label_file，mean_file，其中mean_file是均值文件，存放了img.channels x height x width个float型的数，每个float数，是所有训练样本该位置的均值。在有些情况下，均值已经确定，imgdata=(src-127.5)*0.0078125，故可以将均值直接赋值给Classifier类的成员变量mean_。

void Classifier::SetMean1()

{

	mean_ = cv::Mat(input_geometry_, CV_32FC3, cv::Scalar(127.5, 127.5, 127.5));

}

此时，main函数只需要输入3个参数，prototxt，caffemodel，label.txt文件。

该工程中包含两个文件，caffe_layer.h，classification.cpp

classification.cpp

#define USE_OPENCV 1

#include <caffe/caffe.hpp>

#ifdef USE_OPENCV

#include <opencv2/core/core.hpp>

#include <opencv2/highgui/highgui.hpp>

#include <opencv2/imgproc/imgproc.hpp>

#endif  // USE_OPENCV

#include <algorithm>

#include <iosfwd>

#include <memory>

#include <string>

#include <utility>

#include <vector>

#include <fstream>

#include <time.h>

#include "caffe_layer.h"

#ifdef USE_OPENCV

using namespace caffe;  // NOLINT(build/namespaces)

using std::string;

using namespace cv;

/* Pair (label, confidence) representing a prediction. */

typedef std::pair<string, float> Prediction;

class Classifier {

 public:

  Classifier(const string& model_file,

             const string& trained_file,

             const string& label_file);

  std::vector<Prediction> Classify(const cv::Mat& img, int N = 5);

  int Classify1(const cv::Mat& img);

 private:

  void SetMean(const string& mean_file);

  void SetMean1();

  std::vector<float> Predict(const cv::Mat& img);

  void WrapInputLayer(std::vector<cv::Mat>* input_channels);

  void Preprocess(const cv::Mat& img,

                  std::vector<cv::Mat>* input_channels);

 private:

  shared_ptr<Net<float> > net_;

  cv::Size input_geometry_;

  int num_channels_;

  cv::Mat mean_;

  std::vector<string> labels_;

};

Classifier::Classifier(const string& model_file,

                       const string& trained_file,

                       const string& label_file) {

#ifdef CPU_ONLY

  Caffe::set_mode(Caffe::CPU);

#else

  Caffe::set_mode(Caffe::GPU);

#endif

  /* Load the network. */

  net_.reset(new Net<float>(model_file, TEST));

  net_->CopyTrainedLayersFrom(trained_file);

  CHECK_EQ(net_->num_inputs(), 1) << "Network should have exactly one input.";

  CHECK_EQ(net_->num_outputs(), 1) << "Network should have exactly one output.";

  Blob<float>* input_layer = net_->input_blobs()[0];

  num_channels_ = input_layer->channels();

  //std::cout << num_channels_ << std::endl;

  CHECK(num_channels_ == 3 || num_channels_ == 1)

    << "Input layer should have 1 or 3 channels.";

  input_geometry_ = cv::Size(input_layer->width(), input_layer->height());

  /* Load the binaryproto mean file. */

  //SetMean(mean_file);

  SetMean1();

  /* Load labels. */

  std::ifstream labels(label_file.c_str());

  CHECK(labels) << "Unable to open labels file " << label_file;

  string line;

  while (std::getline(labels, line))

    labels_.push_back(string(line));

  Blob<float>* output_layer = net_->output_blobs()[0];

  CHECK_EQ(labels_.size(), output_layer->channels())

    << "Number of labels is different from the output layer dimension.";

}

static bool PairCompare(const std::pair<float, int>& lhs,

                        const std::pair<float, int>& rhs) {

  return lhs.first > rhs.first;

}

/* Return the indices of the top N values of vector v. */

static std::vector<int> Argmax(const std::vector<float>& v, int N) {

  std::vector<std::pair<float, int> > pairs;

  for (size_t i = 0; i < v.size(); ++i)

    pairs.push_back(std::make_pair(v[i], static_cast<int>(i)));

  std::partial_sort(pairs.begin(), pairs.begin() + N, pairs.end(), PairCompare);

  std::vector<int> result;

  for (int i = 0; i < N; ++i)

    result.push_back(pairs[i].second);

  return result;

}

/* Return the top N predictions. */

std::vector<Prediction> Classifier::Classify(const cv::Mat& img, int N) {

  std::vector<float> output = Predict(img);

  N = std::min<int>(labels_.size(), N);

  std::vector<int> maxN = Argmax(output, N);

  std::vector<Prediction> predictions;

  for (int i = 0; i < N; ++i) {

    int idx = maxN[i];

    predictions.push_back(std::make_pair(labels_[idx], output[idx]));

  }

  return predictions;

}

int Classifier::Classify1(const cv::Mat& img) {

	std::vector<float> output = Predict(img);

	float max = output[0];

	int max_id = 0;

	for (int i = 1; i < output.size(); i++)

	{

		if (output[i]>max)

			max_id = i;

	}

	return max_id;

}

/* Load the mean file in binaryproto format. */

void Classifier::SetMean(const string& mean_file) {

  BlobProto blob_proto;

  ReadProtoFromBinaryFileOrDie(mean_file.c_str(), &blob_proto);

  /* Convert from BlobProto to Blob<float> */

  Blob<float> mean_blob;

  mean_blob.FromProto(blob_proto);

  CHECK_EQ(mean_blob.channels(), num_channels_)

    << "Number of channels of mean file doesn't match input layer.";

  /* The format of the mean file is planar 32-bit float BGR or grayscale. */

  std::vector<cv::Mat> channels;

  float* data = mean_blob.mutable_cpu_data();

  for (int i = 0; i < num_channels_; ++i) {

    /* Extract an individual channel. */

    cv::Mat channel(mean_blob.height(), mean_blob.width(), CV_32FC1, data);

    channels.push_back(channel);

    data += mean_blob.height() * mean_blob.width();

  }

  /* Merge the separate channels into a single image. */

  cv::Mat mean;

  cv::merge(channels, mean);

  /* Compute the global mean pixel value and create a mean image

   * filled with this value. */

  cv::Scalar channel_mean = cv::mean(mean);

  mean_ = cv::Mat(input_geometry_, mean.type(), channel_mean);

}

void Classifier::SetMean1()

{

	mean_ = cv::Mat(input_geometry_, CV_32FC3, cv::Scalar(127.5, 127.5, 127.5));

}

std::vector<float> Classifier::Predict(const cv::Mat& img) {

  Blob<float>* input_layer = net_->input_blobs()[0];

  input_layer->Reshape(1, num_channels_,

                       input_geometry_.height, input_geometry_.width);

  /* Forward dimension change to all layers. */

  net_->Reshape();

  std::vector<cv::Mat> input_channels;

  WrapInputLayer(&input_channels);

  Preprocess(img, &input_channels);

  net_->Forward();

  /* Copy the output layer to a std::vector */

  Blob<float>* output_layer = net_->output_blobs()[0];

  const float* begin = output_layer->cpu_data();

  const float* end = begin + output_layer->channels();

  return std::vector<float>(begin, end);

}

/* Wrap the input layer of the network in separate cv::Mat objects

 * (one per channel). This way we save one memcpy operation and we

 * don't need to rely on cudaMemcpy2D. The last preprocessing

 * operation will write the separate channels directly to the input

 * layer. */

void Classifier::WrapInputLayer(std::vector<cv::Mat>* input_channels) {

  Blob<float>* input_layer = net_->input_blobs()[0];

  int width = input_layer->width();

  int height = input_layer->height();

  float* input_data = input_layer->mutable_cpu_data();

  for (int i = 0; i < input_layer->channels(); ++i) {

    cv::Mat channel(height, width, CV_32FC1, input_data);

    input_channels->push_back(channel);

    input_data += width * height;

  }

}

void Classifier::Preprocess(const cv::Mat& img,

                            std::vector<cv::Mat>* input_channels) {

  /* Convert the input image to the input image format of the network. */

  cv::Mat sample;

  if (img.channels() == 3 && num_channels_ == 1)

    cv::cvtColor(img, sample, cv::COLOR_BGR2GRAY);

  else if (img.channels() == 4 && num_channels_ == 1)

    cv::cvtColor(img, sample, cv::COLOR_BGRA2GRAY);

  else if (img.channels() == 4 && num_channels_ == 3)

    cv::cvtColor(img, sample, cv::COLOR_BGRA2BGR);

  else if (img.channels() == 1 && num_channels_ == 3)

    cv::cvtColor(img, sample, cv::COLOR_GRAY2BGR);

  else

    sample = img;

  cv::Mat sample_resized;

  if (sample.size() != input_geometry_)

    cv::resize(sample, sample_resized, input_geometry_);

  else

    sample_resized = sample;

  cv::Mat sample_float;

  if (num_channels_ == 3)

    sample_resized.convertTo(sample_float, CV_32FC3);

  else

    sample_resized.convertTo(sample_float, CV_32FC1);

  cv::Mat sample_normalized;

  cv::subtract(sample_float, mean_, sample_normalized);

  cv::Mat img_scale(cv::Size(img.cols, img.rows), CV_32FC3, cv::Scalar(0, 0, 0));

  for (int i = 0; i < img_scale.rows; i++)

	  for (int j = 0; j < img_scale.cols; j++)

	  {

		  //cv::Vec3f *p = img_scale.ptr<Vec3f>(i, j);

		  if (sample_normalized.channels() == 3)

		  {

			  img_scale.at<Vec3f>(i, j)[0] = sample_normalized.at<Vec3f>(i, j)[0] * 0.0078125;

			  img_scale.at<Vec3f>(i, j)[1] = sample_normalized.at<Vec3f>(i, j)[1] * 0.0078125;

			  img_scale.at<Vec3f>(i, j)[2] = sample_normalized.at<Vec3f>(i, j)[2] * 0.0078125;

		  }

	  }

  /* This operation will write the separate BGR planes directly to the

   * input layer of the network because it is wrapped by the cv::Mat

   * objects in input_channels. */

  cv::split(img_scale, *input_channels);

  CHECK(reinterpret_cast<float*>(input_channels->at(0).data)

        == net_->input_blobs()[0]->cpu_data())

    << "Input channels are not wrapping the input layer of the network.";

}

int main(int argc, char** argv)

{

	::google::InitGoogleLogging(argv[0]);

	string model_file = "./infrared_mbfnet/antispoof-infrared.prototxt";

	string trained_file = "./infrared_mbfnet/antispoof-infrared.caffemodel";

	string label_file = "infrared_mbfnet/infrared_label.txt";

	Classifier classifier(model_file, trained_file, label_file);

	string file = "img/0/outdoor_6_964.jpg";

	std::cout << file << " : ";

	cv::Mat img = cv::imread(file, 1);

	CHECK(!img.empty()) << "Unable to decode image " << file;

	int predict_id = classifier.Classify1(img);

	std::cout << predict_id << std::endl;

	system("pause");

	return 1;

}

/*

int main(int argc, char** argv)

{

	::google::InitGoogleLogging(argv[0]);

	string model_file = "./infrared_mbfnet/antispoof-infrared.prototxt";

	string trained_file = "./infrared_mbfnet/antispoof-infrared.caffemodel";

	string label_file = "infrared_mbfnet/infrared_label.txt";

	Classifier classifier(model_file, trained_file, label_file);

	//string file = "img/0/outdoor_6_964.jpg";

	string txtpath = "infrared_test.txt";

	fstream fin;

	fin.open(txtpath, ios::in);

	if (!fin.is_open())

	{

		return -1;

	}

	string line;

	int total_num = 0;

	int pos_num = 0;

	while (!fin.eof())

	{

		total_num += 1;

		fin >> line;

		size_t pos1 = line.rfind('/');

		size_t pos2 = line.rfind('/', pos1-1);

		string true_label = line.substr(pos2 + 1, pos1 - pos2 - 1);

		cv::Mat img = cv::imread(line, 1);

		CHECK(!img.empty()) << "Unable to decode image " << line;

		int predict_id = classifier.Classify1(img);

		std::cout <<line<<" : "<< predict_id << std::endl;

		//std::cout << true_label << " " << predict_id << std::endl;

		if (atoi(true_label.c_str()) == predict_id)

			pos_num += 1;

	}

	float accuracy = pos_num*1.0 / total_num;

	std::cout << "accuracy:" << accuracy << std::endl;

	system("pause");

	return 1;

}

*/

#else

int main(int argc, char** argv) {

  LOG(FATAL) << "This example requires OpenCV; compile with USE_OPENCV.";

}

#endif  // USE_OPENCV

若想将该inference的功能，集成在其他项目中，可将类的声明和类的实现，以及main函数分离：

caffe_layer.h(如上文所示）

classification.h

//#define USE_OPENCV 1

#include <caffe/caffe.hpp>

//#ifdef USE_OPENCV

#include <opencv2/core/core.hpp>

#include <opencv2/highgui/highgui.hpp>

#include <opencv2/imgproc/imgproc.hpp>

//#endif  // USE_OPENCV

#include <algorithm>

#include <iosfwd>

#include <memory>

#include <string>

#include <utility>

#include <vector>

#include <fstream>

#include <time.h>

//#ifdef USE_OPENCV

using namespace caffe;  // NOLINT(build/namespaces)

using std::string;

using namespace cv;

/* Pair (label, confidence) representing a prediction. */

typedef std::pair<string, float> Prediction;

class Classifier {

public:

	Classifier(const string& model_file,

		const string& trained_file,

		const string& label_file);

	std::vector<Prediction> Classify(const cv::Mat& img, int N = 5);

	int Classify1(const cv::Mat& img);

private:

	void SetMean(const string& mean_file);

	void SetMean1();

	std::vector<float> Predict(const cv::Mat& img);

	void WrapInputLayer(std::vector<cv::Mat>* input_channels);

	void Preprocess(const cv::Mat& img,

		std::vector<cv::Mat>* input_channels);

private:

	shared_ptr<Net<float> > net_;

	cv::Size input_geometry_;

	int num_channels_;

	cv::Mat mean_;

	std::vector<string> labels_;

};

classficaion.cpp

#include "classification.h"

Classifier::Classifier(const string& model_file,

                       const string& trained_file,

                       const string& label_file) {

#ifdef CPU_ONLY

  Caffe::set_mode(Caffe::CPU);

#else

  Caffe::set_mode(Caffe::GPU);

#endif

  /* Load the network. */

  net_.reset(new Net<float>(model_file, TEST));

  net_->CopyTrainedLayersFrom(trained_file);

  CHECK_EQ(net_->num_inputs(), 1) << "Network should have exactly one input.";

  CHECK_EQ(net_->num_outputs(), 1) << "Network should have exactly one output.";

  Blob<float>* input_layer = net_->input_blobs()[0];

  num_channels_ = input_layer->channels();

  //std::cout << num_channels_ << std::endl;

  CHECK(num_channels_ == 3 || num_channels_ == 1)

    << "Input layer should have 1 or 3 channels.";

  input_geometry_ = cv::Size(input_layer->width(), input_layer->height());

  /* Load the binaryproto mean file. */

  //SetMean(mean_file);

  SetMean1();

  /* Load labels. */

  std::ifstream labels(label_file.c_str());

  CHECK(labels) << "Unable to open labels file " << label_file;

  string line;

  while (std::getline(labels, line))

    labels_.push_back(string(line));

  Blob<float>* output_layer = net_->output_blobs()[0];

  CHECK_EQ(labels_.size(), output_layer->channels())

    << "Number of labels is different from the output layer dimension.";

}

static bool PairCompare(const std::pair<float, int>& lhs,

                        const std::pair<float, int>& rhs) {

  return lhs.first > rhs.first;

}

/* Return the indices of the top N values of vector v. */

static std::vector<int> Argmax(const std::vector<float>& v, int N) {

  std::vector<std::pair<float, int> > pairs;

  for (size_t i = 0; i < v.size(); ++i)

    pairs.push_back(std::make_pair(v[i], static_cast<int>(i)));

  std::partial_sort(pairs.begin(), pairs.begin() + N, pairs.end(), PairCompare);

  std::vector<int> result;

  for (int i = 0; i < N; ++i)

    result.push_back(pairs[i].second);

  return result;

}

/* Return the top N predictions. */

std::vector<Prediction> Classifier::Classify(const cv::Mat& img, int N) {

  std::vector<float> output = Predict(img);

  N = std::min<int>(labels_.size(), N);

  std::vector<int> maxN = Argmax(output, N);

  std::vector<Prediction> predictions;

  for (int i = 0; i < N; ++i) {

    int idx = maxN[i];

    predictions.push_back(std::make_pair(labels_[idx], output[idx]));

  }

  return predictions;

}

int Classifier::Classify1(const cv::Mat& img) {

	std::vector<float> output = Predict(img);

	float max = output[0];

	int max_id = 0;

	for (int i = 1; i < output.size(); i++)

	{

		if (output[i]>max)

			max_id = i;

	}

	return max_id;

}

/* Load the mean file in binaryproto format. */

void Classifier::SetMean(const string& mean_file) {

  BlobProto blob_proto;

  ReadProtoFromBinaryFileOrDie(mean_file.c_str(), &blob_proto);

  /* Convert from BlobProto to Blob<float> */

  Blob<float> mean_blob;

  mean_blob.FromProto(blob_proto);

  CHECK_EQ(mean_blob.channels(), num_channels_)

    << "Number of channels of mean file doesn't match input layer.";

  /* The format of the mean file is planar 32-bit float BGR or grayscale. */

  std::vector<cv::Mat> channels;

  float* data = mean_blob.mutable_cpu_data();

  for (int i = 0; i < num_channels_; ++i) {

    /* Extract an individual channel. */

    cv::Mat channel(mean_blob.height(), mean_blob.width(), CV_32FC1, data);

    channels.push_back(channel);

    data += mean_blob.height() * mean_blob.width();

  }

  /* Merge the separate channels into a single image. */

  cv::Mat mean;

  cv::merge(channels, mean);

  /* Compute the global mean pixel value and create a mean image

   * filled with this value. */

  cv::Scalar channel_mean = cv::mean(mean);

  mean_ = cv::Mat(input_geometry_, mean.type(), channel_mean);

}

void Classifier::SetMean1()

{

	mean_ = cv::Mat(input_geometry_, CV_32FC3, cv::Scalar(127.5, 127.5, 127.5));

}

std::vector<float> Classifier::Predict(const cv::Mat& img) {

  Blob<float>* input_layer = net_->input_blobs()[0];

  input_layer->Reshape(1, num_channels_,

                       input_geometry_.height, input_geometry_.width);

  /* Forward dimension change to all layers. */

  net_->Reshape();

  std::vector<cv::Mat> input_channels;

  WrapInputLayer(&input_channels);

  Preprocess(img, &input_channels);

  net_->Forward();

  /* Copy the output layer to a std::vector */

  Blob<float>* output_layer = net_->output_blobs()[0];

  const float* begin = output_layer->cpu_data();

  const float* end = begin + output_layer->channels();

  return std::vector<float>(begin, end);

}

/* Wrap the input layer of the network in separate cv::Mat objects

 * (one per channel). This way we save one memcpy operation and we

 * don't need to rely on cudaMemcpy2D. The last preprocessing

 * operation will write the separate channels directly to the input

 * layer. */

void Classifier::WrapInputLayer(std::vector<cv::Mat>* input_channels) {

  Blob<float>* input_layer = net_->input_blobs()[0];

  int width = input_layer->width();

  int height = input_layer->height();

  float* input_data = input_layer->mutable_cpu_data();

  for (int i = 0; i < input_layer->channels(); ++i) {

    cv::Mat channel(height, width, CV_32FC1, input_data);

    input_channels->push_back(channel);

    input_data += width * height;

  }

}

void Classifier::Preprocess(const cv::Mat& img,

                            std::vector<cv::Mat>* input_channels) {

  /* Convert the input image to the input image format of the network. */

  cv::Mat sample;

  if (img.channels() == 3 && num_channels_ == 1)

    cv::cvtColor(img, sample, cv::COLOR_BGR2GRAY);

  else if (img.channels() == 4 && num_channels_ == 1)

    cv::cvtColor(img, sample, cv::COLOR_BGRA2GRAY);

  else if (img.channels() == 4 && num_channels_ == 3)

    cv::cvtColor(img, sample, cv::COLOR_BGRA2BGR);

  else if (img.channels() == 1 && num_channels_ == 3)

    cv::cvtColor(img, sample, cv::COLOR_GRAY2BGR);

  else

    sample = img;

  cv::Mat sample_resized;

  if (sample.size() != input_geometry_)

    cv::resize(sample, sample_resized, input_geometry_);

  else

    sample_resized = sample;

  cv::Mat sample_float;

  if (num_channels_ == 3)

    sample_resized.convertTo(sample_float, CV_32FC3);

  else

    sample_resized.convertTo(sample_float, CV_32FC1);

  cv::Mat sample_normalized;

  cv::subtract(sample_float, mean_, sample_normalized);

  cv::Mat img_scale(cv::Size(img.cols, img.rows), CV_32FC3, cv::Scalar(0, 0, 0));

  for (int i = 0; i < img_scale.rows; i++)

	  for (int j = 0; j < img_scale.cols; j++)

	  {

		  //cv::Vec3f *p = img_scale.ptr<Vec3f>(i, j);

		  if (sample_normalized.channels() == 3)

		  {

			  img_scale.at<Vec3f>(i, j)[0] = sample_normalized.at<Vec3f>(i, j)[0] * 0.0078125;

			  img_scale.at<Vec3f>(i, j)[1] = sample_normalized.at<Vec3f>(i, j)[1] * 0.0078125;

			  img_scale.at<Vec3f>(i, j)[2] = sample_normalized.at<Vec3f>(i, j)[2] * 0.0078125;

		  }

	  }

  /* This operation will write the separate BGR planes directly to the

   * input layer of the network because it is wrapped by the cv::Mat

   * objects in input_channels. */

  cv::split(img_scale, *input_channels);

  CHECK(reinterpret_cast<float*>(input_channels->at(0).data)

        == net_->input_blobs()[0]->cpu_data())

    << "Input channels are not wrapping the input layer of the network.";

}

//#else

//int main(int argc, char** argv) {

//  LOG(FATAL) << "This example requires OpenCV; compile with USE_OPENCV.";

//}

//#endif  // USE_OPENCV

main.cpp

#include "classification.h"

#include "caffe_layer.h"

int main(int argc, char** argv)

{

	::google::InitGoogleLogging(argv[0]);

	string model_file = "./infrared_mbfnet/antispoof-infrared.prototxt";

	string trained_file = "./infrared_mbfnet/antispoof-infrared.caffemodel";

	string label_file = "infrared_mbfnet/infrared_label.txt";

	Classifier classifier(model_file, trained_file, label_file);

	string file = "img/0/outdoor_6_964.jpg";

	std::cout << file << " : ";

	cv::Mat img = cv::imread(file, 1);

	CHECK(!img.empty()) << "Unable to decode image " << file;

	int predict_id = classifier.Classify1(img);

	std::cout << predict_id << std::endl;

	system("pause");

	return 1;

}

/*

int main(int argc, char** argv)

{

::google::InitGoogleLogging(argv[0]);

string model_file = "./infrared_mbfnet/antispoof-infrared.prototxt";

string trained_file = "./infrared_mbfnet/antispoof-infrared.caffemodel";

string label_file = "infrared_mbfnet/infrared_label.txt";

Classifier classifier(model_file, trained_file, label_file);

//string file = "img/0/outdoor_6_964.jpg";

string txtpath = "infrared_test.txt";

fstream fin;

fin.open(txtpath, ios::in);

if (!fin.is_open())

{

return -1;

}

string line;

int total_num = 0;

int pos_num = 0;

while (!fin.eof())

{

total_num += 1;

fin >> line;

size_t pos1 = line.rfind('/');

size_t pos2 = line.rfind('/', pos1-1);

string true_label = line.substr(pos2 + 1, pos1 - pos2 - 1);

cv::Mat img = cv::imread(line, 1);

CHECK(!img.empty()) << "Unable to decode image " << line;

int predict_id = classifier.Classify1(img);

std::cout <<line<<" : "<< predict_id << std::endl;

//std::cout << true_label << " " << predict_id << std::endl;

if (atoi(true_label.c_str()) == predict_id)

pos_num += 1;

}

float accuracy = pos_num*1.0 / total_num;

std::cout << "accuracy:" << accuracy << std::endl;

system("pause");

return 1;

}

*/

注意：该工程是在vs2013下的release模式下调用，用vs2013的原因，是因为NugetPackages中仅有vs2013的lib和dll库，release的原因，因为caffe是在release模式下编译的，debug模式下没有试过。　　

巴特西

windows下用c++调用caffe做前向

最新文章

热门文章