import gradio as gr
from PIL import Image
import numpy as np
import cv2
import os
import tensorflow as tf

if tf.__version__ >= '2.0':
    tf = tf.compat.v1

class ImageMattingPipeline:
    def __init__(self, model_dir: str, input_name: str = 'input_image:0', output_name: str = 'output_png:0'):
        model_path = os.path.join(model_dir, 'tf_graph.pb')
        if not os.path.exists(model_path):
            raise FileNotFoundError("Model file not found at {}".format(model_path))
        config = tf.ConfigProto(allow_soft_placement=True)
        config.gpu_options.allow_growth = True
        self.graph = tf.Graph()
        with self.graph.as_default():
            self._session = tf.Session(config=config)
            with tf.gfile.FastGFile(model_path, 'rb') as f:
                graph_def = tf.GraphDef()
                graph_def.ParseFromString(f.read())
                tf.import_graph_def(graph_def, name='')
            self.output = self._session.graph.get_tensor_by_name(output_name)
            self.input_name = input_name

    def preprocess(self, input_image):
        img = np.array(input_image)
        img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)  
        img = img.astype(float)
        return {'img': img}    

    def forward(self, input, output_mask=False, alpha_threshold=128):
        with self.graph.as_default(), self._session.as_default():
            feed_dict = {self.input_name: input['img']}
            output_img = self._session.run(self.output, feed_dict=feed_dict)
            result = {'output_img': output_img}
            if output_mask:
                alpha_channel = output_img[:, :, 3]
                mask = np.zeros(alpha_channel.shape, dtype=np.uint8)
                mask[alpha_channel >= alpha_threshold] = 255
                output_img[mask == 0, 3] = 0
                result['mask'] = mask  
            return result

def apply_filters(mask: np.array, closing_kernel: tuple = (5, 5), opening_kernel: tuple = (5, 5), 
                  blur_kernel: tuple = (3, 3), bilateral_params: tuple = (9, 75, 75), 
                  min_area: int = 2000) -> np.array:
    mask = mask.astype(np.uint8)
    closing_element = np.ones(closing_kernel, np.uint8)
    opening_element = np.ones(opening_kernel, np.uint8)
    closed_mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, closing_element)
    opened_mask = cv2.morphologyEx(closed_mask, cv2.MORPH_OPEN, opening_element)
    smoothed_mask = cv2.GaussianBlur(opened_mask, blur_kernel, 0)
    edge_smoothed_mask = cv2.bilateralFilter(smoothed_mask, *bilateral_params)
    num_labels, labels, stats, _ = cv2.connectedComponentsWithStats(edge_smoothed_mask, connectivity=8)
    large_component_mask = np.zeros_like(edge_smoothed_mask)
    for i in range(1, num_labels):
        if stats[i, cv2.CC_STAT_AREA] >= min_area:
            large_component_mask[labels == i] = 255
    return large_component_mask

def matting_interface(input_image, apply_morphology):
    input_image = np.array(input_image)
    input_image = input_image[:, :, ::-1]
    
    pipeline = ImageMattingPipeline(model_dir='cv_unet_universal-matting')
    preprocessed = pipeline.preprocess(input_image)
    result = pipeline.forward(preprocessed, output_mask=True)
    
    if apply_morphology:
        mask = apply_filters(result['mask'])
    else:
        mask = result.get('mask', None)

    output_img_pil = Image.fromarray(result['output_img'].astype(np.uint8)) 
    mask_pil = Image.fromarray(mask) if mask is not None else None
    
    return output_img_pil, mask_pil

iface = gr.Interface(
    fn=matting_interface,
    inputs=[
        gr.components.Image(type="pil", image_mode="RGB"),
        gr.components.Checkbox(label="Apply Morphological Processing for Mask")
    ],
    outputs=[
        gr.components.Image(type="pil", label="Matting Result"),
        gr.components.Image(type="pil", label="Mask"),
    ],
    title="Image Matting and Mask",
    description="Upload an image to get the matting result and mask. "
                "Use the checkbox to enable or disable morphological processing on the mask."
)

iface.launch()