int main(int argc, char **argv) {
::testing::InitGoogleTest(&argc, argv);
QGuiApplication app(argc, argv);
Q_UNUSED(app);
QSurfaceFormat format;
format.setMajorVersion(3);
format.setMinorVersion(0);
QOpenGLContext context;
context.setFormat(format);
context.create();
if (!context.isValid()) return 1;
qDebug() << QString::fromLatin1("Context created.");
QOffscreenSurface surface;
surface.setFormat(format);
surface.create();
if(!surface.isValid()) return 2;
qDebug() << QString::fromLatin1("Surface created.");
context.makeCurrent(&surface);
return RUN_ALL_TESTS();
}
void PlayerQuickItem::onSynchronize()
{
if (!m_renderer && m_mpv)
{
m_renderer = new PlayerRenderer(m_mpv, window());
if (!m_renderer->init())
{
delete m_renderer;
m_renderer = NULL;
emit onFatalError(tr("Could not initialize OpenGL."));
return;
}
connect(window(), &QQuickWindow::beforeRendering, m_renderer, &PlayerRenderer::render, Qt::DirectConnection);
connect(window(), &QQuickWindow::frameSwapped, m_renderer, &PlayerRenderer::swap, Qt::DirectConnection);
window()->setPersistentOpenGLContext(true);
window()->setPersistentSceneGraph(true);
window()->setClearBeforeRendering(false);
m_debugInfo = "";
QOpenGLContext* glctx = QOpenGLContext::currentContext();
if (glctx && glctx->isValid())
{
m_debugInfo += "\nOpenGL:\n";
int syms[4] = {GL_VENDOR, GL_RENDERER, GL_VERSION, GL_SHADING_LANGUAGE_VERSION};
for (auto sym : syms)
{
auto s = (char *)glctx->functions()->glGetString(sym);
if (s)
m_debugInfo += QString(" ") + QString::fromUtf8(s) + "\n";
}
m_debugInfo += "\n";
}
}
if (m_renderer)
m_renderer->m_size = window()->size() * window()->devicePixelRatio();
}
/*!
Sets the global default surface \a format.
This format is used by default in QOpenGLContext, QWindow, QOpenGLWidget and
similar classes.
It can always be overridden on a per-instance basis by using the class in
question's own setFormat() function. However, it is often more convenient to
set the format for all windows once at the start of the application. It also
guarantees proper behavior in cases where shared contexts are required,
because settings the format via this function guarantees that all contexts
and surfaces, even the ones created internally by Qt, will use the same
format.
\note When setting Qt::AA_ShareOpenGLContexts, it is strongly recommended to
place the call to this function before the construction of the
QGuiApplication or QApplication. Otherwise \a format will not be applied to
the global share context and therefore issues may arise with context sharing
afterwards.
\since 5.4
\sa defaultFormat()
*/
void QSurfaceFormat::setDefaultFormat(const QSurfaceFormat &format)
{
#ifndef QT_NO_OPENGL
if (qApp) {
QOpenGLContext *globalContext = QOpenGLContext::globalShareContext();
if (globalContext && globalContext->isValid()) {
qWarning("Warning: Setting a new default format with a different version or profile "
"after the global shared context is created may cause issues with context "
"sharing.");
}
}
#endif
*qt_default_surface_format() = format;
}
void GLWidget277::debugContextVersion() {
QOpenGLContext *ctx = context();
QSurfaceFormat form = format();
QSurfaceFormat ctxform = ctx->format();
QSurfaceFormat::OpenGLContextProfile prof = ctxform.profile();
const char *profile =
prof == QSurfaceFormat::CoreProfile ? "Core" :
prof == QSurfaceFormat::CompatibilityProfile ? "Compatibility" :
"None";
int ctxmajor = ctxform.majorVersion();
int ctxminor = ctxform.minorVersion();
bool valid = ctx->isValid();
int formmajor = form.majorVersion();
int formminor = form.minorVersion();
const char *vendor = glGS(GL_VENDOR);
const char *renderer = glGS(GL_RENDERER);
const char *version = glGS(GL_VERSION);
const char *s_glsl = glGS(GL_SHADING_LANGUAGE_VERSION);
printf("Widget version: %d.%d\n", ctxmajor, ctxminor);
printf("Context valid: %s\n", valid ? "yes" : "NO");
printf("Format version: %d.%d\n", formmajor, formminor);
printf("Profile: %s\n", profile);
printf(" Vendor: %s\n", vendor);
printf(" Renderer: %s\n", renderer);
printf(" Version: %s\n", version);
printf(" GLSL: %s\n", s_glsl);
QString glsl = s_glsl;
if (ctxmajor < 3 || glsl.startsWith("1.10") || glsl.startsWith("1.20")) {
printf("ERROR: "
"Unable to get an OpenGL 3.x context with GLSL 1.30 or newer. "
"If your hardware should support it, update your drivers. "
"If you have switchable graphics, make sure that you are using the discrete GPU.\n");
QApplication::exit();
} else if ((ctxmajor == 3 && ctxminor < 2) || glsl.startsWith("1.30") || glsl.startsWith("1.40")) {
printf("WARNING: "
"Unable to get an OpenGL 3.2 context with GLSL 1.50. "
"If your hardware should support it, update your drivers. "
"If you have switchable graphics, make sure that you are using the discrete GPU. "
"If you cannot get 3.2 support, it is possible to port this project....");
// Note: doing this requires at least the following actions:
// * Change the header and base class in glwidget277.h to 3.0/3.1 instead of 3.2 Core.
// * Change the shaders to require GLSL 1.30 or 1.40.
}
}
int main(int argc, char* argv[])
{
// Parse command line arguments
std::vector<string> input_paths, seg_paths;
string output_path, landmarks_path;
string model_3dmm_h5_path, model_3dmm_dat_path;
string reg_model_path, reg_deploy_path, reg_mean_path;
string seg_model_path, seg_deploy_path;
string cfg_path;
bool generic, with_expr, with_gpu;
unsigned int gpu_device_id, verbose;
try {
options_description desc("Allowed options");
desc.add_options()
("help,h", "display the help message")
("verbose,v", value<unsigned int>(&verbose)->default_value(0), "output debug information [0, 4]")
("input,i", value<std::vector<string>>(&input_paths)->required(), "image paths [source target]")
("output,o", value<string>(&output_path)->required(), "output path")
("segmentations,s", value<std::vector<string>>(&seg_paths), "segmentation paths [source target]")
("landmarks,l", value<string>(&landmarks_path)->required(), "path to landmarks model file")
("model_3dmm_h5", value<string>(&model_3dmm_h5_path)->required(), "path to 3DMM file (.h5)")
("model_3dmm_dat", value<string>(&model_3dmm_dat_path)->required(), "path to 3DMM file (.dat)")
("reg_model,r", value<string>(®_model_path)->required(), "path to 3DMM regression CNN model file (.caffemodel)")
("reg_deploy,d", value<string>(®_deploy_path)->required(), "path to 3DMM regression CNN deploy file (.prototxt)")
("reg_mean,m", value<string>(®_mean_path)->required(), "path to 3DMM regression CNN mean file (.binaryproto)")
("seg_model", value<string>(&seg_model_path), "path to face segmentation CNN model file (.caffemodel)")
("seg_deploy", value<string>(&seg_deploy_path), "path to face segmentation CNN deploy file (.prototxt)")
("generic,g", value<bool>(&generic)->default_value(false), "use generic model without shape regression")
("expressions,e", value<bool>(&with_expr)->default_value(true), "with expressions")
("gpu", value<bool>(&with_gpu)->default_value(true), "toggle GPU / CPU")
("gpu_id", value<unsigned int>(&gpu_device_id)->default_value(0), "GPU's device id")
("cfg", value<string>(&cfg_path)->default_value("face_swap_image.cfg"), "configuration file (.cfg)")
;
variables_map vm;
store(command_line_parser(argc, argv).options(desc).
positional(positional_options_description().add("input", -1)).run(), vm);
if (vm.count("help")) {
cout << "Usage: face_swap_image [options]" << endl;
cout << desc << endl;
exit(0);
}
// Read config file
std::ifstream ifs(vm["cfg"].as<string>());
store(parse_config_file(ifs, desc), vm);
notify(vm);
if(input_paths.size() != 2) throw error("Both source and target must be specified in input!");
if (!is_regular_file(input_paths[0])) throw error("source input must be a path to an image!");
if (!is_regular_file(input_paths[1])) throw error("target input target must be a path to an image!");
if (seg_paths.size() > 0 && !is_regular_file(seg_paths[0]))
throw error("source segmentation must be a path to an image!");
if (seg_paths.size() > 1 && !is_regular_file(seg_paths[1]))
throw error("target segmentation must be a path to an image!");
if (!is_regular_file(landmarks_path)) throw error("landmarks must be a path to a file!");
if (!is_regular_file(model_3dmm_h5_path)) throw error("model_3dmm_h5 must be a path to a file!");
if (!is_regular_file(model_3dmm_dat_path)) throw error("model_3dmm_dat must be a path to a file!");
if (!is_regular_file(reg_model_path)) throw error("reg_model must be a path to a file!");
if (!is_regular_file(reg_deploy_path)) throw error("reg_deploy must be a path to a file!");
if (!is_regular_file(reg_mean_path)) throw error("reg_mean must be a path to a file!");
if (!seg_model_path.empty() && !is_regular_file(seg_model_path))
throw error("seg_model must be a path to a file!");
if (!seg_deploy_path.empty() && !is_regular_file(seg_deploy_path))
throw error("seg_deploy must be a path to a file!");
}
catch (const error& e) {
cerr << "Error while parsing command-line arguments: " << e.what() << endl;
cerr << "Use --help to display a list of options." << endl;
exit(1);
}
try
{
// Intialize OpenGL context
QApplication a(argc, argv);
QSurfaceFormat surfaceFormat;
surfaceFormat.setMajorVersion(1);
surfaceFormat.setMinorVersion(5);
QOpenGLContext openGLContext;
openGLContext.setFormat(surfaceFormat);
openGLContext.create();
if (!openGLContext.isValid()) return -1;
QOffscreenSurface surface;
surface.setFormat(surfaceFormat);
surface.create();
if (!surface.isValid()) return -2;
openGLContext.makeCurrent(&surface);
// Initialize GLEW
GLenum err = glewInit();
if (GLEW_OK != err)
{
// Problem: glewInit failed, something is seriously wrong
fprintf(stderr, "Error: %s\n", glewGetErrorString(err));
throw std::runtime_error("Failed to initialize GLEW!");
}
// Initialize face swap
face_swap::FaceSwap fs(landmarks_path, model_3dmm_h5_path, model_3dmm_dat_path,
reg_model_path, reg_deploy_path, reg_mean_path, generic, with_expr,
with_gpu, (int)gpu_device_id);
// Read source and target images
cv::Mat source_img = cv::imread(input_paths[0]);
cv::Mat target_img = cv::imread(input_paths[1]);
// Read source and target segmentations or initialize segmentation model
cv::Mat source_seg, target_seg;
if (seg_model_path.empty() || seg_deploy_path.empty())
{
if (seg_paths.size() > 0)
source_seg = cv::imread(seg_paths[0], cv::IMREAD_GRAYSCALE);
if (seg_paths.size() > 1)
target_seg = cv::imread(seg_paths[1], cv::IMREAD_GRAYSCALE);
}
else fs.setSegmentationModel(seg_model_path, seg_deploy_path);
// Set source and target
if (!fs.setSource(source_img, source_seg))
throw std::runtime_error("Failed to find faces in source image!");
if (!fs.setTarget(target_img, target_seg))
throw std::runtime_error("Failed to find faces in target image!");
// Do face swap
cv::Mat rendered_img = fs.swap();
if (rendered_img.empty())
throw std::runtime_error("Face swap failed!");
// Write output to file
path out_file_path = output_path;
path out_dir_path = output_path;
if (is_directory(output_path))
{
path outputName = (path(input_paths[0]).stem() += "_") +=
(path(input_paths[1]).stem() += ".jpg");
out_file_path = path(output_path) /= outputName;
}
else out_dir_path = path(output_path).parent_path();
cv::imwrite(out_file_path.string(), rendered_img);
// Debug
if (verbose > 0)
{
// Write rendered image
path debug_render_path = out_dir_path /
(out_file_path.stem() += "_render.jpg");
cv::Mat debug_render_img = fs.debugRender();
cv::imwrite(debug_render_path.string(), debug_render_img);
}
if (verbose > 1)
{
// Write projected meshes
path debug_src_mesh_path = out_dir_path /
(out_file_path.stem() += "_src_mesh.jpg");
cv::Mat debug_src_mesh_img = fs.debugSourceMesh();
cv::imwrite(debug_src_mesh_path.string(), debug_src_mesh_img);
path debug_tgt_mesh_path = out_dir_path /
(out_file_path.stem() += "_tgt_mesh.jpg");
cv::Mat debug_tgt_mesh_img = fs.debugTargetMesh();
cv::imwrite(debug_tgt_mesh_path.string(), debug_tgt_mesh_img);
}
if (verbose > 2)
{
// Write landmarks render
path debug_src_lms_path = out_dir_path /
(out_file_path.stem() += "_src_landmarks.jpg");
cv::Mat debug_src_lms_img = fs.debugSourceLandmarks();
cv::imwrite(debug_src_lms_path.string(), debug_src_lms_img);
path debug_tgt_lms_path = out_dir_path /
(out_file_path.stem() += "_tgt_landmarks.jpg");
cv::Mat debug_tgt_lms_img = fs.debugTargetLandmarks();
cv::imwrite(debug_tgt_lms_path.string(), debug_tgt_lms_img);
}
if (verbose > 3)
{
// Write meshes
path debug_src_ply_path = out_dir_path /
(out_file_path.stem() += "_src_mesh.ply");
path debug_tgt_ply_path = out_dir_path /
(out_file_path.stem() += "_tgt_mesh.ply");
face_swap::Mesh::save_ply(fs.getSourceMesh(), debug_src_ply_path.string());
face_swap::Mesh::save_ply(fs.getTargetMesh(), debug_tgt_ply_path.string());
}
}
catch (std::exception& e)
{
cerr << e.what() << endl;
return 1;
}
return 0;
}
