Mirror/waifu2x-caffe
1
0
Fork 0
mirror of https://github.com/lltcggie/waifu2x-caffe.git synced 2025-06-26 13:42:48 +00:00
Code Issues Packages Projects Releases Wiki Activity

noise_scaleに対応

Browse Source
This commit is contained in:
lltcggie 2016-07-03 17:13:02 +09:00
parent ebc71b317c
commit 1e834f2c7b
13 changed files with 356 additions and 710 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
bin/models/upconv_7_anime_style_art_rgb/noise1_model.json
View File

File diff suppressed because one or more lines are too long

187
bin/models/upconv_7_anime_style_art_rgb/noise1_model.prototxt
View File

@ -1,187 +0,0 @@
name: "srcnn"
layer {
name: "input"
type: "Input"
top: "input"
input_param { shape: { dim: 1 dim: 3 dim: 142 dim: 142 } }
}
layer {
name: "conv1_layer"
type: "Convolution"
bottom: "input"
top: "conv1"
convolution_param {
num_output: 32
kernel_size: 3
stride: 1
weight_filler {
type: "gaussian"
std: 0.01
}
}
}
layer {
name: "conv1_relu_layer"
type: "ReLU"
bottom: "conv1"
top: "conv1"
relu_param {
negative_slope: 0.1
}
}
layer {
name: "conv2_layer"
type: "Convolution"
bottom: "conv1"
top: "conv2"
convolution_param {
num_output: 32
kernel_size: 3
stride: 1
weight_filler {
type: "gaussian"
std: 0.01
}
}
}
layer {
name: "conv2_relu_layer"
type: "ReLU"
bottom: "conv2"
top: "conv2"
relu_param {
negative_slope: 0.1
}
}
layer {
name: "conv3_layer"
type: "Convolution"
bottom: "conv2"
top: "conv3"
convolution_param {
num_output: 64
kernel_size: 3
stride: 1
weight_filler {
type: "gaussian"
std: 0.01
}
}
}
layer {
name: "conv3_relu_layer"
type: "ReLU"
bottom: "conv3"
top: "conv3"
relu_param {
negative_slope: 0.1
}
}
layer {
name: "conv4_layer"
type: "Convolution"
bottom: "conv3"
top: "conv4"
convolution_param {
num_output: 64
kernel_size: 3
stride: 1
weight_filler {
type: "gaussian"
std: 0.01
}
}
}
layer {
name: "conv4_relu_layer"
type: "ReLU"
bottom: "conv4"
top: "conv4"
relu_param {
negative_slope: 0.1
}
}
layer {
name: "conv5_layer"
type: "Convolution"
bottom: "conv4"
top: "conv5"
convolution_param {
num_output: 128
kernel_size: 3
stride: 1
weight_filler {
type: "gaussian"
std: 0.01
}
}
}
layer {
name: "conv5_relu_layer"
type: "ReLU"
bottom: "conv5"
top: "conv5"
relu_param {
negative_slope: 0.1
}
}
layer {
name: "conv6_layer"
type: "Convolution"
bottom: "conv5"
top: "conv6"
convolution_param {
num_output: 128
kernel_size: 3
stride: 1
weight_filler {
type: "gaussian"
std: 0.01
}
}
}
layer {
name: "conv6_relu_layer"
type: "ReLU"
bottom: "conv6"
top: "conv6"
relu_param {
negative_slope: 0.1
}
}
layer {
name: "conv7_layer"
type: "Convolution"
bottom: "conv6"
top: "conv7"
convolution_param {
num_output: 3
kernel_size: 3
stride: 1
weight_filler {
type: "gaussian"
std: 0.01
}
}
}
layer {
name: "target"
type: "MemoryData"
top: "target"
top: "dummy_label2"
memory_data_param {
batch_size: 1
channels: 1
height: 142
width: 142
}
include: { phase: TRAIN }
}
layer {
name: "loss"
type: "EuclideanLoss"
bottom: "conv7"
bottom: "target"
top: "loss"
include: { phase: TRAIN }
}

1
bin/models/upconv_7_anime_style_art_rgb/noise2_model.json
View File

File diff suppressed because one or more lines are too long

187
bin/models/upconv_7_anime_style_art_rgb/noise2_model.prototxt
View File

@ -1,187 +0,0 @@
name: "srcnn"
layer {
name: "input"
type: "Input"
top: "input"
input_param { shape: { dim: 1 dim: 3 dim: 142 dim: 142 } }
}
layer {
name: "conv1_layer"
type: "Convolution"
bottom: "input"
top: "conv1"
convolution_param {
num_output: 32
kernel_size: 3
stride: 1
weight_filler {
type: "gaussian"
std: 0.01
}
}
}
layer {
name: "conv1_relu_layer"
type: "ReLU"
bottom: "conv1"
top: "conv1"
relu_param {
negative_slope: 0.1
}
}
layer {
name: "conv2_layer"
type: "Convolution"
bottom: "conv1"
top: "conv2"
convolution_param {
num_output: 32
kernel_size: 3
stride: 1
weight_filler {
type: "gaussian"
std: 0.01
}
}
}
layer {
name: "conv2_relu_layer"
type: "ReLU"
bottom: "conv2"
top: "conv2"
relu_param {
negative_slope: 0.1
}
}
layer {
name: "conv3_layer"
type: "Convolution"
bottom: "conv2"
top: "conv3"
convolution_param {
num_output: 64
kernel_size: 3
stride: 1
weight_filler {
type: "gaussian"
std: 0.01
}
}
}
layer {
name: "conv3_relu_layer"
type: "ReLU"
bottom: "conv3"
top: "conv3"
relu_param {
negative_slope: 0.1
}
}
layer {
name: "conv4_layer"
type: "Convolution"
bottom: "conv3"
top: "conv4"
convolution_param {
num_output: 64
kernel_size: 3
stride: 1
weight_filler {
type: "gaussian"
std: 0.01
}
}
}
layer {
name: "conv4_relu_layer"
type: "ReLU"
bottom: "conv4"
top: "conv4"
relu_param {
negative_slope: 0.1
}
}
layer {
name: "conv5_layer"
type: "Convolution"
bottom: "conv4"
top: "conv5"
convolution_param {
num_output: 128
kernel_size: 3
stride: 1
weight_filler {
type: "gaussian"
std: 0.01
}
}
}
layer {
name: "conv5_relu_layer"
type: "ReLU"
bottom: "conv5"
top: "conv5"
relu_param {
negative_slope: 0.1
}
}
layer {
name: "conv6_layer"
type: "Convolution"
bottom: "conv5"
top: "conv6"
convolution_param {
num_output: 128
kernel_size: 3
stride: 1
weight_filler {
type: "gaussian"
std: 0.01
}
}
}
layer {
name: "conv6_relu_layer"
type: "ReLU"
bottom: "conv6"
top: "conv6"
relu_param {
negative_slope: 0.1
}
}
layer {
name: "conv7_layer"
type: "Convolution"
bottom: "conv6"
top: "conv7"
convolution_param {
num_output: 3
kernel_size: 3
stride: 1
weight_filler {
type: "gaussian"
std: 0.01
}
}
}
layer {
name: "target"
type: "MemoryData"
top: "target"
top: "dummy_label2"
memory_data_param {
batch_size: 1
channels: 1
height: 142
width: 142
}
include: { phase: TRAIN }
}
layer {
name: "loss"
type: "EuclideanLoss"
bottom: "conv7"
bottom: "target"
top: "loss"
include: { phase: TRAIN }
}

1
bin/models/upconv_7_anime_style_art_rgb/noise3_model.json
View File

File diff suppressed because one or more lines are too long

187
bin/models/upconv_7_anime_style_art_rgb/noise3_model.prototxt
View File

@ -1,187 +0,0 @@
name: "srcnn"
layer {
name: "input"
type: "Input"
top: "input"
input_param { shape: { dim: 1 dim: 3 dim: 142 dim: 142 } }
}
layer {
name: "conv1_layer"
type: "Convolution"
bottom: "input"
top: "conv1"
convolution_param {
num_output: 32
kernel_size: 3
stride: 1
weight_filler {
type: "gaussian"
std: 0.01
}
}
}
layer {
name: "conv1_relu_layer"
type: "ReLU"
bottom: "conv1"
top: "conv1"
relu_param {
negative_slope: 0.1
}
}
layer {
name: "conv2_layer"
type: "Convolution"
bottom: "conv1"
top: "conv2"
convolution_param {
num_output: 32
kernel_size: 3
stride: 1
weight_filler {
type: "gaussian"
std: 0.01
}
}
}
layer {
name: "conv2_relu_layer"
type: "ReLU"
bottom: "conv2"
top: "conv2"
relu_param {
negative_slope: 0.1
}
}
layer {
name: "conv3_layer"
type: "Convolution"
bottom: "conv2"
top: "conv3"
convolution_param {
num_output: 64
kernel_size: 3
stride: 1
weight_filler {
type: "gaussian"
std: 0.01
}
}
}
layer {
name: "conv3_relu_layer"
type: "ReLU"
bottom: "conv3"
top: "conv3"
relu_param {
negative_slope: 0.1
}
}
layer {
name: "conv4_layer"
type: "Convolution"
bottom: "conv3"
top: "conv4"
convolution_param {
num_output: 64
kernel_size: 3
stride: 1
weight_filler {
type: "gaussian"
std: 0.01
}
}
}
layer {
name: "conv4_relu_layer"
type: "ReLU"
bottom: "conv4"
top: "conv4"
relu_param {
negative_slope: 0.1
}
}
layer {
name: "conv5_layer"
type: "Convolution"
bottom: "conv4"
top: "conv5"
convolution_param {
num_output: 128
kernel_size: 3
stride: 1
weight_filler {
type: "gaussian"
std: 0.01
}
}
}
layer {
name: "conv5_relu_layer"
type: "ReLU"
bottom: "conv5"
top: "conv5"
relu_param {
negative_slope: 0.1
}
}
layer {
name: "conv6_layer"
type: "Convolution"
bottom: "conv5"
top: "conv6"
convolution_param {
num_output: 128
kernel_size: 3
stride: 1
weight_filler {
type: "gaussian"
std: 0.01
}
}
}
layer {
name: "conv6_relu_layer"
type: "ReLU"
bottom: "conv6"
top: "conv6"
relu_param {
negative_slope: 0.1
}
}
layer {
name: "conv7_layer"
type: "Convolution"
bottom: "conv6"
top: "conv7"
convolution_param {
num_output: 3
kernel_size: 3
stride: 1
weight_filler {
type: "gaussian"
std: 0.01
}
}
}
layer {
name: "target"
type: "MemoryData"
top: "target"
top: "dummy_label2"
memory_data_param {
batch_size: 1
channels: 1
height: 142
width: 142
}
include: { phase: TRAIN }
}
layer {
name: "loss"
type: "EuclideanLoss"
bottom: "conv7"
bottom: "target"
top: "loss"
include: { phase: TRAIN }
}

245
common/cNet.cpp
View File

@ -128,21 +128,146 @@ static Waifu2x::eWaifu2xError readProtoBinary(const boost::filesystem::path &pat
return Waifu2x::eWaifu2xError_OK;
}
cNet::cNet() : mModelScale(0), mInnerScale(0), mNetOffset(0), mInputPlane(0)
namespace
{
Waifu2x::eWaifu2xError ReadJson(const boost::filesystem::path &info_path, rapidjson::Document &d, std::vector<char> &jsonBuf)
{
try
{
boost::iostreams::stream<boost::iostreams::file_descriptor_source> is;
try
{
is.open(info_path, std::ios_base::in | std::ios_base::binary);
}
catch (...)
{
return Waifu2x::eWaifu2xError_FailedOpenModelFile;
}
if (!is)
return Waifu2x::eWaifu2xError_FailedOpenModelFile;
const size_t size = is.seekg(0, std::ios::end).tellg();
is.seekg(0, std::ios::beg);
jsonBuf.resize(size + 1);
is.read(jsonBuf.data(), jsonBuf.size());
jsonBuf[jsonBuf.size() - 1] = '\0';
d.Parse(jsonBuf.data());
}
catch (...)
{
return Waifu2x::eWaifu2xError_FailedParseModelFile;
}
return Waifu2x::eWaifu2xError_OK;
}
};
cNet::cNet() : mModelScale(0), mInnerScale(0), mNetOffset(0), mInputPlane(0), mHasNoiseScaleModel(false)
{}
cNet::~cNet()
{}
Waifu2x::eWaifu2xError cNet::GetInfo(const boost::filesystem::path & info_path, stInfo &info)
{
rapidjson::Document d;
std::vector<char> jsonBuf;
try
{
Waifu2x::eWaifu2xError ret;
ret = ReadJson(info_path, d, jsonBuf);
if (ret != Waifu2x::eWaifu2xError_OK)
return ret;
const auto name = d["name"].GetString();
const auto arch_name = d["arch_name"].GetString();
const bool has_noise_scale = d.HasMember("has_noise_scale") && d["has_noise_scale"].GetBool() ? true : false;
const int channels = d["channels"].GetInt();
info.name = name;
info.arch_name = arch_name;
info.has_noise_scale = has_noise_scale;
info.channels = channels;
if (d.HasMember("offset"))
{
const int offset = d["offset"].GetInt();
info.noise.offset = offset;
info.scale.offset = offset;
info.noise_scale.offset = offset;
}
if (d.HasMember("scale_factor"))
{
const int scale_factor = d["scale_factor"].GetInt();
info.noise.scale_factor = scale_factor;
info.scale.scale_factor = scale_factor;
info.noise_scale.scale_factor = scale_factor;
}
if (d.HasMember("offset_noise"))
{
const int offset = d["offset_noise"].GetInt();
info.noise.offset = offset;
}
if (d.HasMember("scale_factor_noise"))
{
const int scale_factor = d["scale_factor_noise"].GetInt();
info.noise.scale_factor = scale_factor;
}
if (d.HasMember("offset_scale"))
{
const int offset = d["offset_scale"].GetInt();
info.scale.offset = offset;
}
if (d.HasMember("scale_factor_scale"))
{
const int scale_factor = d["scale_factor_scale"].GetInt();
info.scale.scale_factor = scale_factor;
}
if (d.HasMember("offset_noise_scale"))
{
const int offset = d["offset_noise_scale"].GetInt();
info.noise_scale.offset = offset;
}
if (d.HasMember("scale_factor_noise_scale"))
{
const int scale_factor = d["scale_factor_noise_scale"].GetInt();
info.noise_scale.scale_factor = scale_factor;
}
}
catch (...)
{
return Waifu2x::eWaifu2xError_FailedParseModelFile;
}
return Waifu2x::eWaifu2xError_OK;
}
// モデルファイルからネットワークを構築
// processでcudnnが指定されなかった場合はcuDNNが呼び出されないように変更する
Waifu2x::eWaifu2xError cNet::ConstractNet(const boost::filesystem::path &model_path, const boost::filesystem::path &param_path, const boost::filesystem::path &info_path, const std::string &process)
Waifu2x::eWaifu2xError cNet::ConstractNet(const Waifu2x::eWaifu2xModelType mode, const boost::filesystem::path &model_path, const boost::filesystem::path &param_path, const stInfo &info, const std::string &process)
{
Waifu2x::eWaifu2xError ret;
ret = LoadInfoFromJson(info_path);
if (ret != Waifu2x::eWaifu2xError_OK)
return ret;
mMode = mode;
LoadParamFromInfo(mode, info);
boost::filesystem::path modelbin_path = model_path;
modelbin_path += ".protobin";
@ -184,75 +309,35 @@ Waifu2x::eWaifu2xError cNet::ConstractNet(const boost::filesystem::path &model_p
return Waifu2x::eWaifu2xError_OK;
}
namespace
void cNet::LoadParamFromInfo(const Waifu2x::eWaifu2xModelType mode, const stInfo &info)
{
Waifu2x::eWaifu2xError ReadJson(const boost::filesystem::path &info_path, rapidjson::Document &d, std::vector<char> &jsonBuf)
{
try
{
boost::iostreams::stream<boost::iostreams::file_descriptor_source> is;
try
{
is.open(info_path, std::ios_base::in | std::ios_base::binary);
}
catch (...)
{
return Waifu2x::eWaifu2xError_FailedOpenModelFile;
}
if (!is)
return Waifu2x::eWaifu2xError_FailedOpenModelFile;
const size_t size = is.seekg(0, std::ios::end).tellg();
is.seekg(0, std::ios::beg);
jsonBuf.resize(size + 1);
is.read(jsonBuf.data(), jsonBuf.size());
jsonBuf[jsonBuf.size() - 1] = '\0';
d.Parse(jsonBuf.data());
}
catch (...)
{
return Waifu2x::eWaifu2xError_FailedParseModelFile;
}
return Waifu2x::eWaifu2xError_OK;
}
};
Waifu2x::eWaifu2xError cNet::LoadInfoFromJson(const boost::filesystem::path &info_path)
{
rapidjson::Document d;
std::vector<char> jsonBuf;
try
{
Waifu2x::eWaifu2xError ret;
ret = ReadJson(info_path, d, jsonBuf);
if (ret != Waifu2x::eWaifu2xError_OK)
return ret;
const bool resize = d.HasMember("resize") && d["resize"].GetBool() ? true : false;
const auto name = d["name"].GetString();
const int channels = d["channels"].GetInt();
const int net_offset = d["offset"].GetInt();
const int inner_scale = d["scale_factor"].GetInt();
mModelScale = 2; // TODO: 動的に設定するようにする
mInnerScale = inner_scale;
mNetOffset = net_offset;
mInputPlane = channels;
}
catch (...)
stInfo::stParam param;
switch (mode)
{
return Waifu2x::eWaifu2xError_FailedParseModelFile;
case Waifu2x::eWaifu2xModelTypeNoise:
param = info.noise;
break;
case Waifu2x::eWaifu2xModelTypeScale:
param = info.scale;
break;
case Waifu2x::eWaifu2xModelTypeNoiseScale:
param = info.noise_scale;
break;
case Waifu2x::eWaifu2xModelTypeAutoScale:
param = info.noise_scale;
break;
}
return Waifu2x::eWaifu2xError_OK;
mInnerScale = param.scale_factor;
mNetOffset = param.offset;
mInputPlane = info.channels;
mHasNoiseScaleModel = info.has_noise_scale;
}
Waifu2x::eWaifu2xError cNet::SetParameter(caffe::NetParameter &param, const std::string &process) const
@ -732,26 +817,12 @@ Waifu2x::eWaifu2xError cNet::ReconstructImage(const bool UseTTA, const int crop_
std::string cNet::GetModelName(const boost::filesystem::path &info_path)
{
rapidjson::Document d;
std::vector<char> jsonBuf;
std::string str;
try
{
Waifu2x::eWaifu2xError ret;
ret = ReadJson(info_path, d, jsonBuf);
stInfo info;
ret = GetInfo(info_path, info);
if (ret != Waifu2x::eWaifu2xError_OK)
return str;
return std::string();
const auto name = d["name"].GetString();
str = name;
}
catch (...)
{
}
return str;
return info.name;
}

27
common/cNet.h
View File

@ -4,27 +4,50 @@
#include "waifu2x.h"
struct stInfo
{
struct stParam
{
int scale_factor;
int offset;
};
std::string name;
std::string arch_name;
bool has_noise_scale;
int channels;
stParam noise;
stParam scale;
stParam noise_scale;
};
class cNet
{
private:
Waifu2x::eWaifu2xModelType mMode;
boost::shared_ptr<caffe::Net<float>> mNet;
int mModelScale; // モデルが対象とする拡大率
int mInnerScale; // ネット内部で拡大される倍率
int mNetOffset; // ネットに入力するとどれくらい削れるか
int mInputPlane; // ネットへの入力チャンネル数
bool mHasNoiseScaleModel;
private:
void LoadParamFromInfo(const Waifu2x::eWaifu2xModelType mode, const stInfo &info);
Waifu2x::eWaifu2xError LoadParameterFromJson(const boost::filesystem::path &model_path, const boost::filesystem::path &param_path
, const boost::filesystem::path &modelbin_path, const boost::filesystem::path &caffemodel_path, const std::string &process);
Waifu2x::eWaifu2xError LoadInfoFromJson(const boost::filesystem::path &info_path);
Waifu2x::eWaifu2xError SetParameter(caffe::NetParameter &param, const std::string &process) const;
public:
cNet();
~cNet();
Waifu2x::eWaifu2xError ConstractNet(const boost::filesystem::path &model_path, const boost::filesystem::path &param_path, const boost::filesystem::path &info_path, const std::string &process);
static Waifu2x::eWaifu2xError GetInfo(const boost::filesystem::path &info_path, stInfo &info);
Waifu2x::eWaifu2xError ConstractNet(const Waifu2x::eWaifu2xModelType mode, const boost::filesystem::path &model_path, const boost::filesystem::path &param_path, const stInfo &info, const std::string &process);
int GetInputPlane() const;
int GetInnerScale() const;

14
common/stImage.cpp
View File

@ -633,14 +633,14 @@ void stImage::ShrinkImage(const double scale)
const double shrinkRatio = scale >= 1.0 ? scale / std::pow(scaleBase, scaleNum) : scale;
const cv::Size_<int> ns(mOrgSize.width * scale, mOrgSize.height * scale);
//if (mEndImage.size().width != ns.width || mEndImage.size().height != ns.height)
//{
// int argo = cv::INTER_CUBIC;
// if (scale < 0.5)
// argo = cv::INTER_AREA;
if (mEndImage.size().width != ns.width || mEndImage.size().height != ns.height)
{
int argo = cv::INTER_CUBIC;
if (scale < 0.5)
argo = cv::INTER_AREA;
// cv::resize(mEndImage, mEndImage, ns, 0.0, 0.0, argo);
//}
cv::resize(mEndImage, mEndImage, ns, 0.0, 0.0, argo);
}
}
cv::Mat stImage::DeconvertFromFloat(const cv::Mat &im, const int depth)

117
common/waifu2x.cpp
View File

@ -257,7 +257,7 @@ Waifu2x::~Waifu2x()
Destroy();
}
Waifu2x::eWaifu2xError Waifu2x::Init(const std::string &mode, const int noise_level,
Waifu2x::eWaifu2xError Waifu2x::Init(const eWaifu2xModelType mode, const int noise_level,
const boost::filesystem::path &model_dir, const std::string &process)
{
Waifu2x::eWaifu2xError ret;
@ -303,28 +303,47 @@ Waifu2x::eWaifu2xError Waifu2x::Init(const std::string &mode, const int noise_le
mInputPlane = 0;
mMaxNetOffset = 0;
// TODO: ノイズ除去と拡大を同時に行うネットワークへの対処を考える
const boost::filesystem::path info_path = GetInfoPath(mode_dir_path);
if (mode == "noise" || mode == "noise_scale" || mode == "auto_scale")
stInfo info;
ret = cNet::GetInfo(info_path, info);
if (ret != Waifu2x::eWaifu2xError_OK)
return ret;
mHasNoiseScale = info.has_noise_scale;
mInputPlane = info.channels;
if (mode == eWaifu2xModelTypeNoise || mode == eWaifu2xModelTypeNoiseScale || mode == eWaifu2xModelTypeAutoScale)
{
const std::string base_name = "noise" + std::to_string(noise_level) + "_model";
std::string base_name;
mNoiseNet.reset(new cNet);
eWaifu2xModelType Mode = mode;
if (info.has_noise_scale) // ノイズ除去と拡大を同時に行う
{
// ノイズ除去拡大ネットの構築はeWaifu2xModelTypeNoiseScaleを指定する必要がある
Mode = eWaifu2xModelTypeNoiseScale;
base_name = "noise" + std::to_string(noise_level) + "_scale2.0x_model";
}
else // ノイズ除去だけ
{
Mode = eWaifu2xModelTypeNoise;
base_name = "noise" + std::to_string(noise_level) + "_model";
}
const boost::filesystem::path model_path = mode_dir_path / (base_name + ".prototxt");
const boost::filesystem::path param_path = mode_dir_path / (base_name + ".json");
mNoiseNet.reset(new cNet);
ret = mNoiseNet->ConstractNet(model_path, param_path, info_path, mProcess);
ret = mNoiseNet->ConstractNet(Mode, model_path, param_path, info, mProcess);
if (ret != Waifu2x::eWaifu2xError_OK)
return ret;
mInputPlane = mNoiseNet->GetInputPlane();
mMaxNetOffset = mNoiseNet->GetNetOffset();
}
if (mode == "scale" || mode == "noise_scale" || mode == "auto_scale")
// noise_scaleを持っている場合はαチャンネルの拡大のためにmScaleNetも構築する必要がある
if (info.has_noise_scale || mode == eWaifu2xModelTypeScale || mode == eWaifu2xModelTypeNoiseScale || mode == eWaifu2xModelTypeAutoScale)
{
const std::string base_name = "scale2.0x_model";
@ -333,13 +352,12 @@ Waifu2x::eWaifu2xError Waifu2x::Init(const std::string &mode, const int noise_le
mScaleNet.reset(new cNet);
ret = mScaleNet->ConstractNet(model_path, param_path, info_path, mProcess);
ret = mScaleNet->ConstractNet(eWaifu2xModelTypeScale, model_path, param_path, info, mProcess);
if (ret != Waifu2x::eWaifu2xError_OK)
return ret;
assert(mInputPlane == 0 || mInputPlane == mScaleNet->GetInputPlane());
mInputPlane = mScaleNet->GetInputPlane();
mMaxNetOffset = std::max(mScaleNet->GetNetOffset(), mMaxNetOffset);
}
else
@ -399,15 +417,19 @@ Waifu2x::eWaifu2xError Waifu2x::waifu2x(const boost::filesystem::path &input_fil
image.Preprocess(mInputPlane, mMaxNetOffset);
const bool isReconstructNoise = mMode == "noise" || mMode == "noise_scale" || (mMode == "auto_scale" && image.RequestDenoise());
const bool isReconstructScale = mMode == "scale" || mMode == "noise_scale" || mMode == "auto_scale";
const bool isReconstructNoise = mMode == eWaifu2xModelTypeNoise || mMode == eWaifu2xModelTypeNoiseScale || (mMode == eWaifu2xModelTypeAutoScale && image.RequestDenoise());
const bool isReconstructScale = mMode == eWaifu2xModelTypeScale || mMode == eWaifu2xModelTypeNoiseScale || mMode == eWaifu2xModelTypeAutoScale;
double Factor = factor;
if (!isReconstructScale)
Factor = 1.0;
cv::Mat reconstruct_image;
ret = ReconstructImage(factor, crop_w, crop_h, use_tta, batch_size, isReconstructNoise, isReconstructScale, cancel_func, image);
ret = ReconstructImage(Factor, crop_w, crop_h, use_tta, batch_size, isReconstructNoise, isReconstructScale, cancel_func, image);
if (ret != Waifu2x::eWaifu2xError_OK)
return ret;
image.Postprocess(mInputPlane, factor, output_depth);
image.Postprocess(mInputPlane, Factor, output_depth);
ret = image.Save(output_file, output_quality);
if (ret != Waifu2x::eWaifu2xError_OK)
@ -424,6 +446,7 @@ Waifu2x::eWaifu2xError Waifu2x::waifu2x(const double factor, const void* source,
if (!mIsInited)
return Waifu2x::eWaifu2xError_NotInitialized;
stImage image;
ret = image.Load(source, width, height, in_channel, in_stride);
if (ret != Waifu2x::eWaifu2xError_OK)
@ -431,15 +454,19 @@ Waifu2x::eWaifu2xError Waifu2x::waifu2x(const double factor, const void* source,
image.Preprocess(mInputPlane, mMaxNetOffset);
const bool isReconstructNoise = mMode == "noise" || mMode == "noise_scale";
const bool isReconstructScale = mMode == "scale" || mMode == "noise_scale" || mMode == "auto_scale";
const bool isReconstructNoise = mMode == eWaifu2xModelTypeNoise || mMode == eWaifu2xModelTypeNoiseScale;
const bool isReconstructScale = mMode == eWaifu2xModelTypeScale || mMode == eWaifu2xModelTypeNoiseScale || mMode == eWaifu2xModelTypeAutoScale;
double Factor = factor;
if (!isReconstructScale)
Factor = 1.0;
cv::Mat reconstruct_image;
ret = ReconstructImage(factor, crop_w, crop_h, use_tta, batch_size, isReconstructNoise, isReconstructScale, nullptr, image);
ret = ReconstructImage(Factor, crop_w, crop_h, use_tta, batch_size, isReconstructNoise, isReconstructScale, nullptr, image);
if (ret != Waifu2x::eWaifu2xError_OK)
return ret;
image.Postprocess(mInputPlane, factor, 8);
image.Postprocess(mInputPlane, Factor, 8);
cv::Mat out_image = image.GetEndImage();
image.Clear();
@ -460,9 +487,11 @@ Waifu2x::eWaifu2xError Waifu2x::ReconstructImage(const double factor, const int
{
Waifu2x::eWaifu2xError ret;
// TODO: ノイズ除去と拡大を同時に行うネットワークへの対処を考える
double Factor = factor;
if (isReconstructNoise)
{
if (!mHasNoiseScale) // ノイズ除去だけ
{
cv::Mat im;
cv::Size_<int> size;
@ -474,15 +503,23 @@ Waifu2x::eWaifu2xError Waifu2x::ReconstructImage(const double factor, const int
image.SetReconstructedRGB(im, size, 1);
}
else // ノイズ除去と拡大
{
ret = ReconstructNoiseScale(crop_w, crop_h, use_tta, batch_size, cancel_func, image);
if (ret != Waifu2x::eWaifu2xError_OK)
return ret;
Factor /= mNoiseNet->GetInnerScale();
}
}
if (cancel_func && cancel_func())
return Waifu2x::eWaifu2xError_Cancel;
const int scaleNum = ceil(log(factor) / log(ScaleBase));
const int scaleNum = ceil(log(Factor) / log(ScaleBase));
if (isReconstructScale)
{
bool isError = false;
for (int i = 0; i < scaleNum; i++)
{
ret = ReconstructScale(crop_w, crop_h, use_tta, batch_size, cancel_func, image);
@ -525,6 +562,40 @@ Waifu2x::eWaifu2xError Waifu2x::ReconstructScale(const int crop_w, const int cro
return Waifu2x::eWaifu2xError_OK;
}
Waifu2x::eWaifu2xError Waifu2x::ReconstructNoiseScale(const int crop_w, const int crop_h, const bool use_tta, const int batch_size,
const Waifu2x::waifu2xCancelFunc cancel_func, stImage &image)
{
Waifu2x::eWaifu2xError ret;
if (image.HasAlpha())
{
// αチャンネルにはノイズ除去を行わない
cv::Mat im;
cv::Size_<int> size;
image.GetScalePaddingedA(im, size, mScaleNet->GetNetOffset(), OuterPadding, crop_w, crop_h, mScaleNet->GetScale() / mScaleNet->GetInnerScale());
ret = ReconstructByNet(mScaleNet, crop_w, crop_h, use_tta, batch_size, cancel_func, im);
if (ret != Waifu2x::eWaifu2xError_OK)
return ret;
image.SetReconstructedA(im, size, mScaleNet->GetInnerScale());
}
cv::Mat im;
cv::Size_<int> size;
image.GetScalePaddingedRGB(im, size, mNoiseNet->GetNetOffset(), OuterPadding, crop_w, crop_h, mNoiseNet->GetScale() / mNoiseNet->GetInnerScale());
ret = ReconstructByNet(mNoiseNet, crop_w, crop_h, use_tta, batch_size, cancel_func, im);
if (ret != Waifu2x::eWaifu2xError_OK)
return ret;
image.SetReconstructedRGB(im, size, mNoiseNet->GetInnerScale());
return Waifu2x::eWaifu2xError_OK;
}
Waifu2x::eWaifu2xError Waifu2x::ReconstructByNet(std::shared_ptr<cNet> net, const int crop_w, const int crop_h, const bool use_tta, const int batch_size,
const Waifu2x::waifu2xCancelFunc cancel_func, cv::Mat &im)
{

15
common/waifu2x.h
View File

@ -28,6 +28,14 @@ class stImage;
class Waifu2x
{
public:
enum eWaifu2xModelType
{
eWaifu2xModelTypeNoise,
eWaifu2xModelTypeScale,
eWaifu2xModelTypeNoiseScale,
eWaifu2xModelTypeAutoScale,
};
enum eWaifu2xError
{
eWaifu2xError_OK = 0,
@ -68,7 +76,7 @@ public:
private:
bool mIsInited;
std::string mMode;
eWaifu2xModelType mMode;
int mNoiseLevel;
std::string mProcess;
@ -79,6 +87,7 @@ private:
int mInputPlane; // ネットへの入力チャンネル数
int mMaxNetOffset; // ネットに入力するとどれくらい削れるか
bool mHasNoiseScale;
float *mInputBlock;
size_t mInputBlockSize;
@ -94,6 +103,8 @@ private:
const bool isReconstructNoise, const bool isReconstructScale, const Waifu2x::waifu2xCancelFunc cancel_func, stImage &image);
Waifu2x::eWaifu2xError ReconstructScale(const int crop_w, const int crop_h, const bool use_tta, const int batch_size,
const Waifu2x::waifu2xCancelFunc cancel_func, stImage &image);
Waifu2x::eWaifu2xError ReconstructNoiseScale(const int crop_w, const int crop_h, const bool use_tta, const int batch_size,
const Waifu2x::waifu2xCancelFunc cancel_func, stImage &image);
Waifu2x::eWaifu2xError ReconstructByNet(std::shared_ptr<cNet> net, const int crop_w, const int crop_h, const bool use_tta, const int batch_size,
const Waifu2x::waifu2xCancelFunc cancel_func, cv::Mat &im);
Waifu2x::eWaifu2xError ProcessNet(std::shared_ptr<cNet> net, const int crop_w, const int crop_h, const bool use_tta, const int batch_size, cv::Mat &im);
@ -112,7 +123,7 @@ public:
// mode: noise or scale or noise_scale or auto_scale
// process: cpu or gpu or cudnn
eWaifu2xError Init(const std::string &mode, const int noise_level,
eWaifu2xError Init(const eWaifu2xModelType mode, const int noise_level,
const boost::filesystem::path &model_dir, const std::string &process);
eWaifu2xError waifu2x(const boost::filesystem::path &input_file, const boost::filesystem::path &output_file,

66
waifu2x-caffe-gui/MainDialog.cpp
View File

@ -123,22 +123,32 @@ tstring DialogEvent::AddName() const
addstr += TEXT(")");
addstr += TEXT("(");
if (mode == "noise")
switch (mode)
{
case Waifu2x::eWaifu2xModelTypeNoise:
addstr += TEXT("noise");
else if (mode == "scale")
break;
case Waifu2x::eWaifu2xModelTypeScale:
addstr += TEXT("scale");
else if (mode == "noise_scale")
break;
case Waifu2x::eWaifu2xModelTypeNoiseScale:
addstr += TEXT("noise_scale");
else if (mode == "auto_scale")
break;
case Waifu2x::eWaifu2xModelTypeAutoScale:
addstr += TEXT("auto_scale");
break;
}
addstr += TEXT(")");
if (mode.find("noise") != mode.npos || mode.find("auto_scale") != mode.npos)
if (mode == Waifu2x::eWaifu2xModelTypeNoise || mode == Waifu2x::eWaifu2xModelTypeNoiseScale || mode == Waifu2x::eWaifu2xModelTypeAutoScale)
addstr += TEXT("(Level") + to_tstring(noise_level) + TEXT(")");
if (use_tta)
addstr += TEXT("(tta)");
if (mode.find("scale") != mode.npos)
if (mode == Waifu2x::eWaifu2xModelTypeScale || mode == Waifu2x::eWaifu2xModelTypeNoiseScale || mode == Waifu2x::eWaifu2xModelTypeAutoScale)
{
if (scaleType == eScaleTypeRatio)
addstr += TEXT("(x") + to_tstring(scale_ratio) + TEXT(")");
@ -176,13 +186,25 @@ bool DialogEvent::SyncMember(const bool NotSyncCropSize, const bool silent)
}
if (SendMessage(GetDlgItem(dh, IDC_RADIO_MODE_NOISE), BM_GETCHECK, 0, 0))
mode = "noise";
{
mode = Waifu2x::eWaifu2xModelTypeNoise;
modeStr = "noise";
}
else if (SendMessage(GetDlgItem(dh, IDC_RADIO_MODE_SCALE), BM_GETCHECK, 0, 0))
mode = "scale";
{
mode = Waifu2x::eWaifu2xModelTypeScale;
modeStr = "scale";
}
else if (SendMessage(GetDlgItem(dh, IDC_RADIO_MODE_NOISE_SCALE), BM_GETCHECK, 0, 0))
mode = "noise_scale";
{
mode = Waifu2x::eWaifu2xModelTypeNoiseScale;
modeStr = "noise_scale";
}
else
mode = "auto_scale";
{
mode = Waifu2x::eWaifu2xModelTypeAutoScale;
modeStr = "auto_scale";
}
if (SendMessage(GetDlgItem(dh, IDC_RADIONOISE_LEVEL1), BM_GETCHECK, 0, 0))
noise_level = 1;
@ -895,14 +917,24 @@ void DialogEvent::SaveIni(const bool isSyncMember)
else
tScaleHeight = TEXT("");
if (mode == ("noise"))
switch (mode)
{
case Waifu2x::eWaifu2xModelTypeNoise:
tmode = TEXT("noise");
else if (mode == ("scale"))
break;
case Waifu2x::eWaifu2xModelTypeScale:
tmode = TEXT("scale");
else if (mode == ("auto_scale"))
tmode = TEXT("auto_scale");
else // noise_scale
break;
case Waifu2x::eWaifu2xModelTypeNoiseScale:
tmode = TEXT("noise_scale");
break;
case Waifu2x::eWaifu2xModelTypeAutoScale:
tmode = TEXT("auto_scale");
break;
}
if (process == "gpu")
tprcess = TEXT("gpu");
@ -1142,7 +1174,7 @@ UINT_PTR DialogEvent::OFNHookProcOut(HWND hdlg, UINT uiMsg, WPARAM wParam, LPARA
return 0L;
}
DialogEvent::DialogEvent() : dh(nullptr), mode("noise_scale"), noise_level(1), scale_ratio(2.0), scale_width(0), scale_height(0), model_dir(TEXT("models/anime_style_art_rgb")),
DialogEvent::DialogEvent() : dh(nullptr), mode(Waifu2x::eWaifu2xModelTypeNoiseScale), modeStr("noise_scale"), noise_level(1), scale_ratio(2.0), scale_width(0), scale_height(0), model_dir(TEXT("models/anime_style_art_rgb")),
process("gpu"), outputExt(TEXT(".png")), inputFileExt(TEXT("png:jpg:jpeg:tif:tiff:bmp:tga")),
use_tta(false), output_depth(8), crop_size(128), batch_size(1), isLastError(false), scaleType(eScaleTypeEnd),
TimeLeftThread(-1), TimeLeftGetTimeThread(0), isCommandLineStart(false), tAutoMode(TEXT("none")),
@ -1423,8 +1455,8 @@ void DialogEvent::SetWindowTextLang()
SendMessage(hwndCombo, CB_ADDSTRING, 0, (LPARAM)langStringList.GetString(L"IDC_RADIO_MODEL_RGB").c_str());
SendMessage(hwndCombo, CB_ADDSTRING, 0, (LPARAM)langStringList.GetString(L"IDC_RADIO_MODEL_PHOTO").c_str());
SendMessage(hwndCombo, CB_ADDSTRING, 0, (LPARAM)langStringList.GetString(L"IDC_RADIO_MODEL_Y").c_str());
SendMessage(hwndCombo, CB_ADDSTRING, 0, (LPARAM)langStringList.GetString(L"IDC_RADIO_MODEL_UPCONV_RGB").c_str());
SendMessage(hwndCombo, CB_ADDSTRING, 0, (LPARAM)langStringList.GetString(L"IDC_RADIO_MODEL_Y").c_str());
SendMessage(GetDlgItem(dh, IDC_COMBO_MODEL), CB_SETCURSEL, cur, 0);
}

4
waifu2x-caffe-gui/MainDialog.h
View File

@ -9,6 +9,7 @@
#include <atomic>
#include <boost/filesystem.hpp>
#include <boost/optional.hpp>
#include "../common/waifu2x.h"
#include "resource.h"
#include "tstring.h"
#include "LangStringList.h"
@ -33,7 +34,8 @@ private:
tstring input_str;
std::vector<tstring> input_str_multi;
tstring output_str;
std::string mode;
std::string modeStr;
Waifu2x::eWaifu2xModelType mode;
int noise_level;
double scale_ratio;
int scale_width;