app.py

import tensorflow as tf
import os
import pathlib
import time
import datetime
from matplotlib import pyplot as plt
import numpy as np
from cv2 import cv2
import math 
import keras


#tuz-karabiber gürültüsü
def saltpepperNoise(image):
  row,col,ch = image.shape
  s_vs_p = 0.5
  amount = 0.004
  out = image
  # Salt mode
  num_salt = np.ceil(amount * image.size * s_vs_p)
  coords = [np.random.randint(0, i - 1, int(num_salt))
            for i in image.shape]
  out[coords] = 1

  # Pepper mode
  num_pepper = np.ceil(amount* image.size * (1. - s_vs_p))
  coords = [np.random.randint(0, i - 1, int(num_pepper))
            for i in image.shape]
  out[coords] = 0
  return out

def color_imread(path):
    img = cv2.imread(path)
    img = cv2.cvtColor(img , cv2.COLOR_BGR2RGB)
    img = (img/127.5) - 1
    img = img.astype(np.float32)
    return img

def gray_imread(path):
    img = cv2.imread(path)
    img = cv2.cvtColor(img ,cv2.COLOR_BGR2GRAY)
    img = img.astype(np.float32)
    return img

def load():
  input_paths = sorted('*.png')
  real_paths = sorted('*.png')
  input_images = []
  real_images = []
  for path in input_paths:
      image = gray_imread(path)
      input_images.append(image)
  for path in real_paths:
      image = color_imread(path)
      real_images.append(image)

  return input_images , real_images

def reshape(gray_img):
  gray_img = np.asarray(gray_img)
  gray_img = gray_img.reshape(256,256,1)
  return gray_img

#input_images , real_images = load()

#test = gray_imread("/content/drive/MyDrive/ColabNotebooks/enhance/landscape.png")
#test = cv2.resize(test,(256,256))

#for i in range(len(input_images)):
# input_images[i] = reshape(input_images[i])

#test = reshape(test)

#print(np.asarray(test).shape)

def ssim(original,predict):
   ssim = tf.image.ssim(original, predict, max_val=1.0, filter_size=11, filter_sigma=1.5, k1=0.01, k2=0.03)
   return ssim

def psnr(img1, img2):
  psnr = tf.image.psnr(img1, img2, max_val=255)
  return psnr

array_Gen_loss=[]

def histogram_graphic(img):
  hist,bins = np.histogram(img.flatten(),256,[0,256])
  cdf = hist.cumsum()
  cdf_normalized = cdf * float(hist.max()) / cdf.max()
  plt.plot(cdf_normalized, color = 'b')
  plt.hist(img.flatten(),256,[0,256], color = 'r')
  plt.xlim([0, 230])
  plt.legend(('cdf','histogram'), loc = 'upper left')
  plt.show()

def preprocessing(path):
  img = cv2.imread(path)
  img = np.asarray(img).reshape(256,256,3)
  #print(img.shape)
  #cv2.imshow(img)
  #cv2.imwrite("/content/drive/MyDrive/ColabNotebooks/enhance/Before_hist_equalizer.png",img)
    
  #Işık ayarı
  hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV) #hsv formatında gerekiyor
  hue, sat, val = cv2.split(hsv)

  mid = 0.5
  mean = np.mean(val)
  gamma = math.log(mid*255)/math.log(mean)
  #print("Gamma:",gamma)
  #Çıkan gamma değerine göre ters işlem uygulayacak

  #value kanalında gamma correction
  #val_gamma = np.power(val, gamma).clip(0,255).astype(np.uint8)

  # yeni value kanalı orijinal hue ve sat kanallarıyla birleştiriliyor 
  #hsv_gamma = cv2.merge([hue, sat, val_gamma])
  #img_gamma = cv2.cvtColor(hsv_gamma, cv2.COLOR_HSV2BGR)
  #cv2.imwrite("/content/drive/MyDrive/ColabNotebooks/img_gamma.png",img_gamma)
  #cv2.imshow(img_gamma)

  #Adaptive Histogram Equalization
  #gamma_path = "/content/drive/MyDrive/ColabNotebooks/img_gamma.png"
  #img2 = cv2.imread(gamma_path,0)
  #img2 = np.asarray(img2).reshape(256,256,1)
  #clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
  #clipLimit -> Kontrast sınırı
  #clahe_equ = clahe.apply(img2)
  #cv2.imshow(clahe_equ)
  #cv2.imwrite("/content/drive/MyDrive/ColabNotebooks/enhance/After_clahe_equalizer.png",clahe_equ)
  #return clahe_equ

#preprocessing("/content/drive/MyDrive/ColabNotebooks/enhance/landscape.png")

def image_colorfulness(image):
    # split the image into its respective RGB components
    (B, G, R) = cv2.split(image.astype("float"))

    # compute rg = R - G
    rg = np.absolute(R - G)

    # compute yb = 0.5 * (R + G) - B
    yb = np.absolute(0.5 * (R + G) - B)

    # compute the mean and standard deviation of both `rg` and `yb`
    (rbMean, rbStd) = (np.mean(rg), np.std(rg))
    (ybMean, ybStd) = (np.mean(yb), np.std(yb))

    # combine the mean and standard deviations
    stdRoot = np.sqrt((rbStd ** 2) + (ybStd ** 2))
    meanRoot = np.sqrt((rbMean ** 2) + (ybMean ** 2))

    # derive the "colorfulness" metric and return it
    return stdRoot + (0.3 * meanRoot) # sınırı 24

from PIL import Image, ImageEnhance
def add_saturation(path):
  clr = cv2.imread(path)
  value = image_colorfulness(clr)
  print(value)
  img = Image.open(path)
  enhanced_obj = ImageEnhance.Color(img)
  if value<30 :  #renk doygunluğu iyi durumda çıkanları da bir miktar arttırmak için sınırı 30 yapıyoruz 
    enhanced_obj.enhance((30-value)*0.1 + 0.75).save("enhance/deneme_sat.jpg")

#add_saturation("/content/drive/MyDrive/ColabNotebooks/enhance/cikti2.jpeg")

def unsharp_mask(image, kernel_size=(5, 5), sigma=1.0, amount=1.0, threshold=0):
    """Return a sharpened version of the image, using an unsharp mask."""
    blurred = cv2.GaussianBlur(image, kernel_size, sigma)
    sharpened = float(amount + 1) * image - float(amount) * blurred
    sharpened = np.maximum(sharpened, np.zeros(sharpened.shape))
    sharpened = np.minimum(sharpened, 255 * np.ones(sharpened.shape))
    sharpened = sharpened.round().astype(np.uint8)
    if threshold > 0:
        low_contrast_mask = np.absolute(image - blurred) < threshold
        np.copyto(sharpened, image, where=low_contrast_mask)
    return sharpened

def example(image,name):
    sharpened_image = unsharp_mask(image)
    cv2.imwrite(name, sharpened_image)

#s_img= cv2.imread("/content/drive/MyDrive/ColabNotebooks/enhance/deneme.jpg")
#example(s_img,"/content/drive/MyDrive/ColabNotebooks/enhance/deneme_sharp.jpg")

#img2 = cv2.imread("/content/drive/MyDrive/ColabNotebooks/enhance/landscape.png")
#newimg2 = cv2.imread("/content/drive/MyDrive/ColabNotebooks/enhance/Output/nadam_image9.png")

#psnr(img2,newimg2)
#ssim(img2,newimg2)

import math
import cv2
import numpy as np

#original = cv2.imread("/content/drive/MyDrive/ColabNotebooks/enhance/landscape.png",0)
#contrast = cv2.imread("/content/drive/MyDrive/ColabNotebooks/enhance/After_clahe_equalizer_with_gamma.png",0)

#print(original.dtype)
def psnr(img1, img2, MAX=None):
    if MAX is None:
		    MAX = np.iinfo(img1.dtype).max
    mse = np.mean((img1 - img2) ** 2)
    if mse == 0:
        return 100
    return 20 * math.log10(MAX / math.sqrt(mse))


#db = psnr(original, contrast)
#print(db)

OUTPUT_CHANNELS = 3

def downsample(filters, size, apply_batchnorm=True):
  initializer = tf.random_normal_initializer(0., 0.02)

  result = tf.keras.Sequential()
  result.add(tf.keras.layers.Conv2D(filters, size, strides=2, padding='same',kernel_initializer=initializer, use_bias=False))
  # Burada 2'ye bölüyoruz 256 --> 128
  if apply_batchnorm:
    result.add(tf.keras.layers.BatchNormalization())

  result.add(tf.keras.layers.LeakyReLU())

  return result

def upsample(filters, size, apply_dropout=False):
  initializer = tf.random_normal_initializer(0., 0.02)

  result = tf.keras.Sequential()
  result.add(
    tf.keras.layers.Conv2DTranspose(filters, size, strides=2,
                                    padding='same',
                                    kernel_initializer=initializer,
                                    use_bias=False))
# burada da 2 kat arttırıyoruz
  result.add(tf.keras.layers.BatchNormalization())

  if apply_dropout:
      result.add(tf.keras.layers.Dropout(0.5))

  result.add(tf.keras.layers.ReLU())

  return result

def Generator(tpu=False):
  inputs = tf.keras.layers.Input(shape=[256, 256, 1])

  down_stack = [
    downsample(64, 4, apply_batchnorm=False),  # (batch_size, 128, 128, 64)
    downsample(128, 4),  # (batch_size, 64, 64, 128)
    downsample(256, 4),  # (batch_size, 32, 32, 256)
    downsample(512, 4),  # (batch_size, 16, 16, 512)
    downsample(512, 4),  # (batch_size, 8, 8, 512)
    downsample(512, 4),  # (batch_size, 4, 4, 512)
    downsample(512, 4),  # (batch_size, 2, 2, 512)
    downsample(512, 4),  # (batch_size, 1, 1, 512)
  ]

  up_stack = [
    upsample(512, 4, apply_dropout=True),  # (batch_size, 2, 2, 1024)
    upsample(512, 4, apply_dropout=True),  # (batch_size, 4, 4, 1024)
    upsample(512, 4, apply_dropout=True),  # (batch_size, 8, 8, 1024)
    upsample(512, 4),  # (batch_size, 16, 16, 1024)
    upsample(256, 4),  # (batch_size, 32, 32, 512)
    upsample(128, 4),  # (batch_size, 64, 64, 256)
    upsample(64, 4),  # (batch_size, 128, 128, 128)
  ]
  initializer = tf.random_normal_initializer(0., 0.02)
  last = tf.keras.layers.Conv2DTranspose(OUTPUT_CHANNELS, 4,
                                         strides=2,
                                         padding='same',
                                         kernel_initializer=initializer,
                                         activation='tanh')  # (batch_size, 256, 256, 3)
# Build U-NET
  x = inputs

  # Downsampling through the model
  skips = []
  for down in down_stack:
    x = down(x)
    skips.append(x)

  skips = reversed(skips[:-1]) # son elemani almadan terste yazdirir

  # Upsampling and establishing the skip connections
  for up, skip in zip(up_stack, skips):
    x = up(x)
    x = tf.keras.layers.Concatenate()([x, skip])

  x = last(x)
  model = tf.keras.Model(inputs=inputs, outputs=x)
  
  return model

pre_trained = Generator()
pre_trained.compile(optimizer='adam',loss=tf.keras.losses.BinaryCrossentropy(from_logits=True))

from tensorflow.keras.models import *
from tensorflow.keras.layers import *
from tensorflow.keras.optimizers import *

#integer = (input_images[0]+1)*127.5

LAMBDA = 100
loss_object = tf.keras.losses.BinaryCrossentropy(from_logits=True)

def generator_loss(disc_generated_output, gen_output, target,total_loop):
  gan_loss = loss_object(tf.ones_like(disc_generated_output), disc_generated_output)
  # Mean absolute error
  l1_loss = tf.reduce_mean(tf.abs(target - gen_output))
  total_gen_loss = gan_loss + (LAMBDA * l1_loss)
  if total_loop % 2 == 0:
    array_Gen_loss.append(total_gen_loss)
  return total_gen_loss, gan_loss, l1_loss

ssim_results = []
psnr_results = []

def ssim_psnr(pre,target):
    ssim_res = ssim(pre,target)
    psnr_res = psnr(pre,target)
    ssim_results.append(ssim_res)
    psnr_results.append(ssim_results)

def Discriminator():
  initializer = tf.random_normal_initializer(0., 0.02)

  inp = tf.keras.layers.Input(shape=[256, 256, 1], name='input_image') # lr
  tar = tf.keras.layers.Input(shape=[256, 256, 3], name='target_image') # hr

  x = tf.keras.layers.concatenate([inp, tar])  # (batch_size, 256, 256, channels*2)

  down1 = downsample(64, 4, False)(x)  # (batch_size, 128, 128, 64)
  down2 = downsample(128, 4)(down1)  # (batch_size, 64, 64, 128)
  down3 = downsample(256, 4)(down2)  # (batch_size, 32, 32, 256)

  zero_pad1 = tf.keras.layers.ZeroPadding2D()(down3)  # (batch_size, 34, 34, 256)
  conv = tf.keras.layers.Conv2D(512, 4, strides=1,
                                kernel_initializer=initializer,
                                use_bias=False)(zero_pad1)  # (batch_size, 31, 31, 512)

  batchnorm1 = tf.keras.layers.BatchNormalization()(conv)

  leaky_relu = tf.keras.layers.LeakyReLU()(batchnorm1)

  zero_pad2 = tf.keras.layers.ZeroPadding2D()(leaky_relu)  # (batch_size, 33, 33, 512)

  last = tf.keras.layers.Conv2D(1, 4, strides=1,
                                kernel_initializer=initializer)(zero_pad2)  # (batch_size, 30, 30, 1)

  return tf.keras.Model(inputs=[inp, tar], outputs=last)

discriminator = Discriminator()

def discriminator_loss(disc_real_output, disc_generated_output):
  real_loss = loss_object(tf.ones_like(disc_real_output), disc_real_output)

  generated_loss = loss_object(tf.zeros_like(disc_generated_output), disc_generated_output)

  total_disc_loss = real_loss + generated_loss #  0.5 ile de çarpabilirsin

  return total_disc_loss

generator_optimizer = tf.keras.optimizers.Nadam(learning_rate=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-07, name="Nadam")
discriminator_optimizer = tf.keras.optimizers.Nadam(learning_rate=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-07, name="Nadam")

def generate_images(model, test_input,step):
  if (step%1 == 0):
    prediction = model(test_input, training=True)
    pre = prediction[0]
    pre = (pre+1)*127.5
    pre = np.uint8(pre)
    name = 'image{step}.png'.format(step=step)
    plt.imsave(name,pre)

#test = np.array(test).reshape(1,256,256,1)
#input_images = np.array(input_images).reshape(-1,1,256,256,1)
#real_images = np.array(real_images).reshape(-1,1,256,256,3)
#print(real_images[0].shape)

def train_step(input_image, target, step):
  with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape:
    gen_output = pre_trained(input_image, training=True)

    disc_real_output = discriminator([input_image, target], training=True)
    disc_generated_output = discriminator([input_image, gen_output], training=True)

    gen_total_loss, gen_gan_loss, gen_l1_loss = generator_loss(disc_generated_output, gen_output, target,10)
    disc_loss = discriminator_loss(disc_real_output, disc_generated_output)
  
  generator_gradients = gen_tape.gradient(gen_total_loss,
                                          pre_trained.trainable_variables)
  discriminator_gradients = disc_tape.gradient(disc_loss,
                                               discriminator.trainable_variables)

  generator_optimizer.apply_gradients(zip(generator_gradients,
                                          pre_trained.trainable_variables))
  discriminator_optimizer.apply_gradients(zip(discriminator_gradients,
                                              discriminator.trainable_variables))

def fit(input_images,real_images,test,steps):
  example_input = test
  start = time.time()
  step = 0
  i = 0
  while step<steps:
    print("Step = ",step)
    while i < len(input_images):
          train_step(input_images[i], real_images[i], step)
          if (i%200 == 0):
            print('i= ',i)
          i +=1
    generate_images(pre_trained, example_input,step)
    step+=1
    i = 0
  generate_images(pre_trained, example_input,step)

#fit(input_images,real_images,test,10)

#pre_trained.save("enhance/pix2pix.h5")

a = array_Gen_loss
a = np.asarray(a)
plt.plot(a)
plt.ylabel('Loss Percent')
plt.xlabel('Epochs')
plt.show()

pre_trained = keras.models.load("gradio_pix2pix.h5")

#pre_trained.summary()

#pre_trained.optimizer

#path2 = '/content/drive/MyDrive/ColabNotebooks/enhance/landscape.png'
#image = gray_imread(path2)
#image = saltpepperNoise(image)
#image = np.array(image).reshape(1,256,256,1)

#prediction = pre_trained(image,training=True)
#pre = prediction[0]
#pre = (pre+1)*127.5
#pre = np.uint8(pre)
#name = '/content/drive/MyDrive/ColabNotebooks/enhance/pre_trained.png'
#plt.imsave(name,pre)
#cv2.imshow(pre)

def result(Input):
    size0 = Input.shape[0]
    size1 = Input.shape[1]
    Input = cv2.resize(Input, (256,256), interpolation = cv2.INTER_AREA)
    Input = cv2.cvtColor(Input , cv2.COLOR_BGR2GRAY)
    Input = np.array(Input).reshape(1,256,256,1)
    prediction = pre_trained(Input,training=True)
    Input = prediction[0]
    Input = (Input+1)*127.5
    Input = np.uint8(Input)
    Input = cv2.resize(Input, (size1,size0), interpolation = cv2.INTER_AREA)
    return Input

#lst = cv2.imread('/content/drive/MyDrive/ColabNotebooks/enhance/low-sat.jpg')
#r = result(lst)
#cv2.imshow(r)

import gradio as gr

iface = gr.Interface(fn=result, inputs=gr.inputs.Image(type="numpy",image_mode="RGB"), outputs=gr.outputs.Image( type="auto", label=None),theme="grass"
,allow_flagging="never",css=""" body {background-color: rgba(127,191,63,0.48)} """,title="Image Colorization")
iface.launch(debug='False')