int main(int argc, char **argv) { char *dst_path; size_t path_len; struct W2XConv *c; int r; char *src_path; if (argc < 2) { puts("usage : w2xc <in.png>"); return 1; } src_path = argv[1]; path_len = strlen(src_path); dst_path = malloc(path_len + 5); dst_path[0] = 'm'; dst_path[1] = 'a'; dst_path[2] = 'i'; dst_path[3] = '_'; strcpy(dst_path+4, argv[1]); c = w2xconv_init(1, 0, 0); r = w2xconv_load_models(c, "models"); if (r < 0) { goto error; } r = w2xconv_convert_file(c, dst_path, src_path, 1, 2.0, 512); if (r < 0) { goto error; } w2xconv_fini(c); return 0; error: { char *err = w2xconv_strerror(&c->last_error); puts(err); w2xconv_free(err); } w2xconv_fini(c); return 1; }
int main(int argc, char** argv) { int ret = 1; // definition of command line arguments TCLAP::CmdLine cmd("waifu2x reimplementation using OpenCV", ' ', "1.0.0"); TCLAP::ValueArg<std::string> cmdInputFile("i", "input_file", "path to input image file (you should input full path)", true, "", "string", cmd); TCLAP::ValueArg<std::string> cmdOutputFile("o", "output_file", "path to output image file (you should input full path)", false, "(auto)", "string", cmd); std::vector<std::string> cmdModeConstraintV; cmdModeConstraintV.push_back("noise"); cmdModeConstraintV.push_back("scale"); cmdModeConstraintV.push_back("noise_scale"); TCLAP::ValuesConstraint<std::string> cmdModeConstraint(cmdModeConstraintV); TCLAP::ValueArg<std::string> cmdMode("m", "mode", "image processing mode", false, "noise_scale", &cmdModeConstraint, cmd); std::vector<int> cmdNRLConstraintV; cmdNRLConstraintV.push_back(1); cmdNRLConstraintV.push_back(2); TCLAP::ValuesConstraint<int> cmdNRLConstraint(cmdNRLConstraintV); TCLAP::ValueArg<int> cmdNRLevel("", "noise_level", "noise reduction level", false, 1, &cmdNRLConstraint, cmd); TCLAP::ValueArg<double> cmdScaleRatio("", "scale_ratio", "custom scale ratio", false, 2.0, "double", cmd); TCLAP::ValueArg<std::string> cmdModelPath("", "model_dir", "path to custom model directory (don't append last / )", false, "models_rgb", "string", cmd); TCLAP::ValueArg<int> cmdNumberOfJobs("j", "jobs", "number of threads launching at the same time", false, 0, "integer", cmd); TCLAP::SwitchArg cmdForceOpenCL("", "force-OpenCL", "force to use OpenCL on Intel Platform", cmd, false); TCLAP::SwitchArg cmdDisableGPU("", "disable-gpu", "disable GPU", cmd, false); TCLAP::ValueArg<int> cmdBlockSize("", "block_size", "block size", false, 0, "integer", cmd); // definition of command line argument : end // parse command line arguments try { cmd.parse(argc, argv); } catch (std::exception &e) { std::cerr << e.what() << std::endl; std::cerr << "Error : cmd.parse() threw exception" << std::endl; std::exit(-1); } std::string outputFileName = cmdOutputFile.getValue(); if (outputFileName == "(auto)") { outputFileName = cmdInputFile.getValue(); int tailDot = outputFileName.find_last_of('.'); outputFileName.erase(tailDot, outputFileName.length()); outputFileName = outputFileName + "(" + cmdMode.getValue() + ")"; std::string &mode = cmdMode.getValue(); if(mode.find("noise") != mode.npos){ outputFileName = outputFileName + "(Level" + std::to_string(cmdNRLevel.getValue()) + ")"; } if(mode.find("scale") != mode.npos){ outputFileName = outputFileName + "(x" + std::to_string(cmdScaleRatio.getValue()) + ")"; } outputFileName += ".png"; } enum W2XConvGPUMode gpu = W2XCONV_GPU_AUTO; if (cmdDisableGPU.getValue()) { gpu = W2XCONV_GPU_DISABLE; } else if (cmdForceOpenCL.getValue()) { gpu = W2XCONV_GPU_FORCE_OPENCL; } W2XConv *converter = w2xconv_init(gpu, cmdNumberOfJobs.getValue(), 1); double time_start = getsec(); switch (converter->target_processor.type) { case W2XCONV_PROC_HOST: printf("CPU: %s\n", converter->target_processor.dev_name); break; case W2XCONV_PROC_CUDA: printf("CUDA: %s\n", converter->target_processor.dev_name); break; case W2XCONV_PROC_OPENCL: printf("OpenCL: %s\n", converter->target_processor.dev_name); break; } int bs = cmdBlockSize.getValue(); int r = w2xconv_load_models(converter, cmdModelPath.getValue().c_str()); if (r < 0) { goto error; } { int nrLevel = 0; if (cmdMode.getValue() == "noise" || cmdMode.getValue() == "noise_scale") { nrLevel = cmdNRLevel.getValue(); } double scaleRatio = 1; if (cmdMode.getValue() == "scale" || cmdMode.getValue() == "noise_scale") { scaleRatio = cmdScaleRatio.getValue(); } r = w2xconv_convert_file(converter, outputFileName.c_str(), cmdInputFile.getValue().c_str(), nrLevel, scaleRatio, bs); } if (r < 0) { goto error; } { double time_end = getsec(); double gflops_proc = (converter->flops.flop/(1000.0*1000.0*1000.0)) / converter->flops.filter_sec; double gflops_all = (converter->flops.flop/(1000.0*1000.0*1000.0)) / (time_end-time_start); std::cout << "process successfully done! (all:" << (time_end - time_start) << "[sec], " << gflops_all << "[GFLOPS], filter:" << converter->flops.filter_sec << "[sec], " << gflops_proc << "[GFLOPS])" << std::endl; } ret = 0; error: if (ret != 0) { char *err = w2xconv_strerror(&converter->last_error); puts(err); w2xconv_free(err); } w2xconv_fini(converter); return ret; }
int w2xconv_test(struct W2XConv *conv, int block_size) { int w = 200; int h = 100; int r; cv::Mat src_rgb = cv::Mat::zeros(h, w, CV_8UC3); cv::Mat dst = cv::Mat::zeros(h, w, CV_8UC3); cv::line(src_rgb, cv::Point(10, 10), cv::Point(20, 20), cv::Scalar(255,0,0), 8); cv::line(src_rgb, cv::Point(20, 10), cv::Point(10, 20), cv::Scalar(0,255,0), 8); cv::line(src_rgb, cv::Point(50, 30), cv::Point(10, 30), cv::Scalar(0,0,255), 1); cv::line(src_rgb, cv::Point(50, 80), cv::Point(10, 80), cv::Scalar(255,255,255), 3); cv::Mat src_32fc3; cv::Mat src_yuv; src_rgb.convertTo(src_32fc3, CV_32F, 1.0 / 255.0); cv::cvtColor(src_32fc3, src_yuv, cv::COLOR_RGB2YUV); cv::Mat dst_rgb_x2(h*2, w*2, CV_8UC3); cv::Mat dst_rgb_f32_x2(h*2, w*2, CV_32FC3); cv::Mat dst_yuv_x2(h*2, w*2, CV_32FC3); cv::imwrite("test_src.png", src_rgb); w2xconv_convert_rgb(conv, dst_rgb_x2.data, dst_rgb_x2.step[0], src_rgb.data, src_rgb.step[0], w, h, 1, 2.0, block_size); cv::imwrite("test_rgb.png", dst_rgb_x2); w2xconv_convert_rgb_f32(conv, dst_rgb_f32_x2.data, dst_rgb_f32_x2.step[0], src_32fc3.data, src_32fc3.step[0], w, h, 1, 2.0, block_size); dst_rgb_f32_x2.convertTo(dst_rgb_x2, CV_8U, 255.0); cv::imwrite("test_rgb_f32.png", dst_rgb_x2); r = w2xconv_convert_yuv(conv, dst_yuv_x2.data, dst_yuv_x2.step[0], src_yuv.data, src_yuv.step[0], w, h, 1, 2.0, block_size); if (r < 0) { char *e = w2xconv_strerror(&conv->last_error); puts(e); w2xconv_free(e); } else { cv::cvtColor(dst_yuv_x2, dst_yuv_x2, cv::COLOR_YUV2RGB); dst_yuv_x2.convertTo(dst_rgb_x2, CV_8U, 255.0); cv::imwrite("test_yuv.png", dst_rgb_x2); } std::vector<cv::Mat> imageSplit; cv::split(src_yuv, imageSplit); cv::Mat split_src = imageSplit[0].clone(); cv::Mat split_dst, dst_rgb; cv::Mat split_dsty(h, w, CV_32F); r = w2xconv_apply_filter_y(conv, W2XCONV_FILTER_DENOISE1, split_dsty.data, split_dsty.step[0], split_src.data, split_src.step[0], w, h, block_size); if (r < 0) { char *e = w2xconv_strerror(&conv->last_error); puts(e); w2xconv_free(e); } else { imageSplit[0] = split_dsty.clone(); cv::merge(imageSplit, split_dst); cv::cvtColor(split_dst, split_dst, cv::COLOR_YUV2RGB); split_dst.convertTo(dst_rgb, CV_8U, 255.0); cv::imwrite("test_apply.png", dst_rgb); } return 0; }