a

Syn_img_lowlight_withnoise.h5

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

app.py

@@ -0,0 +1,74 @@
+import os
+import time
+import logging
+import numpy as np
+import keras.optimizers
+import cv2
+import gradio as gr
+import Network
+import utls
+
+class ImageProcessor:
+
+    def __init__(self, model_name):
+        self.model_name = model_name
+        self.mbllen = Network.build_mbllen((None, None, 3))
+        self.mbllen.load_weights(f'{model_name}.h5')
+        self.opt = keras.optimizers.Adam(lr=2 * 1e-04, beta_1=0.9, beta_2=0.999, epsilon=1e-08)
+        self.mbllen.compile(loss='mse', optimizer=self.opt)
+
+    def process_image(self, image, highpercent, lowpercent, gamma, maxrange):
+        img_A = np.array(image) / 255.0
+        img_A = img_A[np.newaxis, :]
+
+        maxrange /= 10.
+        hsvgamma = gamma / 10.
+
+        out_pred = self.mbllen.predict(img_A)
+
+        fake_B = out_pred[0, :, :, :3]
+        fake_B = self.adjust_image(fake_B, maxrange, highpercent, lowpercent, hsvgamma)
+
+        return fake_B
+
+    def adjust_image(self, fake_B, maxrange, highpercent, lowpercent, hsvgamma):
+        gray_fake_B = fake_B[:, :, 0] * 0.299 + fake_B[:, :, 1] * 0.587 + fake_B[:, :, 1] * 0.114
+        percent_max = sum(sum(gray_fake_B >= maxrange)) / sum(sum(gray_fake_B <= 1.0))
+        max_value = np.percentile(gray_fake_B[:], highpercent)
+        if percent_max < (100-highpercent)/100.:
+            scale = maxrange / max_value
+            fake_B = fake_B * scale
+            fake_B = np.minimum(fake_B, 1.0)
+
+        gray_fake_B = fake_B[:,:,0]*0.299 + fake_B[:,:,1]*0.587 + fake_B[:,:,1]*0.114
+        sub_value = np.percentile(gray_fake_B[:], lowpercent)
+        fake_B = (fake_B - sub_value) * (1./(1-sub_value))
+
+        imgHSV = cv2.cvtColor(fake_B, cv2.COLOR_RGB2HSV)
+        H, S, V = cv2.split(imgHSV)
+        S = np.power(S, hsvgamma)
+        imgHSV = cv2.merge([H, S, V])
+        fake_B = cv2.cvtColor(imgHSV, cv2.COLOR_HSV2RGB)
+        fake_B = np.minimum(fake_B, 1.0)
+
+        return fake_B
+
+if __name__ == "__main__":
+    logging.basicConfig(filename='image_processor.log', level=logging.INFO)
+
+    image_processor = ImageProcessor(model_name='Syn_img_lowlight_withnoise')
+    iface = gr.Interface(
+    image_processor.process_image,
+    [
+        gr.inputs.Image(shape=(None, None)),  # Corrected line
+        gr.inputs.Slider(85, 100, default=95, label="High Percent"),
+        gr.inputs.Slider(0, 100, default=5, label="Low Percent"),
+        gr.inputs.Slider(6, 10, default=8, label="Gamma"),
+        gr.inputs.Slider(0, 20, default=8, label="Max Range"),
+    ],
+    gr.outputs.Image(type="numpy"),
+)
+
+
+
+    iface.launch(debug=True,share=True)

requirements.txt

@@ -0,0 +1,4 @@
+Tensorflow==1.6.0
+Keras==2.2.0
+Opencv-python==3.4.2
+logging

utls.py

@@ -0,0 +1,124 @@
+import tensorflow as tf
+from keras import backend as K
+import numpy as np
+import scipy
+import os
+import cv2 as cv
+
+def bright_mae(y_true, y_pred):
+    return K.mean(K.abs(y_pred[:,:,:,:3] - y_true[:,:,:,:3]))
+
+def bright_mse(y_true, y_pred):
+    return K.mean((y_pred[:,:,:,:3] - y_true[:,:,:,:3])**2)
+
+def bright_AB(y_true, y_pred):
+            return K.abs(K.mean(y_true[:,:,:,:3])-K.mean(y_pred[:,:,:,:3]))
+
+def log10(x):
+    numerator = K.log(x)
+    denominator = K.log(K.constant(10, dtype=numerator.dtype))
+    return numerator / denominator
+
+def bright_psnr(y_true, y_pred):
+    mse = K.mean((K.abs(y_pred[:,:,:,:3] - y_true[:,:,:,:3])) ** 2)
+    max_num = 1.0
+    psnr = 10 * log10(max_num ** 2 / mse)
+    return psnr
+
+def _tf_fspecial_gauss(size, sigma):
+    """Function to mimic the 'fspecial' gaussian MATLAB function
+    """
+    x_data, y_data = np.mgrid[-size//2 + 1:size//2 + 1, -size//2 + 1:size//2 + 1]
+
+    x_data = np.expand_dims(x_data, axis=-1)
+    x_data = np.expand_dims(x_data, axis=-1)
+
+    y_data = np.expand_dims(y_data, axis=-1)
+    y_data = np.expand_dims(y_data, axis=-1)
+
+    x = tf.constant(x_data, dtype=tf.float32)
+    y = tf.constant(y_data, dtype=tf.float32)
+
+    g = tf.exp(-((x**2 + y**2)/(2.0*sigma**2)))
+    return g / tf.reduce_sum(g)
+
+def tf_ssim(img1, img2, cs_map=False, mean_metric=True, size=11, sigma=1.5):
+    window = _tf_fspecial_gauss(size, sigma) # window shape [size, size]
+    K1 = 0.01
+    K2 = 0.03
+    L = 1  # depth of image (255 in case the image has a differnt scale)
+    C1 = (K1*L)**2
+    C2 = (K2*L)**2
+    mu1 = tf.nn.conv2d(img1, window, strides=[1,1,1,1], padding='VALID')
+    mu2 = tf.nn.conv2d(img2, window, strides=[1,1,1,1],padding='VALID')
+    mu1_sq = mu1*mu1
+    mu2_sq = mu2*mu2
+    mu1_mu2 = mu1*mu2
+    sigma1_sq = tf.nn.conv2d(img1*img1, window, strides=[1,1,1,1],padding='VALID') - mu1_sq
+    sigma2_sq = tf.nn.conv2d(img2*img2, window, strides=[1,1,1,1],padding='VALID') - mu2_sq
+    sigma12 = tf.nn.conv2d(img1*img2, window, strides=[1,1,1,1],padding='VALID') - mu1_mu2
+    if cs_map:
+        value = (((2*mu1_mu2 + C1)*(2*sigma12 + C2))/((mu1_sq + mu2_sq + C1)*
+                            (sigma1_sq + sigma2_sq + C2)),
+                        (2.0*sigma12 + C2)/(sigma1_sq + sigma2_sq + C2))
+    else:
+        value = ((2*mu1_mu2 + C1)*(2*sigma12 + C2))/((mu1_sq + mu2_sq + C1)*
+                            (sigma1_sq + sigma2_sq + C2))
+
+    if mean_metric:
+        value = tf.reduce_mean(value)
+    return value
+
+def tf_ms_ssim(img1, img2, mean_metric=True, level=5):
+    weight = tf.constant([0.0448, 0.2856, 0.3001, 0.2363, 0.1333], dtype=tf.float32)
+    mssim = []
+    mcs = []
+    for l in range(level):
+        ssim_map, cs_map = tf_ssim(img1, img2, cs_map=True, mean_metric=False)
+        mssim.append(tf.reduce_mean(ssim_map))
+        mcs.append(tf.reduce_mean(cs_map))
+        filtered_im1 = tf.nn.avg_pool(img1, [1,2,2,1], [1,2,2,1], padding='SAME')
+        filtered_im2 = tf.nn.avg_pool(img2, [1,2,2,1], [1,2,2,1], padding='SAME')
+        img1 = filtered_im1
+        img2 = filtered_im2
+
+    # list to tensor of dim D+1
+    mssim = tf.stack(mssim, axis=0)
+    mcs = tf.stack(mcs, axis=0)
+
+    value = (tf.reduce_prod(mcs[0:level-1]**weight[0:level-1])*
+                                    (mssim[level-1]**weight[level-1]))
+
+    if mean_metric:
+        value = tf.reduce_mean(value)
+    return value
+
+def bright_SSIM(y_true, y_pred):
+    SSIM_loss = tf_ssim(tf.expand_dims(y_pred[:,:,:,0], -1), tf.expand_dims(y_true[:,:,:,0], -1))+tf_ssim(tf.expand_dims(y_pred[:,:,:,1], -1), tf.expand_dims(y_true[:,:,:,1], -1)) + tf_ssim(tf.expand_dims(y_pred[:,:,:,2], -1), tf.expand_dims(y_true[:,:,:,2], -1))
+    return SSIM_loss/3
+
+def psnr_cau(y_true, y_pred):
+    mse = np.mean((np.abs(y_pred - y_true)) ** 2)
+    max_num = 1.0
+    psnr = 10 * np.log10(max_num ** 2 / mse)
+    return psnr
+
+def save_model(model, name, epoch, batch_i):
+    modelname = './Res_models/' + str(epoch) + '_' + str(batch_i) + name + '.h5'
+    model.save_weights(modelname)
+
+def imread_color(path):
+    img = cv.imread(path, cv.IMREAD_COLOR | cv.IMREAD_ANYDEPTH) / 255.
+    b, g, r = cv.split(img)
+    img_rgb = cv.merge([r, g, b])
+    return img_rgb
+    # return scipy.misc.imread(path, mode='RGB').astype(np.float) / 255.
+
+def imwrite(path, img):
+    r, g, b = cv.split(img*255)
+    img_rgb = cv.merge([b, g, r])
+    cv.imwrite(path, img_rgb)
+    # scipy.misc.toimage(img * 255, high=255, low=0, cmin=0, cmax=255).save(path)
+
+def range_scale(x):
+    return x * 2 - 1.