import gradio as gr
from PIL import Image
from patchify import patchify, unpatchify
import numpy as np
from skimage.io import imshow, imsave
import tensorflow
import tensorflow as tf
from tensorflow.keras import backend as K
from tensorflow.keras.models import Model
import os
os.environ["SM_FRAMEWORK"] = "tf.keras"

from tensorflow import keras
import segmentation_models as sm


def jacard(y_true, y_pred):
    y_true_c = K.flatten(y_true)
    y_pred_c = K.flatten(y_pred)
    intersection = K.sum(y_true_c * y_pred_c)
    return (intersection + 1.0) / (K.sum(y_true_c) + K.sum(y_pred_c) - intersection + 1.0)


def bce_dice(y_true, y_pred):
    bce = tf.keras.losses.BinaryCrossentropy()
    return bce(y_true, y_pred) - K.log(jacard(y_true, y_pred))



pach_size = 256


def predict_2(image):
        size = 1024
        sizes_list = [256*10, 256*9, 256*8, 256*7, 256*6, 256*5, 256*4, 256*3, 256*2, 256*1]
        min_size = min(image.shape)
        if min_size%256==0:
                size = min_size
        else:
            for i in sizes_list:
                if min_size-i >= 0:
                    size = i
                    break
            
            
        image = Image.fromarray(image).resize((size,size))
        image = np.array(image)        
        stride = 1
        steps = int(pach_size/stride)
        patches_img = patchify(image, (pach_size, pach_size, 3), step=steps)  #Step=256 for 256 patches means no overlap        
        patches_img = patches_img[:,:,0,:,:,:]
        patched_prediction = []

        
        for i in range(patches_img.shape[0]):
              for j in range(patches_img.shape[1]):
    
                  single_patch_img = patches_img[i,j,:,:,:]
    
    
                  single_patch_img = single_patch_img/255
    
                  single_patch_img = np.expand_dims(single_patch_img, axis=0)
                  pred = model.predict(single_patch_img)
                  # Postprocess the mask
    
                  pred = np.argmax(pred, axis=3)
                  #print(pred.shape)
                  pred = pred[0, :,:]
    
    
                  patched_prediction.append(pred)
      
      
        patched_prediction = np.reshape(patched_prediction, [patches_img.shape[0], patches_img.shape[1],
                                                  patches_img.shape[2], patches_img.shape[3]])
      
        unpatched_prediction = unpatchify(patched_prediction, (image.shape[0], image.shape[1]))
        labels = LABEL_NAMES
        res = np.bincount(unpatched_prediction.reshape(-1))/unpatched_prediction.reshape(-1).shape[0]
        out = dict(list(zip(labels, res)))
        unpatched_prediction = targets_classes_colors[unpatched_prediction]
        

        return out, unpatched_prediction

LABEL_NAMES = ["unlabeled",    
               "paved-area",  
                     "dirt", 
                    "grass",    
                   "gravel",  
                    "water",   
                    "rocks",   
                     "pool",   
               "vegetation",  
                     "roof",  
                     "wall",  
                   "window",  
                     "door",  
                    "fence",  
               "fence-pole",  
                   "person",  
                      "dog",  
                      "car",    
                  "bicycle",  
                     "tree",   
                "bald-tree",  
                "ar-marker",  
                 "obstacle",    
              "conflicting",
            ]
targets_classes_colors = np.array([[  0,   0,   0],
                          [128,  64, 128],
                          [130,  76,   0],
                          [  0, 102,   0],
                          [112, 103,  87],
                          [ 28,  42, 168],
                          [ 48,  41,  30],
                          [  0,  50,  89],
                          [107, 142,  35],
                          [ 70,  70,  70],
                          [102, 102, 156],
                          [254, 228,  12],
                          [254, 148,  12],
                          [190, 153, 153],
                          [153, 153, 153],
                          [255,  22,  96],
                          [102,  51,   0],
                          [  9, 143, 150],
                          [119,  11,  32],
                          [ 51,  51,   0],
                          [190, 250, 190],
                          [112, 150, 146],
                          [  2, 135, 115],
                          [255,   0,   0]])

class_weights = {0: 0.1,
 1: 0.1,
 2: 2.171655596616696,
 3: 0.1,
 4: 0.1,
 5: 2.2101197049812593,
 6: 11.601519937899578,
 7: 7.99072122367673,
 8: 0.1,
 9: 0.1,
 10: 2.5426918173402457,
 11: 11.187574445057574,
 12: 241.57620214903147,
 13: 9.234779790464515,
 14: 1077.2745952165694,
 15: 7.396021659003857,
 16: 855.6730643687165,
 17: 6.410869993189135,
 18: 42.0186736125025,
 19: 2.5648760196752947,
 20: 4.089194047656931,
 21: 27.984593442818955,
 22: 2.0509251319694712}

weight_list = list(class_weights.values())

def weighted_categorical_crossentropy(weights):
    weights = weight_list
    def wcce(y_true, y_pred):
        Kweights = K.constant(weights)
        if not tf.is_tensor(y_pred): y_pred = K.constant(y_pred)
        y_true = K.cast(y_true, y_pred.dtype)
        return bce_dice(y_true, y_pred) * K.sum(y_true * Kweights, axis=-1)
    return wcce

from tensorflow.python.keras.utils import generic_utils
    
# Load the model
#model = tf.keras.models.load_model("model.h5", custom_objects={"jacard":jacard, "wcce":weighted_categorical_crossentropy})
#model = tf.keras.models.load_model("model_2.h5", custom_objects={"jacard":jacard, "bce_dice":bce_dice})
###model = tf.keras.models.load_model("model_2_A.h5", custom_objects={"jacard":jacard, "bce_dice":bce_dice})
model = tf.keras.models.load_model("model_2_A_0.h5", custom_objects={"jacard":jacard, "bce_dice":bce_dice})


# Create a user interface for the model
my_app = gr.Blocks()

with my_app:
  gr.Markdown("Statellite Image Segmentation Application UI with Gradio")
  with gr.Tabs():
    with gr.TabItem("Select your image"):
      with gr.Row():
        with gr.Column():
            img_source = gr.Image(label="Please select source Image")
            source_image_loader = gr.Button("Load above Image")
            img1 = gr.Image("__results___83_0 (2).png")
        with gr.Column():
            output_label = gr.Label(label="Predicted Masked Image")
            img_output = gr.Image(label="Image Output")
    source_image_loader.click(
        predict_2,
        [
            img_source
        ],
        [
            output_label,
            img_output
        ]
    )

my_app.launch(debug=True, share=True)

my_app.close()