import warnings warnings.filterwarnings('ignore') import subprocess, io, os, sys, time run_gradio = False if os.environ.get('IS_MY_DEBUG') is None: run_gradio = True else: run_gradio = False # run_gradio = True if run_gradio: 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 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 if lama_cleaner_enable: try: from lama_cleaner.model_manager import ModelManager from lama_cleaner.schema import Config as lama_Config except Exception as e: lama_cleaner_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 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 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 get_grounding_output(model, image, caption, box_threshold, text_threshold, with_logits=True, device="cpu"): caption = caption.lower() caption = caption.strip() if not caption.endswith("."): caption = caption + "." model = model.to(device) image = image.to(device) with torch.no_grad(): outputs = model(image[None], captions=[caption]) logits = outputs["pred_logits"].cpu().sigmoid()[0] # (nq, 256) boxes = outputs["pred_boxes"].cpu()[0] # (nq, 4) logits.shape[0] # filter output logits_filt = logits.clone() boxes_filt = boxes.clone() filt_mask = logits_filt.max(dim=1)[0] > box_threshold logits_filt = logits_filt[filt_mask] # num_filt, 256 boxes_filt = boxes_filt[filt_mask] # num_filt, 4 logits_filt.shape[0] # get phrase tokenlizer = model.tokenizer tokenized = tokenlizer(caption) # build pred pred_phrases = [] for logit, box in zip(logits_filt, boxes_filt): pred_phrase = get_phrases_from_posmap(logit > text_threshold, tokenized, tokenlizer) if with_logits: pred_phrases.append(pred_phrase + f"({str(logit.max().item())[:4]})") else: pred_phrases.append(pred_phrase) return boxes_filt, pred_phrases 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 load_groundingdino_model(device): # initialize groundingdino model global groundingdino_model logger.info(f"initialize groundingdino model...") groundingdino_model = load_model_hf(config_file, ckpt_repo_id, ckpt_filenmae, device=device) #'cpu') logger.info(f"initialize groundingdino model...{type(groundingdino_model)}") 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', '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 load_lama_cleaner_model(device): # initialize lama_cleaner global lama_cleaner_model logger.info(f"initialize lama_cleaner...") lama_cleaner_model = ModelManager( name='lama', device=device, ) def lama_cleaner_process(image, mask, cleaner_size_limit=1080): try: logger.info(f'_______lama_cleaner_process_______1____') ori_image = image if mask.shape[0] == image.shape[1] and mask.shape[1] == image.shape[0] and mask.shape[0] != mask.shape[1]: # rotate image logger.info(f'_______lama_cleaner_process_______2____') ori_image = np.transpose(image[::-1, ...][:, ::-1], axes=(1, 0, 2))[::-1, ...] logger.info(f'_______lama_cleaner_process_______3____') image = ori_image logger.info(f'_______lama_cleaner_process_______4____') original_shape = ori_image.shape logger.info(f'_______lama_cleaner_process_______5____') interpolation = cv2.INTER_CUBIC size_limit = cleaner_size_limit if size_limit == -1: logger.info(f'_______lama_cleaner_process_______6____') size_limit = max(image.shape) else: logger.info(f'_______lama_cleaner_process_______7____') size_limit = int(size_limit) logger.info(f'_______lama_cleaner_process_______8____') config = lama_Config( ldm_steps=25, ldm_sampler='plms', zits_wireframe=True, hd_strategy='Original', hd_strategy_crop_margin=196, hd_strategy_crop_trigger_size=1280, hd_strategy_resize_limit=2048, prompt='', use_croper=False, croper_x=0, croper_y=0, croper_height=512, croper_width=512, sd_mask_blur=5, sd_strength=0.75, sd_steps=50, sd_guidance_scale=7.5, sd_sampler='ddim', sd_seed=42, cv2_flag='INPAINT_NS', cv2_radius=5, ) logger.info(f'_______lama_cleaner_process_______9____') if config.sd_seed == -1: config.sd_seed = random.randint(1, 999999999) # logger.info(f"Origin image shape_0_: {original_shape} / {size_limit}") logger.info(f'_______lama_cleaner_process_______10____') image = resize_max_size(image, size_limit=size_limit, interpolation=interpolation) # logger.info(f"Resized image shape_1_: {image.shape}") # logger.info(f"mask image shape_0_: {mask.shape} / {type(mask)}") logger.info(f'_______lama_cleaner_process_______11____') mask = resize_max_size(mask, size_limit=size_limit, interpolation=interpolation) # logger.info(f"mask image shape_1_: {mask.shape} / {type(mask)}") logger.info(f'_______lama_cleaner_process_______12____') res_np_img = lama_cleaner_model(image, mask, config) logger.info(f'_______lama_cleaner_process_______13____') torch.cuda.empty_cache() logger.info(f'_______lama_cleaner_process_______14____') image = Image.open(io.BytesIO(numpy_to_bytes(res_np_img, 'png'))) logger.info(f'_______lama_cleaner_process_______15____') except Exception as e: logger.info(f'lama_cleaner_process[Error]:' + str(e)) image = None return image class Ram_Predictor(RamPredictor): def __init__(self, config, device='cpu'): self.config = config self.device = torch.device(device) self._build_model() def _build_model(self): self.model = RamModel(**self.config.model).to(self.device) if self.config.load_from is not None: self.model.load_state_dict(torch.load(self.config.load_from, map_location=self.device)) self.model.train() def load_ram_model(device): # load ram model global ram_model if os.environ.get('IS_MY_DEBUG') is not None: return model_path = "./checkpoints/ram_epoch12.pth" ram_config = dict( model=dict( pretrained_model_name_or_path='bert-base-uncased', load_pretrained_weights=False, num_transformer_layer=2, input_feature_size=256, output_feature_size=768, cls_feature_size=512, num_relation_classes=56, pred_type='attention', loss_type='multi_label_ce', ), load_from=model_path, ) ram_config = mmengine_Config(ram_config) ram_model = Ram_Predictor(ram_config, device) # 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 def relate_anything(input_image, k): logger.info(f'relate_anything_1_{input_image.size}_') w, h = input_image.size max_edge = 1500 if w > max_edge or h > max_edge: ratio = max(w, h) / max_edge new_size = (int(w / ratio), int(h / ratio)) input_image.thumbnail(new_size) logger.info(f'relate_anything_2_') # load image pil_image = input_image.convert('RGBA') image = np.array(input_image) sam_masks = sam_mask_generator.generate(image) filtered_masks = sort_and_deduplicate(sam_masks) logger.info(f'relate_anything_3_') feat_list = [] for fm in filtered_masks: feat = torch.Tensor(fm['feat']).unsqueeze(0).unsqueeze(0).to(device) feat_list.append(feat) feat = torch.cat(feat_list, dim=1).to(device) matrix_output, rel_triplets = ram_model.predict(feat) logger.info(f'relate_anything_4_') pil_image_list = [] for i, rel in enumerate(rel_triplets[:k]): s,o,r = int(rel[0]),int(rel[1]),int(rel[2]) relation = relation_classes[r] mask_image = Image.new('RGBA', pil_image.size, color=(0, 0, 0, 0)) mask_draw = ImageDraw.Draw(mask_image) draw_selected_mask(filtered_masks[s]['segmentation'], mask_draw) draw_object_mask(filtered_masks[o]['segmentation'], mask_draw) current_pil_image = pil_image.copy() current_pil_image.alpha_composite(mask_image) title_image = create_title_image('Red', relation, 'Blue', current_pil_image.size[0]) concate_pil_image = concatenate_images_vertical(current_pil_image, title_image) pil_image_list.append(concate_pil_image) logger.info(f'relate_anything_5_{len(pil_image_list)}') return pil_image_list mask_source_draw = "draw a mask on input image" mask_source_segment = "type what to detect below" 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, text_prompt, task_type, inpaint_prompt, box_threshold, text_threshold, iou_threshold, inpaint_mode, mask_source_radio, remove_mode, remove_mask_extend, num_relation, kosmos_input, cleaner_size_limit=1080): text_prompt = getTextTrans(text_prompt, source='zh', target='en') inpaint_prompt = getTextTrans(inpaint_prompt, source='zh', target='en') run_task_time = 0 time_cost_str = '' run_task_time, time_cost_str = get_time_cost(run_task_time, time_cost_str) if (task_type == 'Kosmos-2'): global kosmos_model, kosmos_processor if isinstance(input_image, dict): image_pil, image = load_image(input_image['image'].convert("RGB")) input_img = input_image['image'] else: image_pil, image = load_image(input_image.convert("RGB")) input_img = input_image kosmos_image, kosmos_text, kosmos_entities = kosmos_generate_predictions(image_pil, kosmos_input, kosmos_model, kosmos_processor) run_task_time, time_cost_str = get_time_cost(run_task_time, time_cost_str) return None, None, time_cost_str, kosmos_image, gr.Textbox.update(visible=(time_cost_str !='')), kosmos_text, kosmos_entities if (task_type == 'relate anything'): output_images = relate_anything(input_image['image'], num_relation) run_task_time, time_cost_str = get_time_cost(run_task_time, time_cost_str) return output_images, gr.Gallery.update(label='relate images'), time_cost_str, gr.Textbox.update(visible=(time_cost_str !='')), None, None, None text_prompt = text_prompt.strip() if not ((task_type in ['inpainting', 'outpainting'] or task_type == 'remove') and mask_source_radio == mask_source_draw): if text_prompt == '': return [], gr.Gallery.update(label='Detection prompt is not found!😂😂😂😂'), time_cost_str, gr.Textbox.update(visible=(time_cost_str !='')), None, None, None if input_image is None: return [], gr.Gallery.update(label='Please upload a image!😂😂😂😂'), time_cost_str, gr.Textbox.update(visible=(time_cost_str !='')), None, None, None file_temp = int(time.time()) logger.info(f'run_anything_task_002/{device}_[{file_temp}]_{task_type}/{inpaint_mode}/[{mask_source_radio}]/{remove_mode}/{remove_mask_extend}_[{text_prompt}]/[{inpaint_prompt}]___1_') output_images = [] # load image if mask_source_radio == mask_source_draw: input_mask_pil = input_image['mask'] input_mask = np.array(input_mask_pil.convert("L")) 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' if device != 'cpu': try: from groundingdino import _C groundingdino_device = 'cuda:0' except: warnings.warn("Failed to load custom C++ ops. Running on CPU mode Only in groundingdino!") boxes_filt, pred_phrases = get_grounding_output( groundingdino_model, image, text_prompt, box_threshold, text_threshold, device=groundingdino_device ) if boxes_filt.size(0) == 0: logger.info(f'run_anything_task_[{file_temp}]_{task_type}_[{text_prompt}]_1___{groundingdino_device}/[No objects detected, please try others.]_') return [], gr.Gallery.update(label='No objects detected, please try others.😂😂😂😂'), time_cost_str, gr.Textbox.update(visible=(time_cost_str !='')), None, None, None boxes_filt_ori = copy.deepcopy(boxes_filt) pred_dict = { "boxes": boxes_filt, "size": [size[1], size[0]], # H,W "labels": pred_phrases, } image_with_box = plot_boxes_to_image(copy.deepcopy(image_pil), pred_dict)[0] output_images.append(image_with_box) 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}_2_') if task_type == 'segment' or ((task_type in ['inpainting', 'outpainting'] or task_type == 'remove') and mask_source_radio == mask_source_segment): image = np.array(input_img) if sam_predictor: sam_predictor.set_image(image) for i in range(boxes_filt.size(0)): boxes_filt[i] = boxes_filt[i] * torch.Tensor([W, H, W, H]) boxes_filt[i][:2] -= boxes_filt[i][2:] / 2 boxes_filt[i][2:] += boxes_filt[i][:2] if sam_predictor: boxes_filt = boxes_filt.to(sam_device) transformed_boxes = sam_predictor.transform.apply_boxes_torch(boxes_filt, image.shape[:2]) masks, _, _, _ = sam_predictor.predict_torch( point_coords = None, point_labels = None, boxes = transformed_boxes, multimask_output = False, ) # masks: [9, 1, 512, 512] assert sam_checkpoint, 'sam_checkpoint is not found!' else: masks = torch.zeros(len(boxes_filt), 1, H, W) mask_count = 0 for box in boxes_filt: masks[mask_count, 0, int(box[1]):int(box[3]), int(box[0]):int(box[2])] = 1 mask_count += 1 masks = torch.where(masks > 0, True, False) run_mode = "rectangle" # draw output image plt.figure(figsize=(10, 10)) plt.imshow(image) for mask in masks: show_mask(mask.cpu().numpy(), 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) 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 !='')), None, None, None elif task_type in ['inpainting', 'outpainting'] or task_type == 'remove': if inpaint_prompt.strip() == '' and mask_source_radio == mask_source_segment: task_type = 'remove' logger.info(f'run_anything_task_[{file_temp}]_{task_type}_4_') if mask_source_radio == mask_source_draw: mask_pil = input_mask_pil mask = input_mask else: masks_ori = copy.deepcopy(masks) if inpaint_mode == 'merge': masks = torch.sum(masks, dim=0).unsqueeze(0) 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', 'outpainting']: # inpainting pipeline image_source_for_inpaint = image_pil.resize((512, 512)) image_mask_for_inpaint = mask_pil.resize((512, 512)) if task_type in ['outpainting']: # reverse mask img_arr = np.array(image_mask_for_inpaint) img_arr = np.where(img_arr > 0, 1, img_arr) img_arr = 1 - img_arr image_mask_for_inpaint = Image.fromarray(255*img_arr.astype('uint8')) output_images.append(image_mask_for_inpaint.convert("RGB")) run_task_time, time_cost_str = get_time_cost(run_task_time, time_cost_str) image_inpainting = sd_model(prompt=inpaint_prompt, image=image_source_for_inpaint, mask_image=image_mask_for_inpaint).images[0] else: # remove from mask if mask_source_radio == mask_source_segment: mask_imgs = [] masks_shape = masks_ori.shape boxes_filt_ori_array = boxes_filt_ori.numpy() if inpaint_mode == 'merge': extend_shape_0 = masks_shape[0] extend_shape_1 = masks_shape[1] else: extend_shape_0 = 1 extend_shape_1 = 1 for i in range(extend_shape_0): for j in range(extend_shape_1): mask = masks_ori[i][j].cpu().numpy() mask_pil = Image.fromarray(mask) if remove_mode == 'segment': useRectangle = False else: useRectangle = True try: remove_mask_extend = int(remove_mask_extend) except: remove_mask_extend = 10 mask_pil_exp = mask_extend(copy.deepcopy(mask_pil).convert("RGB"), xywh_to_xyxy(torch.tensor(boxes_filt_ori_array[i]), W, H), extend_pixels=remove_mask_extend, useRectangle=useRectangle) mask_imgs.append(mask_pil_exp) mask_pil = mix_masks(mask_imgs) output_images.append(mask_pil.convert("RGB")) 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}_6_') image_inpainting = lama_cleaner_process(np.array(image_pil), np.array(mask_pil.convert("L")), cleaner_size_limit) if image_inpainting is None: logger.info(f'run_anything_task_failed_') return None, None, None, 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(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 !='')), None, None, None 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 !='')), None, None, None def change_radio_display(task_type, mask_source_radio): text_prompt_visible = True inpaint_prompt_visible = False 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 if task_type == "Kosmos-2": if kosmos_enable: text_prompt_visible = False image_gallery_visible = False kosmos_input_visible = True kosmos_output_visible = True kosmos_text_output_visible = True if task_type in ['inpainting', 'outpainting']: inpaint_prompt_visible = True if task_type in ['inpainting', 'outpainting'] or task_type == "remove": mask_source_radio_visible = True if mask_source_radio == mask_source_draw: text_prompt_visible = False if task_type == "relate anything": text_prompt_visible = False num_relation_visible = True return (gr.Textbox.update(visible=text_prompt_visible), gr.Textbox.update(visible=inpaint_prompt_visible), gr.Radio.update(visible=mask_source_radio_visible), gr.Slider.update(visible=num_relation_visible), gr.Gallery.update(visible=image_gallery_visible), gr.Radio.update(visible=kosmos_input_visible), gr.Image.update(visible=kosmos_output_visible), gr.HighlightedText.update(visible=kosmos_text_output_visible)) 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 main_gradio(args): block = gr.Blocks().queue() with block: with gr.Row(): with gr.Column(): task_types = ["detection"] if sam_enable: task_types.append("segment") if inpainting_enable: task_types.append("inpainting") task_types.append("outpainting") if lama_cleaner_enable: task_types.append("remove") if ram_enable: task_types.append("relate anything") if kosmos_enable: task_types.append("Kosmos-2") input_image = gr.Image(source='upload', elem_id="image_upload", tool='sketch', type='pil', label="Upload", height=512, brush_color='#00FFFF', mask_opacity=0.6) task_type = gr.Radio(task_types, value="detection", label='Task type', visible=True) mask_source_radio = gr.Radio([mask_source_draw, mask_source_segment], value=mask_source_segment, label="Mask from", visible=False) text_prompt = gr.Textbox(label="Detection Prompt[To detect multiple objects, seperating each with '.', like this: cat . dog . chair ]", placeholder="Cannot be empty") inpaint_prompt = gr.Textbox(label="Inpaint/Outpaint Prompt (if this is empty, then remove)", 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) kosmos_input = gr.Radio(["Brief", "Detailed"], label="Kosmos Description Type", value="Brief", 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="auto") time_cost = gr.Textbox(label="Time cost by step (ms):", visible=False, interactive=False) kosmos_output = gr.Image(type="pil", label="result images", visible=False) kosmos_text_output = gr.HighlightedText( label="Generated Description", combine_adjacent=False, show_legend=True, visible=False, ).style(color_map=color_map) # record which text span (label) is selected selected = gr.Number(-1, show_label=False, placeholder="Selected", visible=False) # record the current `entities` entity_output = gr.Textbox(visible=False) # get the current selected span label def get_text_span_label(evt: gr.SelectData): if evt.value[-1] is None: return -1 return int(evt.value[-1]) # and set this information to `selected` kosmos_text_output.select(get_text_span_label, None, selected) # update output image when we change the span (enity) selection def update_output_image(img_input, image_output, entities, idx): entities = ast.literal_eval(entities) updated_image = draw_entity_boxes_on_image(img_input, entities, entity_index=idx) return updated_image selected.change(update_output_image, [kosmos_output, kosmos_output, entity_output, selected], [kosmos_output]) run_button.click(fn=run_anything_task, inputs=[ input_image, text_prompt, task_type, inpaint_prompt, box_threshold, text_threshold, iou_threshold, inpaint_mode, mask_source_radio, remove_mode, remove_mask_extend, num_relation, kosmos_input], outputs=[image_gallery, image_gallery, time_cost, time_cost, kosmos_output, kosmos_text_output, entity_output], show_progress=True, queue=True) mask_source_radio.change(fn=change_radio_display, inputs=[task_type, mask_source_radio], outputs=[text_prompt, inpaint_prompt, mask_source_radio, num_relation]) task_type.change(fn=change_radio_display, inputs=[task_type, mask_source_radio], outputs=[text_prompt, inpaint_prompt, mask_source_radio, num_relation, image_gallery, kosmos_input, kosmos_output, kosmos_text_output ]) DESCRIPTION = f'### This demo from [Grounded-Segment-Anything](https://github.com/IDEA-Research/Grounded-Segment-Anything).
' if lama_cleaner_enable: DESCRIPTION += f'Remove(cleaner) from [lama-cleaner](https://github.com/Sanster/lama-cleaner).
' if kosmos_enable: DESCRIPTION += f'Kosmos-2 from [Kosmos-2](https://github.com/microsoft/unilm/tree/master/kosmos-2).
' if ram_enable: DESCRIPTION += f'RAM from [RelateAnything](https://github.com/Luodian/RelateAnything).
' DESCRIPTION += f'Thanks for their excellent work.' DESCRIPTION += f'

For faster inference without waiting in queue, you may duplicate the space and upgrade to GPU in settings. \ Duplicate Space

' gr.Markdown(DESCRIPTION) print(f'device = {device}') print(f'torch.cuda.is_available = {torch.cuda.is_available()}') computer_info() block.launch(server_name='0.0.0.0', server_port=args.port, debug=args.debug, share=args.share) import signal import json from datetime import date, datetime, timedelta from gevent import pywsgi import base64 def imgFile_to_base64(image_file): with open(image_file, "rb") as f: im_bytes = f.read() im_b64_encode = base64.b64encode(im_bytes) im_b64 = im_b64_encode.decode("utf8") return im_b64 def base64_to_bytes(im_b64): im_b64_encode = im_b64.encode("utf-8") im_bytes = base64.b64decode(im_b64_encode) return im_bytes def base64_to_PILImage(im_b64): im_bytes = base64_to_bytes(im_b64) pil_img = Image.open(io.BytesIO(im_bytes)) return pil_img class API_Starter: def __init__(self): from flask import Flask, request, jsonify, make_response from flask_cors import CORS, cross_origin import logging app = Flask(__name__) app.logger.setLevel(logging.ERROR) CORS(app, supports_credentials=True, resources={r"/*": {"origins": "*"}}) @app.route('/imgCLeaner', methods=['GET', 'POST']) @cross_origin() def processAssist(): if request.method == 'GET': ret_json = {'code': -1, 'reason':'no support to get'} elif request.method == 'POST': request_data = request.data.decode('utf-8') data = json.loads(request_data) result = self.handle_data(data) if result is None: ret_json = {'code': -2, 'reason':'handle error'} else: ret_json = {'code': 0, 'result':result} return jsonify(ret_json) self.app = app now_time = datetime.now().strftime('%Y%m%d_%H%M%S') logger.add(f'./logs/logger_[{args.port}]_{now_time}.log') signal.signal(signal.SIGINT, self.signal_handler) def handle_data(self, data): im_b64 = data['img'] img = base64_to_PILImage(im_b64) remove_texts = data['remove_texts'] remove_mask_extend = data['mask_extend'] results = run_anything_task(input_image = img, text_prompt = f"{remove_texts}", task_type = 'remove', inpaint_prompt = '', box_threshold = 0.3, text_threshold = 0.25, iou_threshold = 0.8, inpaint_mode = "merge", mask_source_radio = "type what to detect below", remove_mode = "rectangle", # ["segment", "rectangle"] remove_mask_extend = f"{remove_mask_extend}", num_relation = 5, kosmos_input = None, cleaner_size_limit = -1, ) output_images = results[0] if output_images is None: return None ret_json_images = [] file_temp = int(time.time()) count = 0 output_images = output_images[-1:] for image_pil in output_images: try: img_format = image_pil.format.lower() except Exception as e: img_format = 'png' image_path = os.path.join(output_dir, f"api_images_{file_temp}_{count}.{img_format}") count += 1 try: image_pil.save(image_path) except Exception as e: Image.fromarray(image_pil).save(image_path) im_b64 = imgFile_to_base64(image_path) ret_json_images.append(im_b64) os.remove(image_path) data = { 'imgs': ret_json_images, } return data def signal_handler(self, signal, frame): print('\nSignal Catched! You have just type Ctrl+C!') sys.exit(0) def run(self): from gevent import pywsgi logger.info(f'\nargs={args}\n') computer_info() print(f"Start a api server: http://0.0.0.0:{args.port}/imgCLeaner") server = pywsgi.WSGIServer(('0.0.0.0', args.port), self.app) server.serve_forever() def main_api(args): if args.port == 0: print('Please give valid port!') else: api_starter = API_Starter() api_starter.run() 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) if inpainting_enable: load_sd_model(device) 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") if run_gradio: # Provide gradio services main_gradio(args) else: # Provide API services main_api(args)