# 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=""" Article""").launch(debug="True")