|
#include "vp_face_swap_node.h"
|
|
namespace vp_nodes {
|
|
vp_face_swap_node::vp_face_swap_node(std::string node_name,
|
std::string yunet_face_detect_model,
|
std::string buffalo_l_face_encoding_model,
|
std::string emap_file_for_embeddings,
|
std::string insightface_swap_model,
|
std::string swap_source_image,
|
int swap_source_face_index,
|
int min_face_w_h,
|
bool swap_on_osd,
|
bool act_as_primary_detector):
|
vp_primary_infer_node(node_name, ""),
|
act_as_primary_detector(act_as_primary_detector),
|
swap_on_osd(swap_on_osd),
|
min_face_w_h(min_face_w_h) {
|
/* init net*/
|
face_extract_net = cv::dnn::readNetFromONNX(yunet_face_detect_model);
|
face_encoding_net = cv::dnn::readNetFromONNX(buffalo_l_face_encoding_model);
|
face_swap_net = cv::dnn::readNetFromONNX(insightface_swap_model);
|
#ifdef VP_WITH_CUDA
|
face_extract_net.setPreferableBackend(cv::dnn::DNN_BACKEND_CUDA);
|
face_extract_net.setPreferableTarget(cv::dnn::DNN_TARGET_CUDA);
|
face_encoding_net.setPreferableBackend(cv::dnn::DNN_BACKEND_CUDA);
|
face_encoding_net.setPreferableTarget(cv::dnn::DNN_TARGET_CUDA);
|
face_swap_net.setPreferableBackend(cv::dnn::DNN_BACKEND_CUDA);
|
face_swap_net.setPreferableTarget(cv::dnn::DNN_TARGET_CUDA);
|
#endif
|
init_source_face_embeddings(swap_source_image, swap_source_face_index, emap_file_for_embeddings);
|
this->initialized();
|
}
|
|
vp_face_swap_node::~vp_face_swap_node() {
|
deinitialized();
|
}
|
|
// please refer to vp_infer_node::run_infer_combinations
|
void vp_face_swap_node::run_infer_combinations(const std::vector<std::shared_ptr<vp_objects::vp_frame_meta>>& frame_meta_with_batch) {
|
assert(frame_meta_with_batch.size() == 1);
|
auto& frame_meta = frame_meta_with_batch[0];
|
|
if (frame_meta->face_targets.size() == 0) {
|
if (!act_as_primary_detector) {
|
return;
|
}
|
// extract faces and update back to frame meta
|
// to-do
|
}
|
|
auto start_time = std::chrono::system_clock::now();
|
// iterate each face target
|
for (int i = 0; i < frame_meta->face_targets.size(); i++) {
|
if (frame_meta->face_targets[i]->width < min_face_w_h || frame_meta->face_targets[i]->height < min_face_w_h) {
|
continue;
|
}
|
|
cv::Mat aligned_face, swapped_face;
|
|
//auto t = std::chrono::system_clock::now();
|
// align and crop first
|
auto warp_mat = align_crop(frame_meta->frame, frame_meta->face_targets[i]->key_points, aligned_face);
|
//auto T = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now() - t).count();
|
|
//std::cout << "1st T:" << T << std::endl;
|
//t = std::chrono::system_clock::now();
|
// swap
|
swap(aligned_face, swapped_face);
|
//T = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now() - t).count();
|
//std::cout << "2nd T:" << T << std::endl;
|
|
//t = std::chrono::system_clock::now();
|
// past back to frame or osd frame
|
if (swap_on_osd) {
|
if (frame_meta->osd_frame.empty()) {
|
frame_meta->osd_frame = frame_meta->frame.clone();
|
}
|
}
|
auto& bg = swap_on_osd ? frame_meta->osd_frame : frame_meta->frame;
|
paste_back(bg, swapped_face, warp_mat);
|
//T = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now() - t).count();
|
//std::cout << "3rd T:" << T << std::endl;
|
}
|
|
//auto total_time = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now() - start_time).count();
|
//std::cout << "total T:" << total_time << std::endl;
|
}
|
|
cv::Mat vp_face_swap_node::read_emap_mat_from_txt(const std::string& emap_file_for_embeddings, int rows, int cols) {
|
std::ifstream file(emap_file_for_embeddings);
|
|
cv::Mat matrix(rows, cols, CV_32F);
|
std::string line;
|
for (int i = 0; i < rows; ++i) {
|
std::getline(file, line);
|
std::istringstream iss(line);
|
for (int j = 0; j < cols; ++j) {
|
float value;
|
assert(iss >> value);
|
matrix.at<float>(i, j) = value;
|
}
|
}
|
file.close();
|
return matrix;
|
}
|
|
cv::Mat vp_face_swap_node::process_embeddings_using_emap(const cv::Mat& source_face_normed_embedding, const cv::Mat& emap) {
|
cv::Mat latent = source_face_normed_embedding.clone().reshape(1, 1);
|
cv::Mat result = latent * emap;
|
cv::normalize(result, result);
|
return result;
|
}
|
|
cv::Mat vp_face_swap_node::get_similarity_transform_matrix(float src[5][2]) {
|
using namespace cv;
|
//float dst[5][2] = { {38.2946f, 51.6963f}, {73.5318f, 51.5014f}, {56.0252f, 71.7366f}, {41.5493f, 92.3655f}, {70.7299f, 92.2041f} }; // for 112*112
|
float dst[5][2] = { {43.0f, 58.0f}, {85.0f, 58.0f}, {64.0f, 81.0f}, {47.0f, 105.0f}, {80.0f, 105.0f} }; // for 128*128
|
//float dst[5][2] = { {38.0f, 54.0f}, {90.0f, 54.0f}, {64.0f, 85.0f}, {47.0f, 109.0f}, {80.0f, 109.0f} }; // for 128*128, zoom out
|
float avg0 = (src[0][0] + src[1][0] + src[2][0] + src[3][0] + src[4][0]) / 5;
|
float avg1 = (src[0][1] + src[1][1] + src[2][1] + src[3][1] + src[4][1]) / 5;
|
//Compute mean of src and dst.
|
float src_mean[2] = { avg0, avg1 };
|
float dst_mean[2] = { 56.0262f, 71.9008f };
|
//Subtract mean from src and dst.
|
float src_demean[5][2];
|
for (int i = 0; i < 2; i++)
|
{
|
for (int j = 0; j < 5; j++)
|
{
|
src_demean[j][i] = src[j][i] - src_mean[i];
|
}
|
}
|
float dst_demean[5][2];
|
for (int i = 0; i < 2; i++)
|
{
|
for (int j = 0; j < 5; j++)
|
{
|
dst_demean[j][i] = dst[j][i] - dst_mean[i];
|
}
|
}
|
double A00 = 0.0, A01 = 0.0, A10 = 0.0, A11 = 0.0;
|
for (int i = 0; i < 5; i++)
|
A00 += dst_demean[i][0] * src_demean[i][0];
|
A00 = A00 / 5;
|
for (int i = 0; i < 5; i++)
|
A01 += dst_demean[i][0] * src_demean[i][1];
|
A01 = A01 / 5;
|
for (int i = 0; i < 5; i++)
|
A10 += dst_demean[i][1] * src_demean[i][0];
|
A10 = A10 / 5;
|
for (int i = 0; i < 5; i++)
|
A11 += dst_demean[i][1] * src_demean[i][1];
|
A11 = A11 / 5;
|
Mat A = (Mat_<double>(2, 2) << A00, A01, A10, A11);
|
double d[2] = { 1.0, 1.0 };
|
double detA = A00 * A11 - A01 * A10;
|
if (detA < 0)
|
d[1] = -1;
|
double T[3][3] = { {1.0, 0.0, 0.0}, {0.0, 1.0, 0.0}, {0.0, 0.0, 1.0} };
|
Mat s, u, vt, v;
|
SVD::compute(A, s, u, vt);
|
double smax = s.ptr<double>(0)[0]>s.ptr<double>(1)[0] ? s.ptr<double>(0)[0] : s.ptr<double>(1)[0];
|
double tol = smax * 2 * FLT_MIN;
|
int rank = 0;
|
if (s.ptr<double>(0)[0]>tol)
|
rank += 1;
|
if (s.ptr<double>(1)[0]>tol)
|
rank += 1;
|
double arr_u[2][2] = { {u.ptr<double>(0)[0], u.ptr<double>(0)[1]}, {u.ptr<double>(1)[0], u.ptr<double>(1)[1]} };
|
double arr_vt[2][2] = { {vt.ptr<double>(0)[0], vt.ptr<double>(0)[1]}, {vt.ptr<double>(1)[0], vt.ptr<double>(1)[1]} };
|
double det_u = arr_u[0][0] * arr_u[1][1] - arr_u[0][1] * arr_u[1][0];
|
double det_vt = arr_vt[0][0] * arr_vt[1][1] - arr_vt[0][1] * arr_vt[1][0];
|
if (rank == 1)
|
{
|
if ((det_u*det_vt) > 0)
|
{
|
Mat uvt = u*vt;
|
T[0][0] = uvt.ptr<double>(0)[0];
|
T[0][1] = uvt.ptr<double>(0)[1];
|
T[1][0] = uvt.ptr<double>(1)[0];
|
T[1][1] = uvt.ptr<double>(1)[1];
|
}
|
else
|
{
|
double temp = d[1];
|
d[1] = -1;
|
Mat D = (Mat_<double>(2, 2) << d[0], 0.0, 0.0, d[1]);
|
Mat Dvt = D*vt;
|
Mat uDvt = u*Dvt;
|
T[0][0] = uDvt.ptr<double>(0)[0];
|
T[0][1] = uDvt.ptr<double>(0)[1];
|
T[1][0] = uDvt.ptr<double>(1)[0];
|
T[1][1] = uDvt.ptr<double>(1)[1];
|
d[1] = temp;
|
}
|
}
|
else
|
{
|
Mat D = (Mat_<double>(2, 2) << d[0], 0.0, 0.0, d[1]);
|
Mat Dvt = D*vt;
|
Mat uDvt = u*Dvt;
|
T[0][0] = uDvt.ptr<double>(0)[0];
|
T[0][1] = uDvt.ptr<double>(0)[1];
|
T[1][0] = uDvt.ptr<double>(1)[0];
|
T[1][1] = uDvt.ptr<double>(1)[1];
|
}
|
double var1 = 0.0;
|
for (int i = 0; i < 5; i++)
|
var1 += src_demean[i][0] * src_demean[i][0];
|
var1 = var1 / 5;
|
double var2 = 0.0;
|
for (int i = 0; i < 5; i++)
|
var2 += src_demean[i][1] * src_demean[i][1];
|
var2 = var2 / 5;
|
double scale = 1.0 / (var1 + var2)* (s.ptr<double>(0)[0] * d[0] + s.ptr<double>(1)[0] * d[1]);
|
double TS[2];
|
TS[0] = T[0][0] * src_mean[0] + T[0][1] * src_mean[1];
|
TS[1] = T[1][0] * src_mean[0] + T[1][1] * src_mean[1];
|
T[0][2] = dst_mean[0] - scale*TS[0];
|
T[1][2] = dst_mean[1] - scale*TS[1];
|
T[0][0] *= scale;
|
T[0][1] *= scale;
|
T[1][0] *= scale;
|
T[1][1] *= scale;
|
Mat transform_mat = (Mat_<double>(2, 3) << T[0][0], T[0][1], T[0][2], T[1][0], T[1][1], T[1][2]);
|
return transform_mat;
|
}
|
|
cv::Mat vp_face_swap_node::align_crop(cv::Mat& src_img, std::vector<std::pair<int, int>>& kps, cv::Mat& aligned_image) {
|
float face_keypoints[5][2] =
|
{{kps[0].first, kps[0].second},
|
{kps[1].first, kps[1].second},
|
{kps[2].first, kps[2].second},
|
{kps[3].first, kps[3].second},
|
{kps[4].first, kps[4].second}};
|
|
cv::Mat warp_mat = get_similarity_transform_matrix(face_keypoints);
|
cv::warpAffine(src_img, aligned_image, warp_mat, cv::Size(128, 128), cv::INTER_LINEAR);
|
return warp_mat;
|
}
|
|
void vp_face_swap_node::extract_faces(const cv::Mat& frame, std::vector<face_box>& face_boxes) {
|
auto blob_to_infer = cv::dnn::blobFromImage(frame);
|
face_extract_net.setInput(blob_to_infer);
|
const std::vector<std::string> out_names = {"loc", "conf", "iou"};
|
std::vector<cv::Mat> raw_outputs;
|
face_extract_net.forward(raw_outputs, out_names);
|
|
using namespace cv;
|
float scoreThreshold = 0.7;
|
float nmsThreshold = 0.5;
|
int topK = 50;
|
int inputW = frame.cols;
|
int inputH = frame.rows;
|
|
// 3 heads of output
|
assert(raw_outputs.size() == 3);
|
|
// Extract from output_blobs
|
Mat loc = raw_outputs[0];
|
Mat conf = raw_outputs[1];
|
Mat iou = raw_outputs[2];
|
|
// we need generate priors if input size changed or priors is not initialized
|
if (loc.rows != priors.size()) {
|
generatePriors(inputW, inputH);
|
}
|
|
assert(loc.rows == priors.size());
|
assert(loc.rows == conf.rows);
|
assert(loc.rows == iou.rows);
|
|
// Decode from deltas and priors
|
const std::vector<float> variance = {0.1f, 0.2f};
|
float* loc_v = (float*)(loc.data);
|
float* conf_v = (float*)(conf.data);
|
float* iou_v = (float*)(iou.data);
|
Mat faces;
|
// (tl_x, tl_y, w, h, re_x, re_y, le_x, le_y, nt_x, nt_y, rcm_x, rcm_y, lcm_x, lcm_y, score)
|
// 'tl': top left point of the bounding box
|
// 're': right eye, 'le': left eye
|
// 'nt': nose tip
|
// 'rcm': right corner of mouth, 'lcm': left corner of mouth
|
Mat face(1, 15, CV_32FC1);
|
for (size_t i = 0; i < priors.size(); ++i) {
|
// Get score
|
float clsScore = conf_v[i*2+1];
|
float iouScore = iou_v[i];
|
// Clamp
|
if (iouScore < 0.f) {
|
iouScore = 0.f;
|
}
|
else if (iouScore > 1.f) {
|
iouScore = 1.f;
|
}
|
float score = std::sqrt(clsScore * iouScore);
|
face.at<float>(0, 14) = score;
|
|
// Get bounding box
|
float cx = (priors[i].x + loc_v[i*14+0] * variance[0] * priors[i].width) * inputW;
|
float cy = (priors[i].y + loc_v[i*14+1] * variance[0] * priors[i].height) * inputH;
|
float w = priors[i].width * exp(loc_v[i*14+2] * variance[0]) * inputW;
|
float h = priors[i].height * exp(loc_v[i*14+3] * variance[1]) * inputH;
|
float x1 = cx - w / 2;
|
float y1 = cy - h / 2;
|
face.at<float>(0, 0) = x1;
|
face.at<float>(0, 1) = y1;
|
face.at<float>(0, 2) = w;
|
face.at<float>(0, 3) = h;
|
|
// Get landmarks
|
face.at<float>(0, 4) = (priors[i].x + loc_v[i*14+ 4] * variance[0] * priors[i].width) * inputW; // right eye, x
|
face.at<float>(0, 5) = (priors[i].y + loc_v[i*14+ 5] * variance[0] * priors[i].height) * inputH; // right eye, y
|
face.at<float>(0, 6) = (priors[i].x + loc_v[i*14+ 6] * variance[0] * priors[i].width) * inputW; // left eye, x
|
face.at<float>(0, 7) = (priors[i].y + loc_v[i*14+ 7] * variance[0] * priors[i].height) * inputH; // left eye, y
|
face.at<float>(0, 8) = (priors[i].x + loc_v[i*14+ 8] * variance[0] * priors[i].width) * inputW; // nose tip, x
|
face.at<float>(0, 9) = (priors[i].y + loc_v[i*14+ 9] * variance[0] * priors[i].height) * inputH; // nose tip, y
|
face.at<float>(0, 10) = (priors[i].x + loc_v[i*14+10] * variance[0] * priors[i].width) * inputW; // right corner of mouth, x
|
face.at<float>(0, 11) = (priors[i].y + loc_v[i*14+11] * variance[0] * priors[i].height) * inputH; // right corner of mouth, y
|
face.at<float>(0, 12) = (priors[i].x + loc_v[i*14+12] * variance[0] * priors[i].width) * inputW; // left corner of mouth, x
|
face.at<float>(0, 13) = (priors[i].y + loc_v[i*14+13] * variance[0] * priors[i].height) * inputH; // left corner of mouth, y
|
|
faces.push_back(face);
|
}
|
|
if (faces.rows > 1) {
|
// Retrieve boxes and scores
|
std::vector<Rect2i> faceBoxes;
|
std::vector<float> faceScores;
|
for (int rIdx = 0; rIdx < faces.rows; rIdx++)
|
{
|
faceBoxes.push_back(Rect2i(int(faces.at<float>(rIdx, 0)),
|
int(faces.at<float>(rIdx, 1)),
|
int(faces.at<float>(rIdx, 2)),
|
int(faces.at<float>(rIdx, 3))));
|
faceScores.push_back(faces.at<float>(rIdx, 14));
|
}
|
|
std::vector<int> keepIdx;
|
dnn::NMSBoxes(faceBoxes, faceScores, scoreThreshold, nmsThreshold, keepIdx, 1.f, topK);
|
|
// Get NMS results
|
Mat nms_faces;
|
for (int idx: keepIdx)
|
{
|
nms_faces.push_back(faces.row(idx));
|
}
|
|
// insert face target back to frame meta
|
for (int i = 0; i < nms_faces.rows; i++) {
|
auto x = int(nms_faces.at<float>(i, 0));
|
auto y = int(nms_faces.at<float>(i, 1));
|
auto w = int(nms_faces.at<float>(i, 2));
|
auto h = int(nms_faces.at<float>(i, 3));
|
|
// check value range
|
x = std::max(x, 0);
|
y = std::max(y, 0);
|
w = std::min(w, frame.cols - x);
|
h = std::min(h, frame.rows - y);
|
|
auto kp1 = std::pair<int, int>(int(nms_faces.at<float>(i, 4)), int(nms_faces.at<float>(i, 5)));
|
auto kp2 = std::pair<int, int>(int(nms_faces.at<float>(i, 6)), int(nms_faces.at<float>(i, 7)));
|
auto kp3 = std::pair<int, int>(int(nms_faces.at<float>(i, 8)), int(nms_faces.at<float>(i, 9)));
|
auto kp4 = std::pair<int, int>(int(nms_faces.at<float>(i, 10)), int(nms_faces.at<float>(i, 11)));
|
auto kp5 = std::pair<int, int>(int(nms_faces.at<float>(i, 12)), int(nms_faces.at<float>(i, 13)));
|
auto score = nms_faces.at<float>(i, 14);
|
|
face_box face;
|
face.x = x;
|
face.y = y;
|
face.width = w;
|
face.height = h;
|
face.score = score;
|
face.kps = std::vector<std::pair<int, int>>{kp1, kp2, kp3, kp4, kp5};
|
face_boxes.push_back(face);
|
}
|
}
|
}
|
|
void vp_face_swap_node::init_source_face_embeddings(std::string& swap_source_image, int swap_source_face_index, std::string& emap_file_for_embeddings) {
|
std::vector<face_box> source_faces;
|
auto source_mat = cv::imread(swap_source_image);
|
|
// extract faces
|
extract_faces(source_mat, source_faces);
|
|
assert(source_faces.size() > 0);
|
// sort from left to right
|
std::sort(source_faces.begin(), source_faces.end(), [](face_box a, face_box b){ return a.x < b.x;});
|
|
auto the_selected_face = (swap_source_face_index < 0 || swap_source_face_index >= source_faces.size()) ? source_faces[0] : source_faces[swap_source_face_index];
|
cv::Mat aligned_face;
|
auto warp_mat = align_crop(source_mat, the_selected_face.kps, aligned_face);
|
// for debug
|
cv::imwrite("selected_source_face.jpg", aligned_face);
|
|
// read emap from file
|
auto emap = read_emap_mat_from_txt(emap_file_for_embeddings);
|
|
// encoding for the selected face (infer for only 1 time)
|
cv::Mat source_blob = cv::dnn::blobFromImage(aligned_face, 1 / 127.5, cv::Size(112, 112), (127.5, 127.5, 127.5), true);
|
std::vector<cv::Mat> source_outputs;
|
face_encoding_net.setInput(source_blob);
|
face_encoding_net.forward(source_outputs, face_encoding_net.getUnconnectedOutLayersNames());
|
|
auto& source_output = source_outputs[0];
|
// process using emap
|
source_face_embeddings = process_embeddings_using_emap(source_output, emap);
|
}
|
|
void vp_face_swap_node::swap(cv::Mat& aligned_face, cv::Mat& swapped_face) {
|
cv::Mat target_blob = cv::dnn::blobFromImage(aligned_face, 1 / 255.0, cv::Size(128, 128), (0, 0, 0), true);
|
std::vector<cv::Mat> target_outputs;
|
face_swap_net.setInput(target_blob, "target");
|
face_swap_net.setInput(source_face_embeddings, "source");
|
face_swap_net.forward(target_outputs, face_swap_net.getUnconnectedOutLayersNames());
|
|
auto& output = target_outputs[0];
|
cv::Mat output_channel_last;
|
cv::transposeND(output, {0,2,3,1}, output_channel_last);
|
|
cv::Mat img_fake(output_channel_last.size[1], output_channel_last.size[2], CV_32FC3, output_channel_last.data);
|
cv::cvtColor(img_fake, swapped_face, cv::COLOR_RGB2BGR);
|
}
|
|
void vp_face_swap_node::paste_back(cv::Mat& bg, cv::Mat& swapped_face, const cv::Mat& transform_matrix) {
|
bg.convertTo(bg, CV_32FC3, 1.0 / 255);
|
|
cv::Mat IM;
|
cv::invertAffineTransform(transform_matrix, IM);
|
cv::Mat img_mask(swapped_face.rows, swapped_face.cols, CV_32FC1, 1);
|
cv::warpAffine(swapped_face, swapped_face, IM, bg.size());
|
cv::warpAffine(img_mask, img_mask, IM, bg.size());
|
|
// create mask
|
cv::threshold(img_mask, img_mask, 0, 1, cv::THRESH_BINARY);
|
cv::Point min_loc, max_loc;
|
double min_val, max_val;
|
cv::minMaxLoc(img_mask, &min_val, &max_val, &min_loc, &max_loc);
|
|
int mask_h = max_loc.y - min_loc.y;
|
int mask_w = max_loc.x - min_loc.x;
|
|
int mask_size = std::sqrt(mask_h * mask_w);
|
int k = std::max(mask_size / 10, 10);
|
|
cv::Mat kernel = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(k, k));
|
cv::erode(img_mask, img_mask, kernel);
|
|
k = std::max(mask_size / 20, 5);
|
cv::GaussianBlur(img_mask, img_mask, cv::Size(2 * k + 1, 2 * k + 1), 0);
|
cv::cvtColor(img_mask, img_mask, cv::COLOR_GRAY2BGR);
|
|
// merge swapped face and original background
|
cv::Mat ones(bg.rows, bg.cols, CV_32FC3, cv::Scalar(1, 1, 1));
|
bg = img_mask.mul(swapped_face) + (ones - img_mask).mul(bg);
|
bg.convertTo(bg, CV_8U, 255);
|
}
|
|
void vp_face_swap_node::generatePriors(int inputW, int inputH) {
|
using namespace cv;
|
// Calculate shapes of different scales according to the shape of input image
|
Size feature_map_2nd = {
|
int(int((inputW+1)/2)/2), int(int((inputH+1)/2)/2)
|
};
|
Size feature_map_3rd = {
|
int(feature_map_2nd.width/2), int(feature_map_2nd.height/2)
|
};
|
Size feature_map_4th = {
|
int(feature_map_3rd.width/2), int(feature_map_3rd.height/2)
|
};
|
Size feature_map_5th = {
|
int(feature_map_4th.width/2), int(feature_map_4th.height/2)
|
};
|
Size feature_map_6th = {
|
int(feature_map_5th.width/2), int(feature_map_5th.height/2)
|
};
|
|
std::vector<Size> feature_map_sizes;
|
feature_map_sizes.push_back(feature_map_3rd);
|
feature_map_sizes.push_back(feature_map_4th);
|
feature_map_sizes.push_back(feature_map_5th);
|
feature_map_sizes.push_back(feature_map_6th);
|
|
// Fixed params for generating priors
|
const std::vector<std::vector<float>> min_sizes = {
|
{10.0f, 16.0f, 24.0f},
|
{32.0f, 48.0f},
|
{64.0f, 96.0f},
|
{128.0f, 192.0f, 256.0f}
|
};
|
CV_Assert(min_sizes.size() == feature_map_sizes.size()); // just to keep vectors in sync
|
const std::vector<int> steps = { 8, 16, 32, 64 };
|
|
// Generate priors
|
priors.clear();
|
for (size_t i = 0; i < feature_map_sizes.size(); ++i)
|
{
|
Size feature_map_size = feature_map_sizes[i];
|
std::vector<float> min_size = min_sizes[i];
|
|
for (int _h = 0; _h < feature_map_size.height; ++_h)
|
{
|
for (int _w = 0; _w < feature_map_size.width; ++_w)
|
{
|
for (size_t j = 0; j < min_size.size(); ++j)
|
{
|
float s_kx = min_size[j] / inputW;
|
float s_ky = min_size[j] / inputH;
|
|
float cx = (_w + 0.5f) * steps[i] / inputW;
|
float cy = (_h + 0.5f) * steps[i] / inputH;
|
|
Rect2f prior = { cx, cy, s_kx, s_ky };
|
priors.push_back(prior);
|
}
|
}
|
}
|
}
|
}
|
|
void vp_face_swap_node::postprocess(const std::vector<cv::Mat>& raw_outputs, const std::vector<std::shared_ptr<vp_objects::vp_frame_meta>>& frame_meta_with_batch) {
|
|
}
|
}
|
