OpenCV DNNへの移行テスト中

.gitignore

@@ -243,5 +243,8 @@ ModelManifest.xml
 
 # FAKE - F# Make
 .fake/
+
 *.caffemodel
 *.protobin
+/lib/
+/opencv_contrib-*/

.gitmodules

@@ -7,10 +7,6 @@
 [submodule "msgpack-c"]
 	path = msgpack-c
 	url = https://github.com/msgpack/msgpack-c
-[submodule "caffe"]
-	path = caffe
-	url = https://github.com/lltcggie/caffe.git
-	branch = lltcggie/custom
 [submodule "opencv"]
 	path = opencv
 	url = https://github.com/opencv/opencv.git

bin/models/upresnet10/noise0_scale2.0x_model.prototxt

@@ -196,7 +196,7 @@ layer {
 }
 layer {
   name: "/res1/axpy"
-  type: "Axpy"
+  type: "AxpyFast"
   bottom: "/res1/fc2_sigmoid"
   bottom: "/res1/conv2_relu"
   bottom: "/res1/crop"
@@ -353,7 +353,7 @@ layer {
 }
 layer {
   name: "/res2/axpy"
-  type: "Axpy"
+  type: "AxpyFast"
   bottom: "/res2/fc2_sigmoid"
   bottom: "/res2/conv2_relu"
   bottom: "/res2/crop"
@@ -510,7 +510,7 @@ layer {
 }
 layer {
   name: "/res3/axpy"
-  type: "Axpy"
+  type: "AxpyFast"
   bottom: "/res3/fc2_sigmoid"
   bottom: "/res3/conv2_relu"
   bottom: "/res3/crop"
@@ -667,7 +667,7 @@ layer {
 }
 layer {
   name: "/res4/axpy"
-  type: "Axpy"
+  type: "AxpyFast"
   bottom: "/res4/fc2_sigmoid"
   bottom: "/res4/conv2_relu"
   bottom: "/res4/crop"
@@ -824,7 +824,7 @@ layer {
 }
 layer {
   name: "/res5/axpy"
-  type: "Axpy"
+  type: "AxpyFast"
   bottom: "/res5/fc2_sigmoid"
   bottom: "/res5/conv2_relu"
   bottom: "/res5/crop"

caffe

@@ -1 +0,0 @@
-Subproject commit 9d5aa36c65a0082768f10c1d474c56d8a7cc9934

caffe_build.bat

@@ -4,7 +4,7 @@ cd /d "%~dp0"
 
 cd caffe
 
-set MSVC_VERSION=14
+set MSVC_VERSION=17
 set USE_CUDNN=1
 set USE_NCCL=0
 set USE_OPENCV=0
@@ -21,7 +21,8 @@ set BUILD_PYTHON_LAYER=0
 set RUN_TESTS=0
 set CMAKE_INSTALL_PREFIX=../../lib
 set RUN_INSTALL=1
-set CUDA_ARCH_BIN=35 50 52 53 60 61 62 70 75 80
+rem set CUDA_ARCH_BIN=75 80 86 89 90 100 120
-set CUDA_ARCH_PTX=80
+set CUDA_ARCH_BIN=89
+set CUDA_ARCH_PTX=120
 
 scripts\build_win.cmd

common/cNet.cpp

@@ -29,7 +29,7 @@ static bool readFile(boost::iostreams::stream<boost::iostreams::file_descriptor_
 }
 
 template<typename BufType>
-static bool readFile(const boost::filesystem::path &path, std::vector<BufType> &buf)
+static bool readFile(const std::filesystem::path &path, std::vector<BufType> &buf)
 {
 	boost::iostreams::stream<boost::iostreams::file_descriptor_source> is;
 
@@ -45,7 +45,7 @@ static bool readFile(const boost::filesystem::path &path, std::vector<BufType> &
 	return readFile(is, buf);
 }
 
-static Waifu2x::eWaifu2xError readProtoText(const boost::filesystem::path &path, ::google::protobuf::Message* proto)
+static Waifu2x::eWaifu2xError readProtoText(const std::filesystem::path &path, ::google::protobuf::Message* proto)
 {
 	boost::iostreams::stream<boost::iostreams::file_descriptor_source> is;
 
@@ -74,7 +74,7 @@ static Waifu2x::eWaifu2xError readProtoText(const boost::filesystem::path &path,
 	return Waifu2x::eWaifu2xError_OK;
 }
 
-static Waifu2x::eWaifu2xError writeProtoBinary(const ::google::protobuf::Message& proto, const boost::filesystem::path &path)
+static Waifu2x::eWaifu2xError writeProtoBinary(const ::google::protobuf::Message& proto, const std::filesystem::path &path)
 {
 	boost::iostreams::stream<boost::iostreams::file_descriptor> os;
 
@@ -96,7 +96,7 @@ static Waifu2x::eWaifu2xError writeProtoBinary(const ::google::protobuf::Message
 	return Waifu2x::eWaifu2xError_OK;
 }
 
-static Waifu2x::eWaifu2xError readProtoBinary(const boost::filesystem::path &path, ::google::protobuf::Message* proto)
+static Waifu2x::eWaifu2xError readProtoBinary(const std::filesystem::path &path, ::google::protobuf::Message* proto)
 {
 	boost::iostreams::stream<boost::iostreams::file_descriptor_source> is;
 
@@ -130,7 +130,7 @@ static Waifu2x::eWaifu2xError readProtoBinary(const boost::filesystem::path &pat
 
 namespace
 {
-	Waifu2x::eWaifu2xError ReadJson(const boost::filesystem::path &info_path, rapidjson::Document &d, std::vector<char> &jsonBuf)
+	Waifu2x::eWaifu2xError ReadJson(const std::filesystem::path &info_path, rapidjson::Document &d, std::vector<char> &jsonBuf)
 	{
 		try
 		{
@@ -174,7 +174,7 @@ cNet::cNet() : mModelScale(0), mInnerScale(0), mNetOffset(0), mInputPlane(0), mH
 cNet::~cNet()
 {}
 
-Waifu2x::eWaifu2xError cNet::GetInfo(const boost::filesystem::path & info_path, Waifu2x::stInfo &info)
+Waifu2x::eWaifu2xError cNet::GetInfo(const std::filesystem::path & info_path, Waifu2x::stInfo &info)
 {
 	rapidjson::Document d;
 	std::vector<char> jsonBuf;
@@ -291,7 +291,7 @@ Waifu2x::eWaifu2xError cNet::GetInfo(const boost::filesystem::path & info_path,
 
 // モデルファイルからネットワークを構築
 // processでcudnnが指定されなかった場合はcuDNNが呼び出されないように変更する
-Waifu2x::eWaifu2xError cNet::ConstractNet(const Waifu2x::eWaifu2xModelType mode, const boost::filesystem::path &model_path, const boost::filesystem::path &param_path, const Waifu2x::stInfo &info, const std::string &process)
+Waifu2x::eWaifu2xError cNet::ConstractNet(const Waifu2x::eWaifu2xModelType mode, const std::filesystem::path &model_path, const std::filesystem::path &param_path, const Waifu2x::stInfo &info, const std::string &process)
 {
 	Waifu2x::eWaifu2xError ret;
 
@@ -299,9 +299,9 @@ Waifu2x::eWaifu2xError cNet::ConstractNet(const Waifu2x::eWaifu2xModelType mode,
 
 	LoadParamFromInfo(mode, info);
 
-	boost::filesystem::path modelbin_path = model_path;
+	std::filesystem::path modelbin_path = model_path;
 	modelbin_path += ".protobin";
-	boost::filesystem::path caffemodel_path = param_path;
+	std::filesystem::path caffemodel_path = param_path;
 	caffemodel_path += ".caffemodel";
 
 	caffe::NetParameter param_model;
@@ -331,7 +331,7 @@ Waifu2x::eWaifu2xError cNet::ConstractNet(const Waifu2x::eWaifu2xModelType mode,
 		if (!caffe::UpgradeNetAsNeeded(caffemodel_path.string(), &param_caffemodel))
 			return Waifu2x::eWaifu2xError_FailedParseModelFile;
 
-		mNet = boost::shared_ptr<caffe::Net<float>>(new caffe::Net<float>(param_model));
+		mNet = std::shared_ptr<caffe::Net<float>>(new caffe::Net<float>(param_model));
 		mNet->CopyTrainedLayersFrom(param_caffemodel);
 	}
 	else
@@ -437,8 +437,8 @@ Waifu2x::eWaifu2xError cNet::SetParameter(caffe::NetParameter &param, const std:
 	return Waifu2x::eWaifu2xError_OK;
 }
 
-Waifu2x::eWaifu2xError cNet::LoadParameterFromJson(const boost::filesystem::path &model_path, const boost::filesystem::path &param_path
+Waifu2x::eWaifu2xError cNet::LoadParameterFromJson(const std::filesystem::path &model_path, const std::filesystem::path &param_path
-	, const boost::filesystem::path &modelbin_path, const boost::filesystem::path &caffemodel_path, const std::string &process)
+	, const std::filesystem::path &modelbin_path, const std::filesystem::path &caffemodel_path, const std::string &process)
 {
 	Waifu2x::eWaifu2xError ret;
 
@@ -455,7 +455,7 @@ Waifu2x::eWaifu2xError cNet::LoadParameterFromJson(const boost::filesystem::path
 	if (ret != Waifu2x::eWaifu2xError_OK)
 		return ret;
 
-	mNet = boost::shared_ptr<caffe::Net<float>>(new caffe::Net<float>(param));
+	mNet = std::shared_ptr<caffe::Net<float>>(new caffe::Net<float>(param));
 
 	rapidjson::Document d;
 	std::vector<char> jsonBuf;
@@ -509,7 +509,7 @@ Waifu2x::eWaifu2xError cNet::LoadParameterFromJson(const boost::filesystem::path
 	if (inputPlane != outputPlane)
 		return Waifu2x::eWaifu2xError_FailedParseModelFile;
 
-	std::vector<boost::shared_ptr<caffe::Layer<float>>> list;
+	std::vector<std::shared_ptr<caffe::Layer<float>>> list;
 	auto &v = mNet->layers();
 	for (auto &l : v)
 	{
@@ -858,7 +858,7 @@ Waifu2x::eWaifu2xError cNet::ReconstructImage(const bool UseTTA, const int crop_
 	return Waifu2x::eWaifu2xError_OK;
 }
 
-std::string cNet::GetModelName(const boost::filesystem::path &info_path)
+std::string cNet::GetModelName(const std::filesystem::path &info_path)
 {
 	Waifu2x::eWaifu2xError ret;
 

common/cNet.h

@@ -9,7 +9,7 @@ class cNet
 private:
 	Waifu2x::eWaifu2xModelType mMode;
 
-	boost::shared_ptr<caffe::Net<float>> mNet;
+	std::shared_ptr<caffe::Net<float>> mNet;
 
 	int mModelScale; // モデルが対象とする拡大率
 	int mInnerScale; // ネット内部で拡大される倍率
@@ -18,18 +18,18 @@ private:
 	bool mHasNoiseScaleModel;
 
 private:
-	void LoadParamFromInfo(const Waifu2x::eWaifu2xModelType mode, const Waifu2x::stInfo &info);
+	void LoadParamFromInfo(const Waifu2x::eWaifu2xModelType mode, const Waifu2x::stInfo& info);
-	Waifu2x::eWaifu2xError LoadParameterFromJson(const boost::filesystem::path &model_path, const boost::filesystem::path &param_path
+	Waifu2x::eWaifu2xError LoadParameterFromJson(const std::filesystem::path& model_path, const std::filesystem::path& param_path
-		, const boost::filesystem::path &modelbin_path, const boost::filesystem::path &caffemodel_path, const std::string &process);
+		, const std::filesystem::path& modelbin_path, const std::filesystem::path& caffemodel_path, const std::string& process);
-	Waifu2x::eWaifu2xError SetParameter(caffe::NetParameter &param, const std::string &process) const;
+	Waifu2x::eWaifu2xError SetParameter(caffe::NetParameter& param, const std::string& process) const;
 
 public:
 	cNet();
 	~cNet();
 
-	static Waifu2x::eWaifu2xError GetInfo(const boost::filesystem::path &info_path, Waifu2x::stInfo &info);
+	static Waifu2x::eWaifu2xError GetInfo(const std::filesystem::path& info_path, Waifu2x::stInfo& info);
 
-	Waifu2x::eWaifu2xError ConstractNet(const Waifu2x::eWaifu2xModelType mode, const boost::filesystem::path &model_path, const boost::filesystem::path &param_path, const Waifu2x::stInfo &info, const std::string &process);
+	Waifu2x::eWaifu2xError ConstractNet(const Waifu2x::eWaifu2xModelType mode, const std::filesystem::path& model_path, const std::filesystem::path& param_path, const Waifu2x::stInfo& info, const std::string& process);
 
 	int GetInputPlane() const;
 	int GetInnerScale() const;
@@ -39,7 +39,7 @@ public:
 	int GetInputMemorySize(const int crop_w, const int crop_h, const int outer_padding, const int batch_size) const;
 	int GetOutputMemorySize(const int crop_w, const int crop_h, const int outer_padding, const int batch_size) const;
 
-	Waifu2x::eWaifu2xError ReconstructImage(const bool UseTTA, const int crop_w, const int crop_h, const int outer_padding, const int batch_size, float *outputBlockBuf, const cv::Mat &inMat, cv::Mat &outMat);
+	Waifu2x::eWaifu2xError ReconstructImage(const bool UseTTA, const int crop_w, const int crop_h, const int outer_padding, const int batch_size, float* outputBlockBuf, const cv::Mat& inMat, cv::Mat& outMat);
 
-	static std::string GetModelName(const boost::filesystem::path &info_path);
+	static std::string GetModelName(const std::filesystem::path& info_path);
 };

common/stImage.cpp

@@ -1,7 +1,7 @@
 #include "stImage.h"
-#include <boost/iostreams/stream.hpp>
+//#include <boost/iostreams/stream.hpp>
-#include <boost/iostreams/device/file_descriptor.hpp>
+//#include <boost/iostreams/device/file_descriptor.hpp>
-#include <boost/algorithm/string.hpp>
+//#include <boost/algorithm/string.hpp>
 #include <opencv2/core.hpp>
 #include <opencv2/imgproc.hpp>
 #include <opencv2/imgcodecs.hpp>
@@ -11,10 +11,10 @@
 #define STB_IMAGE_WRITE_IMPLEMENTATION
 #include <stb_image_write.h>
 
-const int YToRGBConvertMode = CV_GRAY2RGB;
+const int YToRGBConvertMode = cv::COLOR_GRAY2RGB;
-const int YToRGBConverInversetMode = CV_RGB2GRAY;
+const int YToRGBConverInversetMode = cv::COLOR_RGB2GRAY;
-const int BGRToYConvertMode = CV_BGR2YUV;
+const int BGRToYConvertMode = cv::COLOR_BGR2YUV;
-const int BGRToConvertInverseMode = CV_YUV2BGR;
+const int BGRToConvertInverseMode = cv::COLOR_YUV2BGR;
 
 // floatな画像をuint8_tな画像に変換する際の四捨五入に使う値
 // https://github.com/nagadomi/waifu2x/commit/797b45ae23665a1c5e3c481c018e48e6f0d0e383
@@ -24,39 +24,22 @@ const double clip_eps32 = 1.0 * 0.5 - (1.0e-7 * 0.5);
 
 const std::vector<stImage::stOutputExtentionElement> stImage::OutputExtentionList =
 {
-	{L".png",{8, 16}, boost::optional<int>(), boost::optional<int>(), boost::optional<int>(), boost::optional<int>()},
+	{L".png",{8, 16}, std::optional<int>(), std::optional<int>(), std::optional<int>(), std::optional<int>()},
-	{L".bmp",{8}, boost::optional<int>(), boost::optional<int>(), boost::optional<int>(), boost::optional<int>()},
+	{L".bmp",{8}, std::optional<int>(), std::optional<int>(), std::optional<int>(), std::optional<int>()},
 	{L".jpg",{8}, 0, 100, 95, cv::IMWRITE_JPEG_QUALITY},
-	{L".jp2",{8, 16}, boost::optional<int>(), boost::optional<int>(), boost::optional<int>(), boost::optional<int>()},
+	{L".jp2",{8, 16}, std::optional<int>(), std::optional<int>(), std::optional<int>(), std::optional<int>()},
-	{L".sr",{8}, boost::optional<int>(), boost::optional<int>(), boost::optional<int>(), boost::optional<int>()},
+	{L".sr",{8}, std::optional<int>(), std::optional<int>(), std::optional<int>(), std::optional<int>()},
-	{L".tif",{8, 16, 32}, boost::optional<int>(), boost::optional<int>(), boost::optional<int>(), boost::optional<int>()},
+	{L".tif",{8, 16, 32}, std::optional<int>(), std::optional<int>(), std::optional<int>(), std::optional<int>()},
-	{L".hdr",{8, 16, 32}, boost::optional<int>(), boost::optional<int>(), boost::optional<int>(), boost::optional<int>()},
+	{L".hdr",{8, 16, 32}, std::optional<int>(), std::optional<int>(), std::optional<int>(), std::optional<int>()},
-	{L".exr",{8, 16, 32}, boost::optional<int>(), boost::optional<int>(), boost::optional<int>(), boost::optional<int>()},
+	{L".exr",{8, 16, 32}, std::optional<int>(), std::optional<int>(), std::optional<int>(), std::optional<int>()},
-	{L".ppm",{8, 16}, boost::optional<int>(), boost::optional<int>(), boost::optional<int>(), boost::optional<int>()},
+	{L".ppm",{8, 16}, std::optional<int>(), std::optional<int>(), std::optional<int>(), std::optional<int>()},
 	{L".webp",{8}, 1, 100, 100, cv::IMWRITE_WEBP_QUALITY},
 	{L".tga",{8}, 0, 1, 0, 0},
 };
 
 
 template<typename BufType>
-static bool readFile(boost::iostreams::stream<boost::iostreams::file_descriptor_source> &is, std::vector<BufType> &buf)
+static bool readFile(const std::filesystem::path& path, std::vector<BufType>& buf)
-{
-	if (!is)
-		return false;
-
-	const auto size = is.seekg(0, std::ios::end).tellg();
-	is.seekg(0, std::ios::beg);
-
-	buf.resize((size / sizeof(BufType)) + (size % sizeof(BufType)));
-	is.read(buf.data(), size);
-	if (is.gcount() != size)
-		return false;
-
-	return true;
-}
-
-template<typename BufType>
-static bool readFile(const boost::filesystem::path &path, std::vector<BufType> &buf)
 {
 	boost::iostreams::stream<boost::iostreams::file_descriptor_source> is;
 
@@ -73,21 +56,7 @@ static bool readFile(const boost::filesystem::path &path, std::vector<BufType> &
 }
 
 template<typename BufType>
-static bool writeFile(boost::iostreams::stream<boost::iostreams::file_descriptor> &os, const std::vector<BufType> &buf)
+static bool writeFile(const std::filesystem::path& path, std::vector<BufType>& buf)
-{
-	if (!os)
-		return false;
-
-	const auto WriteSize = sizeof(BufType) * buf.size();
-	os.write((const char *)buf.data(), WriteSize);
-	if (os.fail())
-		return false;
-
-	return true;
-}
-
-template<typename BufType>
-static bool writeFile(const boost::filesystem::path &path, std::vector<BufType> &buf)
 {
 	boost::iostreams::stream<boost::iostreams::file_descriptor> os;
 
@@ -103,10 +72,10 @@ static bool writeFile(const boost::filesystem::path &path, std::vector<BufType>
 	return writeFile(os, buf);
 }
 
-static void Waifu2x_stbi_write_func(void *context, void *data, int size)
+static void Waifu2x_stbi_write_func(void* context, void* data, int size)
 {
-	boost::iostreams::stream<boost::iostreams::file_descriptor> *osp = (boost::iostreams::stream<boost::iostreams::file_descriptor> *)context;
+	boost::iostreams::stream<boost::iostreams::file_descriptor>* osp = (boost::iostreams::stream<boost::iostreams::file_descriptor> *)context;
-	osp->write((const char *)data, size);
+	osp->write((const char*)data, size);
 }
 
 int stImage::DepthBitToCVDepth(const int depth_bit)
@@ -164,7 +133,7 @@ double stImage::GetEPS(const int cv_depth)
 }
 
 
-Waifu2x::eWaifu2xError stImage::AlphaMakeBorder(std::vector<cv::Mat> &planes, const cv::Mat &alpha, const int offset)
+Waifu2x::eWaifu2xError stImage::AlphaMakeBorder(std::vector<cv::Mat>& planes, const cv::Mat& alpha, const int offset)
 {
 	// このカーネルと画像の畳込みを行うと、(x, y)を中心とした3×3領域の合計値が求まる
 	const static cv::Mat sum2d_kernel = (cv::Mat_<double>(3, 3) <<
@@ -178,7 +147,7 @@ Waifu2x::eWaifu2xError stImage::AlphaMakeBorder(std::vector<cv::Mat> &planes, co
 	cv::Mat mask_nega;
 	cv::threshold(mask, mask_nega, 0.0, 1.0, cv::THRESH_BINARY_INV); // 反転したマスク（値が1の箇所は完全透明でない有効な画素となる）
 
-	for (auto &p : planes) // 完全に透明なピクセルにあるゴミを取る
+	for (auto& p : planes) // 完全に透明なピクセルにあるゴミを取る
 	{
 		p = p.mul(mask);
 	}
@@ -191,7 +160,7 @@ Waifu2x::eWaifu2xError stImage::AlphaMakeBorder(std::vector<cv::Mat> &planes, co
 		cv::Mat mask_nega_u8;
 		mask_nega.convertTo(mask_nega_u8, CV_8U, 255.0, clip_eps8); // mask_negaのCV_U8版（OpenCVのAPI上必要になる）
 
-		for (auto &p : planes) // 1チャンネルずつ処理
+		for (auto& p : planes) // 1チャンネルずつ処理
 		{
 			// チャンネルの3×3領域内の有効画素の平均値を求める
 			cv::Mat border;
@@ -209,7 +178,7 @@ Waifu2x::eWaifu2xError stImage::AlphaMakeBorder(std::vector<cv::Mat> &planes, co
 	}
 
 	// 画素を0から1にクリッピング
-	for (auto &p : planes)
+	for (auto& p : planes)
 	{
 		cv::threshold(p, p, 1.0, 1.0, cv::THRESH_TRUNC);
 		cv::threshold(p, p, 0.0, 0.0, cv::THRESH_TOZERO);
@@ -219,7 +188,7 @@ Waifu2x::eWaifu2xError stImage::AlphaMakeBorder(std::vector<cv::Mat> &planes, co
 }
 
 // 画像を読み込んで値を0.0f～1.0fの範囲に変換
-Waifu2x::eWaifu2xError stImage::LoadMat(cv::Mat &im, const boost::filesystem::path &input_file)
+Waifu2x::eWaifu2xError stImage::LoadMat(cv::Mat& im, const std::filesystem::path& input_file)
 {
 	cv::Mat original_image;
 
@@ -228,7 +197,7 @@ Waifu2x::eWaifu2xError stImage::LoadMat(cv::Mat &im, const boost::filesystem::pa
 		if (!readFile(input_file, img_data))
 			return Waifu2x::eWaifu2xError_FailedOpenInputFile;
 
-		const boost::filesystem::path ipext(input_file.extension());
+		const std::filesystem::path ipext(input_file.extension());
 		if (!boost::iequals(ipext.string(), ".bmp")) // 特定のファイル形式の場合OpenCVで読むとバグることがあるのでSTBIを優先させる
 		{
 			cv::Mat im(img_data.size(), 1, CV_8U, img_data.data());
@@ -259,10 +228,10 @@ Waifu2x::eWaifu2xError stImage::LoadMat(cv::Mat &im, const boost::filesystem::pa
 	return Waifu2x::eWaifu2xError_OK;
 }
 
-Waifu2x::eWaifu2xError stImage::LoadMatBySTBI(cv::Mat &im, const std::vector<char> &img_data)
+Waifu2x::eWaifu2xError stImage::LoadMatBySTBI(cv::Mat& im, const std::vector<char>& img_data)
 {
 	int x, y, comp;
-	stbi_uc *data = stbi_load_from_memory((const stbi_uc *)img_data.data(), img_data.size(), &x, &y, &comp, 0);
+	stbi_uc* data = stbi_load_from_memory((const stbi_uc*)img_data.data(), img_data.size(), &x, &y, &comp, 0);
 	if (!data)
 		return Waifu2x::eWaifu2xError_FailedOpenInputFile;
 
@@ -315,7 +284,7 @@ Waifu2x::eWaifu2xError stImage::LoadMatBySTBI(cv::Mat &im, const std::vector<cha
 	return Waifu2x::eWaifu2xError_OK;
 }
 
-cv::Mat stImage::ConvertToFloat(const cv::Mat &im)
+cv::Mat stImage::ConvertToFloat(const cv::Mat& im)
 {
 	cv::Mat convert;
 	switch (im.depth())
@@ -354,7 +323,7 @@ void stImage::Clear()
 	mEndImage.release();
 }
 
-Waifu2x::eWaifu2xError stImage::Load(const boost::filesystem::path &input_file)
+Waifu2x::eWaifu2xError stImage::Load(const std::filesystem::path& input_file)
 {
 	Clear();
 
@@ -369,8 +338,8 @@ Waifu2x::eWaifu2xError stImage::Load(const boost::filesystem::path &input_file)
 	mOrgChannel = im.channels();
 	mOrgSize = im.size();
 
-	const boost::filesystem::path ip(input_file);
+	const std::filesystem::path ip(input_file);
-	const boost::filesystem::path ipext(ip.extension());
+	const std::filesystem::path ipext(ip.extension());
 
 	const bool isJpeg = boost::iequals(ipext.string(), ".jpg") || boost::iequals(ipext.string(), ".jpeg");
 
@@ -383,7 +352,7 @@ Waifu2x::eWaifu2xError stImage::Load(const void* source, const int width, const
 {
 	Clear();
 
-	cv::Mat original_image(cv::Size(width, height), CV_MAKETYPE(CV_8U, channel), (void *)source, stride);
+	cv::Mat original_image(cv::Size(width, height), CV_MAKETYPE(CV_8U, channel), (void*)source, stride);
 
 	if (original_image.channels() >= 3) // RGBなのでBGRにする
 	{
@@ -426,7 +395,7 @@ void stImage::Preprocess(const int input_plane, const int net_offset)
 	ConvertToNetFormat(input_plane, net_offset);
 }
 
-bool stImage::IsOneColor(const cv::Mat & im)
+bool stImage::IsOneColor(const cv::Mat& im)
 {
 	assert(im.channels() == 1);
 
@@ -437,7 +406,7 @@ bool stImage::IsOneColor(const cv::Mat & im)
 	if (Width == 0 && Height == 0)
 		return true;
 
-	const float *ptr = (const float *)im.data;
+	const float* ptr = (const float*)im.data;
 	const float color = ptr[0];
 
 	for (size_t i = 0; i < Height; i++)
@@ -524,7 +493,7 @@ void stImage::ConvertToNetFormat(const int input_plane, const int alpha_offset)
 }
 
 // 画像から輝度の画像を取り出す
-Waifu2x::eWaifu2xError stImage::CreateBrightnessImage(const cv::Mat &float_image, cv::Mat &im)
+Waifu2x::eWaifu2xError stImage::CreateBrightnessImage(const cv::Mat& float_image, cv::Mat& im)
 {
 	if (float_image.channels() > 1)
 	{
@@ -548,29 +517,29 @@ bool stImage::HasAlpha() const
 	return !mTmpImageA.empty();
 }
 
-void stImage::GetScalePaddingedRGB(cv::Mat &im, cv::Size_<int> &size, const int net_offset, const int outer_padding,
+void stImage::GetScalePaddingedRGB(cv::Mat& im, cv::Size_<int>& size, const int net_offset, const int outer_padding,
 	const int crop_w, const int crop_h, const int scale)
 {
 	GetScalePaddingedImage(mTmpImageRGB, im, size, net_offset, outer_padding, crop_w, crop_h, scale);
 }
 
-void stImage::SetReconstructedRGB(cv::Mat &im, const cv::Size_<int> &size, const int inner_scale)
+void stImage::SetReconstructedRGB(cv::Mat& im, const cv::Size_<int>& size, const int inner_scale)
 {
 	SetReconstructedImage(mTmpImageRGB, im, size, inner_scale);
 }
 
-void stImage::GetScalePaddingedA(cv::Mat &im, cv::Size_<int> &size, const int net_offset, const int outer_padding,
+void stImage::GetScalePaddingedA(cv::Mat& im, cv::Size_<int>& size, const int net_offset, const int outer_padding,
 	const int crop_w, const int crop_h, const int scale)
 {
 	GetScalePaddingedImage(mTmpImageA, im, size, net_offset, outer_padding, crop_w, crop_h, scale);
 }
 
-void stImage::SetReconstructedA(cv::Mat &im, const cv::Size_<int> &size, const int inner_scale)
+void stImage::SetReconstructedA(cv::Mat& im, const cv::Size_<int>& size, const int inner_scale)
 {
 	SetReconstructedImage(mTmpImageA, im, size, inner_scale);
 }
 
-void stImage::GetScalePaddingedImage(cv::Mat &in, cv::Mat &out, cv::Size_<int> &size, const int net_offset, const int outer_padding,
+void stImage::GetScalePaddingedImage(cv::Mat& in, cv::Mat& out, cv::Size_<int>& size, const int net_offset, const int outer_padding,
 	const int crop_w, const int crop_h, const int scale)
 {
 	cv::Mat ret;
@@ -597,8 +566,8 @@ void stImage::GetScalePaddingedImage(cv::Mat &in, cv::Mat &out, cv::Size_<int> &
 
 // 入力画像の(Photoshopでいう)キャンバスサイズをoutput_sizeの倍数に変更
 // 画像は左上配置、余白はcv::BORDER_REPLICATEで埋める
-void stImage::PaddingImage(const cv::Mat &input, const int net_offset, const int outer_padding,
+void stImage::PaddingImage(const cv::Mat& input, const int net_offset, const int outer_padding,
-	const int crop_w, const int crop_h, cv::Mat &output)
+	const int crop_w, const int crop_h, cv::Mat& output)
 {
 	const auto pad_w1 = net_offset + outer_padding;
 	const auto pad_h1 = net_offset + outer_padding;
@@ -609,7 +578,7 @@ void stImage::PaddingImage(const cv::Mat &input, const int net_offset, const int
 }
 
 // 拡大、パディングされた画像を設定
-void stImage::SetReconstructedImage(cv::Mat &dst, cv::Mat &src, const cv::Size_<int> &size, const int inner_scale)
+void stImage::SetReconstructedImage(cv::Mat& dst, cv::Mat& src, const cv::Size_<int>& size, const int inner_scale)
 {
 	const cv::Size_<int> s(size * inner_scale);
 
@@ -718,7 +687,7 @@ void stImage::DeconvertFromNetFormat(const int input_plane)
 			if (!mTmpImageA.empty()) // Aもあるので合体
 			{
 				// RGBから1chに戻す
-				cv::cvtColor(mTmpImageA, mTmpImageA, CV_RGB2GRAY);
+				cv::cvtColor(mTmpImageA, mTmpImageA, cv::COLOR_RGB2GRAY);
 
 				planes.push_back(mTmpImageA);
 				mTmpImageA.release();
@@ -775,7 +744,7 @@ void stImage::ShrinkImage(const int width, const int height)
 	}
 }
 
-cv::Mat stImage::DeconvertFromFloat(const cv::Mat &im, const int depth)
+cv::Mat stImage::DeconvertFromFloat(const cv::Mat& im, const int depth)
 {
 	const int cv_depth = DepthBitToCVDepth(depth);
 	const double max_val = GetValumeMaxFromCVDepth(cv_depth);
@@ -793,15 +762,15 @@ cv::Mat stImage::DeconvertFromFloat(const cv::Mat &im, const int depth)
 namespace
 {
 	template<typename T>
-	void AlphaZeroToZero(std::vector<cv::Mat> &planes)
+	void AlphaZeroToZero(std::vector<cv::Mat>& planes)
 	{
 		cv::Mat alpha(planes[3]);
 
-		const T *aptr = (const T *)alpha.data;
+		const T* aptr = (const T*)alpha.data;
 
-		T *ptr0 = (T *)planes[0].data;
+		T* ptr0 = (T*)planes[0].data;
-		T *ptr1 = (T *)planes[1].data;
+		T* ptr1 = (T*)planes[1].data;
-		T *ptr2 = (T *)planes[2].data;
+		T* ptr2 = (T*)planes[2].data;
 
 		const size_t Line = alpha.step1();
 		const size_t Width = alpha.size().width;
@@ -820,7 +789,7 @@ namespace
 	}
 }
 
-void stImage::AlphaCleanImage(cv::Mat &im)
+void stImage::AlphaCleanImage(cv::Mat& im)
 {
 	// 完全透明のピクセルの色を消す(処理の都合上、完全透明のピクセルにも色を付けたから)
 	// モデルによっては画像全域の完全透明の場所にごく小さい値のアルファが広がることがある。それを消すためにcv_depthへ変換してからこの処理を行うことにした
@@ -858,7 +827,7 @@ void stImage::AlphaCleanImage(cv::Mat &im)
 
 
 // 入力画像をzoom_sizeの大きさにcv::INTER_CUBICで拡大し、色情報のみを残す
-Waifu2x::eWaifu2xError stImage::CreateZoomColorImage(const cv::Mat &float_image, const cv::Size_<int> &zoom_size, std::vector<cv::Mat> &cubic_planes)
+Waifu2x::eWaifu2xError stImage::CreateZoomColorImage(const cv::Mat& float_image, const cv::Size_<int>& zoom_size, std::vector<cv::Mat>& cubic_planes)
 {
 	cv::Mat zoom_cubic_image;
 	cv::resize(float_image, zoom_cubic_image, zoom_size, 0.0, 0.0, cv::INTER_CUBIC);
@@ -881,19 +850,19 @@ cv::Mat stImage::GetEndImage() const
 	return mEndImage;
 }
 
-Waifu2x::eWaifu2xError stImage::Save(const boost::filesystem::path &output_file, const boost::optional<int> &output_quality)
+Waifu2x::eWaifu2xError stImage::Save(const std::filesystem::path& output_file, const std::optional<int>& output_quality)
 {
 	return WriteMat(mEndImage, output_file, output_quality);
 }
 
-Waifu2x::eWaifu2xError stImage::WriteMat(const cv::Mat &im, const boost::filesystem::path &output_file, const boost::optional<int> &output_quality)
+Waifu2x::eWaifu2xError stImage::WriteMat(const cv::Mat& im, const std::filesystem::path& output_file, const std::optional<int>& output_quality)
 {
-	const boost::filesystem::path ip(output_file);
+	const std::filesystem::path ip(output_file);
 	const std::string ext = ip.extension().string();
 
 	if (boost::iequals(ext, ".tga"))
 	{
-		unsigned char *data = im.data;
+		unsigned char* data = im.data;
 
 		std::vector<unsigned char> rgbimg;
 		if (im.channels() >= 3 || im.step1() != im.size().width * im.channels()) // RGB用バッファにコピー(あるいはパディングをとる)
@@ -943,8 +912,8 @@ Waifu2x::eWaifu2xError stImage::WriteMat(const cv::Mat &im, const boost::filesys
 
 		// RLE圧縮の設定
 		bool isSet = false;
-		const auto &OutputExtentionList = stImage::OutputExtentionList;
+		const auto& OutputExtentionList = stImage::OutputExtentionList;
-		for (const auto &elm : OutputExtentionList)
+		for (const auto& elm : OutputExtentionList)
 		{
 			if (elm.ext == L".tga")
 			{
@@ -970,13 +939,13 @@ Waifu2x::eWaifu2xError stImage::WriteMat(const cv::Mat &im, const boost::filesys
 
 	try
 	{
-		const boost::filesystem::path op(output_file);
+		const std::filesystem::path op(output_file);
-		const boost::filesystem::path opext(op.extension());
+		const std::filesystem::path opext(op.extension());
 
 		std::vector<int> params;
 
-		const auto &OutputExtentionList = stImage::OutputExtentionList;
+		const auto& OutputExtentionList = stImage::OutputExtentionList;
-		for (const auto &elm : OutputExtentionList)
+		for (const auto& elm : OutputExtentionList)
 		{
 			if (elm.ext == opext)
 			{

common/stImage.h

@@ -28,10 +28,10 @@ public:
 	{
 		std::wstring ext;
 		std::vector<int> depthList;
-		boost::optional<int> imageQualityStart;
+		std::optional<int> imageQualityStart;
-		boost::optional<int> imageQualityEnd;
+		std::optional<int> imageQualityEnd;
-		boost::optional<int> imageQualityDefault;
+		std::optional<int> imageQualityDefault;
-		boost::optional<int> imageQualitySettingVolume;
+		std::optional<int> imageQualitySettingVolume;
 	};
 
 	const static std::vector<stOutputExtentionElement> OutputExtentionList;
@@ -46,7 +46,7 @@ private:
 	static cv::Mat DeconvertFromFloat(const cv::Mat &im, const int depth);
 	static void AlphaCleanImage(cv::Mat &im);
 
-	static Waifu2x::eWaifu2xError WriteMat(const cv::Mat &im, const boost::filesystem::path &output_file, const boost::optional<int> &output_quality);
+	static Waifu2x::eWaifu2xError WriteMat(const cv::Mat &im, const std::filesystem::path &output_file, const std::optional<int> &output_quality);
 
 	// im(1ch)が単色で構成されているか判定
 	static bool IsOneColor(const cv::Mat &im);
@@ -81,9 +81,9 @@ public:
 
 	void Clear();
 
-	static Waifu2x::eWaifu2xError LoadMat(cv::Mat &im, const boost::filesystem::path &input_file);
+	static Waifu2x::eWaifu2xError LoadMat(cv::Mat &im, const std::filesystem::path &input_file);
 
-	Waifu2x::eWaifu2xError Load(const boost::filesystem::path &input_file);
+	Waifu2x::eWaifu2xError Load(const std::filesystem::path &input_file);
 
 	// source: (4チャンネルの場合は)RGBAな画素配列
 	// dest: (4チャンネルの場合は)処理したRGBAな画素配列
@@ -130,5 +130,5 @@ public:
 
 	cv::Mat GetEndImage() const;
 
-	Waifu2x::eWaifu2xError Save(const boost::filesystem::path &output_file, const boost::optional<int> &output_quality);
+	Waifu2x::eWaifu2xError Save(const std::filesystem::path &output_file, const std::optional<int> &output_quality);
 };

common/waifu2x.cpp

@@ -327,7 +327,7 @@ private:
 		}
 		catch (...)
 		{
-			boost::filesystem::remove(SavePath);
+			std::filesystem::remove(SavePath);
 		}
 
 		return true;
@@ -550,7 +550,7 @@ Waifu2x::~Waifu2x()
 }
 
 Waifu2x::eWaifu2xError Waifu2x::Init(const eWaifu2xModelType mode, const int noise_level,
-	const boost::filesystem::path &model_dir, const std::string &process, const int GPUNo)
+	const std::filesystem::path &model_dir, const std::string &process, const int GPUNo)
 {
 	Waifu2x::eWaifu2xError ret;
 
@@ -581,38 +581,38 @@ Waifu2x::eWaifu2xError Waifu2x::Init(const eWaifu2xModelType mode, const int noi
 		if (Process == "cudnn")
 		{
 			// exeのディレクトリにcuDNNのアルゴリズムデータ保存
-			boost::filesystem::path cudnn_data_base_dir_path(ExeDir);
+			std::filesystem::path cudnn_data_base_dir_path(ExeDir);
 			if (cudnn_data_base_dir_path.is_relative())
-				cudnn_data_base_dir_path = boost::filesystem::system_complete(cudnn_data_base_dir_path);
+				cudnn_data_base_dir_path = std::filesystem::system_complete(cudnn_data_base_dir_path);
 
-			if (!boost::filesystem::is_directory(cudnn_data_base_dir_path))
+			if (!std::filesystem::is_directory(cudnn_data_base_dir_path))
 				cudnn_data_base_dir_path = cudnn_data_base_dir_path.branch_path();
 
-			if (!boost::filesystem::exists(cudnn_data_base_dir_path))
+			if (!std::filesystem::exists(cudnn_data_base_dir_path))
 			{
 				// exeのディレクトリが取得できなければカレントディレクトリに保存
 
-				cudnn_data_base_dir_path = boost::filesystem::current_path();
+				cudnn_data_base_dir_path = std::filesystem::current_path();
 
 				if (cudnn_data_base_dir_path.is_relative())
-					cudnn_data_base_dir_path = boost::filesystem::system_complete(cudnn_data_base_dir_path);
+					cudnn_data_base_dir_path = std::filesystem::system_complete(cudnn_data_base_dir_path);
 
-				if (!boost::filesystem::exists(cudnn_data_base_dir_path))
+				if (!std::filesystem::exists(cudnn_data_base_dir_path))
 					cudnn_data_base_dir_path = "./";
 			}
 
-			if (boost::filesystem::exists(cudnn_data_base_dir_path))
+			if (std::filesystem::exists(cudnn_data_base_dir_path))
 			{
-				const boost::filesystem::path cudnn_data_dir_path(cudnn_data_base_dir_path / "cudnn_data");
+				const std::filesystem::path cudnn_data_dir_path(cudnn_data_base_dir_path / "cudnn_data");
 
 				bool isOK = false;
-				if (boost::filesystem::exists(cudnn_data_dir_path))
+				if (std::filesystem::exists(cudnn_data_dir_path))
 					isOK = true;
 
 				if (!isOK)
 				{
 					boost::system::error_code error;
-					const bool result = boost::filesystem::create_directory(cudnn_data_dir_path, error);
+					const bool result = std::filesystem::create_directory(cudnn_data_dir_path, error);
 					if (result && !error)
 						isOK = true;
 				}
@@ -628,8 +628,8 @@ Waifu2x::eWaifu2xError Waifu2x::Init(const eWaifu2xModelType mode, const int noi
 						std::string deconv_filename(prop.name);
 						deconv_filename += " deconv ";
 
-						const boost::filesystem::path conv_data_path = cudnn_data_dir_path / conv_filename;
+						const std::filesystem::path conv_data_path = cudnn_data_dir_path / conv_filename;
-						const boost::filesystem::path deconv_data_path = cudnn_data_dir_path / deconv_filename;
+						const std::filesystem::path deconv_data_path = cudnn_data_dir_path / deconv_filename;
 
 						g_ConvCcuDNNAlgorithm.SetDataPath(conv_data_path.string());
 						g_DeconvCcuDNNAlgorithm.SetDataPath(deconv_data_path.string());
@@ -638,8 +638,8 @@ Waifu2x::eWaifu2xError Waifu2x::Init(const eWaifu2xModelType mode, const int noi
 			}
 		}
 
-		const boost::filesystem::path mode_dir_path(GetModeDirPath(model_dir));
+		const std::filesystem::path mode_dir_path(GetModeDirPath(model_dir));
-		if (!boost::filesystem::exists(mode_dir_path))
+		if (!std::filesystem::exists(mode_dir_path))
 			return Waifu2x::eWaifu2xError_FailedOpenModelFile;
 
 		CudaDeviceSet devset(process, mGPUNo);
@@ -661,7 +661,7 @@ Waifu2x::eWaifu2xError Waifu2x::Init(const eWaifu2xModelType mode, const int noi
 		mInputPlane = 0;
 		mMaxNetOffset = 0;
 
-		const boost::filesystem::path info_path = GetInfoPath(mode_dir_path);
+		const std::filesystem::path info_path = GetInfoPath(mode_dir_path);
 
 		stInfo info;
 		ret = cNet::GetInfo(info_path, info);
@@ -693,8 +693,8 @@ Waifu2x::eWaifu2xError Waifu2x::Init(const eWaifu2xModelType mode, const int noi
 				base_name = "noise" + std::to_string(noise_level) + "_model";
 			}
 
-			const boost::filesystem::path model_path = mode_dir_path / (base_name + ".prototxt");
+			const std::filesystem::path model_path = mode_dir_path / (base_name + ".prototxt");
-			const boost::filesystem::path param_path = mode_dir_path / (base_name + ".json");
+			const std::filesystem::path param_path = mode_dir_path / (base_name + ".json");
 
 			ret = mNoiseNet->ConstractNet(Mode, model_path, param_path, info, mProcess);
 			if (ret != Waifu2x::eWaifu2xError_OK)
@@ -708,8 +708,8 @@ Waifu2x::eWaifu2xError Waifu2x::Init(const eWaifu2xModelType mode, const int noi
 		{
 			const std::string base_name = "scale2.0x_model";
 
-			const boost::filesystem::path model_path = mode_dir_path / (base_name + ".prototxt");
+			const std::filesystem::path model_path = mode_dir_path / (base_name + ".prototxt");
-			const boost::filesystem::path param_path = mode_dir_path / (base_name + ".json");
+			const std::filesystem::path param_path = mode_dir_path / (base_name + ".json");
 
 			mScaleNet.reset(new cNet);
 
@@ -736,16 +736,16 @@ Waifu2x::eWaifu2xError Waifu2x::Init(const eWaifu2xModelType mode, const int noi
 	return Waifu2x::eWaifu2xError_OK;
 }
 
-boost::filesystem::path Waifu2x::GetModeDirPath(const boost::filesystem::path &model_dir)
+std::filesystem::path Waifu2x::GetModeDirPath(const std::filesystem::path &model_dir)
 {
-	boost::filesystem::path mode_dir_path(model_dir);
+	std::filesystem::path mode_dir_path(model_dir);
 	if (!mode_dir_path.is_absolute()) // model_dirが相対パスなら絶対パスに直す
 	{
 		// まずはカレントディレクトリ下にあるか探す
-		mode_dir_path = boost::filesystem::absolute(model_dir);
+		mode_dir_path = std::filesystem::absolute(model_dir);
-		if (!boost::filesystem::exists(mode_dir_path) && !ExeDir.empty()) // 無かったらargv[0]から実行ファイルのあるフォルダを推定し、そのフォルダ下にあるか探す
+		if (!std::filesystem::exists(mode_dir_path) && !ExeDir.empty()) // 無かったらargv[0]から実行ファイルのあるフォルダを推定し、そのフォルダ下にあるか探す
 		{
-			boost::filesystem::path a0(ExeDir);
+			std::filesystem::path a0(ExeDir);
 			if (a0.is_absolute())
 				mode_dir_path = a0.branch_path() / model_dir;
 		}
@@ -754,17 +754,17 @@ boost::filesystem::path Waifu2x::GetModeDirPath(const boost::filesystem::path &m
 	return mode_dir_path;
 }
 
-boost::filesystem::path Waifu2x::GetInfoPath(const boost::filesystem::path &mode_dir_path)
+std::filesystem::path Waifu2x::GetInfoPath(const std::filesystem::path &mode_dir_path)
 {
-	const boost::filesystem::path info_path = mode_dir_path / "info.json";
+	const std::filesystem::path info_path = mode_dir_path / "info.json";
 
 	return info_path;
 }
 
-Waifu2x::eWaifu2xError Waifu2x::waifu2x(const boost::filesystem::path &input_file, const boost::filesystem::path &output_file,
+Waifu2x::eWaifu2xError Waifu2x::waifu2x(const std::filesystem::path &input_file, const std::filesystem::path &output_file,
-	const boost::optional<double> scale_ratio, const boost::optional<int> scale_width, const boost::optional<int> scale_height, 
+	const std::optional<double> scale_ratio, const std::optional<int> scale_width, const std::optional<int> scale_height, 
 	const waifu2xCancelFunc cancel_func, const int crop_w, const int crop_h,
-	const boost::optional<int> output_quality, const int output_depth, const bool use_tta,
+	const std::optional<int> output_quality, const int output_depth, const bool use_tta,
 	const int batch_size)
 {
 	Waifu2x::eWaifu2xError ret;
@@ -867,7 +867,7 @@ Waifu2x::eWaifu2xError Waifu2x::waifu2x(const double factor, const void* source,
 	return Waifu2x::eWaifu2xError_OK;
 }
 
-Factor Waifu2x::CalcScaleRatio(const boost::optional<double> scale_ratio, const boost::optional<int> scale_width, const boost::optional<int> scale_height,
+Factor Waifu2x::CalcScaleRatio(const std::optional<double> scale_ratio, const std::optional<int> scale_width, const std::optional<int> scale_height,
 	const stImage &image)
 {
 	if (scale_ratio)
@@ -1155,24 +1155,24 @@ const std::string& Waifu2x::used_process() const
 	return mProcess;
 }
 
-std::string Waifu2x::GetModelName(const boost::filesystem::path & model_dir)
+std::string Waifu2x::GetModelName(const std::filesystem::path & model_dir)
 {
-	const boost::filesystem::path mode_dir_path(GetModeDirPath(model_dir));
+	const std::filesystem::path mode_dir_path(GetModeDirPath(model_dir));
-	if (!boost::filesystem::exists(mode_dir_path))
+	if (!std::filesystem::exists(mode_dir_path))
 		return std::string();
 
-	const boost::filesystem::path info_path = mode_dir_path / "info.json";
+	const std::filesystem::path info_path = mode_dir_path / "info.json";
 
 	return cNet::GetModelName(info_path);
 }
 
-bool Waifu2x::GetInfo(const boost::filesystem::path &model_dir, stInfo &info)
+bool Waifu2x::GetInfo(const std::filesystem::path &model_dir, stInfo &info)
 {
-	const boost::filesystem::path mode_dir_path(GetModeDirPath(model_dir));
+	const std::filesystem::path mode_dir_path(GetModeDirPath(model_dir));
-	if (!boost::filesystem::exists(mode_dir_path))
+	if (!std::filesystem::exists(mode_dir_path))
 		return false;
 
-	const boost::filesystem::path info_path = mode_dir_path / "info.json";
+	const std::filesystem::path info_path = mode_dir_path / "info.json";
 
 	return cNet::GetInfo(info_path, info) == Waifu2x::eWaifu2xError_OK;
 }

common/waifu2x.h

@@ -5,9 +5,9 @@
 #include <vector>
 #include <utility>
 #include <functional>
-#include <boost/shared_ptr.hpp>
+#include <memory>
-#include <boost/filesystem.hpp>
+#include <filesystem>
-#include <boost/optional.hpp>
+#include <optional>
 #include <opencv2/core.hpp>
 
 #define CUDNN_DLL_NAME "cudnn64_8.dll"
@@ -146,31 +146,31 @@ private:
 	int mMaxNetOffset; // ネットに入力するとどれくらい削れるか
 	bool mHasNoiseScaleOnly;
 
-	float *mOutputBlock;
+	float* mOutputBlock;
 	size_t mOutputBlockSize;
 
 private:
-	static boost::filesystem::path GetModeDirPath(const boost::filesystem::path &model_dir);
+	static std::filesystem::path GetModeDirPath(const std::filesystem::path& model_dir);
-	static boost::filesystem::path GetInfoPath(const boost::filesystem::path &model_dir);
+	static std::filesystem::path GetInfoPath(const std::filesystem::path& model_dir);
 
-	static Factor CalcScaleRatio(const boost::optional<double> scale_ratio, const boost::optional<int> scale_width, const boost::optional<int> scale_height,
+	static Factor CalcScaleRatio(const std::optional<double> scale_ratio, const std::optional<int> scale_width, const std::optional<int> scale_height,
-		const stImage &image);
+		const stImage& image);
 
-	static int GetcuDNNAlgorithm(const char *layer_name, int num_input, int num_output, int batch_size,
+	static int GetcuDNNAlgorithm(const char* layer_name, int num_input, int num_output, int batch_size,
 		int width, int height, int kernel_w, int kernel_h, int pad_w, int pad_h, int stride_w, int stride_h);
 
-	static void SetcuDNNAlgorithm(int algo, const char *layer_name, int num_input, int num_output, int batch_size,
+	static void SetcuDNNAlgorithm(int algo, const char* layer_name, int num_input, int num_output, int batch_size,
 		int width, int height, int kernel_w, int kernel_h, int pad_w, int pad_h, int stride_w, int stride_h);
 
 	Waifu2x::eWaifu2xError ReconstructImage(const Factor factor, const int crop_w, const int crop_h, const bool use_tta, const int batch_size,
-		const bool isReconstructNoise, const bool isReconstructScale, const Waifu2x::waifu2xCancelFunc cancel_func, stImage &image);
+		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);
+		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);
+		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);
+		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);
+	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);
 
 public:
 	Waifu2x();
@@ -186,12 +186,12 @@ public:
 	// mode: noise or scale or noise_scale or auto_scale
 	// process: cpu or gpu or cudnn
 	eWaifu2xError Init(const eWaifu2xModelType mode, const int noise_level,
-		const boost::filesystem::path &model_dir, const std::string &process, const int gpu_no = 0);
+		const std::filesystem::path& model_dir, const std::string& process, const int gpu_no = 0);
 
-	eWaifu2xError waifu2x(const boost::filesystem::path &input_file, const boost::filesystem::path &output_file,
+	eWaifu2xError waifu2x(const std::filesystem::path& input_file, const std::filesystem::path& output_file,
-		const boost::optional<double> scale_ratio, const boost::optional<int> scale_width, const boost::optional<int> scale_height,
+		const std::optional<double> scale_ratio, const std::optional<int> scale_width, const std::optional<int> scale_height,
 		const waifu2xCancelFunc cancel_func = nullptr, const int crop_w = 128, const int crop_h = 128,
-		const boost::optional<int> output_quality = boost::optional<int>(), const int output_depth = 8, const bool use_tta = false,
+		const std::optional<int> output_quality = std::optional<int>(), const int output_depth = 8, const bool use_tta = false,
 		const int batch_size = 1);
 
 	// factor: 倍率
@@ -207,6 +207,6 @@ public:
 
 	const std::string& used_process() const;
 
-	static std::string GetModelName(const boost::filesystem::path &model_dir);
+	static std::string GetModelName(const std::filesystem::path& model_dir);
-	static bool GetInfo(const boost::filesystem::path &model_dir, stInfo &info);
+	static bool GetInfo(const std::filesystem::path& model_dir, stInfo& info);
 };

opencv

@@ -1 +1 @@
-Subproject commit b38c50b3d0c31e82294315ec44b54b7ef559ef12
+Subproject commit 6d889ee74c94124f6492eb8f0d50946d9c31d8e9

opencv_build.bat

@@ -1,10 +1,21 @@
 @echo off
 
+call "C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Auxiliary\Build\vcvarsall.bat" amd64
+
+cd /d "%~dp0"
+
+rem wget -O opencv_contrib.zip https://github.com/opencv/opencv_contrib/archive/4.12.0.zip
+rem opencv_contrib.zip を解凍します。
+rem cmake -D OPENCV_EXTRA_MODULES_PATH=%~dp0\opencv_contrib-4.12.0\modules
+
 cd opencv
 mkdir build
 cd build
 
-cmake .. -G "Visual Studio 15 Win64" ^
+set CFLAGS=/Zc:preprocessor
+set CXXFLAGS=/Zc:preprocessor
+
+cmake .. -G Ninja ^
 -DCMAKE_INSTALL_PREFIX=..\..\lib ^
 -DBUILD_WITH_STATIC_CRT=OFF ^
 -DBUILD_IPP_IW=OFF ^
@@ -12,8 +23,8 @@ cmake .. -G "Visual Studio 15 Win64" ^
 -DBUILD_JAVA=OFF ^
 -DBUILD_SHARED_LIBS=OFF ^
 -DBUILD_TESTS=OFF ^
+-DBUILD_PERF_TESTS=OFF ^
 -DBUILD_opencv_calib3d=OFF ^
--DBUILD_opencv_dnn=OFF ^
 -DBUILD_opencv_features2d=OFF ^
 -DBUILD_opencv_flann=OFF ^
 -DBUILD_opencv_highgui=OFF ^
@@ -25,9 +36,60 @@ cmake .. -G "Visual Studio 15 Win64" ^
 -DBUILD_opencv_videostab=OFF ^
 -DBUILD_opencv_java_bindings_generator=OFF ^
 -DBUILD_opencv_python_bindings_generator=OFF ^
+-DBUILD_opencv_apps=OFF ^
+-DBUILD_opencv_aruco=OFF ^
+-DBUILD_opencv_bgsegm=OFF ^
+-DBUILD_opencv_bioinspired=OFF ^
+-DBUILD_opencv_ccalib=OFF ^
+-DBUILD_opencv_cudaarithm=OFF ^
+-DBUILD_opencv_cudabgsegm=OFF ^
+-DBUILD_opencv_cudacodec=OFF ^
+-DBUILD_opencv_cudafeatures2d=OFF ^
+-DBUILD_opencv_cudafilters=OFF ^
+-DBUILD_opencv_cudaimgproc=OFF ^
+-DBUILD_opencv_cudalegacy=OFF ^
+-DBUILD_opencv_cudaobjdetect=OFF ^
+-DBUILD_opencv_cudaoptflow=OFF ^
+-DBUILD_opencv_cudastereo=OFF ^
+-DBUILD_opencv_cudawarping=OFF ^
+-DBUILD_opencv_cudev=OFF ^
+-DBUILD_opencv_datasets=OFF ^
+-DBUILD_opencv_face=OFF ^
+-DBUILD_opencv_freetype=OFF ^
+-DBUILD_opencv_fuzzy=OFF ^
+-DBUILD_opencv_hfs=OFF ^
+-DBUILD_opencv_img_hash=OFF ^
+-DBUILD_opencv_line_descriptor=OFF ^
+-DBUILD_opencv_mcc=OFF ^
+-DBUILD_opencv_objc_bindings_generator=OFF ^
+-DBUILD_opencv_optflow=OFF ^
+-DBUILD_opencv_phase_unwrapping=OFF ^
+-DBUILD_opencv_plot=OFF ^
+-DBUILD_opencv_reg=OFF ^
+-DBUILD_opencv_rgbd=OFF ^
+-DBUILD_opencv_saliency=OFF ^
+-DBUILD_opencv_shape=OFF ^
+-DBUILD_opencv_stereo=OFF ^
+-DBUILD_opencv_structured_light=OFF ^
+-DBUILD_opencv_surface_matching=OFF ^
+-DBUILD_opencv_text=OFF ^
+-DBUILD_opencv_tracking=OFF ^
+-DBUILD_opencv_xfeatures2d=OFF ^
+-DBUILD_opencv_ximgproc=OFF ^
+-DBUILD_opencv_xobjdetect=OFF ^
+-DBUILD_opencv_xphoto=OFF ^
+-DBUILD_opencv_python3=OFF ^
+-DBUILD_opencv_python_tests=OFF ^
+-DBUILD_opencv_quality=OFF ^
+-DBUILD_opencv_rapid=OFF ^
+-DBUILD_opencv_signal=OFF ^
+-DBUILD_opencv_stitching=OFF ^
+-DBUILD_opencv_wechat_qrcode=OFF ^
+-DBUILD_opencv_js_bindings_generator=OFF ^
 -DWITH_1394=OFF ^
--DWITH_CUDA=OFF ^
+-DWITH_CUDA=ON ^
--DWITH_CUFFT=OFF ^
+-DWITH_CUDNN=ON ^
+-DWITH_CUFFT=ON ^
 -DWITH_DIRECTX=OFF ^
 -DWITH_DSHOW=OFF ^
 -DWITH_EIGEN=OFF ^
@@ -37,10 +99,27 @@ cmake .. -G "Visual Studio 15 Win64" ^
 -DWITH_OPENCAMDBALSL=OFF ^
 -DWITH_OPENCLAMDFFT=OFF ^
 -DWITH_OPENCL_SVM=OFF ^
--DWITH_PROTOBUF=OFF ^
+-DWITH_ADE=OFF ^
+-DWITH_ARITH_DEC=OFF ^
+-DWITH_ARITH_ENC=OFF ^
+-DWITH_IPP=OFF ^
+-DWITH_ITT=OFF ^
 -DWITH_VFW=OFF ^
 -DWITH_VTK=OFF ^
--DWITH_WIN32UI=OFF
+-DWITH_TESSERACT=OFF ^
+-DWITH_WIN32UI=OFF ^
+-DBUILD_opencv_dnn=ON ^
+-DBUILD_opencv_cudev=ON ^
+-DWITH_PROTOBUF=ON ^
+-DOPENCV_DNN_CUDA=ON ^
+-DCUDA_ARCH_BIN=8.9 ^
+-DCUDA_ARCH_PTX=12.0 ^
+-DCUDA_USE_STATIC_CUDA_RUNTIME=OFF ^
+-DCMAKE_C_FLAGS="/DWIN32 /D_WINDOWS /W3 /Zc:preprocessor" ^
+-DCMAKE_CXX_FLAGS="/DWIN32 /D_WINDOWS /W3 /GR /EHsc /Zc:preprocessor" ^
+-DOPENCV_EXTRA_MODULES_PATH=%~dp0\opencv_contrib-4.12.0\modules ^
+-DCMAKE_BUILD_TYPE=Debug
 
-rem cmake --build . --config Debug --target install
+
-cmake --build . --config Release --target install
+cmake --build . --config Debug --target install
+rem cmake --build . --config Release --target install

waifu2x-caffe-dll/Source.cpp

@@ -18,7 +18,7 @@ void* Waifu2xInit(const char *mode, const int noise_level, const char *model_dir
 	else if (strcmp("auto_scale", mode) == 0)
 		mt = Waifu2x::eWaifu2xModelTypeAutoScale;
 
-	// if (obj->Init(1, argv, mode, noise_level, 2.0, boost::optional<int>(), boost::optional<int>(), model_dir, process, boost::optional<int>(), output_depth, use_tta, crop_size, batch_size) != Waifu2x::eWaifu2xError_OK)
+	// if (obj->Init(1, argv, mode, noise_level, 2.0, std::optional<int>(), std::optional<int>(), model_dir, process, std::optional<int>(), output_depth, use_tta, crop_size, batch_size) != Waifu2x::eWaifu2xError_OK)
 	if (obj->Init(mt, noise_level, model_dir, process) != Waifu2x::eWaifu2xError_OK)
 	{
 		delete obj;
@@ -43,7 +43,7 @@ void* Waifu2xInitNew(const char *mode, const int noise_level, const char *model_
 	else if (strcmp("auto_scale", mode) == 0)
 		mt = Waifu2x::eWaifu2xModelTypeAutoScale;
 
-	// if (obj->Init(1, argv, mode, noise_level, 2.0, boost::optional<int>(), boost::optional<int>(), model_dir, process, boost::optional<int>(), output_depth, use_tta, crop_size, batch_size) != Waifu2x::eWaifu2xError_OK)
+	// if (obj->Init(1, argv, mode, noise_level, 2.0, std::optional<int>(), std::optional<int>(), model_dir, process, std::optional<int>(), output_depth, use_tta, crop_size, batch_size) != Waifu2x::eWaifu2xError_OK)
 	if (obj->Init(mt, noise_level, model_dir, process) != Waifu2x::eWaifu2xError_OK)
 	{
 		delete obj;

waifu2x-caffe-dll/waifu2x-caffe-dll.vcxproj

@@ -14,19 +14,19 @@
     <ProjectGuid>{DFF94FEB-78AB-41B1-9B92-4D8B7D799E04}</ProjectGuid>
     <Keyword>Win32Proj</Keyword>
     <RootNamespace>waifu2x-caffe-dll</RootNamespace>
-    <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v143</PlatformToolset>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v143</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
@@ -61,6 +61,7 @@
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>BOOST_ALL_NO_LIB;WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <LanguageStandard>stdcpp17</LanguageStandard>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
@@ -79,6 +80,7 @@
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <PreprocessorDefinitions>BOOST_ALL_NO_LIB;WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <LanguageStandard>stdcpp17</LanguageStandard>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>

waifu2x-caffe-gui/MainDialog.cpp

@@ -58,22 +58,22 @@ namespace
 	}
 
 	// http://stackoverflow.com/questions/10167382/boostfilesystem-get-relative-path
-	boost::filesystem::path relativePath(const boost::filesystem::path &path, const boost::filesystem::path &relative_to)
+	std::filesystem::path relativePath(const std::filesystem::path &path, const std::filesystem::path &relative_to)
 	{
 		// create absolute paths
-		boost::filesystem::path p = boost::filesystem::absolute(path);
+		std::filesystem::path p = std::filesystem::absolute(path);
-		boost::filesystem::path r = boost::filesystem::absolute(relative_to);
+		std::filesystem::path r = std::filesystem::absolute(relative_to);
 
 		// if root paths are different, return absolute path
 		if (p.root_path() != r.root_path())
 			return p;
 
 		// initialize relative path
-		boost::filesystem::path result;
+		std::filesystem::path result;
 
 		// find out where the two paths diverge
-		boost::filesystem::path::const_iterator itr_path = p.begin();
+		std::filesystem::path::const_iterator itr_path = p.begin();
-		boost::filesystem::path::const_iterator itr_relative_to = r.begin();
+		std::filesystem::path::const_iterator itr_relative_to = r.begin();
 		while (*itr_path == *itr_relative_to && itr_path != p.end() && itr_relative_to != r.end())
 		{
 			++itr_path;
@@ -497,7 +497,7 @@ bool DialogEvent::SyncMember(const bool NotSyncCropSize, const bool silent)
 	return ret;
 }
 
-void DialogEvent::SetCropSizeList(const boost::filesystem::path & input_path)
+void DialogEvent::SetCropSizeList(const std::filesystem::path & input_path)
 {
 	if (isSetInitCrop)
 		return;
@@ -505,7 +505,7 @@ void DialogEvent::SetCropSizeList(const boost::filesystem::path & input_path)
 	HWND hcrop = GetDlgItem(dh, IDC_COMBO_CROP_SIZE);
 
 	int gcd = 1;
-	if (boost::filesystem::exists(input_path) && !boost::filesystem::is_directory(input_path))
+	if (std::filesystem::exists(input_path) && !std::filesystem::is_directory(input_path))
 	{
 		cv::Mat mat;
 		const auto ret = stImage::LoadMat(mat, input_path.string());
@@ -620,17 +620,17 @@ void DialogEvent::ProcessWaifu2x()
 
 	const auto inputFunc = [this, &file_paths](const tstring &input)
 	{
-		const boost::filesystem::path input_path(boost::filesystem::absolute(input));
+		const std::filesystem::path input_path(std::filesystem::absolute(input));
 
-		if (boost::filesystem::is_directory(input_path)) // input_pathがフォルダならそのディレクトリ以下の画像ファイルを一括変換
+		if (std::filesystem::is_directory(input_path)) // input_pathがフォルダならそのディレクトリ以下の画像ファイルを一括変換
 		{
-			boost::filesystem::path output_path(output_str);
+			std::filesystem::path output_path(output_str);
 
-			output_path = boost::filesystem::absolute(output_path);
+			output_path = std::filesystem::absolute(output_path);
 
-			if (!boost::filesystem::exists(output_path))
+			if (!std::filesystem::exists(output_path))
 			{
-				if (!boost::filesystem::create_directory(output_path))
+				if (!std::filesystem::create_directory(output_path))
 				{
 					SendMessage(dh, WM_FAILD_CREATE_DIR, (WPARAM)&output_path, 0);
 					PostMessage(dh, WM_END_THREAD, 0, 0);
@@ -640,12 +640,12 @@ void DialogEvent::ProcessWaifu2x()
 			}
 
 			// 変換する画像の入力、出力パスを取得
-			const auto func = [this, &input_path, &output_path, &file_paths](const boost::filesystem::path &path)
+			const auto func = [this, &input_path, &output_path, &file_paths](const std::filesystem::path &path)
 			{
-				BOOST_FOREACH(const boost::filesystem::path& p, std::make_pair(boost::filesystem::recursive_directory_iterator(path),
+				BOOST_FOREACH(const std::filesystem::path& p, std::make_pair(std::filesystem::recursive_directory_iterator(path),
-					boost::filesystem::recursive_directory_iterator()))
+					std::filesystem::recursive_directory_iterator()))
 				{
-					if (!boost::filesystem::is_directory(p))
+					if (!std::filesystem::is_directory(p))
 					{
 						tstring ext(getTString(p.extension()));
 #ifdef UNICODE
@@ -674,12 +674,12 @@ void DialogEvent::ProcessWaifu2x()
 
 			for (const auto &p : file_paths)
 			{
-				const boost::filesystem::path out_path(p.second);
+				const std::filesystem::path out_path(p.second);
-				const boost::filesystem::path out_dir(out_path.parent_path());
+				const std::filesystem::path out_dir(out_path.parent_path());
 
-				if (!boost::filesystem::exists(out_dir))
+				if (!std::filesystem::exists(out_dir))
 				{
-					if (!boost::filesystem::create_directories(out_dir))
+					if (!std::filesystem::create_directories(out_dir))
 					{
 						SendMessage(dh, WM_FAILD_CREATE_DIR, (WPARAM)&out_dir, 0);
 						PostMessage(dh, WM_END_THREAD, 0, 0);
@@ -691,12 +691,12 @@ void DialogEvent::ProcessWaifu2x()
 		}
 		else
 		{
-			const boost::filesystem::path output_path(output_str);
+			const std::filesystem::path output_path(output_str);
 			const auto outDir = output_path.branch_path();
 
-			if (!outDir.empty() && !boost::filesystem::exists(outDir))
+			if (!outDir.empty() && !std::filesystem::exists(outDir))
 			{
-				if (!boost::filesystem::create_directories(outDir))
+				if (!std::filesystem::create_directories(outDir))
 				{
 					SendMessage(dh, WM_FAILD_CREATE_DIR, (WPARAM)&outDir, 0);
 					PostMessage(dh, WM_END_THREAD, 0, 0);
@@ -711,8 +711,8 @@ void DialogEvent::ProcessWaifu2x()
 
 	const auto inputFuncMulti = [this, &file_paths](const tstring &input)
 	{
-		const boost::filesystem::path input_path(boost::filesystem::absolute(input));
+		const std::filesystem::path input_path(std::filesystem::absolute(input));
-		const boost::filesystem::path output_path(boost::filesystem::absolute(output_str));
+		const std::filesystem::path output_path(std::filesystem::absolute(output_str));
 
 		const auto outilenameFunc = [&output_path](const tstring &path) -> std::wstring
 		{
@@ -720,11 +720,11 @@ void DialogEvent::ProcessWaifu2x()
 			return out.wstring();
 		};
 
-		if (boost::filesystem::is_directory(input_path)) // input_pathがフォルダならそのディレクトリ以下の画像ファイルを一括変換
+		if (std::filesystem::is_directory(input_path)) // input_pathがフォルダならそのディレクトリ以下の画像ファイルを一括変換
 		{
-			if (!boost::filesystem::exists(output_path))
+			if (!std::filesystem::exists(output_path))
 			{
-				if (!boost::filesystem::create_directory(output_path))
+				if (!std::filesystem::create_directory(output_path))
 				{
 					SendMessage(dh, WM_FAILD_CREATE_DIR, (WPARAM)&output_path, 0);
 					PostMessage(dh, WM_END_THREAD, 0, 0);
@@ -736,12 +736,12 @@ void DialogEvent::ProcessWaifu2x()
 			const auto inputDirName = input_path.filename();
 
 			// 変換する画像の入力、出力パスを取得
-			const auto func = [this, &input_path, &output_path, &file_paths, &inputDirName](const boost::filesystem::path &path)
+			const auto func = [this, &input_path, &output_path, &file_paths, &inputDirName](const std::filesystem::path &path)
 			{
-				BOOST_FOREACH(const boost::filesystem::path& p, std::make_pair(boost::filesystem::recursive_directory_iterator(path),
+				BOOST_FOREACH(const std::filesystem::path& p, std::make_pair(std::filesystem::recursive_directory_iterator(path),
-					boost::filesystem::recursive_directory_iterator()))
+					std::filesystem::recursive_directory_iterator()))
 				{
-					if (!boost::filesystem::is_directory(p))
+					if (!std::filesystem::is_directory(p))
 					{
 						tstring ext(getTString(p.extension()));
 #ifdef UNICODE
@@ -770,12 +770,12 @@ void DialogEvent::ProcessWaifu2x()
 
 			for (const auto &p : file_paths)
 			{
-				const boost::filesystem::path out_path(p.second);
+				const std::filesystem::path out_path(p.second);
-				const boost::filesystem::path out_dir(out_path.parent_path());
+				const std::filesystem::path out_dir(out_path.parent_path());
 
-				if (!boost::filesystem::exists(out_dir))
+				if (!std::filesystem::exists(out_dir))
 				{
-					if (!boost::filesystem::create_directories(out_dir))
+					if (!std::filesystem::create_directories(out_dir))
 					{
 						SendMessage(dh, WM_FAILD_CREATE_DIR, (WPARAM)&out_dir, 0);
 						PostMessage(dh, WM_END_THREAD, 0, 0);
@@ -789,9 +789,9 @@ void DialogEvent::ProcessWaifu2x()
 		{
 			const auto &outDir = output_path;
 
-			if (!boost::filesystem::exists(outDir))
+			if (!std::filesystem::exists(outDir))
 			{
-				if (!boost::filesystem::create_directories(outDir))
+				if (!std::filesystem::create_directories(outDir))
 				{
 					SendMessage(dh, WM_FAILD_CREATE_DIR, (WPARAM)&outDir, 0);
 					PostMessage(dh, WM_END_THREAD, 0, 0);
@@ -849,8 +849,8 @@ void DialogEvent::ProcessWaifu2x()
 
 		ProgessFunc(maxFile, 0);
 
-		boost::optional<double> ScaleRatio;
+		std::optional<double> ScaleRatio;
-		boost::optional<int> ScaleWidth, ScaleHeight;
+		std::optional<int> ScaleWidth, ScaleHeight;
 		switch (scaleType)
 		{
 		case eScaleTypeRatio:
@@ -875,7 +875,7 @@ void DialogEvent::ProcessWaifu2x()
 		const auto fileNum = file_paths.size();
 		for (const auto &p : file_paths)
 		{
-			if (isOutputNoOverwrite && boost::filesystem::exists(p.second)) // 上書き禁止ならメッセージ表示して無視
+			if (isOutputNoOverwrite && std::filesystem::exists(p.second)) // 上書き禁止ならメッセージ表示して無視
 			{
 				SendMessage(dh, WM_ON_WAIFU2X_NO_OVERWRITE, (WPARAM)p.first.c_str(), (LPARAM)p.second.c_str());
 
@@ -943,10 +943,10 @@ void DialogEvent::ReplaceAddString() //
 {
 	SyncMember(true, true);
 
-	const boost::filesystem::path output_path(output_str);
+	const std::filesystem::path output_path(output_str);
 	tstring stem;
 
-	if (input_str_multi.size() == 0 && !boost::filesystem::is_directory(input_str))
+	if (input_str_multi.size() == 0 && !std::filesystem::is_directory(input_str))
 		stem = getTString(output_path.stem());
 	else
 		stem = getTString(output_path.filename());
@@ -963,8 +963,8 @@ void DialogEvent::ReplaceAddString() //
 
 			autoSetAddName = addstr;
 
-			boost::filesystem::path new_out_path;
+			std::filesystem::path new_out_path;
-			if (input_str_multi.size() == 0 && !boost::filesystem::is_directory(input_str))
+			if (input_str_multi.size() == 0 && !std::filesystem::is_directory(input_str))
 				new_out_path = output_path.branch_path() / (new_name + outputExt);
 			else
 				new_out_path = output_path.branch_path() / (new_name);
@@ -1040,7 +1040,7 @@ void DialogEvent::SaveIni(const bool isSyncMember)
 	if (isNotSaveParam)
 		return;
 
-	const boost::filesystem::path SettingFilePath(exeDir / SettingFileName);
+	const std::filesystem::path SettingFilePath(exeDir / SettingFileName);
 
 	tstring tScaleRatio;
 	tstring tScaleWidth;
@@ -1338,8 +1338,8 @@ UINT_PTR DialogEvent::OFNHookProcOut(HWND hdlg, UINT uiMsg, WPARAM wParam, LPARA
 			{
 				szPath[_countof(szPath) - 1] = TEXT('\0');
 
-				boost::filesystem::path p(szPath);
+				std::filesystem::path p(szPath);
-				if (boost::filesystem::exists(p) && (boost::filesystem::is_empty(p) || boost::filesystem::is_directory(p)))
+				if (std::filesystem::exists(p) && (std::filesystem::is_empty(p) || std::filesystem::is_directory(p)))
 				{
 					const auto filename = getTString(p.filename());
 
@@ -1505,7 +1505,7 @@ void DialogEvent::OnDialogEnd(HWND hWnd, WPARAM wParam, LPARAM lParam, LPVOID lp
 
 void DialogEvent::OnFaildCreateDir(HWND hWnd, WPARAM wParam, LPARAM lParam, LPVOID lpData)
 {
-	const boost::filesystem::path *p = (const boost::filesystem::path *)wParam;
+	const std::filesystem::path *p = (const std::filesystem::path *)wParam;
 
 	TCHAR msg[1024 * 2];
 	_stprintf(msg, langStringList.GetString(L"MessageCreateOutDirError").c_str(), getTString(*p).c_str());
@@ -1730,15 +1730,15 @@ void DialogEvent::Create(HWND hWnd, WPARAM wParam, LPARAM lParam, LPVOID lpData)
 		GetModuleFileName(NULL, texepath, _countof(texepath));
 		texepath[_countof(texepath) - 1] = TEXT('\0');
 
-		const boost::filesystem::path exePath(texepath);
+		const std::filesystem::path exePath(texepath);
 		exeDir = exePath.branch_path();
 	}
 
-	const boost::filesystem::path SettingFilePath(exeDir / SettingFileName);
+	const std::filesystem::path SettingFilePath(exeDir / SettingFileName);
 
 	{
-		const boost::filesystem::path LangDirPath(exeDir / LangDir);
+		const std::filesystem::path LangDirPath(exeDir / LangDir);
-		const boost::filesystem::path LangListPath(exeDir / LangListFileName);
+		const std::filesystem::path LangListPath(exeDir / LangListFileName);
 		langStringList.SetLangBaseDir(getTString(LangDirPath));
 		langStringList.ReadLangList(getTString(LangListPath));
 	}
@@ -1811,7 +1811,7 @@ void DialogEvent::Create(HWND hWnd, WPARAM wParam, LPARAM lParam, LPVOID lpData)
 		SendMessage(houtext, CB_SETCURSEL, 0, 0);
 	}
 
-	const boost::filesystem::path CropSizeListPath(exeDir / CropSizeListName);
+	const std::filesystem::path CropSizeListPath(exeDir / CropSizeListName);
 	std::ifstream ifs(CropSizeListPath.wstring());
 	if (ifs)
 	{
@@ -2132,7 +2132,7 @@ void DialogEvent::Create(HWND hWnd, WPARAM wParam, LPARAM lParam, LPVOID lpData)
 
 	SetWindowText(GetDlgItem(hWnd, IDC_EDIT_INPUT_EXT_LIST), inputFileExt.c_str());
 
-	if (tOutputDirFix.length() > 0 && boost::filesystem::exists(tOutputDirFix))
+	if (tOutputDirFix.length() > 0 && std::filesystem::exists(tOutputDirFix))
 	{
 		output_dir = tOutputDirFix;
 		SetWindowText(GetDlgItem(hWnd, IDC_EDIT_OUTPUT), output_dir.c_str());
@@ -2758,9 +2758,9 @@ LRESULT DialogEvent::OnSetInputFilePath(const TCHAR * tPath)
 {
 	HWND hWnd = GetDlgItem(dh, IDC_EDIT_INPUT);
 
-	boost::filesystem::path path(tPath);
+	std::filesystem::path path(tPath);
 
-	if (!boost::filesystem::exists(path))
+	if (!std::filesystem::exists(path))
 	{
 		MessageBox(dh, langStringList.GetString(L"MessageInputCheckError").c_str(), langStringList.GetString(L"MessageTitleError").c_str(), MB_OK | MB_ICONERROR);
 		return 0L;
@@ -2770,9 +2770,9 @@ LRESULT DialogEvent::OnSetInputFilePath(const TCHAR * tPath)
 
 	SyncMember(true, true);
 
-	boost::filesystem::path outpath(output_dir);
+	std::filesystem::path outpath(output_dir);
 
-	if (boost::filesystem::is_directory(path))
+	if (std::filesystem::is_directory(path))
 	{
 		HWND ho = GetDlgItem(dh, IDC_EDIT_OUTPUT);
 
@@ -2832,7 +2832,7 @@ LRESULT DialogEvent::OnSetInputFilePath()
 		const tstring addstr(AddName());
 		autoSetAddName = AddName();
 
-		boost::filesystem::path outpath(output_dir);
+		std::filesystem::path outpath(output_dir);
 
 		if (output_dir.length() == 0) // 出力パス未設定なら入力ファイルと同じフォルダ
 		{
@@ -2840,10 +2840,10 @@ LRESULT DialogEvent::OnSetInputFilePath()
 			outpath = outpath.branch_path();
 		}
 
-		boost::filesystem::path baseDir(input_str_multi[0]);
+		std::filesystem::path baseDir(input_str_multi[0]);
 
 		tstring filename;
-		if (boost::filesystem::is_directory(baseDir))
+		if (std::filesystem::is_directory(baseDir))
 			filename = baseDir.filename().wstring();
 		else
 			filename = baseDir.stem().wstring();
@@ -2865,15 +2865,15 @@ LRESULT DialogEvent::OnSetOutputFilePath(const TCHAR * tPath)
 
 	if (input_str.length() > 0 || input_str_multi.size() > 0)
 	{
-		boost::filesystem::path path(input_str);
+		std::filesystem::path path(input_str);
-		boost::filesystem::path outpath(tPath);
+		std::filesystem::path outpath(tPath);
 
 		if (input_str_multi.size() > 0)
 		{
 			path = input_str_multi[0];
 		}
 
-		if (boost::filesystem::is_directory(path))
+		if (std::filesystem::is_directory(path))
 		{
 			HWND ho = GetDlgItem(dh, IDC_EDIT_OUTPUT);
 
@@ -2952,7 +2952,7 @@ LRESULT DialogEvent::DropInput(HWND hWnd, WPARAM wParam, LPARAM lParam, WNDPROC
 		}
 
 		if (tAutoMode == TEXT("one") ||
-			(tAutoMode == TEXT("multi") && (input_str_multi.size() > 0 || boost::filesystem::is_directory(szTmp))))
+			(tAutoMode == TEXT("multi") && (input_str_multi.size() > 0 || std::filesystem::is_directory(szTmp))))
 		{
 			::PostMessage(GetDlgItem(dh, IDC_BUTTON_EXEC), BM_CLICK, 0, 0);
 		}
@@ -3037,7 +3037,7 @@ void DialogEvent::InputRef(HWND hWnd, WPARAM wParam, LPARAM lParam, LPVOID lpDat
 	*tfp = TEXT('\0');
 	tfp++;
 
-	if (tInputDirFix.length() > 0 && boost::filesystem::exists(tInputDirFix))
+	if (tInputDirFix.length() > 0 && std::filesystem::exists(tInputDirFix))
 		ofn.lpstrInitialDir = tInputDirFix.c_str();
 	else
 		ofn.lpstrInitialDir = szPath;
@@ -3104,7 +3104,7 @@ void DialogEvent::InputRef(HWND hWnd, WPARAM wParam, LPARAM lParam, LPVOID lpDat
 			}
 
 			if (tAutoMode == TEXT("one") ||
-				(tAutoMode == TEXT("multi") && (input_str_multi.size() > 0 || boost::filesystem::is_directory(szFile.data()))))
+				(tAutoMode == TEXT("multi") && (input_str_multi.size() > 0 || std::filesystem::is_directory(szFile.data()))))
 			{
 				::PostMessage(GetDlgItem(dh, IDC_BUTTON_EXEC), BM_CLICK, 0, 0);
 			}
@@ -3139,7 +3139,7 @@ void DialogEvent::OutputRef(HWND hWnd, WPARAM wParam, LPARAM lParam, LPVOID lpDa
 	memcpy(tfp, allFilesExt.c_str(), allFilesExt.length() * sizeof(TCHAR));
 	tfp += allFilesExt.length();
 
-	if (tOutputDirFix.length() > 0 && boost::filesystem::exists(tOutputDirFix))
+	if (tOutputDirFix.length() > 0 && std::filesystem::exists(tOutputDirFix))
 		ofn.lpstrInitialDir = tOutputDirFix.c_str();
 	else
 		ofn.lpstrInitialDir = szPath;
@@ -3417,7 +3417,7 @@ void DialogEvent::AppSetting(HWND hWnd, WPARAM wParam, LPARAM lParam, LPVOID lpD
 		tOutputDirFix = cAppSettingDialogEvent.tOutputDirFix;
 		gpu_no = cAppSettingDialogEvent.gpu_no;
 
-		if (tOutputDirFix.length() > 0 && boost::filesystem::exists(tOutputDirFix))
+		if (tOutputDirFix.length() > 0 && std::filesystem::exists(tOutputDirFix))
 		{
 			output_dir = tOutputDirFix;
 		}

waifu2x-caffe-gui/MainDialog.h

@@ -7,8 +7,8 @@
 #include <string>
 #include <thread>
 #include <atomic>
-#include <boost/filesystem.hpp>
+#include <filesystem>
-#include <boost/optional.hpp>
+#include <optional>
 #include "../common/waifu2x.h"
 #include "resource.h"
 #include "tstring.h"
@@ -77,7 +77,7 @@ private:
 
 	static LangStringList langStringList;
 
-	boost::filesystem::path exeDir;
+	std::filesystem::path exeDir;
 	std::vector<int> CropSizeList;
 
 	tstring input_str;
@@ -96,7 +96,7 @@ private:
 
 	bool use_tta;
 
-	boost::optional<int> output_quality;
+	std::optional<int> output_quality;
 	int output_depth;
 
 	int crop_size;
@@ -158,11 +158,11 @@ private:
 
 	bool SyncMember(const bool NotSyncCropSize, const bool silent = false);
 
-	void SetCropSizeList(const boost::filesystem::path &input_path);
+	void SetCropSizeList(const std::filesystem::path& input_path);
 
-	static boost::filesystem::path GetFileName(const boost::filesystem::path &input_path)
+	static std::filesystem::path GetFileName(const std::filesystem::path& input_path)
 	{
-		if (boost::filesystem::is_directory(input_path))
+		if (std::filesystem::is_directory(input_path))
 			return input_path.stem();
 		else
 			return input_path.filename();
@@ -172,7 +172,7 @@ private:
 
 	void ReplaceAddString();
 
-	void AddLogMessage(const TCHAR *msg);
+	void AddLogMessage(const TCHAR* msg);
 
 	void Waifu2xTime();
 
@@ -231,11 +231,11 @@ public:
 
 	void OnModelChange(HWND hWnd, WPARAM wParam, LPARAM lParam, LPVOID lpData);
 
-	LRESULT OnSetInputFilePath(const TCHAR *tPath);
+	LRESULT OnSetInputFilePath(const TCHAR* tPath);
 
 	LRESULT OnSetInputFilePath();
 
-	LRESULT OnSetOutputFilePath(const TCHAR *tPath);
+	LRESULT OnSetOutputFilePath(const TCHAR* tPath);
 
 	// ここで渡されるhWndはIDC_EDITのHWND(コントロールのイベントだから)
 	LRESULT DropInput(HWND hWnd, WPARAM wParam, LPARAM lParam, WNDPROC OrgSubWnd, LPVOID lpData);

waifu2x-caffe-gui/tstring.h

@@ -6,13 +6,13 @@
 
 #ifdef UNICODE
 typedef std::wstring tstring;
-inline tstring getTString(const boost::filesystem::path& p)
+inline tstring getTString(const std::filesystem::path& p)
 {
 	return p.wstring();
 }
 #else
 typedef std::string tstring;
-inline tstring getTString(const boost::filesystem::path& p)
+inline tstring getTString(const std::filesystem::path& p)
 {
 	return p.string();
 }

waifu2x-caffe-gui/waifu2x-caffe-gui.vcxproj

@@ -14,19 +14,19 @@
     <ProjectGuid>{63FB3EFC-63B0-401C-BB54-F3A984DC233F}</ProjectGuid>
     <Keyword>Win32Proj</Keyword>
     <RootNamespace>waifu2xcaffegui</RootNamespace>
-    <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v143</PlatformToolset>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v143</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
@@ -61,6 +61,7 @@
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>BOOST_ALL_NO_LIB;WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <LanguageStandard>stdcpp17</LanguageStandard>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
@@ -82,6 +83,7 @@
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <PreprocessorDefinitions>BOOST_ALL_NO_LIB;WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <LanguageStandard>stdcpp17</LanguageStandard>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>

waifu2x-caffe/Source.cpp

@@ -1,11 +1,8 @@
 #include <stdio.h>
+#include <iostream>
 #include <algorithm>
-#include <boost/filesystem.hpp>
+#include <filesystem>
-#include <boost/foreach.hpp>
 #include <functional>
-#include <boost/tokenizer.hpp>
-#include <boost/tokenizer.hpp>
-#include <glog/logging.h>
 #include <codecvt>
 #include "../common/waifu2x.h"
 
@@ -17,6 +14,7 @@
 #include <fcntl.h>
 using namespace TCLAPW;
 typedef std::wstring tstring;
+typedef std::wstringstream tstringstream;
 typedef wchar_t TCHAR;
 #ifndef TEXT
 #define TEXT(x) L##x
@@ -26,7 +24,7 @@ typedef wchar_t TCHAR;
 #define tprintf wprintf
 #define CHAR_STR_FORMAT L"%S"
 
-const tstring& path_to_tstring(const boost::filesystem::path &p)
+tstring path_to_tstring(const std::filesystem::path& p)
 {
 	return p.wstring();
 }
@@ -34,6 +32,7 @@ const tstring& path_to_tstring(const boost::filesystem::path &p)
 #include <tclap/CmdLine.h>
 using namespace TCLAP;
 typedef std::string tstring;
+typedef std::stringstream tstringstream;
 typedef char TCHAR;
 #ifndef TEXT
 #define TEXT(x) x
@@ -43,7 +42,7 @@ typedef char TCHAR;
 #define tprintf printf
 #define CHAR_STR_FORMAT "%s"
 
-const tstring& path_to_tstring(const boost::filesystem::path &p)
+tstring path_to_tstring(const std::filesystem::path& p)
 {
 	return p.string();
 }
@@ -51,22 +50,22 @@ const tstring& path_to_tstring(const boost::filesystem::path &p)
 
 
 // http://stackoverflow.com/questions/10167382/boostfilesystem-get-relative-path
-boost::filesystem::path relativePath(const boost::filesystem::path &path, const boost::filesystem::path &relative_to)
+std::filesystem::path relativePath(const std::filesystem::path& path, const std::filesystem::path& relative_to)
 {
 	// create absolute paths
-	boost::filesystem::path p = boost::filesystem::absolute(path);
+	std::filesystem::path p = std::filesystem::absolute(path);
-	boost::filesystem::path r = boost::filesystem::absolute(relative_to);
+	std::filesystem::path r = std::filesystem::absolute(relative_to);
 
 	// if root paths are different, return absolute path
 	if (p.root_path() != r.root_path())
 		return p;
 
 	// initialize relative path
-	boost::filesystem::path result;
+	std::filesystem::path result;
 
 	// find out where the two paths diverge
-	boost::filesystem::path::const_iterator itr_path = p.begin();
+	std::filesystem::path::const_iterator itr_path = p.begin();
-	boost::filesystem::path::const_iterator itr_relative_to = r.begin();
+	std::filesystem::path::const_iterator itr_relative_to = r.begin();
 	while (*itr_path == *itr_relative_to && itr_path != p.end() && itr_relative_to != r.end()) {
 		++itr_path;
 		++itr_relative_to;
@@ -99,14 +98,6 @@ int main(int argc, char** argv)
 
 	Waifu2x::init_liblary(argc, argv);
 
-	// Caffeのエラーでないログを保存しないようにする
-	google::SetLogDestination(google::GLOG_INFO, "");
-	google::SetLogDestination(google::GLOG_WARNING, "");
-
-	// Caffeのエラーログを「error_log_～」に出力
-	google::SetLogDestination(google::GLOG_ERROR, "error_log_");
-	google::SetLogDestination(google::GLOG_FATAL, "error_log_");
-
 	// definition of command line arguments
 	CmdLine cmd(TEXT("waifu2x reimplementation using Caffe"), ' ', TEXT("1.0.0"));
 
@@ -209,22 +200,22 @@ int main(int argc, char** argv)
 	{
 #ifdef WIN_UNICODE
 		int nArgs = 0;
-		LPTSTR *lplpszArgs = CommandLineToArgvW(GetCommandLine(), &nArgs);
+		LPTSTR* lplpszArgs = CommandLineToArgvW(GetCommandLine(), &nArgs);
 		cmd.parse(nArgs, lplpszArgs);
 		LocalFree(lplpszArgs);
 #else
 		cmd.parse(argc, argv);
 #endif
 	}
-	catch (std::exception &e)
+	catch (std::exception& e)
 	{
 		tprintf(TEXT("エラー: ") CHAR_STR_FORMAT TEXT("\n"), e.what());
 		return 1;
 	}
 
-	boost::optional<double> ScaleRatio;
+	std::optional<double> ScaleRatio;
-	boost::optional<int> ScaleWidth;
+	std::optional<int> ScaleWidth;
-	boost::optional<int> ScaleHeight;
+	std::optional<int> ScaleHeight;
 
 	int crop_w = cmdCropSizeFile.getValue();
 	int crop_h = cmdCropSizeFile.getValue();
@@ -236,14 +227,14 @@ int main(int argc, char** argv)
 		crop_h = cmdCropHeight.getValue();
 
 	if (cmdScaleWidth.getValue() > 0)
-		ScaleWidth = cmdScaleWidth.getValue();
+		ScaleWidth = (int)cmdScaleWidth.getValue();
 	if (cmdScaleHeight.getValue() > 0)
-		ScaleHeight = cmdScaleHeight.getValue();
+		ScaleHeight = (int)cmdScaleHeight.getValue();
 
 	if (cmdScaleWidth.getValue() == 0 && cmdScaleHeight.getValue() == 0)
 		ScaleRatio = cmdScaleRatio.getValue();
 
-	const boost::filesystem::path input_path(boost::filesystem::absolute((cmdInputFile.getValue())));
+	const std::filesystem::path input_path(std::filesystem::absolute((cmdInputFile.getValue())));
 
 	tstring outputExt = cmdOutputFileExt.getValue();
 	if (outputExt.length() > 0 && outputExt[0] != TEXT('.'))
@@ -265,9 +256,9 @@ int main(int argc, char** argv)
 	const bool use_tta = cmdTTALevel.getValue() == 1;
 
 	std::vector<std::pair<tstring, tstring>> file_paths;
-	if (boost::filesystem::is_directory(input_path)) // input_pathがフォルダならそのディレクトリ以下の画像ファイルを一括変換
+	if (std::filesystem::is_directory(input_path)) // input_pathがフォルダならそのディレクトリ以下の画像ファイルを一括変換
 	{
-		boost::filesystem::path output_path;
+		std::filesystem::path output_path;
 
 		if (cmdOutputFile.getValue() == TEXT("(auto)"))
 		{
@@ -277,7 +268,7 @@ int main(int argc, char** argv)
 			addstr += tModelName;
 			addstr += TEXT(")");
 
-			const tstring &mode = cmdMode.getValue();
+			const tstring& mode = cmdMode.getValue();
 
 			addstr += TEXT("(") + mode + TEXT(")");
 
@@ -288,7 +279,7 @@ int main(int argc, char** argv)
 				addstr += TEXT("(tta)");
 			if (mode.find(TEXT("scale")) != mode.npos)
 			{
-				if(ScaleRatio)
+				if (ScaleRatio)
 					addstr += TEXT("(x") + to_tstring(*ScaleRatio) + TEXT(")");
 				else if (ScaleWidth && ScaleHeight)
 					addstr += TEXT("(") + to_tstring(*ScaleWidth) + TEXT("x") + to_tstring(*ScaleHeight) + TEXT(")");
@@ -301,16 +292,16 @@ int main(int argc, char** argv)
 			if (cmdOutputDepth.getValue() != 8)
 				addstr += TEXT("(") + to_tstring(cmdOutputDepth.getValue()) + TEXT("bit)");
 
-			output_path = input_path.branch_path() / (path_to_tstring(input_path.stem()) + addstr);
+			output_path = input_path.parent_path() / (path_to_tstring(input_path.stem()) + addstr);
 		}
 		else
 			output_path = cmdOutputFile.getValue();
 
-		output_path = boost::filesystem::absolute(output_path);
+		output_path = std::filesystem::absolute(output_path);
 
-		if (!boost::filesystem::exists(output_path))
+		if (!std::filesystem::exists(output_path))
 		{
-			if (!boost::filesystem::create_directory(output_path))
+			if (!std::filesystem::create_directory(output_path))
 			{
 				tprintf(TEXT("エラー: 出力フォルダ「%s」の作成に失敗しました\n"), path_to_tstring(output_path).c_str());
 				return 1;
@@ -321,34 +312,45 @@ int main(int argc, char** argv)
 		{
 			// input_extention_listを文字列の配列にする
 
-			typedef boost::char_separator<TCHAR> char_separator;
+			tstringstream check1(cmdInputFileExt.getValue());
-			typedef boost::tokenizer<char_separator, tstring::const_iterator, tstring> tokenizer;
+			tstring ext;
-
+			while (std::getline(check1, ext, TEXT(':')))
-			char_separator sep(TEXT(":"), TEXT(""), boost::drop_empty_tokens);
-			tokenizer tokens(cmdInputFileExt.getValue(), sep);
-
-			for (tokenizer::iterator tok_iter = tokens.begin(); tok_iter != tokens.end(); ++tok_iter)
 			{
-				tstring ext(*tok_iter);
 				std::transform(ext.begin(), ext.end(), ext.begin(), totlower);
 				extList.push_back(TEXT(".") + ext);
 			}
+
+			//typedef boost::char_separator<TCHAR> char_separator;
+			//typedef boost::tokenizer<char_separator, tstring::const_iterator, tstring> tokenizer;
+
+			//char_separator sep(TEXT(":"), TEXT(""), boost::drop_empty_tokens);
+			//tokenizer tokens(cmdInputFileExt.getValue(), sep);
+
+			//for (tokenizer::iterator tok_iter = tokens.begin(); tok_iter != tokens.end(); ++tok_iter)
+			//{
+			//	tstring ext(*tok_iter);
+			//	std::transform(ext.begin(), ext.end(), ext.begin(), totlower);
+			//	extList.push_back(TEXT(".") + ext);
+			//}
 		}
 
+
+
 		// 変換する画像の入力、出力パスを取得
-		const auto func = [&extList, &input_path, &output_path, &outputExt, &file_paths](const boost::filesystem::path &path)
+		const auto func = [&extList, &input_path, &output_path, &outputExt, &file_paths](const std::filesystem::path& path)
 			{
-			BOOST_FOREACH(const boost::filesystem::path& p, std::make_pair(boost::filesystem::recursive_directory_iterator(path),
+				for (const auto& i : std::filesystem::recursive_directory_iterator(path))
-				boost::filesystem::recursive_directory_iterator()))
 				{
-				if (boost::filesystem::is_directory(p))
+					const std::filesystem::path& p = i.path();
+
+					if (std::filesystem::is_directory(p))
 					{
 						const auto out_relative = relativePath(p, input_path);
 						const auto out_absolute = output_path / out_relative;
 
-					if (!boost::filesystem::exists(out_absolute))
+						if (!std::filesystem::exists(out_absolute))
 						{
-						if (!boost::filesystem::create_directory(out_absolute))
+							if (!std::filesystem::create_directory(out_absolute))
 							{
 								tprintf(TEXT("エラー: 出力フォルダ「%s」の作成に失敗しました\n"), path_to_tstring(out_absolute).c_str());
 								return false;
@@ -364,7 +366,7 @@ int main(int argc, char** argv)
 							const auto out_relative = relativePath(p, input_path);
 							const auto out_absolute = output_path / out_relative;
 
-						const auto out = path_to_tstring(out_absolute.branch_path() / out_absolute.stem()) + outputExt;
+							const auto out = path_to_tstring(out_absolute.parent_path() / out_absolute.stem()) + outputExt;
 
 							file_paths.emplace_back(path_to_tstring(p), out);
 						}
@@ -393,7 +395,7 @@ int main(int argc, char** argv)
 			addstr += tModelName;
 			addstr += TEXT(")");
 
-			const tstring &mode = cmdMode.getValue();
+			const tstring& mode = cmdMode.getValue();
 
 			addstr += TEXT("(") + mode + TEXT(")");
 
@@ -461,11 +463,11 @@ int main(int argc, char** argv)
 	}
 
 	bool isError = false;
-	for (const auto &p : file_paths)
+	for (const auto& p : file_paths)
 	{
 		const Waifu2x::eWaifu2xError ret = w.waifu2x(p.first, p.second, ScaleRatio, ScaleWidth, ScaleHeight, nullptr,
 			crop_w, crop_h,
-			cmdOutputQuality.getValue() == -1 ? boost::optional<int>() : cmdOutputQuality.getValue(), cmdOutputDepth.getValue(), use_tta, cmdBatchSizeFile.getValue());
+			cmdOutputQuality.getValue() == -1 ? std::optional<int>() : cmdOutputQuality.getValue(), cmdOutputDepth.getValue(), use_tta, cmdBatchSizeFile.getValue());
 		if (ret != Waifu2x::eWaifu2xError_OK)
 		{
 			switch (ret)

waifu2x-caffe/Test.cpp

@@ -0,0 +1,471 @@
+# include <iostream>
+# include <fstream>
+# include <iomanip>
+# include <opencv2/dnn.hpp>
+# include <opencv2/imgproc.hpp>
+# include <opencv2/imgcodecs.hpp>
+
+# include <opencv2/dnn/layer.details.hpp>
+# include <opencv2/dnn/all_layers.hpp>
+
+#define CV_VERSION_STR CVAUX_STR(CV_MAJOR_VERSION) CVAUX_STR(CV_MINOR_VERSION) CVAUX_STR(CV_SUBMINOR_VERSION)
+
+// ビルドモード
+#ifdef _DEBUG
+#define CV_EXT_STR "d.lib"
+#else
+#define CV_EXT_STR ".lib"
+#endif
+
+#ifdef _MSC_VER
+
+#pragma comment(lib, "opencv_core" CV_VERSION_STR CV_EXT_STR)
+#pragma comment(lib, "opencv_imgcodecs" CV_VERSION_STR CV_EXT_STR)
+#pragma comment(lib, "opencv_imgproc" CV_VERSION_STR CV_EXT_STR)
+#pragma comment(lib, "opencv_dnn" CV_VERSION_STR CV_EXT_STR)
+#pragma comment(lib, "libprotobuf" CV_EXT_STR)
+#pragma comment(lib, "IlmImf" CV_EXT_STR)
+#pragma comment(lib, "libjpeg-turbo" CV_EXT_STR)
+#pragma comment(lib, "libopenjp2" CV_EXT_STR)
+#pragma comment(lib, "libpng" CV_EXT_STR)
+#pragma comment(lib, "libtiff" CV_EXT_STR)
+#pragma comment(lib, "libwebp" CV_EXT_STR)
+#pragma comment(lib, "zlib" CV_EXT_STR)
+
+#pragma comment(lib, "cudart.lib")
+//#pragma comment(lib, "curand.lib")
+#pragma comment(lib, "cublas.lib")
+#pragma comment(lib, "cudnn.lib")
+
+#endif
+
+using namespace std;
+
+class CropCenterLayer : public cv::dnn::Layer
+{
+private:
+	std::vector<int> cropSize;
+	cv::Ptr<cv::dnn::Layer> cropLayer;
+
+public:
+	CropCenterLayer(const cv::dnn::LayerParams& params) : Layer(params)
+	{
+		setParamsFrom(params);
+
+		if (params.has("crop_size"))
+		{
+			const auto& paramCropSize = params.get("crop_size");
+			const auto& str = paramCropSize.getStringValue();
+
+			const int s = atoi(str.c_str());
+			cropSize.resize(4);
+			cropSize[0] = 0;
+			cropSize[1] = 0;
+			cropSize[2] = s;
+			cropSize[3] = s;
+		}
+
+		cv::dnn::LayerParams parasm;
+		parasm.set("axis", 0);
+		parasm.set("offset", cv::dnn::DictValue::arrayInt(cropSize.data(), cropSize.size()));
+
+		cropLayer = cv::dnn::CropLayer::create(parasm);
+	}
+
+	// Destructor
+	virtual ~CropCenterLayer() = default;
+
+	static cv::Ptr<cv::dnn::Layer> create(cv::dnn::LayerParams& params)
+	{
+		return cv::Ptr<CropCenterLayer>(new CropCenterLayer(params));
+	}
+
+	// Override virtual functions from cv::dnn::Layer and delegate to cropLayer
+
+	CV_DEPRECATED_EXTERNAL virtual void finalize(const std::vector<cv::Mat*>& input, std::vector<cv::Mat>& output) override
+	{
+		cropLayer->finalize(input, output);
+	}
+
+	virtual void finalize(cv::InputArrayOfArrays inputs_arr, cv::OutputArrayOfArrays outputs_arr) override
+	{
+		std::vector<cv::Mat> inputs;
+		inputs_arr.getMatVector(inputs);
+
+		CV_Assert(inputs.size() == 1);
+		const auto& input = inputs[0];
+
+		//cv::Mat sizeShape(input.dims, input.size.p, input.type());
+		cv::Mat sizeShape(input.size.dims(), input.size.p, input.type());
+
+		auto& sz = sizeShape.size;
+		for (int i = 0; i < sz.dims(); i++)
+		{
+			sz[i] = sz[i] - cropSize[i] * 2;
+			CV_Assert(sz[i] >= 0);
+		}
+
+		inputs.push_back(sizeShape); // dummy second input for CropLayer
+
+		cropLayer->finalize(inputs, outputs_arr);
+	}
+
+	CV_DEPRECATED_EXTERNAL virtual void forward(std::vector<cv::Mat*>& input, std::vector<cv::Mat>& output, std::vector<cv::Mat>& internals)
+	{
+		cropLayer->forward(input, output, internals);
+	}
+
+	virtual void forward(cv::InputArrayOfArrays inputs, cv::OutputArrayOfArrays outputs, cv::OutputArrayOfArrays internals) override
+	{
+		cropLayer->forward(inputs, outputs, internals);
+	}
+
+	virtual bool tryQuantize(const std::vector<std::vector<float>>& scales,
+		const std::vector<std::vector<int>>& zeropoints, cv::dnn::LayerParams& params) override
+	{
+		return cropLayer->tryQuantize(scales, zeropoints, params);
+	}
+
+	CV_DEPRECATED_EXTERNAL void finalize(const std::vector<cv::Mat>& inputs, CV_OUT std::vector<cv::Mat>& outputs)
+	{
+		cropLayer->finalize(inputs, outputs);
+	}
+
+	CV_DEPRECATED std::vector<cv::Mat> finalize(const std::vector<cv::Mat>& inputs)
+	{
+		cropLayer->finalize(inputs);
+	}
+
+	CV_DEPRECATED CV_WRAP void run(const std::vector<cv::Mat>& inputs, CV_OUT std::vector<cv::Mat>& outputs,
+		CV_IN_OUT std::vector<cv::Mat>& internals)
+	{
+		cropLayer->run(inputs, outputs, internals);
+	}
+
+	virtual int inputNameToIndex(cv::String inputName) override
+	{
+		return cropLayer->inputNameToIndex(inputName);
+	}
+
+	virtual int outputNameToIndex(const cv::String& outputName) override
+	{
+		return cropLayer->outputNameToIndex(outputName);
+	}
+
+	virtual bool supportBackend(int backendId) override
+	{
+		return cropLayer->supportBackend(backendId);
+	}
+
+	virtual cv::Ptr<cv::dnn::BackendNode> initHalide(const std::vector<cv::Ptr<cv::dnn::BackendWrapper>>& inputs) override
+	{
+		// preferableTargetを反映させるタイミングがここしかないっぽいので反映させる
+		cropLayer->preferableTarget = preferableTarget;
+		return cropLayer->initHalide(inputs);
+	}
+
+	virtual cv::Ptr<cv::dnn::BackendNode> initNgraph(const std::vector<cv::Ptr<cv::dnn::BackendWrapper>>& inputs,
+		const std::vector<cv::Ptr<cv::dnn::BackendNode>>& nodes) override
+	{
+		// preferableTargetを反映させるタイミングがここしかないっぽいので反映させる
+		cropLayer->preferableTarget = preferableTarget;
+		return cropLayer->initNgraph(inputs, nodes);
+	}
+
+	virtual cv::Ptr<cv::dnn::BackendNode> initVkCom(const std::vector<cv::Ptr<cv::dnn::BackendWrapper>>& inputs,
+		std::vector<cv::Ptr<cv::dnn::BackendWrapper>>& outputs) override
+	{
+		// preferableTargetを反映させるタイミングがここしかないっぽいので反映させる
+		cropLayer->preferableTarget = preferableTarget;
+		return cropLayer->initVkCom(inputs, outputs);
+	}
+
+	virtual cv::Ptr<cv::dnn::BackendNode> initWebnn(const std::vector<cv::Ptr<cv::dnn::BackendWrapper>>& inputs,
+		const std::vector<cv::Ptr<cv::dnn::BackendNode>>& nodes) override
+	{
+		// preferableTargetを反映させるタイミングがここしかないっぽいので反映させる
+		cropLayer->preferableTarget = preferableTarget;
+		return cropLayer->initWebnn(inputs, nodes);
+	}
+
+	virtual cv::Ptr<cv::dnn::BackendNode> initCUDA(void* context,
+		const std::vector<cv::Ptr<cv::dnn::BackendWrapper>>& inputs,
+		const std::vector<cv::Ptr<cv::dnn::BackendWrapper>>& outputs) override
+	{
+		// preferableTargetを反映させるタイミングがここしかないっぽいので反映させる
+		cropLayer->preferableTarget = preferableTarget;
+		return cropLayer->initCUDA(context, inputs, outputs);
+	}
+
+	virtual cv::Ptr<cv::dnn::BackendNode> initTimVX(void* timVxInfo,
+		const std::vector<cv::Ptr<cv::dnn::BackendWrapper>>& inputsWrapper,
+		const std::vector<cv::Ptr<cv::dnn::BackendWrapper>>& outputsWrapper,
+		bool isLast) override
+	{
+		// preferableTargetを反映させるタイミングがここしかないっぽいので反映させる
+		cropLayer->preferableTarget = preferableTarget;
+		return cropLayer->initTimVX(timVxInfo, inputsWrapper, outputsWrapper, isLast);
+	}
+
+	virtual cv::Ptr<cv::dnn::BackendNode> initCann(const std::vector<cv::Ptr<cv::dnn::BackendWrapper>>& inputs,
+		const std::vector<cv::Ptr<cv::dnn::BackendWrapper>>& outputs,
+		const std::vector<cv::Ptr<cv::dnn::BackendNode>>& nodes) override
+	{
+		// preferableTargetを反映させるタイミングがここしかないっぽいので反映させる
+		cropLayer->preferableTarget = preferableTarget;
+		return cropLayer->initCann(inputs, outputs, nodes);
+	}
+
+	virtual void applyHalideScheduler(cv::Ptr<cv::dnn::BackendNode>& node,
+		const std::vector<cv::Mat*>& inputs,
+		const std::vector<cv::Mat>& outputs,
+		int targetId) const override
+	{
+		cropLayer->applyHalideScheduler(node, inputs, outputs, targetId);
+	}
+
+	virtual cv::Ptr<cv::dnn::BackendNode> tryAttach(const cv::Ptr<cv::dnn::BackendNode>& node) override
+	{
+		return cropLayer->tryAttach(node);
+	}
+
+	virtual bool setActivation(const cv::Ptr<cv::dnn::ActivationLayer>& layer) override
+	{
+		return cropLayer->setActivation(layer);
+	}
+
+	virtual bool tryFuse(cv::Ptr<cv::dnn::Layer>& top) override
+	{
+		return cropLayer->tryFuse(top);
+	}
+
+	virtual void getScaleShift(cv::Mat& scale, cv::Mat& shift) const override
+	{
+		cropLayer->getScaleShift(scale, shift);
+	}
+
+	virtual void getScaleZeropoint(float& scale, int& zeropoint) const override
+	{
+		cropLayer->getScaleZeropoint(scale, zeropoint);
+	}
+
+	virtual void unsetAttached() override
+	{
+		cropLayer->unsetAttached();
+	}
+
+	virtual bool getMemoryShapes(const std::vector<cv::dnn::MatShape>& inputs,
+		const int requiredOutputs,
+		std::vector<cv::dnn::MatShape>& outputs,
+		std::vector<cv::dnn::MatShape>& internals) const override
+	{
+		CV_Assert(inputs.size() == 1);
+
+		const auto& srcShape = inputs[0];
+
+		std::vector<int> outShape(srcShape.size());
+		for (int i = 0; i < srcShape.size(); i++)
+		{
+			outShape[i] = inputs[0][i] - cropSize[i] * 2;
+		}
+		outputs.assign(1, outShape);
+
+		return false;
+
+		//return cropLayer->getMemoryShapes(inputs, requiredOutputs, outputs, internals);
+	}
+
+	virtual bool updateMemoryShapes(const std::vector<cv::dnn::MatShape>& inputs) override
+	{
+		return cropLayer->updateMemoryShapes(inputs);
+	}
+};
+
+static double sumAllElements(const cv::Mat& mat)
+{
+	CV_Assert(!mat.empty());
+
+	const cv::Scalar s = cv::sum(mat); // チャンネルごとの合計
+	double total = 0.0;
+	for (int c = 0; c < mat.channels(); ++c) {
+		total += s[c];
+	}
+	return total;
+}
+
+
+// ---- 内部実装 ----
+template<typename T>
+static void printRec(const cv::Mat& m, std::vector<int>& idx, int d) {
+	if (d == m.dims - 1) {
+		// 最終軸：一次元の並びを出力
+		const int cn = m.channels();
+		std::cout << "[";
+		for (int i = 0; i < m.size[d]; ++i) {
+			idx[d] = i;
+			const T* p = m.ptr<T>(idx.data()); // idx の位置の要素先頭（ch=0）へのポインタ
+			if (cn == 1) {
+				std::cout << p[0];
+			}
+			else {
+				std::cout << "(";
+				for (int c = 0; c < cn; ++c) {
+					std::cout << p[c];
+					if (c + 1 < cn) std::cout << ", ";
+				}
+				std::cout << ")";
+			}
+			if (i + 1 < m.size[d]) std::cout << ", ";
+		}
+		std::cout << "]";
+	}
+	else {
+		// 途中軸：再帰で内側へ
+		std::cout << "[";
+		for (int i = 0; i < m.size[d]; ++i) {
+			idx[d] = i;
+			printRec<T>(m, idx, d + 1);
+			if (i + 1 < m.size[d]) std::cout << ",\n";
+		}
+		std::cout << "]";
+	}
+}
+
+template<typename T>
+static void printMatND_T(const cv::Mat& m) {
+	// 浮動小数は小数桁を控えめに
+	if (std::is_floating_point<T>::value) {
+		std::cout << std::fixed << std::setprecision(6);
+	}
+	std::vector<int> idx(m.dims, 0);
+	printRec<T>(m, idx, 0);
+	std::cout << std::endl;
+}
+
+// エントリポイント（cv::Mat の depth に応じてディスパッチ）
+static void printMatND(const cv::Mat& m) {
+	switch (m.depth()) {
+	case CV_8U:  printMatND_T<uchar>(m);   break;
+	case CV_8S:  printMatND_T<schar>(m);   break;
+	case CV_16U: printMatND_T<uint16_t>(m); break;
+	case CV_16S: printMatND_T<int16_t>(m); break;
+	case CV_32S: printMatND_T<int32_t>(m); break;
+	case CV_32F: printMatND_T<float>(m);   break;
+	case CV_64F: printMatND_T<double>(m);  break;
+	default:
+		throw std::runtime_error("Unsupported Mat depth.");
+	}
+}
+
+
+void reg();
+void reg2();
+
+int main(int argc, char** argv) {
+	//CV_DNN_REGISTER_LAYER_CLASS(CropCenter, CropCenterLayer);
+	reg();
+	reg2();
+
+	// ImageNet Caffeリファレンスモデル
+	string protoFile = "models/upresnet10/noise0_scale2.0x_model.prototxt";
+	string modelFile = "models/upresnet10/noise0_scale2.0x_model.json.caffemodel";
+
+	// 画像ファイル
+	//string imageFile = (argc > 1) ? argv[1] : "images/cat.jpg";
+	string imageFile = "red.png";
+
+	// Caffeモデルの読み込み
+	cv::dnn::Net net;
+	try {
+		net = cv::dnn::readNetFromCaffe(protoFile, modelFile);
+
+		//net.setPreferableBackend(cv::dnn::DNN_BACKEND_CUDA);
+		//net.setPreferableTarget(cv::dnn::DNN_TARGET_CUDA);
+
+		net.setPreferableBackend(cv::dnn::DNN_BACKEND_OPENCV);
+		net.setPreferableTarget(cv::dnn::DNN_TARGET_CPU);
+	}
+	catch (const cv::Exception& e) {
+		cerr << e.msg << endl;
+		exit(-1);
+	}
+
+	// テスト用の入力画像ファイルの読み込み
+	cv::Mat img = cv::imread(imageFile);
+	if (img.empty()) {
+		cerr << "can't read image: " << imageFile << endl;
+		exit(-1);
+	}
+	try {
+		// 入力画像をリサイズ
+		int cropSize = 90;
+		cv::resize(img, img, cv::Size(cropSize, cropSize));
+		// Caffeで扱うBlob形式に変換 (実体はcv::Matのラッパークラス)
+		const auto inputBlob = cv::dnn::blobFromImage(img, 1.0 / 255.0, cv::Size(), cv::Scalar(), true, false, CV_32F);
+
+		//printMatND(inputBlob);
+
+		std::vector<int> indim(inputBlob.size.p, inputBlob.size.p + inputBlob.size.dims());
+		// 入力層に画像を入力
+		net.setInput(inputBlob, "input");
+		// フォワードパス(順伝播)の計算&出力層(Softmax)の出力を取得, ここに予測結果が格納されている
+		// ImageNet 1000クラス毎の確率(32bits浮動小数点値)が格納された1x1000の行列(ベクトル)
+		//const auto probMat = net.forward("/conv_post");
+		const auto probMat = net.forward("/res1/axpy");
+
+		std::vector<int> probMatDim(probMat.size.p, probMat.size.p + probMat.size.dims());
+		auto sss = sumAllElements(probMat);
+		//printMatND(probMat);
+
+		std::vector<cv::Mat> outImgs;
+		cv::dnn::imagesFromBlob(probMat, outImgs);
+		//cv::dnn::imagesFromBlob(inputBlob, outImgs);
+		auto outImg = outImgs[0];
+
+		std::vector<int> outdim(outImg.size.p, outImg.size.p + outImg.size.dims());
+		printMatND(outImg);
+
+		//std::cout << cv::format(outImg, cv::Formatter::FMT_DEFAULT) << std::endl;
+
+		// 値を0～1にクリッピング
+		cv::threshold(outImg, outImg, 1.0, 1.0, cv::THRESH_TRUNC);
+		cv::threshold(outImg, outImg, 0.0, 0.0, cv::THRESH_TOZERO);
+
+		const double clip_eps8 = (1.0 / 255.0) * 0.5 - (1.0e-7 * (1.0 / 255.0) * 0.5);
+		outImg.convertTo(outImg, CV_8U, 255.0, clip_eps8);
+
+		cv::cvtColor(outImg, outImg, cv::COLOR_RGB2BGR);
+
+		cv::imwrite("test.png", outImg);
+
+		//// 確率(信頼度)の高い順にソートして、上位5つのインデックスを取得
+		//cv::Mat sorted(probMat.rows, probMat.cols, CV_32F);
+		//cv::sortIdx(probMat, sorted, cv::SORT_EVERY_ROW | cv::SORT_DESCENDING);
+		//cv::Mat topk = sorted(cv::Rect(0, 0, 5, 1));
+		//// カテゴリ名のリストファイル(synset_words.txt)を読み込み
+		//// データ例: categoryList[951] = "lemon";
+		//vector<string> categoryList;
+		//string category;
+		//ifstream fs("synset_words.txt");
+		//if (!fs.is_open()) {
+		//	cerr << "can't read file" << endl;
+		//	exit(-1);
+		//}
+		//while (getline(fs, category)) {
+		//	if (category.length()) {
+		//		categoryList.push_back(category.substr(category.find(' ') + 1));
+		//	}
+		//}
+		//fs.close();
+		//// 予測したカテゴリと確率(信頼度)を出力
+		//cv::Mat_<int>::const_iterator it = topk.begin<int>();
+		//while (it != topk.end<int>()) {
+		//	cout << categoryList[*it] << " : " << probMat.at<float>(*it) * 100 << " %" << endl;
+		//	++it;
+		//}
+	}
+	catch (const cv::Exception& e) {
+		cerr << e.msg << endl;
+	}
+	return 0;
+}

waifu2x-caffe/axpy.hpp

@@ -0,0 +1,106 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#ifndef OPENCV_DNN_SRC_CUDA4DNN_PRIMITIVES_SCALE_SHIFT_HPP
+#define OPENCV_DNN_SRC_CUDA4DNN_PRIMITIVES_SCALE_SHIFT_HPP
+
+//#include "../../op_cuda.hpp"
+//
+//#include "../csl/stream.hpp"
+//#include "../csl/tensor.hpp"
+//
+//#include "../kernels/scale_shift.hpp"
+
+#include <op_cuda.hpp>
+
+#include <opencv2/core.hpp>
+
+#include <cuda4dnn/kernels/scale_shift.hpp>
+
+#include <cstddef>
+#include <utility>
+
+namespace cv {
+	namespace dnn {
+		namespace cuda4dnn {
+
+			template <class T>
+			class AxpyOp final : public CUDABackendNode {
+			public:
+				using wrapper_type = GetCUDABackendWrapperType<T>;
+
+				AxpyOp(csl::Stream stream_)
+					: stream(std::move(stream_)), axis(0)
+				{
+				}
+
+				void forward(
+					const std::vector<cv::Ptr<BackendWrapper>>& inputs,
+					const std::vector<cv::Ptr<BackendWrapper>>& outputs,
+					csl::Workspace& workspace) override
+				{
+					CV_Assert(inputs.size() == 3);
+					CV_Assert(outputs.size() == 1);
+
+					auto input_wrapper = inputs[1].dynamicCast<wrapper_type>();
+					auto input = input_wrapper->getView();
+
+					auto output_wrapper = outputs[0].dynamicCast<wrapper_type>();
+					auto output = output_wrapper->getSpan();
+
+					/* number of batches in the weights/bias
+					 * trainable mode: same for all batches
+					 * untrainable mode: could be different for different batch samples
+					 */
+					std::size_t parameter_batch_size = 1;
+
+					csl::TensorView<T> weights = inputs[0].dynamicCast<wrapper_type>()->getView();
+					parameter_batch_size = weights.get_axis_size(0);
+					CV_Assert(parameter_batch_size == input.get_axis_size(0));
+
+					csl::TensorView<T> bias = inputs[2].dynamicCast<wrapper_type>()->getView();
+					parameter_batch_size = bias.get_axis_size(0);
+					CV_Assert(parameter_batch_size == input.get_axis_size(0));
+
+					CV_Assert(!weights.empty() || !bias.empty());
+					if (!weights.empty() && !bias.empty())
+					{
+						CV_CheckEQ(weights.size(), bias.size(), "different broadcasting options for weights and bias is not supported");
+					}
+
+					const auto num_parameters = !weights.empty() ? weights.size() : bias.size();
+					const auto mid_size = num_parameters / parameter_batch_size;
+
+					/* the scale shift operation might require broadcasting */
+					const int end_axis = [&] {
+						if (num_parameters == 1) {
+							return static_cast<int>(axis + 1);
+						}
+						for (int endAxis = axis + 1; endAxis <= input.rank(); endAxis++) {
+							if (input.size_range(axis, endAxis) == mid_size)
+								return endAxis;
+						}
+						CV_Assert(0 /* failed to find a broadcast config */);
+						}();
+
+					std::size_t inner_size = input.size_range(end_axis, input.rank());
+
+					if (!weights.empty() && !bias.empty())
+						kernels::scaleN_with_biasN<T>(stream, output, input, inner_size, weights, bias);
+					else if (!weights.empty())
+						kernels::scaleN<T>(stream, output, input, inner_size, weights);
+					else
+						kernels::biasN<T>(stream, output, input, inner_size, bias);
+				}
+
+			private:
+				csl::Stream stream;
+				std::size_t axis;
+			};
+
+		}
+	}
+} /* namespace cv::dnn::cuda4dnn */
+
+#endif /* OPENCV_DNN_SRC_CUDA4DNN_PRIMITIVES_SCALE_SHIFT_HPP */

waifu2x-caffe/axpy_fast_layer.cpp

@@ -0,0 +1,371 @@
+#include <opencv2/dnn/all_layers.hpp>
+//#include <opencv2/core/opencl/ocl_defs.hpp>
+#include <cvconfig.h>
+
+//#include <layers/layers_common.hpp>
+#include <op_cuda.hpp>
+#include <op_halide.hpp>
+#include <op_inf_engine.hpp>
+#include <ie_ngraph.hpp>
+#include <op_webnn.hpp>
+
+#include <opencv2/imgproc.hpp>
+#include <opencv2/dnn/shape_utils.hpp>
+
+#include <opencv2/core/utils/logger.hpp>
+#include <opencv2/core/utils/trace.hpp>
+
+#ifdef HAVE_CUDA
+//#include <cuda4dnn/primitives/scale_shift.hpp>
+#include "axpy.hpp"
+using namespace cv::dnn::cuda4dnn;
+#endif
+
+namespace cv
+{
+	namespace dnn
+	{
+
+		class AxpyFastLayerImpl CV_FINAL : public Layer
+		{
+		public:
+#ifdef HAVE_WEBNN
+			mutable int dims;
+			mutable int numChannels;
+#endif
+			AxpyFastLayerImpl(const LayerParams& params)
+			{
+				setParamsFrom(params);
+			}
+
+			bool getMemoryShapes(const std::vector<MatShape>& inputs,
+				const int requiredOutputs,
+				std::vector<MatShape>& outputs,
+				std::vector<MatShape>& internals) const CV_OVERRIDE
+			{
+				outputs.assign(1, inputs[1]);
+#ifdef HAVE_WEBNN
+				dims = inputs[0].size();
+				numChannels = 1;
+				if (inputs.size() > 1)
+				{
+					for (const size_t& dim : inputs[1])
+						numChannels *= dim;
+				}
+#endif
+				return true;
+			}
+
+			virtual void finalize(InputArrayOfArrays inputs_arr, OutputArrayOfArrays) CV_OVERRIDE
+			{
+				std::vector<Mat> inputs;
+				inputs_arr.getMatVector(inputs);
+				CV_Assert(inputs.size() == 3);
+			}
+
+			virtual bool supportBackend(int backendId) CV_OVERRIDE
+			{
+#ifdef HAVE_INF_ENGINE
+				if (backendId == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
+					return true;
+#endif
+				return backendId == DNN_BACKEND_OPENCV ||
+					backendId == DNN_BACKEND_CUDA ||
+					backendId == DNN_BACKEND_HALIDE ||
+					backendId == DNN_BACKEND_WEBNN;
+			}
+
+			void forward(InputArrayOfArrays inputs_arr, OutputArrayOfArrays outputs_arr, OutputArrayOfArrays internals_arr) CV_OVERRIDE
+			{
+				CV_TRACE_FUNCTION();
+				CV_TRACE_ARG_VALUE(name, "name", name.c_str());
+
+				if (inputs_arr.depth() == CV_16F)
+				{
+					forward_fallback(inputs_arr, outputs_arr, internals_arr);
+					return;
+				}
+
+				std::vector<Mat> inputs, outputs;
+				inputs_arr.getMatVector(inputs);
+				outputs_arr.getMatVector(outputs);
+
+				CV_Assert_N(outputs.size() == 1, inputs.size() == 3);
+
+				Mat& inpBlob = inputs[1];
+				Mat& outBlob = outputs[0];
+				// There is a mode when we multiply a first blob by a second one
+				// instead of trainable weights.
+				Mat weights = inputs[0].reshape(1, 1);
+				Mat bias = inputs[2].reshape(1, 1);
+
+				MatShape inpShape0 = shape(inputs[0]);
+				MatShape inpShape1 = shape(inputs[1]);
+				MatShape inpShape2 = shape(inputs[2]);
+
+				// TODO: 向こうが想定しているbiasがこちらが想定しているshapeと違う想定っぽいので計算処理を書き直す
+				// こちらが想定しているの: weights.shape == bias.shape
+				// 向こうが想定しているの: inpBlob.shape == bias.shape
+
+				MatShape inpShape = shape(inpBlob);
+				const int numWeights = weights.total();
+				CV_Assert(numWeights != 0);
+				CV_CheckEQ(weights.total(), bias.total(), "Incompatible weights/bias blobs");
+
+				if (weights.total() == 1)
+				{
+					// The total() of bias should be same as weights.
+					inpBlob.convertTo(outBlob, CV_32F, weights.at<float>(0), bias.at<float>(0));
+					return;
+				}
+
+				int endAxis;
+				for (endAxis = 1; endAxis <= inpBlob.dims; ++endAxis)
+				{
+					if (total(inpShape, 0, endAxis) == numWeights)
+						break;
+				}
+				CV_Assert(total(inpShape, 0, endAxis) == numWeights);
+				CV_Assert(numWeights == bias.total());
+				CV_CheckTypeEQ(inpBlob.type(), CV_32FC1, ""); CV_CheckTypeEQ(outBlob.type(), CV_32FC1, "");
+
+				int numSlices = total(inpShape, 0, 0);
+				float* inpData = (float*)inpBlob.data;
+				float* outData = (float*)outBlob.data;
+
+				if (endAxis != inpBlob.dims)
+				{
+					float* weightsData = (float*)weights.data;
+					float* biasesData = (float*)bias.data;
+					int spatialSize = total(inpShape, endAxis);  // spatialSize != 1
+					for (int i = 0; i < numSlices; ++i)
+					{
+						for (int j = 0; j < numWeights; ++j)
+						{
+							float w = weightsData ? weightsData[j] : 1;
+							float b = biasesData ? biasesData[j] : 0;
+							Mat inpSlice(1, spatialSize, CV_32F, inpData);
+							Mat outSlice(1, spatialSize, CV_32F, outData);
+
+							inpSlice.convertTo(outSlice, CV_32F, w, b);
+
+							inpData += spatialSize;
+							outData += spatialSize;
+						}
+					}
+				}
+				else
+				{
+					for (int i = 0; i < numSlices; ++i)
+					{
+						Mat inpSlice(1, numWeights, CV_32F, inpData);
+						Mat outSlice(1, numWeights, CV_32F, outData);
+
+						multiply(inpSlice, weights, outSlice);
+						add(outSlice, bias, outSlice);
+
+						inpData += numWeights;
+						outData += numWeights;
+					}
+				}
+			}
+
+#ifdef HAVE_CUDA
+			Ptr<BackendNode> initCUDA(
+				void* context_,
+				const std::vector<Ptr<BackendWrapper>>& inputs,
+				const std::vector<Ptr<BackendWrapper>>& outputs
+			) override
+			{
+				auto context = reinterpret_cast<csl::CSLContext*>(context_);
+
+				CV_Assert(inputs.size() == 3);
+
+				return make_cuda_node<cuda4dnn::AxpyOp>(preferableTarget, std::move(context->stream));
+			}
+#endif
+
+			virtual Ptr<BackendNode> tryAttach(const Ptr<BackendNode>& node) CV_OVERRIDE
+			{
+				switch (node->backendId)
+				{
+				case DNN_BACKEND_HALIDE:
+				{
+#ifdef HAVE_HALIDE
+					auto base = node.dynamicCast<HalideBackendNode>();
+					Halide::Func& input = base->funcs.back();
+					Halide::Var x("x"), y("y"), c("c"), n("n");
+					Halide::Func top = attachHalide(input(x, y, c, n));
+					return Ptr<BackendNode>(new HalideBackendNode(base, top));
+#endif  // HAVE_HALIDE
+					break;
+				}
+				}
+				return Ptr<BackendNode>();
+			}
+
+			virtual Ptr<BackendNode> initHalide(const std::vector<Ptr<BackendWrapper> >& inputs) CV_OVERRIDE
+			{
+#ifdef HAVE_HALIDE
+				Halide::Buffer<float> input = halideBuffer(inputs[0]);
+				Halide::Var x("x"), y("y"), c("c"), n("n");
+				Halide::Func top = attachHalide(input(x, y, c, n));
+				return Ptr<BackendNode>(new HalideBackendNode(top));
+#endif  // HAVE_HALIDE
+				return Ptr<BackendNode>();
+			}
+
+#ifdef HAVE_HALIDE
+			// attachHalide can work both with Halide::Buffer and Halide::Func. In the
+			// second case it will be a fusion.
+			Halide::Func attachHalide(const Halide::Expr& input)
+			{
+				Halide::Func top = (name.empty() ? Halide::Func() : Halide::Func(name));
+				Halide::Var x("x"), y("y"), c("c"), n("n");
+
+				const int numChannels = blobs[0].total();
+
+				Halide::Expr topExpr = input;
+				if (hasWeights)
+				{
+					auto weights = wrapToHalideBuffer(blobs[0], { numChannels });
+					topExpr *= weights(c);
+				}
+				if (hasBias)
+				{
+					auto bias = wrapToHalideBuffer(blobs.back(), { numChannels });
+					topExpr += bias(c);
+				}
+				top(x, y, c, n) = topExpr;
+				return top;
+			}
+#endif  // HAVE_HALIDE
+
+
+#ifdef HAVE_DNN_NGRAPH
+			virtual Ptr<BackendNode> initNgraph(const std::vector<Ptr<BackendWrapper> >& inputs, const std::vector<Ptr<BackendNode> >& nodes) CV_OVERRIDE
+			{
+				auto ieInpNode0 = nodes[0].dynamicCast<InfEngineNgraphNode>()->node;
+				ov::Output<ov::Node> ieInpNode1;
+				if (nodes.size() > 1)
+					ieInpNode1 = nodes[1].dynamicCast<InfEngineNgraphNode>()->node;
+
+				size_t numChannels = 1;
+				if (blobs.empty())
+					for (const size_t& dim : ieInpNode1.get_shape())
+						numChannels *= dim;
+				else
+					numChannels = blobs[0].total();
+
+				std::vector<size_t> shape(ieInpNode0.get_shape().size(), 1);
+				int cAxis = normalize_axis(axis, shape.size());
+				shape[cAxis] = numChannels;
+
+				std::shared_ptr<ov::Node> node;
+				if (hasWeights)
+				{
+					ov::Output<ov::Node> weight = blobs.empty() ? ieInpNode1 :
+						std::make_shared<ov::op::v0::Constant>(ov::element::f32, ov::Shape(shape), blobs[0].data);
+					node = std::make_shared<ov::op::v1::Multiply>(ieInpNode0, weight, ov::op::AutoBroadcastType::NUMPY);
+				}
+				if (hasBias || !hasWeights)
+				{
+					ov::Output<ov::Node> bias;
+					if (hasBias)
+					{
+						bias = blobs.empty() ? ieInpNode1 :
+							std::make_shared<ov::op::v0::Constant>(ov::element::f32,
+								ov::Shape(shape), blobs.back().data);
+					}
+					else
+						bias = std::make_shared<ov::op::v0::Constant>(ov::element::f32,
+							ov::Shape(shape), std::vector<float>(numChannels, 0).data());
+					node = std::make_shared<ov::op::v1::Add>(node, bias, ov::op::AutoBroadcastType::NUMPY);
+				}
+				return Ptr<BackendNode>(new InfEngineNgraphNode(node));
+			}
+#endif  // HAVE_DNN_NGRAPH
+
+#ifdef HAVE_WEBNN
+			virtual Ptr<BackendNode> initWebnn(const std::vector<Ptr<BackendWrapper> >& inputs, const std::vector<Ptr<BackendNode> >& nodes) CV_OVERRIDE
+			{
+				Ptr<WebnnBackendNode> node = nodes[0].dynamicCast<WebnnBackendNode>();
+				auto& webnnInpOperand0 = node->operand;
+				auto& webnnGraphBuilder = node->net->builder;
+				auto webnnInpOperand1 = nodes.size() > 1 ? nodes[1].dynamicCast<WebnnBackendNode>()->operand : nullptr;
+				auto webnnInpOperand2 = nodes.size() > 2 ? nodes[1].dynamicCast<WebnnBackendNode>()->operand : nullptr;
+				std::vector<int32_t> shape(dims, 1);
+
+				size_t channels = 1;
+				if (blobs.empty())
+					channels = numChannels;
+				else
+					channels = blobs[0].total();
+
+				int cAxis = normalize_axis(axis, shape.size());
+				shape[cAxis] = channels;
+
+				ml::Operand operand = webnnInpOperand0;
+				if (hasWeights)
+				{
+					ml::Operand webnnWeights = blobs.empty() ? webnnInpOperand1 : webnn::BuildConstant(webnnGraphBuilder, webnn::getShape(blobs[0]), blobs[0].data, blobs[0].total() * blobs[0].elemSize(), ml::OperandType::Float32);
+					webnnWeights = webnnGraphBuilder.Reshape(webnnWeights, shape.data(), shape.size());
+					operand = webnnGraphBuilder.Mul(operand, webnnWeights);
+				}
+				if (hasBias)
+				{
+					ml::Operand webnnBias;
+					if (!hasWeights)
+						webnnBias = blobs.empty() ? webnnInpOperand1 : webnn::BuildConstant(webnnGraphBuilder, webnn::getShape(blobs.back()), blobs.back().data, blobs.back().total() * blobs.back().elemSize(), ml::OperandType::Float32);
+					else
+						webnnBias = blobs.empty() ? webnnInpOperand2 : webnn::BuildConstant(webnnGraphBuilder, webnn::getShape(blobs.back()), blobs.back().data, blobs.back().total() * blobs.back().elemSize(), ml::OperandType::Float32);
+					webnnBias = webnnGraphBuilder.Reshape(webnnBias, shape.data(), shape.size());
+					operand = webnnGraphBuilder.Add(operand, webnnBias);
+				}
+
+				return Ptr<BackendNode>(new WebnnBackendNode(operand));
+			}
+#endif
+
+
+			void getScaleShift(Mat& scale, Mat& shift) const CV_OVERRIDE
+			{
+				scale = Mat();
+				shift = Mat();
+			}
+
+			//bool tryQuantize(const std::vector<std::vector<float> >& scales,
+			//	const std::vector<std::vector<int> >& zeropoints, LayerParams& params) CV_OVERRIDE
+			//{
+			//	params.set("input_scales", DictValue::arrayReal(scales[0].data(), scales[0].size()));
+			//	params.set("input_zeropoints", DictValue::arrayInt(zeropoints[0].data(), zeropoints[0].size()));
+			//	return true;
+			//}
+
+			virtual int64 getFLOPS(const std::vector<MatShape>& inputs,
+				const std::vector<MatShape>& outputs) const CV_OVERRIDE
+			{
+				CV_UNUSED(outputs); // suppress unused variable warning
+				long flops = 0;
+				for (int i = 0; i < inputs.size(); i++)
+				{
+					flops += 3 * total(inputs[i]);
+				}
+				return flops;
+			}
+
+			static Ptr<AxpyFastLayerImpl> create(const LayerParams& params)
+			{
+				return Ptr<AxpyFastLayerImpl>(new AxpyFastLayerImpl(params));
+			}
+		};
+
+	}  // namespace dnn
+}  // namespace cv
+
+# include <opencv2/dnn/layer.details.hpp>
+
+void reg2()
+{
+	CV_DNN_REGISTER_LAYER_CLASS(AxpyFast, cv::dnn::AxpyFastLayerImpl);
+}

waifu2x-caffe/slice_layer.cpp

@@ -0,0 +1,992 @@
+//#include "../precomp.hpp"
+//#include "../op_cuda.hpp"
+//#include "../op_inf_engine.hpp"
+//#include "../ie_ngraph.hpp"
+//#include "../op_cann.hpp"
+
+//#include "layers_common.hpp"
+#include <opencv2/dnn/all_layers.hpp>
+#include <opencv2/dnn/shape_utils.hpp>
+#include <opencv2/core/opencl/ocl_defs.hpp>
+
+#include <opencv2/core/utils/logger.hpp>
+#include <opencv2/core/utils/trace.hpp>
+
+#include <op_cuda.hpp>
+
+#ifdef HAVE_OPENCL
+#include "opencl_kernels_dnn.hpp"
+#endif
+
+#ifdef HAVE_CUDA
+#include <cuda4dnn/primitives/slice.hpp>
+using namespace cv::dnn::cuda4dnn;
+#endif
+
+namespace
+{
+	cv::Range normalizeRange(const cv::Range& input_range, int n)
+	{
+		cv::Range range = input_range;
+
+		if (range.start != n) {
+			range.start = std::min(std::max(range.start, -n), n - 1);
+			if (range.start < 0)
+			{
+				range.start += n;
+			}
+		}
+
+		range.end = std::min(std::max(range.end, -n), n);
+		if (range.end < 0)
+		{
+			range.end += n;
+		}
+
+		return range;
+	}
+
+	// TODO: support cv::Range with steps and negative steps to get rid of this transformation
+	void tranformForNegSteps(const cv::dnn::MatShape& inpShape, std::vector<std::vector<cv::Range> >& sliceRanges, std::vector<std::vector<int> >& sliceSteps)
+	{
+		// in case of negative steps,
+		// x of shape [5, 10], x[5:0:-1, 10:1:-3] <=> np.flip(x[1:5:1, 2:10:3], aixs=(0, 1))
+		// new_end_i = start_i + 1 > dim_i ? dim_i : start_i + 1
+		// new_start_i = end + 1
+		// new_start_i = new_end_i - 1 - ((new_end_i - 1 - new_start_i) / abs(step_i)) * abs(step_i)
+		int start, end, new_start, new_end, step;
+		for (int i = 0; i < sliceSteps[0].size(); ++i)
+		{
+			step = sliceSteps[0][i];
+			if (step > 0)
+				continue;
+
+			step = -step;
+			start = sliceRanges[0][i].start;
+			end = sliceRanges[0][i].end;
+			new_end = start >= inpShape[i] ? inpShape[i] : start + 1;
+			new_start = end + 1;
+			new_start = new_end - 1 - ((new_end - 1 - new_start) / step) * step;
+
+			sliceSteps[0][i] = step;
+			sliceRanges[0][i].start = new_start;
+			sliceRanges[0][i].end = new_end;
+		}
+	}
+
+	std::vector<std::vector<cv::Range> > finalizeSliceRange(const cv::dnn::MatShape& inpShape, int& axis,
+		const std::vector<std::vector<cv::Range> >& inputSliceRanges)
+	{
+		std::vector<std::vector<cv::Range> > sliceRanges = inputSliceRanges;
+		CV_Assert(inpShape.size() > 0);
+		bool axisNeg = (axis < 0);
+		axis = (axis + static_cast<int>(inpShape.size())) % inpShape.size();
+
+		for (size_t i = 0; i < sliceRanges.size(); ++i) {
+			std::vector<cv::Range>& ranges = sliceRanges[i];
+			if (axisNeg)
+			{
+				ranges.insert(ranges.begin(), axis, cv::Range::all());
+			}
+
+			for (size_t j = 0; j < ranges.size(); ++j)
+			{
+				int n = inpShape[j];
+				if (n <= 0)
+				{
+					continue;
+				}
+
+				ranges[j] = normalizeRange(ranges[j], n);
+			}
+		}
+
+		return sliceRanges;
+	}
+}
+
+namespace cv
+{
+	namespace dnn
+	{
+
+
+
+		class SliceLayerImpl : public SliceLayer
+		{
+		public:
+			SliceLayerImpl(const LayerParams& params)
+			{
+				setParamsFrom(params);
+				hasSteps = false;
+				axis = params.get<int>("axis", 1);
+				num_split = params.get<int>("num_split", 0);
+				hasDynamicShapes = params.get<bool>("has_dynamic_shapes", false);
+				shapesInitialized = !hasDynamicShapes;
+
+				if (params.has("slice_point"))
+				{
+					CV_Assert(!params.has("begin") && !params.has("size") && !params.has("end"));
+					const DictValue& indicesValue = params.get("slice_point");
+					int size = axis > 0 ? axis + 1 : 1;
+					sliceRanges.resize(indicesValue.size() + 1,
+						std::vector<Range>(size, Range::all()));
+					int prevSlice = 0;
+					for (int i = 0; i < indicesValue.size(); ++i)
+					{
+						sliceRanges[i][size - 1].start = prevSlice;
+						sliceRanges[i][size - 1].end = indicesValue.get<int>(i);
+						prevSlice = sliceRanges[i][size - 1].end;
+					}
+					sliceRanges.back()[size - 1].start = prevSlice;
+				}
+				else if (params.has("begin"))
+				{
+					CV_Assert(params.has("size") ^ params.has("end"));
+					const DictValue& begins = params.get("begin");
+					const DictValue& sizesOrEnds = params.has("size") ? params.get("size") : params.get("end");
+					CV_Assert(begins.size() == sizesOrEnds.size());
+
+					if (params.has("steps"))
+					{
+						const DictValue& steps = params.get("steps");
+						sliceSteps.resize(1);
+						sliceSteps[0].resize(steps.size());
+
+						for (int i = 0; i < steps.size(); ++i)
+						{
+							int step = steps.get<int>(i);
+							CV_Assert(step != 0);
+							if (step < 0)
+								neg_step_dims.push_back(i);
+							if (std::abs(step) > 1)
+								hasSteps = true;
+							sliceSteps[0][i] = step;
+						}
+					}
+
+					sliceRanges.resize(1);
+					sliceRanges[0].resize(begins.size(), Range::all());
+					for (int i = 0; i < begins.size(); ++i)
+					{
+						int start = begins.get<int>(i);
+						int sizeOrEnd = sizesOrEnds.get<int>(i);  // It may be negative to reverse indexation.
+
+						sliceRanges[0][i].start = start;
+						if (params.has("size"))
+						{
+							int size = sizeOrEnd;
+							CV_Assert(size == -1 || size > 0);  // -1 value means range [start, axis_size).
+							sliceRanges[0][i].end = size > 0 ? (start + size) : INT_MAX;  // We'll finalize a negative value later.
+						}
+						else
+						{
+							int end = sizeOrEnd;
+							if (hasSteps && !neg_step_dims.empty() && sliceSteps[0][i] < 0)
+								CV_Assert(end < 0 || end != start); // if current step is negative, end < start is allowed.
+							else
+								CV_Assert(end < 0 || end > start);  // End index is excluded.
+							sliceRanges[0][i].end = end;  // We'll finalize a negative value later.
+						}
+					}
+				}
+			}
+
+			virtual bool supportBackend(int backendId) CV_OVERRIDE
+			{
+#ifdef HAVE_INF_ENGINE
+				if (backendId == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
+					return sliceRanges.size() == 1 && neg_step_dims.empty();
+#endif
+#ifdef HAVE_CUDA
+				if (backendId == DNN_BACKEND_CUDA)
+					return !hasSteps && neg_step_dims.empty();
+#endif
+				return backendId == DNN_BACKEND_OPENCV || backendId == DNN_BACKEND_CANN;
+			}
+
+			bool getMemoryShapes(const std::vector<MatShape>& inputs,
+				const int requiredOutputs,
+				std::vector<MatShape>& outputs,
+				std::vector<MatShape>& internals) const CV_OVERRIDE
+			{
+				CV_Assert(inputs.size() == 1);
+				MatShape inpShape = inputs[0];
+
+				std::vector<std::vector<int> > sliceSteps_ = sliceSteps;
+				std::vector<std::vector<cv::Range> > sliceRanges_ = sliceRanges;
+				if (hasSteps && !neg_step_dims.empty())
+					tranformForNegSteps(inpShape, sliceRanges_, sliceSteps_);
+
+				int axis_rw = axis;
+				std::vector<std::vector<cv::Range> > sliceRanges_rw = finalizeSliceRange(inpShape, axis_rw, sliceRanges_);
+
+				if (!sliceRanges_rw.empty())
+				{
+					outputs.resize(sliceRanges_rw.size(), inpShape);
+					for (int i = 0; i < outputs.size(); ++i)
+					{
+						CV_Assert(sliceRanges_rw[i].size() <= inpShape.size());
+						for (int j = 0; j < sliceRanges_rw[i].size(); ++j)
+						{
+							if (shapesInitialized || inpShape[j] > 0)
+								outputs[i][j] = normalizeRange(sliceRanges_rw[i][j], inpShape[j]).size();
+
+							if (!sliceSteps_.empty() && (i < sliceSteps_.size()) && (j < sliceSteps_[i].size()) && (sliceSteps_[i][j] > 1))
+								outputs[i][j] = (outputs[i][j] + sliceSteps_[i][j] - 1) / sliceSteps_[i][j];
+						}
+					}
+				}
+				else  // Divide input blob on equal parts by axis.
+				{
+					CV_Assert(0 <= axis_rw && axis_rw < inpShape.size());
+					int splits = num_split ? num_split : requiredOutputs;
+					CV_Assert(splits > 0 && inpShape[axis_rw] % splits == 0);
+					inpShape[axis_rw] /= splits;
+					outputs.resize(splits, inpShape);
+				}
+				return false;
+			}
+
+			bool updateMemoryShapes(const std::vector<MatShape>& inputs) CV_OVERRIDE
+			{
+				shapesInitialized = true;
+				return true;
+			}
+
+			void finalize(InputArrayOfArrays inputs_arr, OutputArrayOfArrays outputs_arr) CV_OVERRIDE
+			{
+#ifdef HAVE_OPENCL
+				ocl_exec_cache.clear();
+#endif
+
+				std::vector<Mat> inputs, outputs;
+				inputs_arr.getMatVector(inputs);
+				outputs_arr.getMatVector(outputs);
+
+				CV_Assert(inputs.size() == 1);
+				MatShape inpShape = shape(inputs[0]);
+
+				if (hasSteps && !neg_step_dims.empty())
+					tranformForNegSteps(inpShape, sliceRanges, sliceSteps);
+
+				finalSliceRanges = finalizeSliceRange(shape(inputs[0]), axis, sliceRanges);
+
+				if (sliceRanges.empty())
+				{
+					// Divide input blob on equal parts by axis.
+					int outAxisSize = inpShape[axis] / outputs.size();
+					finalSliceRanges.resize(outputs.size(),
+						std::vector<Range>(axis + 1, Range::all()));
+					int prevSlice = 0;
+					for (int i = 0; i < outputs.size(); ++i)
+					{
+						finalSliceRanges[i][axis].start = prevSlice;
+						finalSliceRanges[i][axis].end = finalSliceRanges[i][axis].start + outAxisSize;
+						prevSlice = finalSliceRanges[i][axis].end;
+					}
+				}
+				else
+					CV_Assert(outputs.size() == sliceRanges.size());
+
+				for (int i = 0; i < outputs.size(); ++i)
+				{
+					CV_Assert(finalSliceRanges[i].size() <= inpShape.size());
+					// Fill the rest of ranges.
+					for (int j = finalSliceRanges[i].size(); j < inpShape.size(); ++j)
+					{
+						finalSliceRanges[i].push_back(Range::all());
+					}
+					// Clamp.
+					for (int j = 0; j < finalSliceRanges[i].size(); ++j)
+					{
+						finalSliceRanges[i][j] = normalizeRange(finalSliceRanges[i][j], inpShape[j]);
+					}
+				}
+
+				if (!sliceSteps.empty() && sliceSteps[0].size() != inputs[0].dims)
+					sliceSteps[0].resize(inputs[0].dims, 1);
+
+#if 0
+				std::cout << "DEBUG: DNN/Slice: " << outputs.size() << " inpShape=" << inpShape << std::endl;
+				for (int i = 0; i < outputs.size(); ++i)
+				{
+					for (int j = 0; j < finalSliceRanges[i].size(); ++j)
+					{
+						std::cout << finalSliceRanges[i][j];
+					}
+					std::cout << std::endl;
+				}
+#endif
+			}
+
+#ifdef HAVE_OPENCL
+			struct OpenCLExecInfo
+			{
+				std::string kernel_name;
+				std::string build_opts;
+				size_t local_size[2];
+				size_t global_size[2];
+
+				OpenCLExecInfo()
+				{
+					local_size[0] = local_size[1] = 0;
+					global_size[0] = global_size[1] = 0;
+				}
+			};
+			std::vector<OpenCLExecInfo> ocl_exec_cache;
+
+			void ocl_prepare(const std::vector<UMat>& inputs, const std::vector<UMat>& outputs)
+			{
+				CV_TRACE_FUNCTION();
+
+				CV_Assert(outputs.size() == finalSliceRanges.size());
+				ocl_exec_cache.resize(outputs.size());
+
+				const UMat& input = inputs[0];
+				const int dims = input.dims;
+
+				size_t WSZ = 128;
+
+				const int elemSize = (int)input.elemSize();
+				String opts0 = cv::format(
+					"-DDIMS=%d -DELEMSIZE=%d",
+					dims, elemSize
+				);
+				for (int d = 0; d < dims; d++)
+				{
+					opts0 += cv::format(" -DSRC_STEP_%d=%d", d, (int)input.step[dims - 1 - d]);
+				}
+				for (size_t i = 0; i < outputs.size(); i++)
+				{
+					OpenCLExecInfo& ocl = ocl_exec_cache[i];
+
+					const UMat& output = outputs[i];
+					const std::vector<Range>& range = finalSliceRanges[i];
+
+					String opts = opts0;
+
+					CV_CheckEQ(output.dims, dims, "");
+					for (int d = 0; d < dims; d++)
+					{
+						opts += cv::format(" -DDST_STEP_%d=%d -DDST_SZ_%d=%d -DSRC_START_%d=%d",
+							d, (int)output.step[dims - 1 - d],
+							d, (int)output.size[dims - 1 - d],
+							d, (int)range[dims - 1 - d].start
+						);
+						CV_CheckEQ(range[d].size(), (int)output.size[d], "");
+					}
+
+					const size_t param_LIMIT_BLOCK_SIZE_PER_WG = WSZ * 64;
+
+					int block_dims = 0;
+					size_t block_size = elemSize;
+					for (int i = dims - 1; i >= 0; --i)
+					{
+						if (input.step[i] != output.step[i])
+							break;
+						block_size *= output.size[i];
+						block_dims++;
+						if (block_size >= param_LIMIT_BLOCK_SIZE_PER_WG)
+							break;
+					}
+
+					const size_t total = output.total() * elemSize;
+					size_t num_blocks = total / block_size;
+
+					if ((num_blocks <= 8 && block_size >= WSZ * 4) || (block_size >= param_LIMIT_BLOCK_SIZE_PER_WG))
+					{
+						// use 1D copy mode
+						opts += cv::format(" -DUSE_COPY_1D=1");
+
+						opts += cv::format(" -DBLOCK_DIMS=%d", block_dims);
+						opts += cv::format(" -DBLOCK_DIMS_CONTIGUOUS=%d", block_dims);
+						opts += cv::format(" -DBLOCK_SIZE=%d", (int)block_size);
+
+						opts += cv::format(" -DBLOCK_COLS=%d", (int)block_size);
+					}
+					else
+					{
+						// use 2D copy mode
+						int block_cols = block_size;
+						int block_dims_contiguous = block_dims;
+						size_t input_base_step = input.step[dims - 1 - block_dims_contiguous];
+						size_t output_base_step = output.step[dims - 1 - block_dims_contiguous];
+
+						size_t block_rows = 1;
+						for (int i = dims - 1 - block_dims_contiguous; i >= 0; --i)
+						{
+							if (input.step[i] * output_base_step != output.step[i] * input_base_step)
+								break;
+							block_rows *= output.size[i];
+							block_dims++;
+						}
+
+						block_size *= block_rows;
+
+						num_blocks = total / block_size;
+
+						if (block_rows > 1)
+						{
+							opts += cv::format(" -DBLOCK_DIMS=%d", block_dims);
+							opts += cv::format(" -DBLOCK_DIMS_CONTIGUOUS=%d", block_dims_contiguous);
+							opts += cv::format(" -DBLOCK_SIZE=%d", (int)block_size);
+
+							opts += cv::format(" -DBLOCK_COLS=%d", (int)block_cols);
+
+							opts += cv::format(" -DBLOCK_ROWS=%d", (int)block_rows);
+							opts += cv::format(" -DBLOCK_SRC_STRIDE=%d", (int)input_base_step);
+						}
+						else
+						{
+							// use 1D copy mode
+							opts += cv::format(" -DUSE_COPY_1D=1");
+
+							opts += cv::format(" -DBLOCK_DIMS=%d", block_dims_contiguous);
+							opts += cv::format(" -DBLOCK_DIMS_CONTIGUOUS=%d", block_dims_contiguous);
+							opts += cv::format(" -DBLOCK_SIZE=%d", (int)block_size);
+
+							opts += cv::format(" -DBLOCK_COLS=%d", (int)block_size);
+						}
+					}
+
+					const size_t MIN_WORK_ITEMS = 16;
+					if (block_size <= 4 * MIN_WORK_ITEMS)
+						WSZ = 4;
+					else if (block_size <= 8 * MIN_WORK_ITEMS)
+						WSZ = 8;
+					else if (block_size <= 16 * MIN_WORK_ITEMS)
+						WSZ = 16;
+					else if (block_size <= 32 * MIN_WORK_ITEMS)
+						WSZ = 32;
+					else if (block_size <= 64 * MIN_WORK_ITEMS)
+						WSZ = 64;
+
+					opts += cv::format(" -DWSZ=%d", (int)WSZ);
+
+					std::ostringstream kernel_suffix;
+					kernel_suffix << dims << 'x' << elemSize << "_bsz" << block_size;
+					kernel_suffix << "__src_";
+					for (int d = 0; d < dims; d++)
+					{
+						kernel_suffix << input.size[dims - 1 - d] << '_';
+					}
+					kernel_suffix << '_';
+					/*for (int d = 0; d < dims; d++)
+					{
+						kernel_suffix << input.step[dims - 1 - d] << '_';
+					}
+					kernel_suffix << '_';*/
+
+					kernel_suffix << "dst_";
+					for (int d = 0; d < dims; d++)
+					{
+						kernel_suffix << output.size[dims - 1 - d] << '_';
+					}
+					/*kernel_suffix << '_';
+					for (int d = 0; d < dims; d++)
+					{
+						kernel_suffix << output.step[dims - 1 - d] << '_';
+					}*/
+					kernel_suffix << "_slice_";
+					for (int d = 0; d < dims; d++)
+					{
+						kernel_suffix << range[dims - 1 - d].start << '_';
+					}
+					for (int d = 0; d < dims; d++)
+					{
+						kernel_suffix << '_' << range[dims - 1 - d].end;
+					}
+
+					std::string kernel_suffix_str = kernel_suffix.str();
+					opts += cv::format(" -DSLICE_KERNEL_SUFFIX=%s", kernel_suffix_str.c_str());
+
+					ocl.kernel_name = cv::format("slice_%s", kernel_suffix_str.c_str());
+					ocl.build_opts = opts;
+					ocl.local_size[0] = WSZ;
+					ocl.local_size[1] = 1;
+					ocl.global_size[0] = WSZ;
+					ocl.global_size[1] = num_blocks;
+				}  // for outputs.size()
+			}  // ocl_prepare
+
+			bool forward_ocl(InputArrayOfArrays inputs_, OutputArrayOfArrays outputs_, OutputArrayOfArrays internals_)
+			{
+				CV_TRACE_FUNCTION();
+
+				if (hasSteps)
+					return false;  // TODO not implemented yet: https://github.com/opencv/opencv/pull/19546
+
+				std::vector<UMat> inputs;
+				std::vector<UMat> outputs;
+
+				inputs_.getUMatVector(inputs);
+				outputs_.getUMatVector(outputs);
+
+				CV_Assert(outputs.size() == finalSliceRanges.size());
+
+				const UMat& input = inputs[0];
+				const int dims = input.dims;
+				if (dims > 5)
+				{
+					CV_LOG_INFO(NULL, "DNN/OpenCL/Slice: implementation doesn't support dims=" << dims << ". Fallback to CPU");
+					return false;
+				}
+
+				if (ocl_exec_cache.empty())
+				{
+					ocl_prepare(inputs, outputs);
+				}
+				CV_CheckEQ(ocl_exec_cache.size(), outputs.size(), "");
+
+				for (size_t i = 0; i < outputs.size(); i++)
+				{
+					const OpenCLExecInfo& ocl = ocl_exec_cache[i];
+
+					UMat& output = outputs[i];
+
+					ocl::Kernel kernel(ocl.kernel_name.c_str(), ocl::dnn::slice_oclsrc, ocl.build_opts);
+					if (kernel.empty())
+						return false;
+					bool ret = kernel.args(
+						ocl::KernelArg::PtrReadOnly(input),
+						ocl::KernelArg::PtrWriteOnly(output)
+					)
+						.run_(2, (size_t*)ocl.global_size, (size_t*)ocl.local_size, false);
+					if (!ret)
+						return false;
+				}  // for outputs.size()
+
+				return true;
+			}  // forward_ocl
+#endif
+
+			void forward(InputArrayOfArrays inputs_arr, OutputArrayOfArrays outputs_arr, OutputArrayOfArrays internals_arr) CV_OVERRIDE
+			{
+				CV_TRACE_FUNCTION();
+				CV_TRACE_ARG_VALUE(name, "name", name.c_str());
+
+				CV_OCL_RUN(IS_DNN_OPENCL_TARGET(preferableTarget),
+					forward_ocl(inputs_arr, outputs_arr, internals_arr))
+
+					std::vector<Mat> inputs, outputs;
+				inputs_arr.getMatVector(inputs);
+				outputs_arr.getMatVector(outputs);
+
+				const Mat& inpMat = inputs[0];
+				CV_Assert(outputs.size() == finalSliceRanges.size());
+
+				if (!hasSteps)
+				{
+					for (size_t i = 0; i < outputs.size(); i++)
+					{
+						if (finalSliceRanges[i][0].start != finalSliceRanges[i][0].end) {
+							inpMat(finalSliceRanges[i]).copyTo(outputs[i]);
+						}
+					}
+				}
+				else
+				{
+					int dimsNum = inpMat.dims;
+
+					for (size_t i = 0; i < outputs.size(); i++)
+					{
+						std::vector<int> inpIdx(dimsNum, 0);
+						std::vector<int> outIdx(dimsNum, 0);
+						if (inpMat.type() == CV_16F)
+							getSliceRecursive<int16_t>(inpMat, inpIdx, finalSliceRanges[i], sliceSteps[i], 0, dimsNum, outputs[i], outIdx);
+						else if (inpMat.type() == CV_8S)
+							getSliceRecursive<int8_t>(inpMat, inpIdx, finalSliceRanges[i], sliceSteps[i], 0, dimsNum, outputs[i], outIdx);
+						else
+							getSliceRecursive<float>(inpMat, inpIdx, finalSliceRanges[i], sliceSteps[i], 0, dimsNum, outputs[i], outIdx);
+						// flip for negative steps
+						flip(outputs[i]);
+					}
+				}
+			}
+
+#ifdef HAVE_CANN
+			virtual Ptr<BackendNode> initCann(const std::vector<Ptr<BackendWrapper> >& inputs,
+				const std::vector<Ptr<BackendWrapper> >& outputs,
+				const std::vector<Ptr<BackendNode> >& nodes) CV_OVERRIDE
+			{
+				bool isSplit = sliceRanges.size() > 1;
+				auto x = inputs[0].dynamicCast<CannBackendWrapper>();
+
+				if (isSplit)
+				{
+					// create operator
+					auto op = std::make_shared<ge::op::SplitV>(name);
+
+					// set attr
+					int n_split = static_cast<int>(outputs.size());
+					op->set_attr_num_split(n_split);
+
+					// set inputs
+					// set inputs : x
+					auto op_x = nodes[0].dynamicCast<CannBackendNode>()->getOp();
+					op->set_input_x_by_name(*op_x, x->name.c_str());
+					auto desc_x = x->getTensorDesc();
+					op->update_input_desc_x(*desc_x);
+					// set inputs : size_splits
+					std::vector<int> size_splits(n_split);
+					int cnt_split = 0;
+					for (size_t i = 0; i < sliceRanges.size() - 1; ++i)
+					{
+						auto target_range = sliceRanges[i].back();
+						size_splits[i] = target_range.end - target_range.start;
+						cnt_split += size_splits[i];
+					}
+					auto shape_x = desc_x->GetShape().GetDims();
+					CV_CheckGT(shape_x[axis], cnt_split, "DNN/CANN: invalid splits");
+					size_splits[n_split - 1] = shape_x[axis] - cnt_split;
+					std::vector<int> shape_size_splits{ (int)size_splits.size() };
+					Mat size_splits_mat(shape_size_splits, CV_32S, size_splits.data());
+					auto op_const_size_splits = std::make_shared<CannConstOp>(size_splits_mat.data, size_splits_mat.type(), shape_size_splits, cv::format("%s_size_splits", name.c_str()));
+					op->set_input_size_splits(*(op_const_size_splits->getOp()));
+					op->update_input_desc_size_splits(*(op_const_size_splits->getTensorDesc()));
+					// set inputs : split_dim
+					Mat split_dim_mat(1, 1, CV_32S, Scalar(axis));
+					std::vector<int> split_dim_shape{ 1 };
+					auto op_const_split_dim = std::make_shared<CannConstOp>(split_dim_mat.data, split_dim_mat.type(), split_dim_shape, cv::format("%s_split_dim", name.c_str()));
+					op->set_input_split_dim(*(op_const_split_dim->getOp()));
+					op->update_input_desc_split_dim(*(op_const_split_dim->getTensorDesc()));
+
+					// set outputs
+					op->create_dynamic_output_y(n_split);
+					for (uint32_t i = 0; i < n_split; ++i)
+					{
+						auto desc_output_y_i = std::make_shared<ge::TensorDesc>(ge::Shape(), ge::FORMAT_NCHW, ge::DT_FLOAT);
+						op->update_dynamic_output_desc_y(i, *desc_output_y_i);
+					}
+
+					return Ptr<BackendNode>(new CannBackendNode(op));
+				}
+
+				// ONNX-Slice
+				CV_CheckEQ(sliceRanges.size(), (size_t)1, "");
+				if (hasSteps)
+				{
+					CV_CheckEQ(sliceSteps.size(), (size_t)1, "DNN/CANN/Slice: no support to multiple slices");
+					CV_CheckEQ(sliceRanges[0].size(), sliceSteps[0].size(), "DNN/CANN/Slice: number of slice ranges does not match number of slice steps");
+				}
+
+				const int dims = x->host->dims;
+
+				// create operator
+				auto op = std::make_shared<ge::op::StridedSliceV2>(name);
+
+				// retrieve begins, ends, axes and steps
+				std::vector<int> begins, ends, axes, steps;
+				for (int i = 0; i < sliceRanges[0].size(); i++)
+				{
+					begins.push_back(sliceRanges[0][i].start);
+					ends.push_back(sliceRanges[0][i].end);
+					axes.push_back(i);
+					if (hasSteps)
+						steps.push_back(sliceSteps[0][i]);
+					else
+						steps.push_back(1); // put 1 by default
+				}
+				std::vector<int> shape_{ dims };
+
+				// set inputs
+				// set inputs : x
+				auto op_x = nodes[0].dynamicCast<CannBackendNode>()->getOp();
+				op->set_input_x_by_name(*op_x, x->name.c_str());
+				auto x_desc = x->getTensorDesc();
+				op->update_input_desc_x(*x_desc);
+				// set inputs : begin
+				Mat begin_mat(shape_, CV_32S, &begins[0]);
+				auto op_const_begin = std::make_shared<CannConstOp>(begin_mat.data, begin_mat.type(), shape_, cv::format("%s_begin", name.c_str()));
+				op->set_input_begin(*(op_const_begin->getOp()));
+				op->update_input_desc_begin(*(op_const_begin->getTensorDesc()));
+				// set inputs : end
+				Mat end_mat(shape_, CV_32S, &ends[0]);
+				auto op_const_end = std::make_shared<CannConstOp>(end_mat.data, end_mat.type(), shape_, cv::format("%s_end", name.c_str()));
+				op->set_input_end(*(op_const_end->getOp()));
+				op->update_input_desc_end(*(op_const_end->getTensorDesc()));
+				// set inputs : axes
+				Mat axes_mat(shape_, CV_32S, &axes[0]);
+				auto op_const_axes = std::make_shared<CannConstOp>(axes_mat.data, axes_mat.type(), shape_, cv::format("%s_axes", name.c_str()));
+				op->set_input_axes(*(op_const_axes->getOp()));
+				op->update_input_desc_axes(*(op_const_axes->getTensorDesc()));
+				// set inputs : strides
+				Mat strides_mat(shape_, CV_32S, &steps[0]);
+				auto op_const_strides = std::make_shared<CannConstOp>(strides_mat.data, strides_mat.type(), shape_, cv::format("%s_strides", name.c_str()));
+				op->set_input_strides(*(op_const_strides->getOp()));
+				op->update_input_desc_strides(*(op_const_strides->getTensorDesc()));
+
+				// set outputs
+				auto output_desc = std::make_shared<ge::TensorDesc>(ge::Shape(), ge::FORMAT_NCHW, ge::DT_FLOAT);
+				op->update_output_desc_y(*output_desc);
+
+				return Ptr<BackendNode>(new CannBackendNode(op));
+			}
+#endif
+
+#ifdef HAVE_DNN_NGRAPH
+			virtual Ptr<BackendNode> initNgraph(const std::vector<Ptr<BackendWrapper> >& inputs,
+				const std::vector<Ptr<BackendNode> >& nodes) CV_OVERRIDE
+			{
+				CV_Assert_N(nodes.size() <= 2);
+				auto& ieInpNode = nodes[0].dynamicCast<InfEngineNgraphNode>()->node;
+				CV_Assert(finalSliceRanges[0].size() == ieInpNode.get_shape().size());
+
+				std::vector<int64_t> offsets, dims, steps;
+				for (int i = 0; i < finalSliceRanges[0].size(); ++i)
+				{
+					offsets.push_back(finalSliceRanges[0][i].start);
+					dims.push_back(finalSliceRanges[0][i].end);
+				}
+				if (hasSteps)
+					steps = std::vector<int64_t>(sliceSteps[0].begin(), sliceSteps[0].end());
+				else
+					steps = std::vector<int64_t>((int64_t)dims.size(), 1);
+
+				auto lower_bounds = std::make_shared<ov::op::v0::Constant>(ov::element::i64,
+					ov::Shape{ offsets.size() }, offsets.data());
+				auto upper_bounds = std::make_shared<ov::op::v0::Constant>(ov::element::i64,
+					ov::Shape{ dims.size() }, dims.data());
+				auto strides = std::make_shared<ov::op::v0::Constant>(ov::element::i64,
+					ov::Shape{ dims.size() }, steps);
+
+				auto slice = std::make_shared<ov::op::v1::StridedSlice>(ieInpNode,
+					lower_bounds, upper_bounds, strides, std::vector<int64_t>{}, std::vector<int64_t>{});
+
+				return Ptr<BackendNode>(new InfEngineNgraphNode(slice));
+			}
+#endif  // HAVE_DNN_NGRAPH
+
+
+#ifdef HAVE_CUDA
+			Ptr<BackendNode> initCUDA(
+				void* context_,
+				const std::vector<Ptr<BackendWrapper>>& inputs,
+				const std::vector<Ptr<BackendWrapper>>& outputs
+			) override
+			{
+				auto context = reinterpret_cast<csl::CSLContext*>(context_);
+
+				std::vector<std::vector<std::size_t>> offsets;
+				for (const auto& ranges : finalSliceRanges)
+				{
+					std::vector<std::size_t> offsets_i;
+					for (const auto& range : ranges)
+						offsets_i.push_back(range.start);
+					offsets.push_back(std::move(offsets_i));
+				}
+
+				return make_cuda_node<cuda4dnn::SliceOp>(preferableTarget, std::move(context->stream), std::move(offsets));
+			}
+#endif
+
+			bool tryQuantize(const std::vector<std::vector<float> >& scales,
+				const std::vector<std::vector<int> >& zeropoints, LayerParams& params) CV_OVERRIDE
+			{
+				const int numOutputs = scales[1].size();
+				for (int i = 0; i < numOutputs; i++)
+				{
+					if (scales[1][i] != scales[0][0])
+						return false;
+				}
+				return true;
+			}
+
+		private:
+			template <typename T>
+			void getSliceRecursive(const Mat& inpMat, std::vector<int>& inpIdx,
+				const std::vector<Range>& sliceRanges,
+				const std::vector<int>& sliceSteps, int dim, int dimsNum,
+				Mat& outputs, std::vector<int>& outIdx)
+			{
+				int begin = sliceRanges[dim].start;
+				int end = sliceRanges[dim].end;
+				int step = !sliceSteps.empty() ? sliceSteps[dim] : 1;
+
+				// TODO optimization is required (for 2D tail case at least)
+				for (int k = begin, j = 0; k < end; k += step, j++)
+				{
+					inpIdx[dim] = k;
+					outIdx[dim] = j;
+
+					if (dim + 1 < dimsNum)
+						getSliceRecursive<T>(inpMat, inpIdx, sliceRanges, sliceSteps, dim + 1, dimsNum, outputs, outIdx);
+					else
+						outputs.at<T>(outIdx.data()) = inpMat.at<T>(inpIdx.data());
+				}
+			}
+
+			void flip(Mat& output) // break if 1d tensor?
+			{
+				for (int i = 0; i < neg_step_dims.size(); ++i)
+					cv::flipND(output, output, neg_step_dims[i]);
+			}
+		protected:
+			// The actual non-negative values determined from @p sliceRanges depends on input size.
+			std::vector<std::vector<Range> > finalSliceRanges;
+			std::vector<int> neg_step_dims;
+			bool hasDynamicShapes;
+			bool shapesInitialized;
+			bool hasSteps;
+		};
+
+		class CropCenterLayerImpl CV_FINAL : public SliceLayerImpl
+		{
+		public:
+			CropCenterLayerImpl(const LayerParams& params) : SliceLayerImpl(LayerParams())
+			{
+				setParamsFrom(params);
+				axis = params.get<int>("axis", 2);
+				const DictValue* paramOffset = params.ptr("offset");
+
+				if (paramOffset)
+				{
+					for (int i = 0; i < paramOffset->size(); i++)
+						offset.push_back(paramOffset->get<int>(i));
+				}
+
+				if (params.has("crop_size"))
+				{
+					const auto& paramCropSize = params.get("crop_size");
+					const auto& str = paramCropSize.getStringValue();
+
+					const int s = atoi(str.c_str());
+					offset.resize(4);
+					offset[0] = 0;
+					offset[1] = 0;
+					offset[2] = s;
+					offset[3] = s;
+
+					axis = 0;
+				}
+			}
+
+			bool getMemoryShapes(const std::vector<MatShape>& inputs,
+				const int requiredOutputs,
+				std::vector<MatShape>& outputs,
+				std::vector<MatShape>& internals) const CV_OVERRIDE
+			{
+				//CV_Assert(inputs.size() == 2);
+
+				//MatShape dstShape = inputs[0];
+				//int start = normalize_axis(axis, dstShape);
+				//for (int i = start; i < dstShape.size(); i++)
+				//{
+				//	dstShape[i] = inputs[1][i];
+				//}
+				//outputs.resize(1, dstShape);
+
+				MatShape dstShape = inputs[0];
+				int start = normalize_axis(axis, dstShape);
+				for (int i = start; i < dstShape.size(); i++)
+				{
+					dstShape[i] = dstShape[i] - offset[i] * 2;
+				}
+				outputs.resize(1, dstShape);
+
+				return false;
+			}
+
+			void finalize(InputArrayOfArrays inputs_arr, OutputArrayOfArrays) CV_OVERRIDE
+			{
+				//std::vector<Mat> inputs;
+				//inputs_arr.getMatVector(inputs);
+				//CV_Assert(2 == inputs.size());
+
+				//const Mat& inpBlob = inputs[0];
+				//const Mat& inpSzBlob = inputs[1];
+
+				//int dims = inpBlob.dims;
+				//int start_axis = normalize_axis(axis, dims);
+
+				//std::vector<int> offset_final(dims, 0);
+				//if (offset.size() == 1)
+				//{
+				//	for (int i = start_axis; i < dims; i++)
+				//		offset_final[i] = offset[0];
+				//}
+				//else if (offset.size() > 1)
+				//{
+				//	if ((int)offset.size() != dims - start_axis)
+				//		CV_Error(Error::StsBadArg, "number of offset values specified must be "
+				//			"equal to the number of dimensions following axis.");
+
+				//	for (int i = start_axis; i < dims; i++)
+				//		offset_final[i] = offset[i - start_axis];
+				//}
+
+				//finalSliceRanges.resize(1);
+				//finalSliceRanges[0].resize(dims);
+				//for (int i = 0; i < start_axis; i++)
+				//{
+				//	finalSliceRanges[0][i] = Range(0, inpBlob.size[i]);
+				//}
+				//for (int i = start_axis; i < dims; i++)
+				//{
+				//	if (offset_final[i] < 0 || offset_final[i] + inpSzBlob.size[i] > inpBlob.size[i])
+				//		CV_Error(Error::StsBadArg, "invalid crop parameters or blob sizes");
+
+				//	finalSliceRanges[0][i] = Range(offset_final[i], offset_final[i] + inpSzBlob.size[i]);
+				//}
+
+
+				std::vector<Mat> inputs;
+				inputs_arr.getMatVector(inputs);
+				CV_Assert(1 == inputs.size());
+
+				const Mat& inpBlob = inputs[0];
+
+				int dims = inpBlob.dims;
+				int start_axis = normalize_axis(axis, dims);
+
+				std::vector<int> offset_final(dims, 0);
+				if (offset.size() == 1)
+				{
+					for (int i = start_axis; i < dims; i++)
+						offset_final[i] = offset[0];
+				}
+				else if (offset.size() > 1)
+				{
+					if ((int)offset.size() != dims - start_axis)
+						CV_Error(Error::StsBadArg, "number of offset values specified must be "
+							"equal to the number of dimensions following axis.");
+
+					for (int i = start_axis; i < dims; i++)
+						offset_final[i] = offset[i - start_axis];
+				}
+
+				finalSliceRanges.resize(1);
+				finalSliceRanges[0].resize(dims);
+				for (int i = 0; i < start_axis; i++)
+				{
+					finalSliceRanges[0][i] = Range(0, inpBlob.size[i]);
+				}
+				for (int i = start_axis; i < dims; i++)
+				{
+					int w = inpBlob.size[i] - offset_final[i] * 2;
+					if (offset_final[i] < 0 || w < 0)
+						CV_Error(Error::StsBadArg, "invalid crop parameters or blob sizes");
+
+					finalSliceRanges[0][i] = Range(offset_final[i], offset_final[i] + w);
+				}
+			}
+
+			static cv::Ptr<cv::dnn::Layer> create(cv::dnn::LayerParams& params)
+			{
+				return cv::Ptr<CropCenterLayerImpl>(new CropCenterLayerImpl(params));
+			}
+
+		private:
+			std::vector<int> offset;
+		};
+
+	}
+}
+
+# include <opencv2/dnn/layer.details.hpp>
+
+void reg()
+{
+	CV_DNN_REGISTER_LAYER_CLASS(CropCenter, cv::dnn::CropCenterLayerImpl);
+}

waifu2x-caffe/waifu2x-caffe.vcxproj

@@ -14,19 +14,19 @@
     <ProjectGuid>{7C406EE4-2309-4D4C-98BB-CB7BA865FC41}</ProjectGuid>
     <Keyword>Win32Proj</Keyword>
     <RootNamespace>waifu2x-caffe</RootNamespace>
-    <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v143</PlatformToolset>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v143</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
@@ -42,15 +42,15 @@
   <PropertyGroup Label="UserMacros" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <LinkIncremental>true</LinkIncremental>
-    <IncludePath>$(CUDA_PATH_V11_0)\include;$(SolutionDir)lib\include;$(USERPROFILE)\.caffe\dependencies\libraries_v140_x64_py27_1.1.0\libraries\include;$(USERPROFILE)\.caffe\dependencies\libraries_v140_x64_py27_1.1.0\libraries\include\boost-1_61;$(SolutionDir)rapidjson\include;$(SolutionDir)stb;$(SolutionDir)include;$(SolutionDir)msgpack-c\include;$(IncludePath)</IncludePath>
+    <IncludePath>$(CUDA_PATH_V13_0)\include;$(SolutionDir)lib\include;$(SolutionDir)lib\include\opencv2;$(SolutionDir)rapidjson\include;$(SolutionDir)stb;$(SolutionDir)include;$(SolutionDir)msgpack-c\include;$(SolutionDir)opencv\modules\dnn\src;$(IncludePath)</IncludePath>
-    <LibraryPath>$(CUDA_PATH_V11_0)\lib\$(PlatformName);$(SolutionDir)lib\$(PlatformName)\vc15\staticlib;$(SolutionDir)lib\lib;$(USERPROFILE)\.caffe\dependencies\libraries_v140_x64_py27_1.1.0\libraries\lib;$(LibraryPath)</LibraryPath>
+    <LibraryPath>$(CUDA_PATH_V13_0)\lib\$(PlatformName);$(SolutionDir)lib\$(PlatformName)\vc17\staticlib;$(SolutionDir)lib\lib;$(LibraryPath)</LibraryPath>
     <OutDir>$(SolutionDir)bin\</OutDir>
     <TargetName>$(ProjectName)d</TargetName>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <LinkIncremental>false</LinkIncremental>
-    <IncludePath>$(CUDA_PATH_V11_0)\include;$(SolutionDir)lib\include;$(USERPROFILE)\.caffe\dependencies\libraries_v140_x64_py27_1.1.0\libraries\include;$(USERPROFILE)\.caffe\dependencies\libraries_v140_x64_py27_1.1.0\libraries\include\boost-1_61;$(SolutionDir)rapidjson\include;$(SolutionDir)stb;$(SolutionDir)include;$(SolutionDir)msgpack-c\include;$(IncludePath)</IncludePath>
+    <IncludePath>$(CUDA_PATH_V13_0)\include;$(SolutionDir)lib\include;$(SolutionDir)lib\include\opencv2;$(SolutionDir)rapidjson\include;$(SolutionDir)stb;$(SolutionDir)include;$(SolutionDir)msgpack-c\include;$(SolutionDir)opencv\modules\dnn\src;$(IncludePath)</IncludePath>
-    <LibraryPath>$(CUDA_PATH_V11_0)\lib\$(PlatformName);$(SolutionDir)lib\$(PlatformName)\vc15\staticlib;$(SolutionDir)lib\lib;$(USERPROFILE)\.caffe\dependencies\libraries_v140_x64_py27_1.1.0\libraries\lib;$(LibraryPath)</LibraryPath>
+    <LibraryPath>$(CUDA_PATH_V13_0)\lib\$(PlatformName);$(SolutionDir)lib\$(PlatformName)\vc17\staticlib;$(SolutionDir)lib\lib;$(LibraryPath)</LibraryPath>
     <OutDir>$(SolutionDir)bin\</OutDir>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
@@ -59,8 +59,9 @@
       </PrecompiledHeader>
       <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
-      <PreprocessorDefinitions>BOOST_ALL_NO_LIB;WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING;WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <LanguageStandard>stdcpp17</LanguageStandard>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
@@ -77,8 +78,9 @@
       <Optimization>MaxSpeed</Optimization>
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
-      <PreprocessorDefinitions>BOOST_ALL_NO_LIB;WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING;WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <LanguageStandard>stdcpp17</LanguageStandard>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
@@ -90,15 +92,31 @@
     </Link>
   </ItemDefinitionGroup>
   <ItemGroup>
-    <ClCompile Include="..\common\cNet.cpp" />
+    <ClCompile Include="..\common\cNet.cpp">
-    <ClCompile Include="..\common\stImage.cpp" />
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
-    <ClCompile Include="..\common\waifu2x.cpp" />
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
-    <ClCompile Include="Source.cpp" />
+    </ClCompile>
+    <ClCompile Include="..\common\stImage.cpp">
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
+    </ClCompile>
+    <ClCompile Include="..\common\waifu2x.cpp">
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
+    </ClCompile>
+    <ClCompile Include="axpy_fast_layer.cpp" />
+    <ClCompile Include="slice_layer.cpp" />
+    <ClCompile Include="Source.cpp">
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
+    </ClCompile>
+    <ClCompile Include="Test.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\common\cNet.h" />
     <ClInclude Include="..\common\stImage.h" />
     <ClInclude Include="..\common\waifu2x.h" />
+    <ClInclude Include="axpy.hpp" />
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">

waifu2x-caffe/waifu2x-caffe.vcxproj.filters

@@ -30,6 +30,15 @@
     <ClCompile Include="..\common\stImage.cpp">
       <Filter>common</Filter>
     </ClCompile>
+    <ClCompile Include="Test.cpp">
+      <Filter>ソース ファイル</Filter>
+    </ClCompile>
+    <ClCompile Include="slice_layer.cpp">
+      <Filter>ソース ファイル</Filter>
+    </ClCompile>
+    <ClCompile Include="axpy_fast_layer.cpp">
+      <Filter>ソース ファイル</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\common\waifu2x.h">
@@ -41,5 +50,8 @@
     <ClInclude Include="..\common\stImage.h">
       <Filter>common</Filter>
     </ClInclude>
+    <ClInclude Include="axpy.hpp">
+      <Filter>ソース ファイル</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>