app.py

# Libraries
import tensorflow as tf
import os
import pathlib
import time
import datetime
from matplotlib import pyplot as plt
import numpy as np
import cv2 as cv2
import math 
from tensorflow import keras
from tensorflow.keras.models import *
from tensorflow.keras.layers import *
from tensorflow.keras.optimizers import *


###YOLOFACE
import sys

CONF_THRESHOLD = 0.5
NMS_THRESHOLD = 0.4
IMG_WIDTH = 416
IMG_HEIGHT = 416

# Default colors
COLOR_BLUE = (255, 0, 0)
COLOR_GREEN = (0, 255, 0)
COLOR_RED = (0, 0, 255)
COLOR_WHITE = (255, 255, 255)
COLOR_YELLOW = (0, 255, 255)

# Get the names of the output layers
def get_outputs_names(net):

    # Get the names of all the layers in the network
    layers_names = net.getLayerNames()

    # Get the names of the output layers, i.e. the layers with unconnected
    # outputs
    return [layers_names[i - 1] for i in net.getUnconnectedOutLayers()]


# Draw the predicted bounding box
def draw_predict(frame, conf, left, top, right, bottom):
    # Draw a bounding box.
    cv2.rectangle(frame, (left, top), (right, bottom), COLOR_YELLOW, 2)

    text = '{:.2f}'.format(conf)

    # Display the label at the top of the bounding box
    label_size, base_line = cv2.getTextSize(text, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 1)

    top = max(top, label_size[1])
    cv2.putText(frame, text, (left, top - 4), cv2.FONT_HERSHEY_SIMPLEX, 0.4,
                COLOR_WHITE, 1)


def post_process(frame, outs, conf_threshold, nms_threshold):
    frame_height = frame.shape[0]
    frame_width = frame.shape[1]

    # Scan through all the bounding boxes output from the network and keep only
    # the ones with high confidence scores. Assign the box's class label as the
    # class with the highest score.
    confidences = []
    boxes = []
    final_boxes = []
    for out in outs:
        for detection in out:
            scores = detection[5:]
            class_id = np.argmax(scores)
            confidence = scores[class_id]
            if confidence > conf_threshold:
                center_x = int(detection[0] * frame_width)
                center_y = int(detection[1] * frame_height)
                width = int(detection[2] * frame_width)
                height = int(detection[3] * frame_height)
                left = int(center_x - width / 2)
                top = int(center_y - height / 2)
                confidences.append(float(confidence))
                boxes.append([left, top, width, height])

    # Perform non maximum suppression to eliminate redundant
    # overlapping boxes with lower confidences.
    indices = cv2.dnn.NMSBoxes(boxes, confidences, conf_threshold,
                               nms_threshold)
    field = 0
    ratio = 0
    face = 0
    for i in indices:
        box = boxes[i]
        left = box[0]
        top = box[1]
        width = box[2]
        height = box[3]
        final_boxes.append(box)
        
        if len(indices)==1:
            field = 2*(width+height)
            ratio = (field * 100) / (256 *256)
            #print("%.2f" % ratio)
        elif len(indices)>1:
            if len(indices) != i+1:
                field += 2*(width+height)
                ratio = (field * 100) / (256 * 256)
            #if len(indices) == i:
                #print("%.2f" % ratio)
                
        
        if ratio > 0.60:
            face = 1
            #print("face!")
            
        left, top, right, bottom = refined_box(left, top, width, height)
        # draw_predict(frame, confidences[i], left, top, left + width,
        #              top + height)
        draw_predict(frame, confidences[i], left, top, right, bottom)
    return final_boxes, face

class FPS:
    def __init__(self):
        # store the start time, end time, and total number of frames
        # that were examined between the start and end intervals
        self._start = None
        self._end = None
        self._num_frames = 0

    def start(self):
        self._start = datetime.datetime.now()
        return self

    def stop(self):
        self._end = datetime.datetime.now()

    def update(self):
        # increment the total number of frames examined during the
        # start and end intervals
        self._num_frames += 1

    def elapsed(self):
        # return the total number of seconds between the start and
        # end interval
        return (self._end - self._start).total_seconds()

    def fps(self):
        # compute the (approximate) frames per second
        return self._num_frames / self.elapsed()

def refined_box(left, top, width, height):
    right = left + width
    bottom = top + height

    original_vert_height = bottom - top
    top = int(top + original_vert_height * 0.15)
    bottom = int(bottom - original_vert_height * 0.05)

    margin = ((bottom - top) - (right - left)) // 2
    left = left - margin if (bottom - top - right + left) % 2 == 0 else left - margin - 1

    right = right + margin

    return left, top, right, bottom


model_cfg = 'yolov3-face.cfg'
model_weights = 'yolov3-wider_16000.weights'


net = cv2.dnn.readNetFromDarknet(model_cfg, model_weights)
net.setPreferableBackend(cv2.dnn.DNN_BACKEND_OPENCV)
net.setPreferableTarget(cv2.dnn.DNN_TARGET_CPU)


def face_detection(image):

    output_file = ''
    index = 1


    while True:
        image = np.array(image)
        # Create a 4D blob from a frame.
        blob = cv2.dnn.blobFromImage(image, 1 / 255, (IMG_WIDTH, IMG_HEIGHT),[0, 0, 0], 1, crop=False)

        # Sets the input to the network
        net.setInput(blob)

        # Runs the forward pass to get output of the output layers
        outs = net.forward(get_outputs_names(net))

        # Remove the bounding boxes with low confidence
        faces = post_process(image, outs, CONF_THRESHOLD, NMS_THRESHOLD)
        
        #print('[i] ==> # detected faces: {}'.format(len(faces)))
        #print('#' * 60)

        # initialize the set of information we'll displaying on the frame
        info = [
            ('number of faces detected', '{}'.format(len(faces)))
        ]
        
        """
        for (i, (txt, val)) in enumerate(info):
            text = '{}: {}'.format(txt, val)
            cv2.putText(frame, text, (10, (i * 20) + 20),
                        cv2.FONT_HERSHEY_SIMPLEX, 0.4, COLOR_RED, 1)
        """
        return faces[1]

        

    cap.release()
    cv2.destroyAllWindows()

###PIX2PIX
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 reshape(gray_img):
  gray_img = np.asarray(gray_img)
  gray_img = gray_img.reshape(256,256,1)
  return gray_img


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


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)


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 alexnet(pretrained_weights = None,input_size = (256,256,3)):
    model = Sequential()
    model.add(Conv2D(input_shape=input_size, filters= 512, kernel_size =(11,11) ,strides=(4,4), activation = keras.layers.LeakyReLU(alpha=0.01)))
    model.add(MaxPooling2D(pool_size=(3, 3), strides=(2,2)))
    
    model.add(Conv2D(filters= 256, kernel_size =(5,5) ,strides=(2,2), activation = keras.layers.LeakyReLU(alpha=0.01) , padding='same'))
    model.add(MaxPooling2D(pool_size=(3, 3), strides=(2,2)))
    
    model.add(Conv2D(filters= 128, kernel_size =(3,3) , activation = keras.layers.LeakyReLU(alpha=0.01) , padding='same'))
    model.add(Conv2D(filters= 32, kernel_size =(3,3) , activation = keras.layers.LeakyReLU(alpha=0.01) , padding='same'))
    model.add(MaxPooling2D(pool_size=(3, 3), strides=(2,2)))
    
    model.add(Flatten())
    model.add(Dense(4096 , activation = keras.layers.LeakyReLU(alpha=0.01)))
    model.add(Dropout(0.3))
    model.add(Dense(4096 , activation = keras.layers.LeakyReLU(alpha=0.01)))
    model.add(Dropout(0.5))
    model.add(Dense(256 , activation = keras.layers.LeakyReLU(alpha=0.01)))
    model.add(Dropout(0.3))
    model.add(Dense(2 , activation='softmax'))
    
    return model

def result(Input,Choice,Step):
    
    if Choice=="Place-Coloring": 
        ###ALEXNET
        model = alexnet()
        model.load_weights('indoor_outdoor.h5')  
        
        image = cv2.cvtColor(Input,cv2.COLOR_BGR2RGB)
        image = cv2.resize(image, (256,256), interpolation = cv2.INTER_AREA)
        image = np.array(image).reshape(-1,256,256,3)
        pred = model.predict(image)
        result = np.argmax(pred, axis=1)
        
        if int(result[0]) == 1:
          if Step == 1.0:
            pre_trained = tf.keras.models.load_model("indoor_1.h5")
          if Step == 2.0:
            pre_trained = tf.keras.models.load_model("indoor_2.h5")
          if Step == 3.0:
            pre_trained = tf.keras.models.load_model("indoor_3.h5")
           
          size0 = Input.shape[0]
          size1 = Input.shape[1]
          start = Input
          Input = cv2.cvtColor(Input,cv2.COLOR_RGB2BGR)
          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)
          Input = unsharp_mask(Input)
          finish = Input
          mse = np.mean((start - finish) ** 2)
          MAX = np.iinfo(start.dtype).max
          if mse == 0:
            Psnr = 100
          else:
            Psnr = 20 * math.log10(MAX / math.sqrt(mse))
          return Input,Psnr
          
        if int(result[0]) == 0:        
        
          if Step == 1.0:
            pre_trained = tf.keras.models.load_model("outdoor_1.h5")
          if Step == 2.0:
            pre_trained = tf.keras.models.load_model("outdoor_2.h5")
          if Step == 3.0:
            pre_trained = tf.keras.models.load_model("outdoor_3.h5")
            
          size0 = Input.shape[0]
          size1 = Input.shape[1]
          start = Input
          Input = cv2.cvtColor(Input,cv2.COLOR_RGB2BGR)
          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)
          Input = unsharp_mask(Input)
          finish = Input
          mse = np.mean((start - finish) ** 2)
          MAX = np.iinfo(start.dtype).max
          if mse == 0:
            Psnr = 100
          else:
            Psnr = 20 * math.log10(MAX / math.sqrt(mse))
          return Input,Psnr
    
    if Choice=="Face-Coloring":
      test_face = face_detection(Input)
      if test_face != 1:
        Psnr = -1
        return Input, Psnr
      else:
        if Step == 1.0:
          pre_trained = tf.keras.models.load_model("face_1.h5")
        if Step == 2.0:
          pre_trained = tf.keras.models.load_model("face_2.h5")
        if Step == 3.0:
          pre_trained = tf.keras.models.load_model("face_3.h5")
          
        size0 = Input.shape[0]
        size1 = Input.shape[1]
        start = Input
        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)
        Input = unsharp_mask(Input)
        finish = Input
        mse = np.mean((start - finish) ** 2)
        MAX = np.iinfo(start.dtype).max
        if mse == 0:
          Psnr = 100
        else:
          Psnr = 20 * math.log10(MAX / math.sqrt(mse))
        return Input,Psnr
          
    if Choice =="Enhancement":
        if Step == 1.0:
          pre_trained = tf.keras.models.load_model("generatorLR-HR_300.h5")
        if Step == 2.0:
          pre_trained = tf.keras.models.load_model("generatorLR-HR_300.h5")
        if Step == 3.0:
          pre_trained = tf.keras.models.load_model("generatorLR-HR_300.h5")
     
        size0 = Input.shape[0]
        size1 = Input.shape[1]
        start = Input
        Input = cv2.resize(Input, (256,256), interpolation = cv2.INTER_AREA)
        Input = cv2.cvtColor(Input , cv2.COLOR_BGR2RGB)
        Input = (Input/127.5) - 1
        Input = Input.astype(np.float32)
        Input = np.array(Input).reshape(1,256,256,3)
        prediction = pre_trained(Input,training=True)
        Input = prediction[0]
        Input = (Input+1)*127.5
        Input = np.uint8(Input)
        Input = np.array(Input).reshape(256,256,3)
        Input = cv2.cvtColor(Input , cv2.COLOR_BGR2RGB)
        Input = cv2.resize(Input, (size1,size0), interpolation = cv2.INTER_AREA)
        Input = unsharp_mask(Input)
        finish = Input
        mse = np.mean((start - finish) ** 2)
        MAX = np.iinfo(start.dtype).max
        if mse == 0:
          Psnr = 100
        else:
          Psnr = 20 * math.log10(MAX / math.sqrt(mse))
        return Input,Psnr

    if Choice=="Repair":
        if Step == 1.0:
          pre_trained = tf.keras.models.load_model("Repair_1.h5")
        if Step == 2.0:
          pre_trained = tf.keras.models.load_model("Repair_2.h5")
        if Step == 3.0:
          pre_trained = tf.keras.models.load_model("Repair_3.h5")
          
        size0 = Input.shape[0]
        size1 = Input.shape[1]
        start = Input
        start = cv2.cvtColor(start , cv2.COLOR_RGB2GRAY)
        start = np.array(start).reshape(256,256)       
        Input = cv2.resize(Input, (256,256), interpolation = cv2.INTER_AREA)
        Input = cv2.cvtColor(Input , cv2.COLOR_RGB2GRAY)
        Input = Input.astype(np.float32)
        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 = np.array(Input).reshape(256,256,3)
        Input = cv2.resize(Input, (size1,size0), interpolation = cv2.INTER_AREA)
        Input = unsharp_mask(Input)
        Input = cv2.cvtColor(Input , cv2.COLOR_RGB2GRAY)
        finish = Input
        mse = np.mean((start - finish) ** 2)
        MAX = np.iinfo(start.dtype).max
        if mse == 0:
          Psnr = 100
        else:
          Psnr = 20 * math.log10(MAX / math.sqrt(mse))
        return Input,Psnr

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

import gradio as gr
gr.Interface(fn=result, inputs=[gr.inputs.Image(type="numpy",image_mode="RGB"), gr.inputs.Radio(
choices=["Place-Coloring","Face-Coloring","Enhancement", "Repair"]),gr.inputs.Slider(minimum=1.0,maximum=3.0,default=3.0,step=1.0)], outputs=[gr.outputs.Image(type="numpy", label="Output"),gr.outputs.Textbox(label="Psnr Between Input and Output")], live=True,title="Color, Enhancement, Restoration for Old Images - ImgCERO",examples=[["repair.png","Repair",3.0],["enhancement.png","Enhancement",3.0],["face_color.png","Face-Coloring",3.0],["indoor_color.png","Place-Coloring",3.0],["outdoor_color.png","Place-Coloring",3.0]],css=""" body {background-color: rgba(127,191,63,0.48)} """,article=""" <a href="https://docs.google.com/document/d/19k6dyR5x_hd1M0yoU8i49dlDWvFmtnBT/edit?usp=sharing&ouid=115743073712072785012&rtpof=true&sd=true" download="example.docx"><img src="https://img.icons8.com/external-itim2101-lineal-color-itim2101/64/000000/external-article-blogger-and-influencer-itim2101-lineal-color-itim2101-1.png" alt="Article"></a>""").launch(debug="True")