Upload 66 files

.dockerignore

@@ -0,0 +1,6 @@
+*.ipynb
+
+model/*.pth
+
+temp_colorization/
+__pycache__/

.gitignore

@@ -0,0 +1,10 @@
+*.ipynb
+*.pth
+*.zip
+
+__pycache__/
+temp_colorization/
+
+static/temp_images/*
+
+!.gitkeep

Dockerfile

@@ -0,0 +1,11 @@
+FROM pytorch/pytorch:1.6.0-cuda10.1-cudnn7-runtime
+
+RUN apt-get update && apt-get install -y libglib2.0-0  libsm6 libxext6 libxrender-dev
+
+COPY . .
+
+RUN pip install --no-cache-dir -r ./requirements.txt
+
+EXPOSE 5000
+
+CMD gunicorn --timeout 200 -w 3 -b 0.0.0.0:5000 drawing:app

configs/train_config.json

@@ -0,0 +1,10 @@
+{
+    "generator_lr" : 1e-4,
+    "discriminator_lr" : 4e-4,
+    "epochs" : 3,
+    "lr_decrease_epoch" : 10,
+    "finetuning_generator_lr" : 1e-6,
+    "finetuning_iterations" : 3500,
+    "batch_size" : 5,
+    "number_of_mults" : 3
+}

configs/xdog_config.json

@@ -0,0 +1,8 @@
+{
+    "sigma" : 0.5,
+     "k" : 8,
+     "phi" : 89.25,
+     "gamma" : 0.95,
+     "eps" : -0.1,
+     "mult" : 7
+}

dataset/datasets.py

@@ -0,0 +1,104 @@
+import torch
+import os
+import torchvision.transforms as transforms
+import matplotlib.pyplot as plt
+import numpy as np
+
+from utils.utils import generate_mask
+
+class TrainDataset(torch.utils.data.Dataset):
+    def __init__(self, data_path, transform=None, mults_amount=1):
+        self.data = os.listdir(os.path.join(data_path, 'color'))
+        self.data_path = data_path
+        self.transform = transform
+        self.mults_amount = mults_amount
+        self.ToTensor = transforms.ToTensor()
+
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self, idx):
+        image_name = self.data[idx]
+
+        if self.mults_amount > 1:
+            mult_number = np.random.choice(range(self.mults_amount))
+            bw_name = image_name[:image_name.rfind('.')] + '_{}.png'.format(mult_number)
+            dfm_name = image_name[:image_name.rfind('.')] + '_{}_dfm.png'.format(mult_number)
+        else:
+            bw_name = image_name
+            dfm_name = os.path.splitext(image_name)[0] + '_dfm.png'
+
+        # Resto del código permanece igual...
+
+        bw_img = np.expand_dims(plt.imread(os.path.join(self.data_path, 'bw', bw_name), 0))  # Load as grayscale
+        dfm_img = np.expand_dims(plt.imread(os.path.join(self.data_path, 'bw', dfm_name), 0))  # Load as grayscale
+
+        # Concatenate bw and dfm channels
+        bw_dfm_img = np.concatenate([bw_img, dfm_img], axis=2)
+
+        color_img = plt.imread(os.path.join(self.data_path, 'color', image_name))
+        if self.transform:
+            result = self.transform(image=color_img, mask=bw_dfm_img)
+            color_img = result['image']
+            bw_dfm_img = result['mask']
+
+        dfm_img = bw_dfm_img[:, :, 1]
+        bw_img = bw_dfm_img[:, :, 0]
+
+        color_img = self.ToTensor(color_img)
+        bw_img = self.ToTensor(bw_img)
+        dfm_img = self.ToTensor(dfm_img)
+
+        color_img = (color_img - 0.5) / 0.5
+
+        mask = generate_mask(bw_img.shape[1], bw_img.shape[2])
+        hint = torch.cat((color_img * mask, mask), 0)
+
+        return bw_img, color_img, hint, dfm_img
+
+class FineTuningDataset(torch.utils.data.Dataset):
+    def __init__(self, data_path, transform = None, mult_amount = 1):
+        self.data = [x for x in os.listdir(os.path.join(data_path, 'real_manga')) if x.find('_dfm') == -1] 
+        self.color_data = [x for x in os.listdir(os.path.join(data_path, 'color'))]
+        self.data_path = data_path
+        self.transform = transform
+        self.mults_amount = mult_amount
+        
+        np.random.shuffle(self.color_data)
+        
+        self.ToTensor = transforms.ToTensor()
+    def __len__(self):
+        return len(self.data)
+    
+    def __getitem__(self, idx):
+        color_img = plt.imread(os.path.join(self.data_path, 'color', self.color_data[idx]))
+        
+        image_name = self.data[idx]
+        if self.mults_amount > 1:
+            mult_number = np.random.choice(range(self.mults_amount))
+            
+            bw_name = image_name[:image_name.rfind('.')] + '_' + str(self.mults_amount) + '.png'
+            dfm_name = image_name[:image_name.rfind('.')] + '_' + str(self.mults_amount) + '_dfm.png'
+        else:
+            bw_name = self.data[idx]
+            dfm_name =  os.path.splitext(self.data[idx])[0] + '_dfm.png'
+        
+        
+        bw_img =  np.expand_dims(plt.imread(os.path.join(self.data_path, 'real_manga', image_name)), 2)
+        dfm_img =  np.expand_dims(plt.imread(os.path.join(self.data_path, 'real_manga', dfm_name)), 2)
+        
+        if self.transform:
+            result = self.transform(image = color_img)
+            color_img = result['image']
+            
+            result = self.transform(image = bw_img,  mask = dfm_img)
+            bw_img = result['image']
+            dfm_img = result['mask']
+        
+        color_img = self.ToTensor(color_img)
+        bw_img = self.ToTensor(bw_img)
+        dfm_img = self.ToTensor(dfm_img)
+        
+        color_img = (color_img - 0.5) / 0.5
+        
+        return bw_img, dfm_img, color_img

denoising/denoiser.py

@@ -0,0 +1,113 @@
+"""
+Denoise an image with the FFDNet denoising method
+
+Copyright (C) 2018, Matias Tassano <matias.tassano@parisdescartes.fr>
+
+This program is free software: you can use, modify and/or
+redistribute it under the terms of the GNU General Public
+License as published by the Free Software Foundation, either
+version 3 of the License, or (at your option) any later
+version. You should have received a copy of this license along
+this program. If not, see <http://www.gnu.org/licenses/>.
+"""
+import os
+import argparse
+import time
+import numpy as np
+import cv2
+import torch
+import torch.nn as nn
+from torch.autograd import Variable
+from denoising.models import FFDNet
+from denoising.utils import normalize, variable_to_cv2_image, remove_dataparallel_wrapper, is_rgb
+    
+class FFDNetDenoiser:
+    def __init__(self, _device, _sigma = 25, _weights_dir = 'denoising/models/', _in_ch = 3):
+        self.sigma = _sigma / 255
+        self.weights_dir = _weights_dir
+        self.channels = _in_ch
+        self.device = _device
+        
+        self.model = FFDNet(num_input_channels = _in_ch)
+        self.load_weights()
+        self.model.eval()
+       
+    
+    def load_weights(self):
+        weights_name = 'net_rgb.pth' if self.channels == 3 else 'net_gray.pth'
+        weights_path = os.path.join(self.weights_dir, weights_name)
+        if self.device == 'cuda':
+            state_dict = torch.load(weights_path, map_location=torch.device('cpu'))
+            device_ids = [0]
+            self.model = nn.DataParallel(self.model, device_ids=device_ids).cuda()
+        else:
+            state_dict = torch.load(weights_path, map_location='cpu')
+            # CPU mode: remove the DataParallel wrapper
+            state_dict = remove_dataparallel_wrapper(state_dict)
+        self.model.load_state_dict(state_dict)
+        
+    def get_denoised_image(self, imorig, sigma = None):
+        
+        if sigma is not None:
+            cur_sigma = sigma / 255
+        else:
+            cur_sigma = self.sigma 
+    
+        if len(imorig.shape) < 3 or imorig.shape[2] == 1:
+            imorig = np.repeat(np.expand_dims(imorig, 2), 3, 2)
+
+        if (max(imorig.shape[0], imorig.shape[1]) > 1200):
+            ratio = max(imorig.shape[0], imorig.shape[1]) / 1200
+            imorig = cv2.resize(imorig, (int(imorig.shape[1] / ratio), int(imorig.shape[0] / ratio)), interpolation = cv2.INTER_AREA)
+
+        imorig = imorig.transpose(2, 0, 1)
+ 
+        if (imorig.max() > 1.2):
+            imorig = normalize(imorig)
+        imorig = np.expand_dims(imorig, 0)
+
+        # Handle odd sizes
+        expanded_h = False
+        expanded_w = False
+        sh_im = imorig.shape
+        if sh_im[2]%2 == 1:
+            expanded_h = True
+            imorig = np.concatenate((imorig, imorig[:, :, -1, :][:, :, np.newaxis, :]), axis=2)
+
+        if sh_im[3]%2 == 1:
+            expanded_w = True
+            imorig = np.concatenate((imorig, imorig[:, :, :, -1][:, :, :, np.newaxis]), axis=3)
+
+
+        imorig = torch.Tensor(imorig)
+
+
+        # Sets data type according to CPU or GPU modes
+        if self.device == 'cuda':
+            dtype = torch.cuda.FloatTensor
+        else:
+            dtype = torch.FloatTensor
+
+        imnoisy = imorig.clone()
+
+
+        with torch.no_grad():
+            imorig, imnoisy = imorig.type(dtype), imnoisy.type(dtype)
+            nsigma = torch.FloatTensor([cur_sigma]).type(dtype)
+
+
+        # Estimate noise and subtract it to the input image
+        im_noise_estim = self.model(imnoisy, nsigma)
+        outim = torch.clamp(imnoisy-im_noise_estim, 0., 1.)
+
+        if expanded_h:
+            imorig = imorig[:, :, :-1, :]
+            outim = outim[:, :, :-1, :]
+            imnoisy = imnoisy[:, :, :-1, :]
+
+        if expanded_w:
+            imorig = imorig[:, :, :, :-1]
+            outim = outim[:, :, :, :-1]
+            imnoisy = imnoisy[:, :, :, :-1]
+        
+        return variable_to_cv2_image(outim)

denoising/functions.py

@@ -0,0 +1,101 @@
+"""
+Functions implementing custom NN layers
+
+Copyright (C) 2018, Matias Tassano <matias.tassano@parisdescartes.fr>
+
+This program is free software: you can use, modify and/or
+redistribute it under the terms of the GNU General Public
+License as published by the Free Software Foundation, either
+version 3 of the License, or (at your option) any later
+version. You should have received a copy of this license along
+this program. If not, see <http://www.gnu.org/licenses/>.
+"""
+import torch
+from torch.autograd import Function, Variable
+
+def concatenate_input_noise_map(input, noise_sigma):
+    r"""Implements the first layer of FFDNet. This function returns a
+    torch.autograd.Variable composed of the concatenation of the downsampled
+    input image and the noise map. Each image of the batch of size CxHxW gets
+    converted to an array of size 4*CxH/2xW/2. Each of the pixels of the
+    non-overlapped 2x2 patches of the input image are placed in the new array
+    along the first dimension.
+
+    Args:
+        input: batch containing CxHxW images
+        noise_sigma: the value of the pixels of the CxH/2xW/2 noise map
+    """
+    # noise_sigma is a list of length batch_size
+    N, C, H, W = input.size()
+    dtype = input.type()
+    sca = 2
+    sca2 = sca*sca
+    Cout = sca2*C
+    Hout = H//sca
+    Wout = W//sca
+    idxL = [[0, 0], [0, 1], [1, 0], [1, 1]]
+
+    # Fill the downsampled image with zeros
+    if 'cuda' in dtype:
+        downsampledfeatures = torch.cuda.FloatTensor(N, Cout, Hout, Wout).fill_(0)
+    else:
+        downsampledfeatures = torch.FloatTensor(N, Cout, Hout, Wout).fill_(0)
+
+    # Build the CxH/2xW/2 noise map
+    noise_map = noise_sigma.view(N, 1, 1, 1).repeat(1, C, Hout, Wout)
+
+    # Populate output
+    for idx in range(sca2):
+        downsampledfeatures[:, idx:Cout:sca2, :, :] = \
+            input[:, :, idxL[idx][0]::sca, idxL[idx][1]::sca]
+
+    # concatenate de-interleaved mosaic with noise map
+    return torch.cat((noise_map, downsampledfeatures), 1)
+
+class UpSampleFeaturesFunction(Function):
+    r"""Extends PyTorch's modules by implementing a torch.autograd.Function.
+    This class implements the forward and backward methods of the last layer
+    of FFDNet. It basically performs the inverse of
+    concatenate_input_noise_map(): it converts each of the images of a
+    batch of size CxH/2xW/2 to images of size C/4xHxW
+    """
+    @staticmethod
+    def forward(ctx, input):
+        N, Cin, Hin, Win = input.size()
+        dtype = input.type()
+        sca = 2
+        sca2 = sca*sca
+        Cout = Cin//sca2
+        Hout = Hin*sca
+        Wout = Win*sca
+        idxL = [[0, 0], [0, 1], [1, 0], [1, 1]]
+
+        assert (Cin%sca2 == 0), 'Invalid input dimensions: number of channels should be divisible by 4'
+
+        result = torch.zeros((N, Cout, Hout, Wout)).type(dtype)
+        for idx in range(sca2):
+            result[:, :, idxL[idx][0]::sca, idxL[idx][1]::sca] = input[:, idx:Cin:sca2, :, :]
+
+        return result
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        N, Cg_out, Hg_out, Wg_out = grad_output.size()
+        dtype = grad_output.data.type()
+        sca = 2
+        sca2 = sca*sca
+        Cg_in = sca2*Cg_out
+        Hg_in = Hg_out//sca
+        Wg_in = Wg_out//sca
+        idxL = [[0, 0], [0, 1], [1, 0], [1, 1]]
+
+        # Build output
+        grad_input = torch.zeros((N, Cg_in, Hg_in, Wg_in)).type(dtype)
+        # Populate output
+        for idx in range(sca2):
+            grad_input[:, idx:Cg_in:sca2, :, :] = grad_output.data[:, :, idxL[idx][0]::sca, idxL[idx][1]::sca]
+
+        return Variable(grad_input)
+
+# Alias functions
+upsamplefeatures = UpSampleFeaturesFunction.apply

denoising/models.py

@@ -0,0 +1,100 @@
+"""
+Definition of the FFDNet model and its custom layers
+
+Copyright (C) 2018, Matias Tassano <matias.tassano@parisdescartes.fr>
+
+This program is free software: you can use, modify and/or
+redistribute it under the terms of the GNU General Public
+License as published by the Free Software Foundation, either
+version 3 of the License, or (at your option) any later
+version. You should have received a copy of this license along
+this program. If not, see <http://www.gnu.org/licenses/>.
+"""
+import torch.nn as nn
+from torch.autograd import Variable
+import denoising.functions as functions
+    
+class UpSampleFeatures(nn.Module):
+    r"""Implements the last layer of FFDNet
+    """
+    def __init__(self):
+        super(UpSampleFeatures, self).__init__()
+    def forward(self, x):
+        return functions.upsamplefeatures(x)
+
+class IntermediateDnCNN(nn.Module):
+    r"""Implements the middel part of the FFDNet architecture, which
+    is basically a DnCNN net
+    """
+    def __init__(self, input_features, middle_features, num_conv_layers):
+        super(IntermediateDnCNN, self).__init__()
+        self.kernel_size = 3
+        self.padding = 1
+        self.input_features = input_features
+        self.num_conv_layers = num_conv_layers
+        self.middle_features = middle_features
+        if self.input_features == 5:
+            self.output_features = 4 #Grayscale image
+        elif self.input_features == 15:
+            self.output_features = 12 #RGB image
+        else:
+            raise Exception('Invalid number of input features')
+
+        layers = []
+        layers.append(nn.Conv2d(in_channels=self.input_features,\
+                                out_channels=self.middle_features,\
+                                kernel_size=self.kernel_size,\
+                                padding=self.padding,\
+                                bias=False))
+        layers.append(nn.ReLU(inplace=True))
+        for _ in range(self.num_conv_layers-2):
+            layers.append(nn.Conv2d(in_channels=self.middle_features,\
+                                    out_channels=self.middle_features,\
+                                    kernel_size=self.kernel_size,\
+                                    padding=self.padding,\
+                                    bias=False))
+            layers.append(nn.BatchNorm2d(self.middle_features))
+            layers.append(nn.ReLU(inplace=True))
+        layers.append(nn.Conv2d(in_channels=self.middle_features,\
+                                out_channels=self.output_features,\
+                                kernel_size=self.kernel_size,\
+                                padding=self.padding,\
+                                bias=False))
+        self.itermediate_dncnn = nn.Sequential(*layers)
+    def forward(self, x):
+        out = self.itermediate_dncnn(x)
+        return out
+
+class FFDNet(nn.Module):
+    r"""Implements the FFDNet architecture
+    """
+    def __init__(self, num_input_channels):
+        super(FFDNet, self).__init__()
+        self.num_input_channels = num_input_channels
+        if self.num_input_channels == 1:
+            # Grayscale image
+            self.num_feature_maps = 64
+            self.num_conv_layers = 15
+            self.downsampled_channels = 5
+            self.output_features = 4
+        elif self.num_input_channels == 3:
+            # RGB image
+            self.num_feature_maps = 96
+            self.num_conv_layers = 12
+            self.downsampled_channels = 15
+            self.output_features = 12
+        else:
+            raise Exception('Invalid number of input features')
+
+        self.intermediate_dncnn = IntermediateDnCNN(\
+                input_features=self.downsampled_channels,\
+                middle_features=self.num_feature_maps,\
+                num_conv_layers=self.num_conv_layers)
+        self.upsamplefeatures = UpSampleFeatures()
+
+    def forward(self, x, noise_sigma):
+        concat_noise_x = functions.concatenate_input_noise_map(x.data, noise_sigma.data)
+        concat_noise_x = Variable(concat_noise_x)
+        h_dncnn = self.intermediate_dncnn(concat_noise_x)
+        pred_noise = self.upsamplefeatures(h_dncnn)
+        return pred_noise

denoising/utils.py

@@ -0,0 +1,66 @@
+"""
+Different utilities such as orthogonalization of weights, initialization of
+loggers, etc
+
+Copyright (C) 2018, Matias Tassano <matias.tassano@parisdescartes.fr>
+
+This program is free software: you can use, modify and/or
+redistribute it under the terms of the GNU General Public
+License as published by the Free Software Foundation, either
+version 3 of the License, or (at your option) any later
+version. You should have received a copy of this license along
+this program. If not, see <http://www.gnu.org/licenses/>.
+"""
+import numpy as np
+import cv2
+
+
+def variable_to_cv2_image(varim):
+    r"""Converts a torch.autograd.Variable to an OpenCV image
+
+    Args:
+        varim: a torch.autograd.Variable
+    """
+    nchannels = varim.size()[1]
+    if nchannels == 1:
+        res = (varim.data.cpu().numpy()[0, 0, :]*255.).clip(0, 255).astype(np.uint8)
+    elif nchannels == 3:
+        res = varim.data.cpu().numpy()[0]
+        res = cv2.cvtColor(res.transpose(1, 2, 0), cv2.COLOR_RGB2BGR)
+        res = (res*255.).clip(0, 255).astype(np.uint8)
+    else:
+        raise Exception('Number of color channels not supported')
+    return res
+
+
+def normalize(data):
+    return np.float32(data/255.)
+
+def remove_dataparallel_wrapper(state_dict):
+    r"""Converts a DataParallel model to a normal one by removing the "module."
+    wrapper in the module dictionary
+
+    Args:
+        state_dict: a torch.nn.DataParallel state dictionary
+    """
+    from collections import OrderedDict
+
+    new_state_dict = OrderedDict()
+    for k, vl in state_dict.items():
+        name = k[7:] # remove 'module.' of DataParallel
+        new_state_dict[name] = vl
+
+    return new_state_dict
+
+def is_rgb(im_path):
+    r""" Returns True if the image in im_path is an RGB image
+    """
+    from skimage.io import imread
+    rgb = False
+    im = imread(im_path)
+    if (len(im.shape) == 3):
+        if not(np.allclose(im[...,0], im[...,1]) and np.allclose(im[...,2], im[...,1])):
+            rgb = True
+    print("rgb: {}".format(rgb))
+    print("im shape: {}".format(im.shape))
+    return rgb

drawing.py

@@ -0,0 +1,165 @@
+import os
+from datetime import datetime
+import base64
+import random
+import string
+import shutil
+import torch
+import matplotlib.pyplot as plt
+import numpy as np
+from flask import Flask, request, jsonify, abort, redirect, url_for, render_template, send_file, Response
+from flask_wtf import FlaskForm
+from wtforms import StringField, FileField, BooleanField, DecimalField
+from wtforms.validators import DataRequired
+from flask import after_this_request
+
+from model.models import Colorizer, Generator
+from model.extractor import get_seresnext_extractor
+from utils.xdog import XDoGSketcher
+from utils.utils import open_json
+from denoising.denoiser import FFDNetDenoiser
+from inference import process_image_with_hint
+from utils.utils import resize_pad
+from utils.dataset_utils import get_sketch
+
+def generate_id(size=25, chars=string.ascii_letters + string.digits):
+    return ''.join(random.SystemRandom().choice(chars) for _ in range(size))
+
+def generate_unique_id(current_ids = set()):
+    id_t = generate_id()
+    while id_t in current_ids:
+        id_t = generate_id()
+        
+    current_ids.add(id_t)    
+        
+    return id_t
+
+app = Flask(__name__)
+app.config.update(dict(
+    SECRET_KEY="lol kek",
+    WTF_CSRF_SECRET_KEY="cheburek"
+))
+
+if torch.cuda.is_available():
+    device = 'cuda'
+else:
+    device = 'cpu'  
+
+colorizer = torch.jit.load('./model/colorizer.zip', map_location=torch.device(device))
+
+sketcher = XDoGSketcher()
+xdog_config = open_json('configs/xdog_config.json')
+for key in xdog_config.keys():
+    if key in sketcher.params:
+        sketcher.params[key] = xdog_config[key]
+
+denoiser = FFDNetDenoiser(device)
+
+color_args = {'colorizer':colorizer, 'sketcher':sketcher, 'device':device, 'dfm' : True, 'auto_hint' : False, 'ignore_gray' : False, 'denoiser' : denoiser, 'denoiser_sigma' : 25}
+
+
+class SubmitForm(FlaskForm):
+    file = FileField(validators=[DataRequired(), ])
+
+def preprocess_image(file_id, ext): 
+    directory_path = os.path.join('static', 'temp_images', file_id)
+    original_path = os.path.join(directory_path, 'original') + ext
+    original_image = plt.imread(original_path)    
+                          
+    resized_image, _ = resize_pad(original_image)
+    resized_image = denoiser.get_denoised_image(resized_image, 25)
+    bw, dfm = get_sketch(resized_image, sketcher, True)
+                                
+    resized_name = 'resized_' + str(resized_image.shape[0]) + '_' + str(resized_image.shape[1]) + '.png'
+    plt.imsave(os.path.join(directory_path, resized_name), resized_image)
+    plt.imsave(os.path.join(directory_path, 'bw.png'), bw, cmap = 'gray')
+    plt.imsave(os.path.join(directory_path, 'dfm.png'), dfm, cmap = 'gray')
+    os.remove(original_path)
+  
+    empty_hint = np.zeros((resized_image.shape[0], resized_image.shape[1], 4), dtype = np.float32)
+    plt.imsave(os.path.join(directory_path, 'hint.png'), empty_hint)
+
+@app.route('/', methods=['GET', 'POST'])
+def upload():
+    form = SubmitForm()
+    if form.validate_on_submit():
+        input_data = form.file.data
+        
+        _, ext = os.path.splitext(input_data.filename)
+        
+        if ext not in ('.jpg', '.png', '.jpeg'):
+            return abort(400)
+        
+        file_id = generate_unique_id()
+        directory = os.path.join('static', 'temp_images', file_id)
+        original_filename =  os.path.join(directory, 'original') + ext
+        
+        try :
+            os.mkdir(directory)
+            input_data.save(original_filename)
+        
+            preprocess_image(file_id, ext)
+        
+            return redirect(f'/draw/{file_id}')
+        
+        except :
+            print('Failed to colorize')
+            if os.path.exists(directory):
+                shutil.rmtree(directory)
+            return abort(400)
+                
+        
+    return render_template("upload.html", form = form)
+
+@app.route('/img/<file_id>')
+def show_image(file_id):
+    if not os.path.exists(os.path.join('static', 'temp_images', str(file_id))):
+        abort(404)
+    return f'<img src="/static/temp_images/{file_id}/colorized.png?{random. randint(1,1000000)}">'
+
+def colorize_image(file_id):
+    directory_path = os.path.join('static', 'temp_images', file_id)
+    
+    bw = plt.imread(os.path.join(directory_path, 'bw.png'))[..., :1]
+    dfm = plt.imread(os.path.join(directory_path, 'dfm.png'))[..., :1]
+    hint = plt.imread(os.path.join(directory_path, 'hint.png'))
+    
+    return process_image_with_hint(bw, dfm, hint, color_args)
+
+@app.route('/colorize', methods=['POST'])
+def colorize():
+    
+    file_id = request.form['save_file_id']
+    file_id = file_id[file_id.rfind('/') + 1:]
+    
+    img_data = request.form['save_image']
+    img_data = img_data[img_data.find(',') + 1:]
+    
+    directory_path = os.path.join('static', 'temp_images', file_id)
+    
+    with open(os.path.join(directory_path, 'hint.png'), "wb") as im:
+        im.write(base64.decodestring(str.encode(img_data)))
+    
+    result = colorize_image(file_id)
+    
+    plt.imsave(os.path.join(directory_path, 'colorized.png'), result)
+      
+    src_path = f'../static/temp_images/{file_id}/colorized.png?{random. randint(1,1000000)}'    
+        
+    return src_path
+
+@app.route('/draw/<file_id>', methods=['GET', 'POST'])
+def paintapp(file_id):
+    if request.method == 'GET':
+        
+        directory_path = os.path.join('static', 'temp_images', str(file_id))
+        if not os.path.exists(directory_path):
+            abort(404)
+        
+        resized_name = [x for x in os.listdir(directory_path) if x.startswith('resized_')][0]
+        
+        split = os.path.splitext(resized_name)[0].split('_')
+        width = int(split[2])
+        height = int(split[1])
+        
+        return render_template("drawing.html", height = height, width = width, img_path = os.path.join('temp_images', str(file_id), resized_name))

inference.py

@@ -0,0 +1,215 @@
+import torch
+import torch.nn as nn
+import numpy as np
+from utils.dataset_utils import get_sketch
+from utils.utils import resize_pad, generate_mask, extract_cbr, create_cbz, sorted_alphanumeric, subfolder_image_search, remove_folder
+from torchvision.transforms import ToTensor
+import os
+import matplotlib.pyplot as plt
+import argparse
+from model.models import Colorizer, Generator
+from model.extractor import get_seresnext_extractor
+from utils.xdog import XDoGSketcher
+from utils.utils import open_json
+import sys
+from denoising.denoiser import FFDNetDenoiser
+
+def colorize_without_hint(inp, color_args):
+    i_hint = torch.zeros(1, 4, inp.shape[2], inp.shape[3]).float().to(color_args['device'])
+    
+    with torch.no_grad():
+        fake_color, _ = color_args['colorizer'](torch.cat([inp, i_hint], 1))
+    
+    if color_args['auto_hint']:
+        mask = generate_mask(fake_color.shape[2], fake_color.shape[3], full = False, prob = 1, sigma = color_args['auto_hint_sigma']).unsqueeze(0)
+        mask = mask.to(color_args['device'])
+        
+        
+        if color_args['ignore_gray']:
+            diff1 = torch.abs(fake_color[:, 0] - fake_color[:, 1])
+            diff2 = torch.abs(fake_color[:, 0] - fake_color[:, 2])
+            diff3 = torch.abs(fake_color[:, 1] - fake_color[:, 2])
+            mask = ((mask + ((diff1 + diff2 + diff3) > 60 / 255).float().unsqueeze(1)) == 2).float()
+        
+        
+        i_hint = torch.cat([fake_color * mask, mask], 1)
+        
+        with torch.no_grad():
+            fake_color, _ = color_args['colorizer'](torch.cat([inp, i_hint], 1))
+        
+    return fake_color
+
+
+def process_image(image, color_args, to_tensor = ToTensor()):
+    image, pad = resize_pad(image)
+    
+    if color_args['denoiser'] is not None:
+        image = color_args['denoiser'].get_denoised_image(image, color_args['denoiser_sigma'])
+    
+    bw, dfm = get_sketch(image, color_args['sketcher'], color_args['dfm'])
+    
+    bw = to_tensor(bw).unsqueeze(0).to(color_args['device'])
+    dfm = to_tensor(dfm).unsqueeze(0).to(color_args['device'])
+    
+    output = colorize_without_hint(torch.cat([bw, dfm], 1), color_args)
+    result = output[0].cpu().permute(1, 2, 0).numpy() * 0.5 + 0.5
+    
+    if pad[0] != 0:
+        result = result[:-pad[0]]
+    if pad[1] != 0:
+        result = result[:, :-pad[1]]
+        
+    return result
+
+def colorize_with_hint(inp, color_args):
+    with torch.no_grad():
+        fake_color, _ = color_args['colorizer'](inp)
+        
+    return fake_color
+    
+def process_image_with_hint(bw, dfm, hint, color_args, to_tensor = ToTensor()):
+    bw = to_tensor(bw).unsqueeze(0).to(color_args['device'])
+    dfm = to_tensor(dfm).unsqueeze(0).to(color_args['device'])
+    
+    i_hint = (torch.FloatTensor(hint[..., :3]).permute(2, 0, 1) - 0.5) / 0.5
+    mask = torch.FloatTensor(hint[..., 3:]).permute(2, 0, 1)
+    i_hint = torch.cat([i_hint * mask, mask], 0).unsqueeze(0).to(color_args['device'])
+    
+    output = colorize_with_hint(torch.cat([bw, dfm, i_hint], 1), color_args)
+    result = output[0].cpu().permute(1, 2, 0).numpy() * 0.5 + 0.5
+    
+    return result
+    
+def colorize_single_image(file_path, save_path, color_args):
+    try:
+        image = plt.imread(file_path)
+
+        colorization = process_image(image, color_args)
+
+        plt.imsave(save_path, colorization)
+        
+        return True
+    except KeyboardInterrupt:
+        sys.exit(0)
+    except:
+        print('Failed to colorize {}'.format(file_path))
+        return False
+
+def colorize_images(source_path, target_path, color_args):
+    images = os.listdir(source_path)
+    
+    for image_name in images:
+        file_path = os.path.join(source_path, image_name)
+        
+        name, ext = os.path.splitext(image_name)
+        if (ext != '.png'):
+            image_name = name + '.png'
+        
+        save_path = os.path.join(target_path, image_name)
+        colorize_single_image(file_path, save_path, color_args)
+            
+def colorize_cbr(file_path, color_args):
+    file_name = os.path.splitext(os.path.basename(file_path))[0]
+    temp_path = 'temp_colorization'
+    
+    if not  os.path.exists(temp_path):
+        os.makedirs(temp_path)
+    extract_cbr(file_path, temp_path)
+    
+    images = subfolder_image_search(temp_path)
+    
+    result_images = []
+    for image_path in images:
+        save_path = image_path
+        
+        path, ext = os.path.splitext(save_path)
+        if (ext != '.png'):
+            save_path = path + '.png'
+        
+        res_flag = colorize_single_image(image_path, save_path, color_args)
+        
+        result_images.append(save_path if res_flag else image_path)
+        
+    
+    result_name = os.path.join(os.path.dirname(file_path), file_name + '_colorized.cbz')
+    
+    create_cbz(result_name, result_images)
+    
+    remove_folder(temp_path)
+    
+    return result_name
+    
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-p", "--path", required=True)
+    parser.add_argument("-gen", "--generator", default = 'model/generator.pth')
+    parser.add_argument("-ext", "--extractor", default = 'model/extractor.pth')
+    parser.add_argument("-s", "--sigma", type = float, default = 0.003)
+    parser.add_argument('-g', '--gpu', dest = 'gpu', action = 'store_true')
+    parser.add_argument('-ah', '--auto', dest = 'autohint', action = 'store_true')
+    parser.add_argument('-ig', '--ignore_grey', dest = 'ignore', action = 'store_true')
+    parser.add_argument('-nd', '--no_denoise', dest = 'denoiser', action = 'store_false')
+    parser.add_argument("-ds", "--denoiser_sigma", type = int, default = 25)
+    parser.set_defaults(gpu = False)
+    parser.set_defaults(autohint = False)
+    parser.set_defaults(ignore = False)
+    parser.set_defaults(denoiser = True)
+    args = parser.parse_args()
+    
+    return args
+
+    
+if __name__ == "__main__":
+    
+    args = parse_args()
+    
+    if args.gpu:
+        device = 'cuda'
+    else:
+        device = 'cpu'
+        
+    generator = Generator()
+    generator.load_state_dict(torch.load(args.generator))
+    
+    extractor = get_seresnext_extractor()
+    extractor.load_state_dict(torch.load(args.extractor))
+    
+    colorizer = Colorizer(generator, extractor)
+    colorizer = colorizer.eval().to(device)
+    
+    sketcher = XDoGSketcher()
+    xdog_config = open_json('configs/xdog_config.json')
+    for key in xdog_config.keys():
+        if key in sketcher.params:
+            sketcher.params[key] = xdog_config[key]
+
+    denoiser = None
+    if args.denoiser:
+        denoiser = FFDNetDenoiser(device, args.denoiser_sigma)
+    
+    color_args = {'colorizer':colorizer, 'sketcher':sketcher, 'auto_hint':args.autohint, 'auto_hint_sigma':args.sigma,\
+                 'ignore_gray':args.ignore, 'device':device, 'dfm' : True, 'denoiser':denoiser, 'denoiser_sigma' : args.denoiser_sigma}
+    
+    
+    if os.path.isdir(args.path):
+        colorization_path = os.path.join(args.path, 'colorization')
+        if not os.path.exists(colorization_path):
+            os.makedirs(colorization_path)
+            
+        colorize_images(args.path, colorization_path, color_args)
+        
+    elif os.path.isfile(args.path):
+        
+        split = os.path.splitext(args.path)
+        
+        if split[1].lower() in ('.cbr', '.cbz', '.rar', '.zip'):
+            colorize_cbr(args.path, color_args)
+        elif split[1].lower() in ('.jpg', '.png', ',jpeg'):
+            new_image_path = split[0] + '_colorized' + '.png'
+            
+            colorize_single_image(args.path, new_image_path, color_args)
+        else:
+            print('Wrong format')
+    else:
+        print('Wrong path')
+    

model/extractor.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ee3c59f02ac8c59298fd9b819fa33d2efa168847e15e4be39b35c286f7c18607
+size 6340842

model/extractor.py

@@ -0,0 +1,127 @@
+import torch
+import torch.nn as nn
+import math
+
+'''https://github.com/blandocs/Tag2Pix/blob/master/model/pretrained.py'''
+
+# Pretrained version
+class Selayer(nn.Module):
+    def __init__(self, inplanes):
+        super(Selayer, self).__init__()
+        self.global_avgpool = nn.AdaptiveAvgPool2d(1)
+        self.conv1 = nn.Conv2d(inplanes, inplanes // 16, kernel_size=1, stride=1)
+        self.conv2 = nn.Conv2d(inplanes // 16, inplanes, kernel_size=1, stride=1)
+        self.relu = nn.ReLU(inplace=True)
+        self.sigmoid = nn.Sigmoid()
+
+    def forward(self, x):
+        out = self.global_avgpool(x)
+        out = self.conv1(out)
+        out = self.relu(out)
+        out = self.conv2(out)
+        out = self.sigmoid(out)
+
+        return x * out
+
+
+class BottleneckX_Origin(nn.Module):
+    expansion = 4
+
+    def __init__(self, inplanes, planes, cardinality, stride=1, downsample=None):
+        super(BottleneckX_Origin, self).__init__()
+        self.conv1 = nn.Conv2d(inplanes, planes * 2, kernel_size=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(planes * 2)
+
+        self.conv2 = nn.Conv2d(planes * 2, planes * 2, kernel_size=3, stride=stride,
+                               padding=1, groups=cardinality, bias=False)
+        self.bn2 = nn.BatchNorm2d(planes * 2)
+
+        self.conv3 = nn.Conv2d(planes * 2, planes * 4, kernel_size=1, bias=False)
+        self.bn3 = nn.BatchNorm2d(planes * 4)
+
+        self.selayer = Selayer(planes * 4)
+
+        self.relu = nn.ReLU(inplace=True)
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x):
+        residual = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+        out = self.relu(out)
+
+        out = self.conv3(out)
+        out = self.bn3(out)
+
+        out = self.selayer(out)
+
+        if self.downsample is not None:
+            residual = self.downsample(x)
+
+        out += residual
+        out = self.relu(out)
+
+        return out
+
+class SEResNeXt_extractor(nn.Module):
+    def __init__(self, block, layers, input_channels=3, cardinality=32):
+        super(SEResNeXt_extractor, self).__init__()
+        self.cardinality = cardinality
+        self.inplanes = 64
+        self.input_channels = input_channels
+
+        self.conv1 = nn.Conv2d(input_channels, 64, kernel_size=7, stride=2, padding=3,
+                               bias=False)
+        self.bn1 = nn.BatchNorm2d(64)
+        self.relu = nn.ReLU(inplace=True)
+        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
+
+        self.layer1 = self._make_layer(block, 64, layers[0])
+        self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
+
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
+                m.weight.data.normal_(0, math.sqrt(2. / n))
+                if m.bias is not None:
+                    m.bias.data.zero_()
+            elif isinstance(m, nn.BatchNorm2d):
+                m.weight.data.fill_(1)
+                m.bias.data.zero_()
+
+    def _make_layer(self, block, planes, blocks, stride=1):
+        downsample = None
+        if stride != 1 or self.inplanes != planes * block.expansion:
+            downsample = nn.Sequential(
+                nn.Conv2d(self.inplanes, planes * block.expansion,
+                          kernel_size=1, stride=stride, bias=False),
+                nn.BatchNorm2d(planes * block.expansion),
+            )
+
+        layers = []
+        layers.append(block(self.inplanes, planes, self.cardinality, stride, downsample))
+        self.inplanes = planes * block.expansion
+        for i in range(1, blocks):
+            layers.append(block(self.inplanes, planes, self.cardinality))
+
+        return nn.Sequential(*layers)
+
+    def forward(self, x):
+        x = self.conv1(x)
+        x = self.bn1(x)
+        x = self.relu(x)
+        x = self.maxpool(x)
+
+        x = self.layer1(x)
+        x = self.layer2(x)
+        
+        return x
+
+def get_seresnext_extractor():
+    return SEResNeXt_extractor(BottleneckX_Origin, [3, 4, 6, 3], 1)