struct type *type_new_from_ast(struct ast *ast) {
switch (ast->type) {
case SYN_VOID:
assert(is_valid_void(ast));
return type_new_void();
case SYN_BOOL:
assert(is_valid_bool(ast));
return type_new_bool();
case SYN_BYTE:
assert(is_valid_byte(ast));
return type_new_byte();
case SYN_SHORT:
assert(is_valid_short(ast));
return type_new_short();
case SYN_INT:
assert(is_valid_int(ast));
return type_new_int();
case SYN_LONG:
assert(is_valid_long(ast));
return type_new_long();
case SYN_UBYTE:
assert(is_valid_ubyte(ast));
return type_new_ubyte();
case SYN_USHORT:
assert(is_valid_ushort(ast));
return type_new_ushort();
case SYN_UINT:
assert(is_valid_uint(ast));
return type_new_uint();
case SYN_ULONG:
assert(is_valid_ulong(ast));
return type_new_ulong();
case SYN_HALF:
assert(is_valid_half(ast));
return type_new_half();
case SYN_FLOAT:
assert(is_valid_float(ast));
return type_new_float();
case SYN_DOUBLE:
assert(is_valid_double(ast));
return type_new_double();
case SYN_POINTER:
assert(is_valid_pointer(ast));
return pointer_ast(&ast->val.op);
case SYN_ARRAY:
assert(is_valid_array(ast));
return array_ast(&ast->val.op);
case SYN_ARRAY_UNDEFINED_SIZE:
assert(is_valid_array_undefined_size(ast));
return array_undefined_size_ast(&ast->val.op);
case SYN_FUNCTION:
assert(is_valid_function(ast));
return function_ast(&ast->val.op);
default:
ERROR_HERE;
}
}
arma::mat DeepPCA::calculateFeature(cv::Mat &processedImage,
std::vector<cv::Rect> &rects) {
arma::mat x(static_cast<int>(rects.size()), fullFeatureSize,
arma::fill::zeros);
cv::Size size(this->imageSizeWidth, this->imageSizeHeight);
std::vector<cv::Mat> images;
std::vector<int> labels;
for (int i = 0; i < rects.size(); i++) {
cv::Mat roi;
roi = processedImage(rects[i]);
cv::Mat resizedRoi;
cv::resize(roi, resizedRoi, size);
images.push_back(resizedRoi);
labels.push_back(0);
}
LOG(INFO) << "Started extracting deep features for " << rects.size()
<< " bounding boxes";
boost::shared_ptr<caffe::MemoryDataLayer<float>> md_layer =
boost::dynamic_pointer_cast<caffe::MemoryDataLayer<float>>(
caffe_net->layers()[0]);
md_layer->set_batch_size(rects.size());
md_layer->AddMatVector(images, labels);
float loss;
caffe_net->ForwardPrefilled(&loss);
boost::shared_ptr<caffe::Blob<float>> prob = caffe_net->blob_by_name("fc7");
LOG(INFO) << "Finished extracting deep features...";
int dim = this->fullFeatureSize;
for (int v = 0; v < rects.size(); v++) {
for (int i = 0; i < dim; i++) {
x(v, i) = prob->cpu_data()[v * dim + i];
}
}
// copy the data into cv::Mat
int n = rects.size();
int m = this->fullFeatureSize;
cv::Mat data(n, m, CV_64F);
int k = this->featureSize;
if (!this->isBasisSet) {
max_elms = arma::max(x, 0);
min_elms = arma::min(x, 0);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if ((max_elms(j) - min_elms(j)) == 0) {
x(i, j) = 0;
} else {
// x(i, j) = (x(i, j) - arma_mean(0, j)) / arma_std(0, j);
//x(i, j) = (x(i, j) - min_elms(j)) / (max_elms(j) - min_elms(j));
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
data.at<double>(i, j) = x(i, j);
}
}
if (!this->isBasisSet) {
LOG(INFO) << "Starting PCA extraction";
pca = new cv::PCA(data, cv::Mat(), CV_PCA_DATA_AS_ROW, k);
LOG(INFO) << "Finished PCA extraction";
}
cv::Mat coeff(1, k, CV_64F);
arma::mat projected_x(n, k, arma::fill::zeros);
LOG(INFO) << "n : " << n << " m: " << m << " k: " << k;
for (int l = 0; l < n; l++) {
cv::Mat vec = data.row(l);
pca->project(vec, coeff);
for (int j = 0; j < k; j++) {
double v = coeff.at<double>(0, j);
if (is_valid_double(v)) {
projected_x(l, j) = coeff.at<double>(0, j);
CHECK_EQ(projected_x(l, j), coeff.at<double>(0, j));
}
}
}
this->isBasisSet = true;
LOG(INFO) << "Max / Min : " << projected_x.max() << " / "
<< projected_x.min();
LOG(INFO) << "Finished calculating projections. ";
return projected_x;
}
