版权声明：如果感觉写的不错，转载标明出处链接哦~blog.csdn.net/wyg1997 https://blog.csdn.net/wyg1997/article/details/82258088
这段代码是DetectionOut层的实现，表示怎么从PriorBox、loc、conf三个层得到检测框的。
源码如下：
detection_output_layer.cpp
#include <algorithm>
#include <fstream> // NOLINT(readability/streams)
#include <map>
#include <string>
#include <utility>
#include <vector>
#include "boost/filesystem.hpp"
#include "boost/foreach.hpp"
#include "caffe/layers/detection_output_layer.hpp"
namespace caffe {
// DetectionOutput层的bottom分别是：loc、conf、prior
// 从prototxt中读取配置参数
template <typename Dtype>
void DetectionOutputLayer<Dtype>::LayerSetUp(const vector<Blob<Dtype>*>& bottom,
const vector<Blob<Dtype>*>& top) {
const DetectionOutputParameter& detection_output_param =
this->layer_param_.detection_output_param();
// 必须指定类别数
CHECK(detection_output_param.has_num_classes()) << "Must specify num_classes";
num_classes_ = detection_output_param.num_classes();
// 所有类别共享位置框，默认是true
share_location_ = detection_output_param.share_location();
num_loc_classes_ = share_location_ ? 1 : num_classes_;
// 背景的id
background_label_id_ = detection_output_param.background_label_id();
code_type_ = detection_output_param.code_type();
variance_encoded_in_target_ =
detection_output_param.variance_encoded_in_target();
keep_top_k_ = detection_output_param.keep_top_k();
// 置信度的阈值，如果没设置就为极小值
confidence_threshold_ = detection_output_param.has_confidence_threshold() ?
detection_output_param.confidence_threshold() : -FLT_MAX;
// 非极大值抑制操作时的阈值，应该为一个非负数
// Parameters used in nms.
nms_threshold_ = detection_output_param.nms_param().nms_threshold();
CHECK_GE(nms_threshold_, 0.) << "nms_threshold must be non negative.";
eta_ = detection_output_param.nms_param().eta();
CHECK_GT(eta_, 0.);
CHECK_LE(eta_, 1.);
top_k_ = -1;
if (detection_output_param.nms_param().has_top_k()) {
top_k_ = detection_output_param.nms_param().top_k();
}
// 保存输出值
const SaveOutputParameter& save_output_param =
detection_output_param.save_output_param();
output_directory_ = save_output_param.output_directory();
if (!output_directory_.empty()) {
if (boost::filesystem::is_directory(output_directory_)) {
boost::filesystem::remove_all(output_directory_);
}
if (!boost::filesystem::create_directories(output_directory_)) {
LOG(WARNING) << "Failed to create directory: " << output_directory_;
}
}
output_name_prefix_ = save_output_param.output_name_prefix();
need_save_ = output_directory_ == "" ? false : true;
output_format_ = save_output_param.output_format();
// 需要提供标签文件
if (save_output_param.has_label_map_file()) {
string label_map_file = save_output_param.label_map_file();
if (label_map_file.empty()) {
// Ignore saving if there is no label_map_file provided.
LOG(WARNING) << "Provide label_map_file if output results to files.";
need_save_ = false;
} else {
LabelMap label_map;
CHECK(ReadProtoFromTextFile(label_map_file, &label_map))
<< "Failed to read label map file: " << label_map_file;
CHECK(MapLabelToName(label_map, true, &label_to_name_))
<< "Failed to convert label to name.";
CHECK(MapLabelToDisplayName(label_map, true, &label_to_display_name_))
<< "Failed to convert label to display name.";
}
} else {
need_save_ = false;
}
if (save_output_param.has_name_size_file()) {
string name_size_file = save_output_param.name_size_file();
if (name_size_file.empty()) {
// Ignore saving if there is no name_size_file provided.
LOG(WARNING) << "Provide name_size_file if output results to files.";
need_save_ = false;
} else {
std::ifstream infile(name_size_file.c_str());
CHECK(infile.good())
<< "Failed to open name size file: " << name_size_file;
// The file is in the following format:
// name height width
// ...
string name;
int height, width;
while (infile >> name >> height >> width) {
names_.push_back(name);
sizes_.push_back(std::make_pair(height, width));
}
infile.close();
if (save_output_param.has_num_test_image()) {
num_test_image_ = save_output_param.num_test_image();
} else {
num_test_image_ = names_.size();
}
CHECK_LE(num_test_image_, names_.size());
}
} else {
need_save_ = false;
}
// 对输出再resize
has_resize_ = save_output_param.has_resize_param();
if (has_resize_) {
resize_param_ = save_output_param.resize_param();
}
name_count_ = 0;
// 可视化
visualize_ = detection_output_param.visualize();
if (visualize_) {
// 可视化的阈值设置
visualize_threshold_ = 0.6;
if (detection_output_param.has_visualize_threshold()) {
visualize_threshold_ = detection_output_param.visualize_threshold();
}
data_transformer_.reset(
new DataTransformer<Dtype>(this->layer_param_.transform_param(),
this->phase_));
data_transformer_->InitRand();
save_file_ = detection_output_param.save_file();
}
bbox_preds_.ReshapeLike(*(bottom[0]));
if (!share_location_) {
bbox_permute_.ReshapeLike(*(bottom[0]));
}
conf_permute_.ReshapeLike(*(bottom[1]));
}
template <typename Dtype>
void DetectionOutputLayer<Dtype>::Reshape(const vector<Blob<Dtype>*>& bottom,
const vector<Blob<Dtype>*>& top) {
if (need_save_) {
CHECK_LE(name_count_, names_.size());
if (name_count_ % num_test_image_ == 0) {
// Clean all outputs.
if (output_format_ == "VOC") {
boost::filesystem::path output_directory(output_directory_);
for (map<int, string>::iterator it = label_to_name_.begin();
it != label_to_name_.end(); ++it) {
if (it->first == background_label_id_) {
continue;
}
std::ofstream outfile;
boost::filesystem::path file(
output_name_prefix_ + it->second + ".txt");
boost::filesystem::path out_file = output_directory / file;
outfile.open(out_file.string().c_str(), std::ofstream::out);
}
}
}
}
// 这里的reshape挺重要的，注意各个数的涵义
CHECK_EQ(bottom[0]->num(), bottom[1]->num());
if (bbox_preds_.num() != bottom[0]->num() ||
bbox_preds_.count(1) != bottom[0]->count(1)) {
bbox_preds_.ReshapeLike(*(bottom[0]));
}
if (!share_location_ && (bbox_permute_.num() != bottom[0]->num() ||
bbox_permute_.count(1) != bottom[0]->count(1))) {
bbox_permute_.ReshapeLike(*(bottom[0]));
}
if (conf_permute_.num() != bottom[1]->num() ||
conf_permute_.count(1) != bottom[1]->count(1)) {
conf_permute_.ReshapeLike(*(bottom[1]));
}
num_priors_ = bottom[2]->height() / 4;
CHECK_EQ(num_priors_ * num_loc_classes_ * 4, bottom[0]->channels())
<< "Number of priors must match number of location predictions.";
CHECK_EQ(num_priors_ * num_classes_, bottom[1]->channels())
<< "Number of priors must match number of confidence predictions.";
// num() and channels() are 1.
vector<int> top_shape(2, 1);
// Since the number of bboxes to be kept is unknown before nms, we manually
// set it to (fake) 1.
top_shape.push_back(1);
// 输出每行7个数，分别表示图片id、标签、置信度以及4个坐标
// Each row is a 7 dimension vector, which stores
// [image_id, label, confidence, xmin, ymin, xmax, ymax]
top_shape.push_back(7);
top[0]->Reshape(top_shape);
}
// 正向传播
template <typename Dtype>
void DetectionOutputLayer<Dtype>::Forward_cpu(
const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) {
// 按照loc、conf、prior顺序传入bottom
const Dtype* loc_data = bottom[0]->cpu_data();
const Dtype* conf_data = bottom[1]->cpu_data();
const Dtype* prior_data = bottom[2]->cpu_data();
// batch num
const int num = bottom[0]->num();
// 如果share_location_为true，则下面用到的num_loc_classes_为1
// 预测框，感觉还得看源码，之前跳过了就不懂了(caffe_root/src/caffe/util/bbox_util.cpp)：
/*
template <typename Dtype>
void GetLocPredictions(const Dtype* loc_data, const int num,
const int num_preds_per_class, const int num_loc_classes,
const bool share_location, vector<LabelBBox>* loc_preds) {
loc_preds->clear();
if (share_location) {
CHECK_EQ(num_loc_classes, 1);
}
loc_preds->resize(num);
// 下面用到的label_bbox是这么声明的：typedef map<int, vector<NormalizedBBox> > LabelBBox
// 是一个map，key值为label，value值为归一化后的bbox
for (int i = 0; i < num; ++i) {
LabelBBox& label_bbox = (*loc_preds)[i];
for (int p = 0; p < num_preds_per_class; ++p) {
int start_idx = p * num_loc_classes * 4;
for (int c = 0; c < num_loc_classes; ++c) {
int label = share_location ? -1 : c;
// 如果当前label不在map中，则先开辟内存(省时间)
if (label_bbox.find(label) == label_bbox.end()) {
label_bbox[label].resize(num_preds_per_class);
}
// 然后为这一张图的这一个label的bbox赋值
label_bbox[label][p].set_xmin(loc_data[start_idx + c * 4]);
label_bbox[label][p].set_ymin(loc_data[start_idx + c * 4 + 1]);
label_bbox[label][p].set_xmax(loc_data[start_idx + c * 4 + 2]);
label_bbox[label][p].set_ymax(loc_data[start_idx + c * 4 + 3]);
}
}
loc_data += num_preds_per_class * num_loc_classes * 4;
}
}
*/
// Retrieve all location predictions.
vector<LabelBBox> all_loc_preds;
GetLocPredictions(loc_data, num, num_priors_, num_loc_classes_,
share_location_, &all_loc_preds);
// 置信度
// Retrieve all confidences.
vector<map<int, vector<float> > > all_conf_scores;
GetConfidenceScores(conf_data, num, num_priors_, num_classes_,
&all_conf_scores);
// prior box，这里把bbox和variances分别取了出来
// Retrieve all prior bboxes. It is same within a batch since we assume all
// images in a batch are of same dimension.
vector<NormalizedBBox> prior_bboxes;
vector<vector<float> > prior_variances;
GetPriorBBoxes(prior_data, num_priors_, &prior_bboxes, &prior_variances);
// 将归一化的坐标转为实际坐标，拿出源码(caffe_root/src/caffe/util/bbox_util.cpp)来看：
/*
void DecodeBBoxesAll(const vector<LabelBBox>& all_loc_preds,
const vector<NormalizedBBox>& prior_bboxes,
const vector<vector<float> >& prior_variances,
const int num, const bool share_location,
const int num_loc_classes, const int background_label_id,
const CodeType code_type, const bool variance_encoded_in_target,
const bool clip, vector<LabelBBox>* all_decode_bboxes) {
CHECK_EQ(all_loc_preds.size(), num);
all_decode_bboxes->clear();
all_decode_bboxes->resize(num);
// 遍历batch中每一张图
for (int i = 0; i < num; ++i) {
// Decode predictions into bboxes.
LabelBBox& decode_bboxes = (*all_decode_bboxes)[i];
// 遍历每个类别
for (int c = 0; c < num_loc_classes; ++c) {
// 这里看一下是不是共享了检测框
int label = share_location ? -1 : c;
// 忽略背景
if (label == background_label_id) {
// Ignore background class.
continue;
}
// 按道理说此时遍历的每个label都应该存在，因为上面GetLocPredictions函数赋值了
if (all_loc_preds[i].find(label) == all_loc_preds[i].end()) {
// Something bad happened if there are no predictions for current label.
LOG(FATAL) << "Could not find location predictions for label " << label;
}
// 取出每一个label的bbox，求检测框
const vector<NormalizedBBox>& label_loc_preds =
all_loc_preds[i].find(label)->second;
DecodeBBoxes(prior_bboxes, prior_variances,
code_type, variance_encoded_in_target, clip,
label_loc_preds, &(decode_bboxes[label]));
}
}
}
void DecodeBBoxes(
const vector<NormalizedBBox>& prior_bboxes,
const vector<vector<float> >& prior_variances,
const CodeType code_type, const bool variance_encoded_in_target,
const bool clip_bbox, const vector<NormalizedBBox>& bboxes,
vector<NormalizedBBox>* decode_bboxes) {
CHECK_EQ(prior_bboxes.size(), prior_variances.size());
CHECK_EQ(prior_bboxes.size(), bboxes.size());
int num_bboxes = prior_bboxes.size();
if (num_bboxes >= 1) {
CHECK_EQ(prior_variances[0].size(), 4);
}
decode_bboxes->clear();
for (int i = 0; i < num_bboxes; ++i) {
NormalizedBBox decode_bbox;
// 这里拿出每一个bbox求出检测框，调用的代码较长，下面单独贴出
DecodeBBox(prior_bboxes[i], prior_variances[i], code_type,
variance_encoded_in_target, clip_bbox, bboxes[i], &decode_bbox);
decode_bboxes->push_back(decode_bbox);
}
}
*/
// Decode all loc predictions to bboxes.
vector<LabelBBox> all_decode_bboxes;
const bool clip_bbox = false;
DecodeBBoxesAll(all_loc_preds, prior_bboxes, prior_variances, num,
share_location_, num_loc_classes_, background_label_id_,
code_type_, variance_encoded_in_target_, clip_bbox,
&all_decode_bboxes);
// 然后处理这么多的检测框
int num_kept = 0;
vector<map<int, vector<int> > > all_indices;
// num为每个batch图片数
for (int i = 0; i < num; ++i) {
const LabelBBox& decode_bboxes = all_decode_bboxes[i];
const map<int, vector<float> >& conf_scores = all_conf_scores[i];
map<int, vector<int> > indices;
int num_det = 0;
// 遍历每个类别
for (int c = 0; c < num_classes_; ++c) {
// 忽略背景
if (c == background_label_id_) {
// Ignore background class.
continue;
}
if (conf_scores.find(c) == conf_scores.end()) {
// Something bad happened if there are no predictions for current label.
LOG(FATAL) << "Could not find confidence predictions for label " << c;
}
const vector<float>& scores = conf_scores.find(c)->second;
int label = share_location_ ? -1 : c;
if (decode_bboxes.find(label) == decode_bboxes.end()) {
// Something bad happened if there are no predictions for current label.
LOG(FATAL) << "Could not find location predictions for label " << label;
continue;
}
// 进行非极大值抑制操作，去掉重叠框，看看怎么实现的(caffe_root/src/caffe/util/bbox_util.cpp)：
/*
void ApplyNMSFast(const vector<NormalizedBBox>& bboxes,
const vector<float>& scores, const float score_threshold,
const float nms_threshold, const float eta, const int top_k,
vector<int>* indices) {
// Sanity check.
CHECK_EQ(bboxes.size(), scores.size())
<< "bboxes and scores have different size.";
// Get top_k scores (with corresponding indices).
vector<pair<float, int> > score_index_vec;
// 这一步就不贴源码了，过程很简单，就是选出conf在阈值以上的，排序后选top_k
GetMaxScoreIndex(scores, score_threshold, top_k, &score_index_vec);
// Do nms.
float adaptive_threshold = nms_threshold;
indices->clear();
while (score_index_vec.size() != 0) {
const int idx = score_index_vec.front().second;
bool keep = true;
// 判断此框和选中框的IOU，如果都小于阈值，则选中
for (int k = 0; k < indices->size(); ++k) {
if (keep) {
const int kept_idx = (*indices)[k];
// 求出IOU
float overlap = JaccardOverlap(bboxes[idx], bboxes[kept_idx]);
keep = overlap <= adaptive_threshold;
} else {
break;
}
}
// 均小于IOU，选中
if (keep) {
indices->push_back(idx);
}
// 选一个擦除一个
score_index_vec.erase(score_index_vec.begin());
// 这里可以设置一个IOU阈值的衰减，使置信度不太高的框不那么容易被选中了
if (keep && eta < 1 && adaptive_threshold > 0.5) {
adaptive_threshold *= eta;
}
}
}
*/
const vector<NormalizedBBox>& bboxes = decode_bboxes.find(label)->second;
ApplyNMSFast(bboxes, scores, confidence_threshold_, nms_threshold_, eta_,
top_k_, &(indices[c]));
// 出来的indices为检测结果的下标
num_det += indices[c].size();
}
// 下面这一段如果是多类别不共用检测框才被调用
if (keep_top_k_ > -1 && num_det > keep_top_k_) {
vector<pair<float, pair<int, int> > > score_index_pairs;
for (map<int, vector<int> >::iterator it = indices.begin();
it != indices.end(); ++it) {
int label = it->first;
const vector<int>& label_indices = it->second;
if (conf_scores.find(label) == conf_scores.end()) {
// Something bad happened for current label.
LOG(FATAL) << "Could not find location predictions for " << label;
continue;
}
const vector<float>& scores = conf_scores.find(label)->second;
for (int j = 0; j < label_indices.size(); ++j) {
int idx = label_indices[j];
CHECK_LT(idx, scores.size());
score_index_pairs.push_back(std::make_pair(
scores[idx], std::make_pair(label, idx)));
}
}
// Keep top k results per image.
std::sort(score_index_pairs.begin(), score_index_pairs.end(),
SortScorePairDescend<pair<int, int> >);
score_index_pairs.resize(keep_top_k_);
// Store the new indices.
map<int, vector<int> > new_indices;
for (int j = 0; j < score_index_pairs.size(); ++j) {
int label = score_index_pairs[j].second.first;
int idx = score_index_pairs[j].second.second;
new_indices[label].push_back(idx);
}
all_indices.push_back(new_indices);
num_kept += keep_top_k_;
}
else {
// 记录进总结果中(各个batch结果的整合)
all_indices.push_back(indices);
num_kept += num_det;
}
}
vector<int> top_shape(2, 1);
top_shape.push_back(num_kept);
top_shape.push_back(7);
Dtype* top_data;
// 如果这一组batch没有一个检测框QAQ
if (num_kept == 0) {
LOG(INFO) << "Couldn't find any detections";
top_shape[2] = num;
top[0]->Reshape(top_shape);
top_data = top[0]->mutable_cpu_data();
// 这里写入了-1
caffe_set<Dtype>(top[0]->count(), -1, top_data);
// Generate fake results per image.
for (int i = 0; i < num; ++i) {
top_data[0] = i;
top_data += 7;
}
}
// 否则就Reshape啦
else {
top[0]->Reshape(top_shape);
top_data = top[0]->mutable_cpu_data();
}
// 写入top
int count = 0;
boost::filesystem::path output_directory(output_directory_);
for (int i = 0; i < num; ++i) {
const map<int, vector<float> >& conf_scores = all_conf_scores[i];
const LabelBBox& decode_bboxes = all_decode_bboxes[i];
for (map<int, vector<int> >::iterator it = all_indices[i].begin();
it != all_indices[i].end(); ++it) {
int label = it->first;
if (conf_scores.find(label) == conf_scores.end()) {
// Something bad happened if there are no predictions for current label.
LOG(FATAL) << "Could not find confidence predictions for " << label;
continue;
}
const vector<float>& scores = conf_scores.find(label)->second;
int loc_label = share_location_ ? -1 : label;
if (decode_bboxes.find(loc_label) == decode_bboxes.end()) {
// Something bad happened if there are no predictions for current label.
LOG(FATAL) << "Could not find location predictions for " << loc_label;
continue;
}
const vector<NormalizedBBox>& bboxes =
decode_bboxes.find(loc_label)->second;
vector<int>& indices = it->second;
if (need_save_) {
CHECK(label_to_name_.find(label) != label_to_name_.end())
<< "Cannot find label: " << label << " in the label map.";
CHECK_LT(name_count_, names_.size());
}
for (int j = 0; j < indices.size(); ++j) {
// 按位置放入数据
int idx = indices[j];
top_data[count * 7] = i;
top_data[count * 7 + 1] = label;
top_data[count * 7 + 2] = scores[idx];
const NormalizedBBox& bbox = bboxes[idx];
top_data[count * 7 + 3] = bbox.xmin();
top_data[count * 7 + 4] = bbox.ymin();
top_data[count * 7 + 5] = bbox.xmax();
top_data[count * 7 + 6] = bbox.ymax();
if (need_save_) {
NormalizedBBox out_bbox;
OutputBBox(bbox, sizes_[name_count_], has_resize_, resize_param_,
&out_bbox);
float score = top_data[count * 7 + 2];
float xmin = out_bbox.xmin();
float ymin = out_bbox.ymin();
float xmax = out_bbox.xmax();
float ymax = out_bbox.ymax();
// 前面用的float计算，这里要四舍五入了
ptree pt_xmin, pt_ymin, pt_width, pt_height;
pt_xmin.put<float>("", round(xmin * 100) / 100.);
pt_ymin.put<float>("", round(ymin * 100) / 100.);
pt_width.put<float>("", round((xmax - xmin) * 100) / 100.);
pt_height.put<float>("", round((ymax - ymin) * 100) / 100.);
ptree cur_bbox;
cur_bbox.push_back(std::make_pair("", pt_xmin));
cur_bbox.push_back(std::make_pair("", pt_ymin));
cur_bbox.push_back(std::make_pair("", pt_width));
cur_bbox.push_back(std::make_pair("", pt_height));
ptree cur_det;
cur_det.put("image_id", names_[name_count_]);
if (output_format_ == "ILSVRC") {
cur_det.put<int>("category_id", label);
} else {
cur_det.put("category_id", label_to_name_[label].c_str());
}
cur_det.add_child("bbox", cur_bbox);
cur_det.put<float>("score", score);
detections_.push_back(std::make_pair("", cur_det));
}
++count;
}
}
// 如果设置了需要存储，按指定格式存就行啦，没必要看了
if (need_save_) {
++name_count_;
if (name_count_ % num_test_image_ == 0) {
if (output_format_ == "VOC") {
map<string, std::ofstream*> outfiles;
for (int c = 0; c < num_classes_; ++c) {
if (c == background_label_id_) {
continue;
}
string label_name = label_to_name_[c];
boost::filesystem::path file(
output_name_prefix_ + label_name + ".txt");
boost::filesystem::path out_file = output_directory / file;
outfiles[label_name] = new std::ofstream(out_file.string().c_str(),
std::ofstream::out);
}
BOOST_FOREACH(ptree::value_type &det, detections_.get_child("")) {
ptree pt = det.second;
string label_name = pt.get<string>("category_id");
if (outfiles.find(label_name) == outfiles.end()) {
std::cout << "Cannot find " << label_name << std::endl;
continue;
}
string image_name = pt.get<string>("image_id");
float score = pt.get<float>("score");
vector<int> bbox;
BOOST_FOREACH(ptree::value_type &elem, pt.get_child("bbox")) {
bbox.push_back(static_cast<int>(elem.second.get_value<float>()));
}
*(outfiles[label_name]) << image_name;
*(outfiles[label_name]) << " " << score;
*(outfiles[label_name]) << " " << bbox[0] << " " << bbox[1];
*(outfiles[label_name]) << " " << bbox[0] + bbox[2];
*(outfiles[label_name]) << " " << bbox[1] + bbox[3];
*(outfiles[label_name]) << std::endl;
}
for (int c = 0; c < num_classes_; ++c) {
if (c == background_label_id_) {
continue;
}
string label_name = label_to_name_[c];
outfiles[label_name]->flush();
outfiles[label_name]->close();
delete outfiles[label_name];
}
} else if (output_format_ == "COCO") {
boost::filesystem::path output_directory(output_directory_);
boost::filesystem::path file(output_name_prefix_ + ".json");
boost::filesystem::path out_file = output_directory / file;
std::ofstream outfile;
outfile.open(out_file.string().c_str(), std::ofstream::out);
boost::regex exp("\"(null|true|false|-?[0-9]+(\\.[0-9]+)?)\"");
ptree output;
output.add_child("detections", detections_);
std::stringstream ss;
//write_json(ss, output);
std::string rv = boost::regex_replace(ss.str(), exp, "$1");
outfile << rv.substr(rv.find("["), rv.rfind("]") - rv.find("["))
<< std::endl << "]" << std::endl;
} else if (output_format_ == "ILSVRC") {
boost::filesystem::path output_directory(output_directory_);
boost::filesystem::path file(output_name_prefix_ + ".txt");
boost::filesystem::path out_file = output_directory / file;
std::ofstream outfile;
outfile.open(out_file.string().c_str(), std::ofstream::out);
BOOST_FOREACH(ptree::value_type &det, detections_.get_child("")) {
ptree pt = det.second;
int label = pt.get<int>("category_id");
string image_name = pt.get<string>("image_id");
float score = pt.get<float>("score");
vector<int> bbox;
BOOST_FOREACH(ptree::value_type &elem, pt.get_child("bbox")) {
bbox.push_back(static_cast<int>(elem.second.get_value<float>()));
}
outfile << image_name << " " << label << " " << score;
outfile << " " << bbox[0] << " " << bbox[1];
outfile << " " << bbox[0] + bbox[2];
outfile << " " << bbox[1] + bbox[3];
outfile << std::endl;
}
}
name_count_ = 0;
detections_.clear();
}
}
}
if (visualize_) {
#ifdef USE_OPENCV
vector<cv::Mat> cv_imgs;
this->data_transformer_->TransformInv(bottom[3], &cv_imgs);
vector<cv::Scalar> colors = GetColors(label_to_display_name_.size());
VisualizeBBox(cv_imgs, top[0], visualize_threshold_, colors,
label_to_display_name_, save_file_);
#endif // USE_OPENCV
}
}
#ifdef CPU_ONLY
STUB_GPU_FORWARD(DetectionOutputLayer, Forward);
#endif
INSTANTIATE_CLASS(DetectionOutputLayer);
REGISTER_LAYER_CLASS(DetectionOutput);
} // namespace caffeDecodeBBox函数(caffe_root/src/caffe/util/bbox_util.cpp)
// 从loc和prior box中取出检测框
// 主要用到的数据有prior box，variance，label_bbox(从loc中分析得到，带标签)
void DecodeBBox(
const NormalizedBBox& prior_bbox, const vector<float>& prior_variance,
const CodeType code_type, const bool variance_encoded_in_target,
const bool clip_bbox, const NormalizedBBox& bbox,
NormalizedBBox* decode_bbox) {
// 以下分各个code_type来处理，表示loc是什么形式的偏移
// CORNER为基于左上角坐标的正(方向)偏移
if (code_type == PriorBoxParameter_CodeType_CORNER) {
if (variance_encoded_in_target) {
// variance is encoded in target, we simply need to add the offset
// predictions.
decode_bbox->set_xmin(prior_bbox.xmin() + bbox.xmin());
decode_bbox->set_ymin(prior_bbox.ymin() + bbox.ymin());
decode_bbox->set_xmax(prior_bbox.xmax() + bbox.xmax());
decode_bbox->set_ymax(prior_bbox.ymax() + bbox.ymax());
} else {
// variance is encoded in bbox, we need to scale the offset accordingly.
decode_bbox->set_xmin(
prior_bbox.xmin() + prior_variance[0] * bbox.xmin());
decode_bbox->set_ymin(
prior_bbox.ymin() + prior_variance[1] * bbox.ymin());
decode_bbox->set_xmax(
prior_bbox.xmax() + prior_variance[2] * bbox.xmax());
decode_bbox->set_ymax(
prior_bbox.ymax() + prior_variance[3] * bbox.ymax());
}
}
// CENTER_SIZE，我一直用的是这个，表示的是中心和边长的偏移(计算起来好像有点复杂?莫非是方便回归)
else if (code_type == PriorBoxParameter_CodeType_CENTER_SIZE) {
float prior_width = prior_bbox.xmax() - prior_bbox.xmin();
CHECK_GT(prior_width, 0);
float prior_height = prior_bbox.ymax() - prior_bbox.ymin();
CHECK_GT(prior_height, 0);
float prior_center_x = (prior_bbox.xmin() + prior_bbox.xmax()) / 2.;
float prior_center_y = (prior_bbox.ymin() + prior_bbox.ymax()) / 2.;
float decode_bbox_center_x, decode_bbox_center_y;
float decode_bbox_width, decode_bbox_height;
if (variance_encoded_in_target) {
// variance is encoded in target, we simply need to retore the offset
// predictions.
decode_bbox_center_x = bbox.xmin() * prior_width + prior_center_x;
decode_bbox_center_y = bbox.ymin() * prior_height + prior_center_y;
decode_bbox_width = exp(bbox.xmax()) * prior_width;
decode_bbox_height = exp(bbox.ymax()) * prior_height;
} else {
// variance is encoded in bbox, we need to scale the offset accordingly.
decode_bbox_center_x =
prior_variance[0] * bbox.xmin() * prior_width + prior_center_x;
decode_bbox_center_y =
prior_variance[1] * bbox.ymin() * prior_height + prior_center_y;
decode_bbox_width =
exp(prior_variance[2] * bbox.xmax()) * prior_width;
decode_bbox_height =
exp(prior_variance[3] * bbox.ymax()) * prior_height;
}
// 然后转成两个坐标的形式
decode_bbox->set_xmin(decode_bbox_center_x - decode_bbox_width / 2.);
decode_bbox->set_ymin(decode_bbox_center_y - decode_bbox_height / 2.);
decode_bbox->set_xmax(decode_bbox_center_x + decode_bbox_width / 2.);
decode_bbox->set_ymax(decode_bbox_center_y + decode_bbox_height / 2.);
}
// CORNER_SIZE也是存的坐标，但偏移和框的长宽有关
else if (code_type == PriorBoxParameter_CodeType_CORNER_SIZE) {
float prior_width = prior_bbox.xmax() - prior_bbox.xmin();
CHECK_GT(prior_width, 0);
float prior_height = prior_bbox.ymax() - prior_bbox.ymin();
CHECK_GT(prior_height, 0);
if (variance_encoded_in_target) {
// variance is encoded in target, we simply need to add the offset
// predictions.
decode_bbox->set_xmin(prior_bbox.xmin() + bbox.xmin() * prior_width);
decode_bbox->set_ymin(prior_bbox.ymin() + bbox.ymin() * prior_height);
decode_bbox->set_xmax(prior_bbox.xmax() + bbox.xmax() * prior_width);
decode_bbox->set_ymax(prior_bbox.ymax() + bbox.ymax() * prior_height);
} else {
// variance is encoded in bbox, we need to scale the offset accordingly.
decode_bbox->set_xmin(
prior_bbox.xmin() + prior_variance[0] * bbox.xmin() * prior_width);
decode_bbox->set_ymin(
prior_bbox.ymin() + prior_variance[1] * bbox.ymin() * prior_height);
decode_bbox->set_xmax(
prior_bbox.xmax() + prior_variance[2] * bbox.xmax() * prior_width);
decode_bbox->set_ymax(
prior_bbox.ymax() + prior_variance[3] * bbox.ymax() * prior_height);
}
} else {
LOG(FATAL) << "Unknown LocLossType.";
}
float bbox_size = BBoxSize(*decode_bbox);
decode_bbox->set_size(bbox_size);
// 剪裁掉出界的部分
if (clip_bbox) {
ClipBBox(*decode_bbox, decode_bbox);
}
}