added Animefy web app files.

adjust_brightness.py

@@ -0,0 +1,69 @@
+import numpy as np
+import cv2
+from PIL import Image
+
+
+# def read_img(image_path):
+#     img = cv2.imread(image_path)
+#     img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+#     assert len(img.shape)==3
+#     return img
+
+def read_img(image_file_buffer):
+    img = Image.open(image_file_buffer).convert('RGB')
+    img = np.array(img)
+    assert len(img.shape)==3
+    return img
+
+# Calculates the average brightness in the specified irregular image
+def calculate_average_brightness(img):
+    # Average value of three color channels
+    R = img[..., 0].mean()
+    G = img[..., 1].mean()
+    B = img[..., 2].mean()
+
+    brightness = 0.299 * R + 0.587 * G + 0.114 * B
+    return brightness, B, G, R
+
+# Adjusting the average brightness of the target image to the average brightness of the source image
+def adjust_brightness_from_src_to_dst(dst, src,path=None,if_show=None, if_info=None):
+    brightness1, B1, G1, R1 = calculate_average_brightness(src)
+    brightness2, B2, G2, R2 = calculate_average_brightness(dst)
+    brightness_difference = brightness1 / brightness2
+
+    if if_info:
+        print('Average brightness of original image', brightness1)
+        print('Average brightness of target', brightness2)
+        print('Brightness Difference between Original Image and Target', brightness_difference)
+
+    # According to the average display brightness
+    dstf = dst * brightness_difference
+
+    # According to the average value of the three-color channel
+    # dstf = dst.copy().astype(np.float32)
+    # dstf[..., 0] = dst[..., 0] * (B1 / B2)
+    # dstf[..., 1] = dst[..., 1] * (G1 / G2)
+    # dstf[..., 2] = dst[..., 2] * (R1 / R2)
+
+    # To limit the results and prevent crossing the border,
+    # it must be converted to uint8, otherwise the default result is float32, and errors will occur.
+    dstf = np.clip(dstf, 0, 255)
+    dstf = np.uint8(dstf)
+
+    ma,na,_ = src.shape
+    mb,nb,_ = dst.shape
+    result_show_img = np.zeros((max(ma, mb), 3 * max(na, nb), 3))
+    result_show_img[:mb, :nb, :] = dst
+    result_show_img[:ma, nb:nb + na, :] = src
+    result_show_img[:mb, nb + na:nb + na + nb, :] = dstf
+    result_show_img = result_show_img.astype(np.uint8)
+
+    if if_show:
+        cv2.imshow('-', cv2.cvtColor(result_show_img, cv2.COLOR_BGR2RGB))
+        cv2.waitKey(0)
+        cv2.destroyAllWindows()
+
+    if path != None:
+        cv2.imwrite(path, cv2.cvtColor(result_show_img, cv2.COLOR_BGR2RGB))
+
+    return dstf

app.py

@@ -0,0 +1,162 @@
+import streamlit as st
+from PIL import Image
+import cv2 as cv
+import numpy as np
+from random import randint
+import threading
+
+# style.py
+import style
+
+st.set_page_config(page_title="Animefy", page_icon="images/animefy_logo.png")
+
+model_lock = threading.Lock()
+
+# remove "Made with Streamlit" footer text
+# uncomment "#MainMenu {visibility: hidden;}" to also remove the default Streamlit hamburger menu
+hide_streamlit = """
+<style>
+    #MainMenu {
+        visibility: hidden;
+    }
+    footer {
+        visibility: hidden;
+    }
+    header {
+        visibility: hidden;
+    }
+</style>
+"""
+st.markdown(hide_streamlit, unsafe_allow_html=True)
+
+# randomizer. a workaround for clearing the contents of the file_uploader
+if 'uploader_key' not in st.session_state:
+    st.session_state['uploader_key'] = str(randint(1000, 100000000))
+
+# home page title and caption
+st.markdown("""
+    # 📸 Animefy
+
+    Convert your photos into **anime** with _ease_ using **AnimeGAN**.
+""")
+
+st.markdown('---')
+
+# main container of the page
+page_container = st.empty()
+
+# store home page contents inside page_container
+home_page = page_container.container()
+
+# step #1
+home_page.markdown("""
+    ### Step #1: Upload the photo that you would like to process!
+""")
+
+# just some notes for the user
+with home_page.expander("📣 Here are some things to take note of...", expanded=True):
+    st.write("""    
+        * Do note that AnimeGAN works best with images containing **sceneries without people**. 
+        * For best results, use images that **do not** contain human subjects.
+        * Due to server hardware limitations, only upload images with **at most** a resolution of **1980x1080**.
+        * Fore more information on AnimeGAN, click [here](https://github.com/TonyLianLong/AnimeGAN.js).
+    """)
+
+# upload image functionality
+uploaded_image = home_page.file_uploader(
+        "If you're ready, you can now upload your image here:", type=['png','jpg','jpeg'], key=st.session_state['uploader_key']
+    )
+
+# if there is an uploaded image, show next steps
+if uploaded_image is not None:
+    # just a preview of the uploaded image
+    home_page.markdown("""
+        #### Uploaded Image
+
+        Here's your photo! Just upload another one if you would like to change it 😉
+    """)
+    home_page.image(Image.open(uploaded_image))
+
+    home_page.write("---")
+
+    # step #2
+    home_page.markdown("""
+        ### Step #2: Now, select your preferred animation style!
+    """)
+
+    # drop down list for anime style to be applied to image
+    anime_style = home_page.selectbox (
+            'Your preferred animation style:',
+            ('Paprika', 'Shinkai', 'Hayao')
+        )
+
+    # just some more notes for the user
+    with home_page.expander("🤔 What are these animation styles?", expanded=False):
+        st.write("""
+            These styles were derived from the works of various directors! Some of these might be familiar to you:   
+            * Satoshi Kon: **Paprika**
+            * Makoto **Shinkai**: Your Name, 5 Centimeters per Second, Weathering with You
+            * **Hayao** Miyazaki: Spirited Away, My Neighbor Totoro, Princess Mononoke
+        """)
+
+    home_page.write("---")
+    
+    # stylize image
+    home_page.markdown("If you're all set, then let's proceed! 😄")
+    stylize_btn = home_page.button("Stylize!")
+
+    # if "stylize" button is clicked,
+    if stylize_btn:
+        # remove processing page contents
+        page_container.empty()
+
+        with st.spinner('Hold on... Please do not close this tab....'):
+            model_lock.acquire()
+
+        # spinner (while processing image)
+        with st.spinner('Hold on... Processing your image...'):
+            # stylize input image and produce output
+            output_image = style.stylize(anime_style, uploaded_image)
+            model_lock.release()
+
+        # step #3
+        st.markdown("""
+            ### Step #3: Download your image!
+        """)
+
+        # display original and output images
+        st.markdown("""
+            Here's a before and after!
+        """)
+        before_col, after_col = st.columns(2)
+        with before_col:
+            # clamp and channels are used since OpenCV was used in processing the image
+            st.image(uploaded_image, clamp=True, channels='RGB')
+        with after_col:
+            # clamp and channels are used since OpenCV was used in processing the image
+            st.image(output_image, clamp=True, channels='RGB')
+
+        st.write("---")
+
+        # prepare output image for downloading
+        img_encode = cv.imencode('.jpg', output_image)[1]
+        data_encode = np.array(img_encode)
+        byte_encode = data_encode.tobytes()
+
+        # some instruction for downloading
+        st.write("Finally, just click this to download your _anime-fied_ image!")
+        # download button
+        st.download_button('Download Image', byte_encode, 'output.jpg', 'jpg')
+
+        st.write("---")
+
+        # retry message
+        st.markdown('Not satisfied? Click this to retry!')
+        # retry button
+        retry_btn = st.button("Retry!")
+        
+        # randomizer. just another workaround.
+        st.session_state['uploader_key'] = str(randint(1000, 100000000))
+
+        if retry_btn:
+            page_container.empty()

generator.py

@@ -0,0 +1,161 @@
+import tensorflow.contrib as tf_contrib
+import tensorflow as tf
+
+def layer_norm(x, scope='layer_norm') :
+    return tf_contrib.layers.layer_norm(x,
+                                        center=True, scale=True,
+                                        scope=scope)
+
+def lrelu(x, alpha=0.2):
+    return tf.nn.leaky_relu(x, alpha)
+
+def Conv2D(inputs, filters, kernel_size=3, strides=1, padding='VALID', Use_bias = None):
+    if kernel_size == 3 and strides == 1:
+        inputs = tf.pad(inputs, [[0, 0], [1, 1], [1, 1], [0, 0]], mode="REFLECT")
+    if kernel_size == 7 and strides == 1:
+        inputs = tf.pad(inputs, [[0, 0], [3, 3], [3, 3], [0, 0]], mode="REFLECT")
+    if strides == 2:
+        inputs = tf.pad(inputs, [[0, 0], [0, 1], [0, 1], [0, 0]], mode="REFLECT")
+    return tf.contrib.layers.conv2d(
+        inputs,
+        num_outputs=filters,
+        kernel_size=kernel_size,
+        stride=strides,
+        weights_initializer=tf.contrib.layers.variance_scaling_initializer(),
+        biases_initializer= Use_bias,
+        normalizer_fn=None,
+        activation_fn=None,
+        padding=padding)
+
+
+def Conv2DNormLReLU(inputs, filters, kernel_size=3, strides=1, padding='VALID', Use_bias = None):
+    x = Conv2D(inputs, filters, kernel_size, strides,padding=padding, Use_bias = Use_bias)
+    x = layer_norm(x,scope=None)
+    return lrelu(x)
+
+def dwise_conv(input, k_h=3, k_w=3, channel_multiplier=1, strides=[1, 1, 1, 1],
+                   padding='VALID', name='dwise_conv', bias = True):
+    input = tf.pad(input, [[0, 0], [1, 1], [1, 1], [0, 0]], mode="REFLECT")
+    with tf.variable_scope(name):
+        in_channel = input.get_shape().as_list()[-1]
+        w = tf.get_variable('w', [k_h, k_w, in_channel, channel_multiplier],regularizer=None,initializer=tf.contrib.layers.variance_scaling_initializer())
+        conv = tf.nn.depthwise_conv2d(input, w, strides, padding, rate=None, name=name, data_format=None)
+        if bias:
+            biases = tf.get_variable('bias', [in_channel * channel_multiplier],initializer=tf.constant_initializer(0.0))
+            conv = tf.nn.bias_add(conv, biases)
+        return conv
+
+
+def Unsample(inputs, filters, kernel_size=3):
+    '''
+        An alternative to transposed convolution where we first resize, then convolve.
+        See http://distill.pub/2016/deconv-checkerboard/
+        For some reason the shape needs to be statically known for gradient propagation
+        through tf.image.resize_images, but we only know that for fixed image size, so we
+        plumb through a "training" argument
+        '''
+    new_H, new_W = 2 * tf.shape(inputs)[1], 2 * tf.shape(inputs)[2]
+    inputs = tf.image.resize_images(inputs, [new_H, new_W])
+
+    return Conv2DNormLReLU(filters=filters, kernel_size=kernel_size, inputs=inputs)
+
+
+class G_net(object):
+
+
+    def __init__(self, inputs):
+
+        with tf.variable_scope('G_MODEL'):
+
+            with tf.variable_scope('A'):
+                inputs = Conv2DNormLReLU(inputs, 32, 7)
+                inputs = Conv2DNormLReLU(inputs, 64, strides=2)
+                inputs = Conv2DNormLReLU(inputs, 64)
+
+            with tf.variable_scope('B'):
+                inputs = Conv2DNormLReLU(inputs, 128, strides=2)
+                inputs = Conv2DNormLReLU(inputs, 128)
+
+            with tf.variable_scope('C'):
+                inputs = Conv2DNormLReLU(inputs, 128)
+                inputs = self.InvertedRes_block(inputs, 2, 256, 1, 'r1')
+                inputs = self.InvertedRes_block(inputs, 2, 256, 1, 'r2')
+                inputs = self.InvertedRes_block(inputs, 2, 256, 1, 'r3')
+                inputs = self.InvertedRes_block(inputs, 2, 256, 1, 'r4')
+                inputs = Conv2DNormLReLU(inputs, 128)
+
+            with tf.variable_scope('D'):
+                inputs = Unsample(inputs, 128)
+                inputs = Conv2DNormLReLU(inputs, 128)
+
+            with tf.variable_scope('E'):
+                inputs = Unsample(inputs,64)
+                inputs = Conv2DNormLReLU(inputs, 64)
+                inputs = Conv2DNormLReLU(inputs, 32, 7)
+            with tf.variable_scope('out_layer'):
+                out = Conv2D(inputs, filters =3, kernel_size=1, strides=1)
+                self.fake = tf.tanh(out)
+
+
+    def InvertedRes_block(self, input, expansion_ratio, output_dim, stride, name, reuse=False, bias=None):
+        with  tf.variable_scope(name, reuse=reuse):
+            # pw
+            bottleneck_dim = round(expansion_ratio * input.get_shape().as_list()[-1])
+            net = Conv2DNormLReLU(input, bottleneck_dim, kernel_size=1, Use_bias=bias)
+
+            # dw
+            net = dwise_conv(net, name=name)
+            net = layer_norm(net,scope='1')
+            net = lrelu(net)
+
+            # pw & linear
+            net = Conv2D(net, output_dim, kernel_size=1)
+            net = layer_norm(net,scope='2')
+
+            # element wise add, only for stride==1
+            if (int(input.get_shape().as_list()[-1]) == output_dim) and stride == 1:
+                net = input + net
+
+            return net
+
+def Downsample(inputs, filters = 256, kernel_size=3):
+    '''
+        An alternative to transposed convolution where we first resize, then convolve.
+        See http://distill.pub/2016/deconv-checkerboard/
+        For some reason the shape needs to be statically known for gradient propagation
+        through tf.image.resize_images, but we only know that for fixed image size, so we
+        plumb through a "training" argument
+        '''
+
+    new_H, new_W =  tf.shape(inputs)[1] // 2, tf.shape(inputs)[2] // 2
+    inputs = tf.image.resize_images(inputs, [new_H, new_W])
+
+    return Separable_conv2d(filters=filters, kernel_size=kernel_size, inputs=inputs)
+
+def Conv2DTransposeLReLU(inputs, filters, kernel_size=2, strides=2, padding='SAME', Use_bias = None):
+
+    return tf.contrib.layers.conv2d_transpose(inputs,
+        num_outputs=filters,
+        kernel_size=kernel_size,
+        stride=strides,
+        biases_initializer=Use_bias,
+        normalizer_fn=tf.contrib.layers.instance_norm,
+        activation_fn=lrelu,
+        padding=padding)
+
+def Separable_conv2d(inputs, filters, kernel_size=3, strides=1, padding='VALID', Use_bias = tf.zeros_initializer()):
+    if kernel_size==3 and strides==1:
+        inputs = tf.pad(inputs, [[0, 0], [1, 1], [1, 1], [0, 0]], mode="REFLECT")
+    if strides == 2:
+        inputs = tf.pad(inputs, [[0, 0], [0, 1], [0, 1], [0, 0]], mode="REFLECT")
+    return tf.contrib.layers.separable_conv2d(
+        inputs,
+        num_outputs=filters,
+        kernel_size=kernel_size,
+        depth_multiplier=1,
+        stride=strides,
+        weights_initializer=tf.contrib.layers.variance_scaling_initializer(),
+        biases_initializer=Use_bias,
+        normalizer_fn=tf.contrib.layers.layer_norm,
+        activation_fn=lrelu,
+        padding=padding)

requirements.txt

@@ -0,0 +1,3 @@
+tensorflow-gpu==1.15.0
+opencv-python-headless
+numpy

style.py

@@ -0,0 +1,39 @@
+import os
+import tensorflow.compat.v1 as tf
+import numpy as np
+os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
+
+# utils.py
+from utils import *
+
+# generator.py
+import generator
+
+# stylize input image with chosen anime style
+def stylize(anime_style, input_image): 
+    test_real = tf.placeholder(tf.float32, [1, None, None, 3], name='test')
+
+    with tf.variable_scope("generator", reuse=False):
+        test_generated = generator.G_net(test_real).fake
+    saver = tf.train.Saver()
+    
+    # get model checkpoint folder according to chosen anime style
+    checkpoint_dir = 'models/' + anime_style
+
+    gpu_options = tf.GPUOptions(allow_growth=True)
+    with tf.Session(config=tf.ConfigProto(allow_soft_placement=True, gpu_options=gpu_options)) as sess:
+        # load style model and its weights
+        ckpt = tf.train.get_checkpoint_state(checkpoint_dir)
+        ckpt_name = os.path.basename(ckpt.model_checkpoint_path)
+        saver.restore(sess, os.path.join(checkpoint_dir, ckpt_name))
+        
+        # load and preprocess input image as a NumPy array
+        image = np.asarray(load_input_image(input_image))
+        
+        # stylize image
+        output_image = sess.run(test_generated, feed_dict = {test_real : image})
+        
+        # adjust brightness of output image
+        output_image = adjust_brightness_from_src_to_dst(inverse_transform(output_image.squeeze()), read_img(input_image))
+        
+        return output_image

utils.py

@@ -0,0 +1,47 @@
+import tensorflow.compat.v1 as tf
+from adjust_brightness import adjust_brightness_from_src_to_dst, read_img
+import cv2
+import numpy as np
+from PIL import Image
+
+# def load_input_image(image_path, size=[256,256]):
+#     img = cv2.imread(image_path).astype(np.float32)
+#     img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+#     img = preprocessing(img,size)
+#     img = np.expand_dims(img, axis=0)
+#     return img
+
+def load_input_image(image_file_buffer, size=[256, 256]):
+    img = Image.open(image_file_buffer).convert('RGB')
+    img = np.array(img).astype(np.float32)
+    img = preprocessing(img, size)
+    img = np.expand_dims(img, axis=0)
+    return img
+
+def preprocessing(img, size):
+    h, w = img.shape[:2]
+    if h <= size[0]:
+        h = size[0]
+    else:
+        x = h % 32
+        h = h - x
+
+    if w < size[1]:
+        w = size[1]
+    else:
+        y = w % 32
+        w = w - y
+    # the cv2 resize func : dsize format is (W ,H)
+    img = cv2.resize(img, (w, h))
+    return img/127.5 - 1.0
+
+def inverse_transform(images):
+    images = (images + 1.) / 2 * 255
+    # The calculation of floating-point numbers is inaccurate, 
+    # and the range of pixel values must be limited to the boundary, 
+    # otherwise, image distortion or artifacts will appear during display.
+    images = np.clip(images, 0, 255)
+    return images.astype(np.uint8)
+
+# def imsave(images, path):
+#     return cv2.imwrite(path, cv2.cvtColor(images, cv2.COLOR_BGR2RGB))