Spaces:
Runtime error
Runtime error
| import warnings | |
| warnings.filterwarnings('ignore') | |
| import subprocess, io, os, sys, time | |
| os.system("pip install gradio==3.50.2") | |
| import gradio as gr | |
| from loguru import logger | |
| os.environ["CUDA_VISIBLE_DEVICES"] = "0" | |
| # if os.environ.get('IS_MY_DEBUG') is None: | |
| # result = subprocess.run(['pip', 'install', '-e', 'GroundingDINO'], check=True) | |
| # print(f'pip install GroundingDINO = {result}') | |
| logger.info(f"Start app...") | |
| result = subprocess.run(['pip', 'list'], check=True) | |
| print(f'pip list = {result}') | |
| sys.path.insert(0, './GroundingDINO') | |
| import argparse | |
| import copy | |
| import numpy as np | |
| import torch | |
| from PIL import Image, ImageDraw, ImageFont, ImageOps | |
| # Grounding DINO | |
| import GroundingDINO.groundingdino.datasets.transforms as T | |
| from GroundingDINO.groundingdino.models import build_model | |
| from GroundingDINO.groundingdino.util import box_ops | |
| from GroundingDINO.groundingdino.util.slconfig import SLConfig | |
| from GroundingDINO.groundingdino.util.utils import clean_state_dict, get_phrases_from_posmap | |
| # I2SB | |
| import sys | |
| sys.path.insert(0, "/home/ubuntu/Thesis-Demo/I2SB") | |
| sys.path.insert(0, "/home/ubuntu/Thesis-Demo/SegFormer") | |
| import numpy as np | |
| import torch | |
| import torch.distributed as dist | |
| import torchvision.transforms as transforms | |
| import torchvision.utils as tu | |
| from easydict import EasyDict as edict | |
| from fastapi import (Body, Depends, FastAPI, File, Form, HTTPException, Query, | |
| UploadFile) | |
| from ipdb import set_trace as debug | |
| from PIL import Image | |
| from torch.multiprocessing import Process | |
| from torch.utils.data import DataLoader, Subset | |
| from torch_ema import ExponentialMovingAverage | |
| import I2SB.distributed_util as dist_util | |
| from I2SB.corruption import build_corruption | |
| from I2SB.dataset import air_liquide | |
| from I2SB.i2sb import Runner, ckpt_util, download_ckpt | |
| from I2SB.logger import Logger | |
| from I2SB.sample import * | |
| from pathlib import Path | |
| inpaint_checkpoint = Path("/home/ubuntu/Thesis-Demo/I2SB/results") | |
| if not inpaint_checkpoint.exists(): | |
| os.system("pip install transformers==4.32.0") | |
| # SegFormer | |
| from PIL import Image | |
| from SegFormer.mmseg.apis import inference_segmentor, init_segmentor, visualize_result_pyplot | |
| from SegFormer.mmseg.core.evaluation import get_palette | |
| import cv2 | |
| import numpy as np | |
| import matplotlib | |
| matplotlib.use('AGG') | |
| plt = matplotlib.pyplot | |
| # import matplotlib.pyplot as plt | |
| groundingdino_enable = True | |
| sam_enable = True | |
| inpainting_enable = True | |
| ram_enable = False | |
| lama_cleaner_enable = True | |
| kosmos_enable = False | |
| # qwen_enable = True | |
| # from qwen_utils import * | |
| if os.environ.get('IS_MY_DEBUG') is not None: | |
| sam_enable = False | |
| ram_enable = False | |
| inpainting_enable = False | |
| kosmos_enable = False | |
| # segment anything | |
| from segment_anything import build_sam, SamPredictor, SamAutomaticMaskGenerator | |
| # diffusers | |
| import PIL | |
| import requests | |
| import torch | |
| from io import BytesIO | |
| from diffusers import StableDiffusionInpaintPipeline | |
| from huggingface_hub import hf_hub_download | |
| from util_computer import computer_info | |
| # relate anything | |
| from ram_utils import iou, sort_and_deduplicate, relation_classes, MLP, show_anns, ram_show_mask | |
| from ram_train_eval import RamModel, RamPredictor | |
| from mmengine.config import Config as mmengine_Config | |
| if lama_cleaner_enable: | |
| from lama_cleaner.helper import ( | |
| load_img, | |
| numpy_to_bytes, | |
| resize_max_size, | |
| ) | |
| # from transformers import AutoProcessor, AutoModelForVision2Seq | |
| import ast | |
| if kosmos_enable: | |
| os.system("pip install transformers@git+https://github.com/huggingface/transformers.git@main") | |
| # os.system("pip install transformers==4.32.0") | |
| from kosmos_utils import * | |
| from util_tencent import getTextTrans | |
| config_file = 'GroundingDINO/groundingdino/config/GroundingDINO_SwinT_OGC.py' | |
| ckpt_repo_id = "ShilongLiu/GroundingDINO" | |
| ckpt_filenmae = "groundingdino_swint_ogc.pth" | |
| sam_checkpoint = './sam_vit_h_4b8939.pth' | |
| output_dir = "outputs" | |
| device = 'cpu' | |
| os.makedirs(output_dir, exist_ok=True) | |
| groundingdino_model = None | |
| sam_device = None | |
| sam_model = None | |
| sam_predictor = None | |
| sam_mask_generator = None | |
| sd_model = None | |
| lama_cleaner_model= None | |
| ram_model = None | |
| kosmos_model = None | |
| kosmos_processor = None | |
| colors = [(255, 0, 0), (0, 255, 0)] | |
| markers = [1, 5] | |
| i2sb_opt = edict( | |
| distributed=False, | |
| device="cuda", | |
| batch_size=1, | |
| nfe=10, | |
| dataset="sample", | |
| dataset_dir=Path(f"dataset/sample"), | |
| n_gpu_per_node=1, | |
| use_fp16=False, | |
| ckpt="inpaint-freeform2030", | |
| image_size=256, | |
| partition=None, | |
| global_size=1, | |
| global_rank=0, | |
| clip_denoise=True | |
| ) | |
| i2sb_transforms = transforms.Compose([ | |
| transforms.Resize(i2sb_opt.image_size), | |
| transforms.CenterCrop(i2sb_opt.image_size), | |
| transforms.ToTensor(), | |
| transforms.Lambda(lambda t: (t * 2) - 1) # [0,1] --> [-1, 1] | |
| ]) | |
| def get_point(img, sel_pix, evt: gr.SelectData): | |
| img = np.array(img, dtype=np.uint8) | |
| sel_pix.append(evt.index) | |
| # draw points | |
| print(sel_pix) | |
| for point in sel_pix: | |
| cv2.drawMarker(img, point, colors[0], markerType=markers[0], markerSize=6, thickness=2) | |
| return Image.fromarray(img).convert("RGB") | |
| def undo_button(orig_img, sel_pix): | |
| if orig_img: | |
| temp = orig_img.copy() | |
| temp = np.array(temp, dtype=np.uint8) | |
| if len(sel_pix) != 0: | |
| sel_pix.pop() | |
| for point in sel_pix: | |
| cv2.drawMarker(temp, point, colors[0], markerType=markers[0], markerSize=6, thickness=2) | |
| return Image.fromarray(temp).convert("RGB") | |
| return orig_img | |
| def clear_button(orig_img): | |
| return orig_img, [] | |
| def toggle_button(orig_img, task_type): | |
| print(task_type) | |
| if task_type == "segment": | |
| ret = gr.Image(value= orig_img,elem_id="image_upload", type='pil', label="Upload", height=512, tool = "editor")# tool = "sketch", brush_color='#00FFFF', mask_opacity=0.6) | |
| elif task_type == "inpainting": | |
| ret = gr.Image(value = orig_img, elem_id="image_upload", type='pil', label="Upload", height=512, tool = "sketch", brush_color='#00FFFF', mask_opacity=0.6) | |
| task_type = not task_type | |
| return ret, task_type | |
| def store_img(img): | |
| print("call for store") | |
| return img, [] # when new image is uploaded, `selected_points` should be empty | |
| def load_model_hf(model_config_path, repo_id, filename, device='cpu'): | |
| args = SLConfig.fromfile(model_config_path) | |
| model = build_model(args) | |
| args.device = device | |
| cache_file = hf_hub_download(repo_id=repo_id, filename=filename) | |
| checkpoint = torch.load(cache_file, map_location=device) | |
| log = model.load_state_dict(clean_state_dict(checkpoint['model']), strict=False) | |
| print("Model loaded from {} \n => {}".format(cache_file, log)) | |
| _ = model.eval() | |
| return model | |
| def load_i2sb_model(): | |
| RESULT_DIR = Path("I2SB/results") | |
| global i2sb_model | |
| global ckpt_opt | |
| global corrupt_type | |
| global nfe | |
| s = time.time() | |
| # main from here | |
| log = Logger(0, ".log") | |
| # get (default) ckpt option | |
| ckpt_opt = ckpt_util.build_ckpt_option(i2sb_opt, log, RESULT_DIR / i2sb_opt.ckpt) | |
| corrupt_type = ckpt_opt.corrupt | |
| nfe = i2sb_opt.nfe or ckpt_opt.interval-1 | |
| # build corruption method | |
| # corrupt_method = build_corruption(i2sb_opt, log, corrupt_type=cor | |
| # rupt_type) | |
| runner = Runner(ckpt_opt, log, save_opt=False) | |
| if i2sb_opt.use_fp16: | |
| runner.ema.copy_to() # copy weight from ema to net | |
| runner.net.diffusion_model.convert_to_fp16() | |
| runner.ema = ExponentialMovingAverage( | |
| runner.net.parameters(), decay=0.99) # re-init ema with fp16 weight | |
| logger.info(f"I2SB Loading time:\t {(time.time()-s)*1e3} ms.") | |
| print("Loading time:", (time.time()-s)*1e3, "ms.") | |
| i2sb_model = runner | |
| return runner | |
| def load_segformer(device): | |
| global segformer_model | |
| s = time.time() | |
| config = "SegFormer/local_configs/segformer/B3/segformer.b3.256x256.wtm.160k.py" | |
| checkpoint = "SegFormer/work_dirs/segformer.b3.256x256.wtm.160k/iter_160000.pth" | |
| model = init_segmentor(config, checkpoint, device=device) | |
| logger.info(f"SegFormer Loading time:\t {(time.time()-s)*1e3} ms.") | |
| segformer_model = model | |
| return model | |
| def plot_boxes_to_image(image_pil, tgt): | |
| H, W = tgt["size"] | |
| boxes = tgt["boxes"] | |
| labels = tgt["labels"] | |
| assert len(boxes) == len(labels), "boxes and labels must have same length" | |
| draw = ImageDraw.Draw(image_pil) | |
| mask = Image.new("L", image_pil.size, 0) | |
| mask_draw = ImageDraw.Draw(mask) | |
| # draw boxes and masks | |
| for box, label in zip(boxes, labels): | |
| # from 0..1 to 0..W, 0..H | |
| box = box * torch.Tensor([W, H, W, H]) | |
| # from xywh to xyxy | |
| box[:2] -= box[2:] / 2 | |
| box[2:] += box[:2] | |
| # random color | |
| color = tuple(np.random.randint(0, 255, size=3).tolist()) | |
| # draw | |
| x0, y0, x1, y1 = box | |
| x0, y0, x1, y1 = int(x0), int(y0), int(x1), int(y1) | |
| draw.rectangle([x0, y0, x1, y1], outline=color, width=6) | |
| # draw.text((x0, y0), str(label), fill=color) | |
| font = ImageFont.load_default() | |
| if hasattr(font, "getbbox"): | |
| bbox = draw.textbbox((x0, y0), str(label), font) | |
| else: | |
| w, h = draw.textsize(str(label), font) | |
| bbox = (x0, y0, w + x0, y0 + h) | |
| # bbox = draw.textbbox((x0, y0), str(label)) | |
| draw.rectangle(bbox, fill=color) | |
| try: | |
| font = os.path.join(cv2.__path__[0],'qt','fonts','DejaVuSans.ttf') | |
| font_size = 36 | |
| new_font = ImageFont.truetype(font, font_size) | |
| draw.text((x0+2, y0+2), str(label), font=new_font, fill="white") | |
| except Exception as e: | |
| pass | |
| mask_draw.rectangle([x0, y0, x1, y1], fill=255, width=6) | |
| return image_pil, mask | |
| def load_image(image_path): | |
| # # load image | |
| if isinstance(image_path, PIL.Image.Image): | |
| image_pil = image_path | |
| else: | |
| image_pil = Image.open(image_path).convert("RGB") # load image | |
| transform = T.Compose( | |
| [ | |
| T.RandomResize([800], max_size=1333), | |
| T.ToTensor(), | |
| T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]), | |
| ] | |
| ) | |
| image, _ = transform(image_pil, None) # 3, h, w | |
| return image_pil, image | |
| def show_mask(mask, ax, random_color=False): | |
| if random_color: | |
| color = np.concatenate([np.random.random(3), np.array([0.6])], axis=0) | |
| else: | |
| color = np.array([30/255, 144/255, 255/255, 0.6]) | |
| h, w = mask.shape[-2:] | |
| mask_image = mask.reshape(h, w, 1) * color.reshape(1, 1, -1) | |
| ax.imshow(mask_image) | |
| def show_box(box, ax, label): | |
| x0, y0 = box[0], box[1] | |
| w, h = box[2] - box[0], box[3] - box[1] | |
| ax.add_patch(plt.Rectangle((x0, y0), w, h, edgecolor='green', facecolor=(0,0,0,0), lw=2)) | |
| ax.text(x0, y0, label) | |
| def xywh_to_xyxy(box, sizeW, sizeH): | |
| if isinstance(box, list): | |
| box = torch.Tensor(box) | |
| box = box * torch.Tensor([sizeW, sizeH, sizeW, sizeH]) | |
| box[:2] -= box[2:] / 2 | |
| box[2:] += box[:2] | |
| box = box.numpy() | |
| return box | |
| def mask_extend(img, box, extend_pixels=10, useRectangle=True): | |
| box[0] = int(box[0]) | |
| box[1] = int(box[1]) | |
| box[2] = int(box[2]) | |
| box[3] = int(box[3]) | |
| region = img.crop(tuple(box)) | |
| new_width = box[2] - box[0] + 2*extend_pixels | |
| new_height = box[3] - box[1] + 2*extend_pixels | |
| region_BILINEAR = region.resize((int(new_width), int(new_height))) | |
| if useRectangle: | |
| region_draw = ImageDraw.Draw(region_BILINEAR) | |
| region_draw.rectangle((0, 0, new_width, new_height), fill=(255, 255, 255)) | |
| img.paste(region_BILINEAR, (int(box[0]-extend_pixels), int(box[1]-extend_pixels))) | |
| return img | |
| def mix_masks(imgs): | |
| re_img = 1 - np.asarray(imgs[0].convert("1")) | |
| for i in range(len(imgs)-1): | |
| re_img = np.multiply(re_img, 1 - np.asarray(imgs[i+1].convert("1"))) | |
| re_img = 1 - re_img | |
| return Image.fromarray(np.uint8(255*re_img)) | |
| def set_device(args): | |
| global device | |
| if os.environ.get('IS_MY_DEBUG') is None: | |
| device = args.cuda if torch.cuda.is_available() else 'cpu' | |
| else: | |
| device = 'cpu' | |
| print(f'device={device}') | |
| def get_sam_vit_h_4b8939(): | |
| if not os.path.exists('./sam_vit_h_4b8939.pth'): | |
| logger.info(f"get sam_vit_h_4b8939.pth...") | |
| result = subprocess.run(['wget', '-nv', 'https://dl.fbaipublicfiles.com/segment_anything/sam_vit_h_4b8939.pth'], check=True) | |
| print(f'wget sam_vit_h_4b8939.pth result = {result}') | |
| def load_sam_model(device): | |
| # initialize SAM | |
| global sam_model, sam_predictor, sam_mask_generator, sam_device | |
| get_sam_vit_h_4b8939() | |
| logger.info(f"initialize SAM model...") | |
| sam_device = device | |
| sam_model = build_sam(checkpoint=sam_checkpoint).to(sam_device) | |
| sam_predictor = SamPredictor(sam_model) | |
| sam_mask_generator = SamAutomaticMaskGenerator(sam_model) | |
| def load_sd_model(device): | |
| # initialize stable-diffusion-inpainting | |
| global sd_model | |
| logger.info(f"initialize stable-diffusion-inpainting...") | |
| sd_model = None | |
| if os.environ.get('IS_MY_DEBUG') is None: | |
| sd_model = StableDiffusionInpaintPipeline.from_pretrained( | |
| "runwayml/stable-diffusion-inpainting", | |
| revision="fp16", | |
| # "stabilityai/stable-diffusion-2-inpainting", | |
| torch_dtype=torch.float16, | |
| ) | |
| sd_model = sd_model.to(device) | |
| def forward_i2sb(img, mask, dilation_mask_extend): | |
| print(np.unique(mask),mask.shape) | |
| mask = np.where(mask > 0, 1, 0) | |
| print(np.unique(mask),mask.shape) | |
| mask = mask.astype(np.uint8) | |
| if dilation_mask_extend.isdigit(): | |
| kernel_size = int(dilation_mask_extend) | |
| kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (int(kernel_size), int(kernel_size))) | |
| mask = cv2.dilate(mask, kernel, iterations = 1) | |
| img_tensor = i2sb_transforms(img).to( | |
| i2sb_opt.device).unsqueeze(0) | |
| mask_tensor = torch.from_numpy(np.resize(np.array(mask), (256,256))).to( | |
| i2sb_opt.device).unsqueeze(0).unsqueeze(0) | |
| # print("POST PROCESSING\t", torch.unique(img_tensor)) | |
| corrupt_tensor = img_tensor * (1. - mask_tensor) + mask_tensor | |
| print("DOUBLE CHECK:\t", corrupt_tensor.shape) | |
| print("DOUBLE CHECK:\t", img_tensor.shape) | |
| print("DOUBLE CHECK:\t", mask_tensor.shape) | |
| f = time.time() | |
| xs, _ = i2sb_model.ddpm_sampling( | |
| ckpt_opt, img_tensor, mask=mask_tensor, cond=None, clip_denoise=i2sb_opt.clip_denoise, nfe=nfe, verbose=i2sb_opt.n_gpu_per_node == 1) | |
| recon_img = xs[:, 0, ...].to(i2sb_opt.device) | |
| # tu.save_image((recon_img+1)/2, "output.png") | |
| # tu.save_image((corrupt_tensor+1)/2, "output.png") | |
| print(recon_img.shape) | |
| return transforms.ToPILImage()(((recon_img+1)/2)[0]), transforms.ToPILImage()(((corrupt_tensor+1)/2)[0]) | |
| def forward_segformer(img): | |
| img_np = np.array(img) | |
| img_np = cv2.cvtColor(img_np, cv2.COLOR_RGB2BGR) | |
| result = inference_segmentor(segformer_model, img_np) | |
| return np.asarray(result[0], dtype=np.uint8) | |
| # visualization | |
| def draw_selected_mask(mask, draw): | |
| color = (255, 0, 0, 153) | |
| nonzero_coords = np.transpose(np.nonzero(mask)) | |
| for coord in nonzero_coords: | |
| draw.point(coord[::-1], fill=color) | |
| def draw_object_mask(mask, draw): | |
| color = (0, 0, 255, 153) | |
| nonzero_coords = np.transpose(np.nonzero(mask)) | |
| for coord in nonzero_coords: | |
| draw.point(coord[::-1], fill=color) | |
| def create_title_image(word1, word2, word3, width, font_path='./assets/OpenSans-Bold.ttf'): | |
| # Define the colors to use for each word | |
| color_red = (255, 0, 0) | |
| color_black = (0, 0, 0) | |
| color_blue = (0, 0, 255) | |
| # Define the initial font size and spacing between words | |
| font_size = 40 | |
| # Create a new image with the specified width and white background | |
| image = Image.new('RGB', (width, 60), (255, 255, 255)) | |
| try: | |
| # Load the specified font | |
| font = ImageFont.truetype(font_path, font_size) | |
| # Keep increasing the font size until all words fit within the desired width | |
| while True: | |
| # Create a draw object for the image | |
| draw = ImageDraw.Draw(image) | |
| word_spacing = font_size / 2 | |
| # Draw each word in the appropriate color | |
| x_offset = word_spacing | |
| draw.text((x_offset, 0), word1, color_red, font=font) | |
| x_offset += font.getsize(word1)[0] + word_spacing | |
| draw.text((x_offset, 0), word2, color_black, font=font) | |
| x_offset += font.getsize(word2)[0] + word_spacing | |
| draw.text((x_offset, 0), word3, color_blue, font=font) | |
| word_sizes = [font.getsize(word) for word in [word1, word2, word3]] | |
| total_width = sum([size[0] for size in word_sizes]) + word_spacing * 3 | |
| # Stop increasing font size if the image is within the desired width | |
| if total_width <= width: | |
| break | |
| # Increase font size and reset the draw object | |
| font_size -= 1 | |
| image = Image.new('RGB', (width, 50), (255, 255, 255)) | |
| font = ImageFont.truetype(font_path, font_size) | |
| draw = None | |
| except Exception as e: | |
| pass | |
| return image | |
| def concatenate_images_vertical(image1, image2): | |
| # Get the dimensions of the two images | |
| width1, height1 = image1.size | |
| width2, height2 = image2.size | |
| # Create a new image with the combined height and the maximum width | |
| new_image = Image.new('RGBA', (max(width1, width2), height1 + height2)) | |
| # Paste the first image at the top of the new image | |
| new_image.paste(image1, (0, 0)) | |
| # Paste the second image below the first image | |
| new_image.paste(image2, (0, height1)) | |
| return new_image | |
| mask_source_draw = "draw a mask on input image" | |
| mask_source_segment = "upload a mask" | |
| def get_time_cost(run_task_time, time_cost_str): | |
| now_time = int(time.time()*1000) | |
| if run_task_time == 0: | |
| time_cost_str = 'start' | |
| else: | |
| if time_cost_str != '': | |
| time_cost_str += f'-->' | |
| time_cost_str += f'{now_time - run_task_time}' | |
| run_task_time = now_time | |
| return run_task_time, time_cost_str | |
| def run_anything_task(input_image, input_points, origin_image, task_type, | |
| mask_source_radio, segmentation_radio, dilation_mask_extend): | |
| run_task_time = 0 | |
| time_cost_str = '' | |
| run_task_time, time_cost_str = get_time_cost(run_task_time, time_cost_str) | |
| print("HERE................", task_type) | |
| if input_image is None: | |
| return [], gr.Gallery.update(label='Please upload a image!😂😂😂😂'), time_cost_str, gr.Textbox.update(visible=(time_cost_str !='')) | |
| file_temp = int(time.time()) | |
| logger.info(f'run_anything_task_002/{device}_[{file_temp}]_{task_type}/[{mask_source_radio}]_1_') | |
| output_images = [] | |
| # load image | |
| if isinstance(input_image, dict): | |
| image_pil, image = load_image(input_image['image'].convert("RGB")) | |
| input_img = input_image['image'] | |
| output_images.append(input_image['image']) | |
| run_task_time, time_cost_str = get_time_cost(run_task_time, time_cost_str) | |
| else: | |
| image_pil, image = load_image(input_image.convert("RGB")) | |
| input_img = input_image | |
| output_images.append(input_image) | |
| run_task_time, time_cost_str = get_time_cost(run_task_time, time_cost_str) | |
| size = image_pil.size | |
| H, W = size[1], size[0] | |
| # run grounding dino model | |
| if (task_type in ['inpainting', 'outpainting'] or task_type == 'remove') and mask_source_radio == mask_source_draw: | |
| pass | |
| else: | |
| groundingdino_device = 'cpu' | |
| logger.info(f'run_anything_task_[{file_temp}]_{task_type}_2_') | |
| if task_type == 'segment' or task_type == 'pipeline': | |
| image = np.array(origin_image) | |
| if segmentation_radio == "SAM": | |
| if sam_predictor: | |
| sam_predictor.set_image(image) | |
| if sam_predictor: | |
| logger.info(f"Forward with: {input_points}") | |
| masks, _, _, _ = sam_predictor.predict( | |
| point_coords = np.array(input_points), | |
| point_labels = np.array([1 for _ in range(len(input_points))]), | |
| # boxes = transformed_boxes, | |
| multimask_output = False, | |
| ) | |
| # masks: [9, 1, 512, 512] | |
| assert sam_checkpoint, 'sam_checkpoint is not found!' | |
| else: | |
| run_mode = "rectangle" | |
| # draw output image | |
| plt.figure(figsize=(10, 10)) | |
| plt.imshow(origin_image) | |
| for mask in masks: | |
| show_mask(mask, plt.gca(), random_color=True) | |
| # for box, label in zip(boxes_filt, pred_phrases): | |
| # show_box(box.cpu().numpy(), plt.gca(), label) | |
| plt.axis('off') | |
| image_path = os.path.join(output_dir, f"grounding_seg_output_{file_temp}.jpg") | |
| plt.savefig(image_path, bbox_inches="tight") | |
| plt.clf() | |
| plt.close('all') | |
| segment_image_result = cv2.cvtColor(cv2.imread(image_path), cv2.COLOR_BGR2RGB) | |
| os.remove(image_path) | |
| else: | |
| masks = forward_segformer(image) | |
| segment_image_result = visualize_result_pyplot(segformer_model, image, masks, get_palette("wtm"), dilation=dilation_mask_extend)# if task_type == "pipeline" else None) | |
| output_images.append(Image.fromarray(segment_image_result)) | |
| run_task_time, time_cost_str = get_time_cost(run_task_time, time_cost_str) | |
| logger.info(f'run_anything_task_[{file_temp}]_{task_type}_3_') | |
| if task_type == 'detection' or task_type == 'segment': | |
| logger.info(f'run_anything_task_[{file_temp}]_{task_type}_9_') | |
| return output_images, gr.Gallery.update(label='result images'), time_cost_str, gr.Textbox.update(visible=(time_cost_str !='')) | |
| elif task_type in ['inpainting', 'outpainting'] or task_type == 'pipeline': | |
| logger.info(f'run_anything_task_[{file_temp}]_{task_type}_4_') | |
| if task_type == "pipeline": | |
| if segmentation_radio == "SAM": | |
| masks_ori = copy.deepcopy(masks) | |
| print(masks.shape) | |
| # masks = torch.where(masks > 0, True, False) | |
| mask = masks[0] | |
| mask_pil = Image.fromarray(mask) | |
| mask = np.where(mask == True, 1, 0) | |
| else: | |
| mask = masks | |
| save_mask = copy.deepcopy(mask) | |
| save_mask = np.where(mask > 0, 255, 0).astype(np.uint8) | |
| print((save_mask.dtype)) | |
| mask_pil = Image.fromarray(save_mask) | |
| else: | |
| if mask_source_radio == mask_source_draw: | |
| input_mask_pil = input_image['mask'] | |
| input_mask = np.array(input_mask_pil.convert("L")) | |
| mask_pil = input_mask_pil | |
| mask = input_mask | |
| else: | |
| pass | |
| # masks_ori = copy.deepcopy(masks) | |
| # masks = torch.where(masks > 0, True, False) | |
| # mask = masks[0][0].cpu().numpy() | |
| # mask_pil = Image.fromarray(mask) | |
| output_images.append(mask_pil.convert("RGB")) | |
| run_task_time, time_cost_str = get_time_cost(run_task_time, time_cost_str) | |
| if task_type in ['inpainting', 'pipeline']: | |
| # image_inpainting = sd_model(prompt = "", image=image_source_for_inpaint, mask_image=image_mask_for_inpaint).images[0] | |
| # input_img.save("test.png") | |
| w, h = input_img.size | |
| input_img = input_img.resize((256,256)) | |
| image_inpainting, corrupted = forward_i2sb(input_img, mask, dilation_mask_extend) | |
| input_img = input_img.resize((w,h)) | |
| corrupted = corrupted.resize((w,h)) | |
| image_inpainting = image_inpainting.resize((w,h)) | |
| # print("RESULT\t", np.array(image_inpainting)) | |
| else: | |
| # remove from mask | |
| aasds = 1 | |
| logger.info(f'run_anything_task_[{file_temp}]_{task_type}_6_') | |
| if image_inpainting is None: | |
| logger.info(f'run_anything_task_failed_') | |
| return None, None, None, None | |
| # output_images.append(image_inpainting) | |
| # run_task_time, time_cost_str = get_time_cost(run_task_time, time_cost_str) | |
| logger.info(f'run_anything_task_[{file_temp}]_{task_type}_7_') | |
| image_inpainting = image_inpainting.resize((image_pil.size[0], image_pil.size[1])) | |
| output_images.append(corrupted) | |
| output_images.append(image_inpainting) | |
| run_task_time, time_cost_str = get_time_cost(run_task_time, time_cost_str) | |
| logger.info(f'run_anything_task_[{file_temp}]_{task_type}_9_') | |
| return output_images, gr.Gallery.update(label='result images'), time_cost_str, gr.Textbox.update(visible=(time_cost_str !='')) | |
| else: | |
| logger.info(f"task_type:{task_type} error!") | |
| logger.info(f'run_anything_task_[{file_temp}]_9_9_') | |
| return output_images, gr.Gallery.update(label='result images'), time_cost_str, gr.Textbox.update(visible=(time_cost_str !='')) | |
| def change_radio_display(task_type, mask_source_radio, orig_img): | |
| mask_source_radio_visible = False | |
| num_relation_visible = False | |
| image_gallery_visible = True | |
| kosmos_input_visible = False | |
| kosmos_output_visible = False | |
| kosmos_text_output_visible = False | |
| print(task_type) | |
| if task_type == "Kosmos-2": | |
| if kosmos_enable: | |
| image_gallery_visible = False | |
| kosmos_input_visible = True | |
| kosmos_output_visible = True | |
| kosmos_text_output_visible = True | |
| if task_type in ['inpainting', 'outpainting'] or task_type == "remove": | |
| mask_source_radio_visible = True | |
| if task_type == "relate anything": | |
| num_relation_visible = True | |
| if task_type == "inpainting": | |
| ret = gr.Image(value = orig_img, elem_id="image_upload", type='pil', label="Upload", height=512, tool = "sketch", brush_color='#00FFFF', mask_opacity=0.6) | |
| elif task_type in ["segment", "pipeline"]: | |
| ret = gr.Image(value= orig_img, elem_id="image_upload", type='pil', label="Upload", height=512, tool = "editor")# tool = "sketch", brush_color='#00FFFF', mask_opacity=0.6) | |
| return (gr.Radio.update(visible=mask_source_radio_visible), | |
| gr.Slider.update(visible=num_relation_visible), | |
| gr.Gallery.update(visible=image_gallery_visible), | |
| gr.Radio(["SegFormer", "SAM"], value="SAM", label="Segementation Model", visible= task_type != "inpainting"), | |
| gr.Textbox(label="Dilation kernel size", value='7', visible= task_type == "pipeline"), | |
| ret, [], | |
| gr.Button("Undo point", visible = task_type != "inpainting"), | |
| gr.Button("Clear point", visible = task_type != "inpainting"),) | |
| def get_model_device(module): | |
| try: | |
| if module is None: | |
| return 'None' | |
| if isinstance(module, torch.nn.DataParallel): | |
| module = module.module | |
| for submodule in module.children(): | |
| if hasattr(submodule, "_parameters"): | |
| parameters = submodule._parameters | |
| if "weight" in parameters: | |
| return parameters["weight"].device | |
| return 'UnKnown' | |
| except Exception as e: | |
| return 'Error' | |
| def click_callback(coords): | |
| print("Clicked at here: ", coords) | |
| def main_gradio(args): | |
| block = gr.Blocks( | |
| title="Thesis-Demo", | |
| # theme="shivi/calm_seafoam@>=0.0.1,<1.0.0", | |
| ) | |
| with block: | |
| with gr.Row(): | |
| with gr.Column(): | |
| selected_points = gr.State([]) | |
| original_image = gr.State(None) | |
| task_types = ["segment"] | |
| if inpainting_enable: | |
| task_types.append("inpainting") | |
| task_types.append("pipeline") | |
| input_image = gr.Image(elem_id="image_upload", type='pil', label="Upload", height=512) | |
| input_image.upload( | |
| store_img, | |
| [input_image], | |
| [original_image, selected_points] | |
| ) | |
| input_image.select( | |
| get_point, | |
| [input_image, selected_points], | |
| [input_image] | |
| ) | |
| with gr.Row(): | |
| with gr.Column(): | |
| undo_point_button = gr.Button("Undo point", visible= True if original_image is not None else False) | |
| undo_point_button.click( | |
| fn= undo_button, | |
| inputs=[original_image, selected_points], | |
| outputs=[input_image] | |
| ) | |
| with gr.Column(): | |
| clear_point_button = gr.Button("Clear point", visible= True if original_image is not None else False) | |
| clear_point_button.click( | |
| fn= clear_button, | |
| inputs=[original_image], | |
| outputs=[input_image, selected_points] | |
| ) | |
| print(dir(input_image)) | |
| task_type = gr.Radio(task_types, value="segment", | |
| label='Task type', visible=True) | |
| mask_source_radio = gr.Radio([mask_source_draw, mask_source_segment], | |
| value=mask_source_draw, label="Mask from", | |
| visible=False) | |
| segmentation_radio = gr.Radio(["SegFormer", "SAM"], | |
| value="SAM", label="Segementation Model", | |
| visible=True) | |
| dilation_mask_extend = gr.Textbox(label="Dilation kernel size", value='5', visible=False) | |
| num_relation = gr.Slider(label="How many relations do you want to see", minimum=1, maximum=20, value=5, step=1, visible=False) | |
| run_button = gr.Button(label="Run", visible=True) | |
| # with gr.Accordion("Advanced options", open=False) as advanced_options: | |
| # box_threshold = gr.Slider( | |
| # label="Box Threshold", minimum=0.0, maximum=1.0, value=0.3, step=0.001 | |
| # ) | |
| # text_threshold = gr.Slider( | |
| # label="Text Threshold", minimum=0.0, maximum=1.0, value=0.25, step=0.001 | |
| # ) | |
| # iou_threshold = gr.Slider( | |
| # label="IOU Threshold", minimum=0.0, maximum=1.0, value=0.8, step=0.001 | |
| # ) | |
| # inpaint_mode = gr.Radio(["merge", "first"], value="merge", label="inpaint_mode") | |
| # with gr.Row(): | |
| # with gr.Column(scale=1): | |
| # remove_mode = gr.Radio(["segment", "rectangle"], value="segment", label='remove mode') | |
| # with gr.Column(scale=1): | |
| # remove_mask_extend = gr.Textbox(label="remove_mask_extend", value='10') | |
| with gr.Column(): | |
| image_gallery = gr.Gallery(label="result images", show_label=True, elem_id="gallery", height=512, visible=True | |
| ).style(preview=True, columns=[5], object_fit="scale-down", height=512) | |
| time_cost = gr.Textbox(label="Time cost by step (ms):", visible=False, interactive=False) | |
| run_button.click(fn=run_anything_task, inputs=[ | |
| input_image, selected_points, original_image, task_type, | |
| mask_source_radio, segmentation_radio, dilation_mask_extend], | |
| outputs=[image_gallery, image_gallery, time_cost, time_cost], show_progress=True, queue=True) | |
| mask_source_radio.change(fn=change_radio_display, inputs=[task_type, mask_source_radio, original_image], | |
| outputs=[mask_source_radio, num_relation]) | |
| task_type.change(fn=change_radio_display, inputs=[task_type, mask_source_radio, original_image], | |
| outputs=[mask_source_radio, num_relation, | |
| image_gallery, segmentation_radio, dilation_mask_extend, input_image, selected_points, undo_point_button, clear_point_button | |
| ]) | |
| # DESCRIPTION = f'### This demo from [Grounded-Segment-Anything](https://github.com/IDEA-Research/Grounded-Segment-Anything). <br>' | |
| # if lama_cleaner_enable: | |
| # DESCRIPTION += f'Remove(cleaner) from [lama-cleaner](https://github.com/Sanster/lama-cleaner). <br>' | |
| # if kosmos_enable: | |
| # DESCRIPTION += f'Kosmos-2 from [Kosmos-2](https://github.com/microsoft/unilm/tree/master/kosmos-2). <br>' | |
| # if ram_enable: | |
| # DESCRIPTION += f'RAM from [RelateAnything](https://github.com/Luodian/RelateAnything). <br>' | |
| # DESCRIPTION += f'Thanks for their excellent work.' | |
| # DESCRIPTION += f'<p>For faster inference without waiting in queue, you may duplicate the space and upgrade to GPU in settings. \ | |
| # <a href="https://huggingface.co/spaces/yizhangliu/Grounded-Segment-Anything?duplicate=true"><img style="display: inline; margin-top: 0em; margin-bottom: 0em" src="https://bit.ly/3gLdBN6" alt="Duplicate Space" /></a></p>' | |
| # gr.Markdown(DESCRIPTION) | |
| print(f'device = {device}') | |
| print(f'torch.cuda.is_available = {torch.cuda.is_available()}') | |
| computer_info() | |
| block.queue(max_size=10, api_open=False) | |
| block.launch(server_name='0.0.0.0', server_port=args.port, debug=args.debug, share=args.share) | |
| if __name__ == "__main__": | |
| parser = argparse.ArgumentParser("Grounded SAM demo", add_help=True) | |
| parser.add_argument("--debug", action="store_true", help="using debug mode") | |
| parser.add_argument("--share", action="store_true", help="share the app") | |
| parser.add_argument("--port", "-p", type=int, default=7860, help="port") | |
| parser.add_argument("--cuda", "-c", type=str, default='cuda:0', help="cuda") | |
| args, _ = parser.parse_known_args() | |
| print(f'args = {args}') | |
| # if os.environ.get('IS_MY_DEBUG') is None: | |
| # os.system("pip list") | |
| set_device(args) | |
| if device == 'cpu': | |
| kosmos_enable = False | |
| # if kosmos_enable: | |
| # kosmos_model, kosmos_processor = load_kosmos_model(device) | |
| # if groundingdino_enable: | |
| # load_groundingdino_model('cpu') | |
| if sam_enable: | |
| load_sam_model(device) | |
| load_segformer(device) | |
| if inpainting_enable: | |
| load_sd_model(device) | |
| load_i2sb_model() | |
| # if lama_cleaner_enable: | |
| # load_lama_cleaner_model(device) | |
| # if ram_enable: | |
| # load_ram_model(device) | |
| # if os.environ.get('IS_MY_DEBUG') is None: | |
| # os.system("pip list") | |
| main_gradio(args) | |