From 7ae1b040d306128e1ed9f7c1c2be80a976862c03 Mon Sep 17 00:00:00 2001 From: MrHandsomeljn <1205197328@qq.com> Date: Tue, 29 Apr 2025 22:29:37 +0800 Subject: [PATCH 1/9] Use Gradio GUI --- .gitignore | 9 + README.md | 6 + app.py | 1069 ++++++++++++++++++++++++++++++++++++++++++++ seg_utils.py | 2 +- segmentation.ipynb | 499 ++++++++++++++++++--- 5 files changed, 1511 insertions(+), 74 deletions(-) create mode 100644 .gitignore create mode 100644 app.py diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..3f45459 --- /dev/null +++ b/.gitignore @@ -0,0 +1,9 @@ +data +imgs +my_pipeline +segmentation.ipynb +gaussiansplatting/submodules/* +gaussiansplatting/dependencies/* +**/__pycache__ +outputs +**.pth \ No newline at end of file diff --git a/README.md b/README.md index ef95a09..c417de5 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,12 @@ # SAGS (Segment Anything in 3D Gaussians) > [**Segment Anything in 3D Gaussians**](https://arxiv.org/abs/2401.17857) +## SAGS with a Gradio Interface +Use it to segment any gaussian easily, capable with multiview annotation ability. +Text prompt would be release when I'm available. +Undo and Redo might incur additional GPU Memory cost. + + ## Introduction 3D Gaussian Splatting has emerged as an alternative 3D representation for novel view synthesis, benefiting from its high-quality rendering results and real-time rendering speed. However, the 3D Gaussians learned by 3D-GS have ambiguous structures without any geometry constraints. This inherent issue in 3D-GS leads to a rough boundary when segmenting individual objects. To remedy these problems, we propose SAGD, a conceptually simple yet effective boundary-enhanced segmentation pipeline for 3D-GS to improve segmentation accuracy while preserving segmentation speed. Specifically, we introduce a Gaussian Decomposition scheme, which ingeniously utilizes the special structure of 3D Gaussian, finds out, and then decomposes the boundary Gaussians. Moreover, to achieve fast interactive 3D segmentation, we introduce a novel training-free pipeline by lifting a 2D foundation model to 3D-GS. Extensive experiments demonstrate that our approach achieves high-quality 3D segmentation without rough boundary issues, which can be easily applied to other scene editing tasks. diff --git a/app.py b/app.py new file mode 100644 index 0000000..a2fe144 --- /dev/null +++ b/app.py @@ -0,0 +1,1069 @@ +""" + +""" + +import gradio as gr +from typing import List, Tuple, Dict + +import os +import sys +import cv2 +import time +import torch + +import numpy as np +import torch.nn.functional as F +import torchvision.transforms.functional as func + +from tqdm import tqdm +from typing import Literal +from plyfile import PlyData, PlyElement +from argparse import ArgumentParser, Namespace + +from gaussiansplatting.scene import Scene +from gaussiansplatting.gaussian_renderer import render +from gaussiansplatting.scene.gaussian_model import GaussianModel +from gaussiansplatting.arguments import ModelParams, PipelineParams + +from seg_utils import grounding_dino_prompt +from seg_utils import conv2d_matrix, compute_ratios, update +from segment_anything import (SamAutomaticMaskGenerator, SamPredictor, + sam_model_registry) +from gradio_litmodel3d import LitModel3D + + +# region 加载Gaussian + +def get_combined_args(parser : ArgumentParser, model_path): + # cmdlne_string = sys.argv[1:] + # cfgfile_string = "Namespace()" + cmdlne_string = ['--model_path', model_path] + cfgfile_string = "Namespace()" + args_cmdline = parser.parse_args(cmdlne_string) + + try: + cfgfilepath = os.path.join(model_path, "cfg_args") + print("Looking for config file in", cfgfilepath) + with open(cfgfilepath) as cfg_file: + print("Config file found: {}".format(cfgfilepath)) + cfgfile_string = cfg_file.read() + except TypeError: + print("Config file not found at") + pass + args_cfgfile = eval(cfgfile_string) + + merged_dict = vars(args_cfgfile).copy() + for k,v in vars(args_cmdline).items(): + if v != None: + merged_dict[k] = v + return Namespace(**merged_dict) + +def load_gaussian_scene(model_path): + parser = ArgumentParser(description="Testing script parameters") + model = ModelParams(parser, sentinel=True) + pipeline = PipelineParams(parser) # 渲染用 + parser.add_argument("--iteration", default=-1, type=int) + parser.add_argument("--skip_train", action="store_true") + parser.add_argument("--skip_test", action="store_true") + parser.add_argument("--quiet", action="store_true") + parser.add_argument("--threshold", default=0.7, type=float, help='threshold of label voting') + parser.add_argument("--gd_interval", default=20, type=int, help='interval of performing gaussian decomposition') + args = get_combined_args(parser, model_path) + + dataset = model.extract(args) + dataset.model_path = args.model_path + gaussians = GaussianModel(dataset.sh_degree) + scene = Scene(dataset, gaussians, load_iteration=args.iteration, shuffle=False) + cameras = scene.getTrainCameras() + dataset.white_background = True + bg_color = [1,1,1] if dataset.white_background else [0, 0, 0] + background = torch.tensor(bg_color, dtype=torch.float32, device="cuda") + + return scene, args, dataset, pipeline, background + +# endregion + + + + +# region 加载Sam & feature + +def load_sam( + SAM_ARCH = 'vit_h', + SAM_CKPT_PATH = './gaussiansplatting/dependencies/sam_ckpt/sam_vit_h_4b8939.pth' + ): + model_type = SAM_ARCH + sam = sam_model_registry[model_type](checkpoint=SAM_CKPT_PATH).to('cuda') + print(f"Loading SAM: {SAM_ARCH} from {SAM_CKPT_PATH}") + predictor = SamPredictor(sam) + return predictor + +# extract and use sam features +def extract_sam_features(predictor, cameras, gaussians, pipeline, background): + sam_features = {} + render_images = {} + print("Prepocessing: extracting SAM features...") + for view in tqdm(cameras): + image_name = view.image_name + render_pkg = render(view, gaussians, pipeline, background) + + render_image = render_pkg["render"].permute(1, 2, 0).detach().cpu().numpy() + render_image = (255 * np.clip(render_image, 0, 1)).astype(np.uint8) + + predictor.set_image(render_image) + sam_features[image_name] = predictor.features + return sam_features + +def extract_sam_features_pt(scene_path, predictor, cameras, gaussians, pipeline, background): + # 检查路径是否存在 + if scene_path and os.path.exists(scene_path): + sam_path = os.path.join(scene_path,"sam_pt") + try: + print(f"Loading sam feature from {sam_path} ...") + sam_features = torch.load(sam_path) + return sam_features + except Exception as e: + print(f" Failed: {e}") + + print("Extract sam feature ...") + sam_features = extract_sam_features(predictor, cameras, gaussians, pipeline, background) + + if scene_path: + sam_path = os.path.join(scene_path,"sam_pt") + os.makedirs(os.path.dirname(sam_path), exist_ok=True) + print(f"保存SAM特征到{sam_path}") + torch.save(sam_features, sam_path) + + return sam_features + +# text guided, masks[id,H,W,C=1] +def text_prompt_seg(image, text): + input_boxes = grounding_dino_prompt(image, text) + + boxes = torch.tensor(input_boxes)[0:1].cuda() + transformed_boxes = predictor.transform.apply_boxes_torch(boxes, image.shape[:2]) + masks, _, _ = predictor.predict_torch( + point_coords=None, + point_labels=None, + boxes=transformed_boxes, + multimask_output=True, + ) + masks = masks[0].cpu().numpy() + return (masks[:, :, :, None]*255).astype(np.uint8) / 255 # id,H,W,1 + +# point guided, masks[id,H,W,C=1], 2D点标注 +def self_prompt_seg(point_prompts, sam_feature): + input_point = point_prompts.detach().cpu().numpy() + # input_point = input_point[::-1] + input_label = np.ones(len(input_point)) + + predictor.features = sam_feature + masks, _, _ = predictor.predict( + point_coords=input_point, + point_labels=input_label, + multimask_output=True, + ) + # return_mask = (masks[ :, :, 0]*255).astype(np.uint8) + # return_mask = (masks[id, :, :, None]*255).astype(np.uint8) # id,H,W,C=1 + return_mask = (masks[:, :, :, None]*255).astype(np.uint8) # id,H,W,C=1 + + return return_mask / 255 + +def self_prompt(point_prompts, sam_feature, id): + input_point = point_prompts.detach().cpu().numpy() + # input_point = input_point[::-1] + input_label = np.ones(len(input_point)) + + predictor.features = sam_feature + masks, _, _ = predictor.predict( + point_coords=input_point, + point_labels=input_label, + multimask_output=True, + ) + # return_mask = (masks[ :, :, 0]*255).astype(np.uint8) + return_mask = (masks[id, :, :, None]*255).astype(np.uint8) + + return return_mask / 255 + +# endregion + + + + +# region 3D投影操作 + +## Project 3D points to 2D plane +def project_to_2d(viewpoint_camera, points3D): + full_matrix = viewpoint_camera.full_proj_transform # w2c @ K + # project to image plane + if points3D.shape[-1] != 4: + points3D = F.pad(input=points3D, pad=(0, 1), mode='constant', value=1) + p_hom = (points3D @ full_matrix).transpose(0, 1) # N, 4 -> 4, N -1 ~ 1 + p_w = 1.0 / (p_hom[-1, :] + 0.0000001) + p_proj = p_hom[:3, :] * p_w + + h = viewpoint_camera.image_height + w = viewpoint_camera.image_width + + point_image = 0.5 * ((p_proj[:2] + 1) * torch.tensor([w, h]).unsqueeze(-1).to(p_proj.device) - 1) # image plane + point_image = point_image.detach().clone() + point_image = torch.round(point_image.transpose(0, 1)) + + return point_image + +# 给定单视角2Dprompt，创建3Dprompt +def get_3d_prompts(prompts_2d, point_image, xyz, depth=None): + r = 4 + x_range = torch.arange(prompts_2d[0] - r, prompts_2d[0] + r) + y_range = torch.arange(prompts_2d[1] - r, prompts_2d[1] + r) + x_grid, y_grid = torch.meshgrid(x_range, y_range) + neighbors = torch.stack([x_grid, y_grid], dim=2).reshape(-1, 2).to("cuda") + prompts_index = [torch.where((point_image == p).all(dim=1))[0] for p in neighbors] + indexs = [] + for index in prompts_index: + if index.nelement() > 0: + indexs.append(index) + indexs = torch.unique(torch.cat(indexs, dim=0)) + indexs_depth = depth[indexs] + valid_depth = indexs_depth[indexs_depth > 0] + _, sorted_indices = torch.sort(valid_depth) + valid_indexs = indexs[depth[indexs] > 0][sorted_indices[0]] + + return xyz[valid_indexs][:3].unsqueeze(0) + +## Given 1st view point prompts, find corresponding 3D Gaussian point prompts +# 将3D点投影到2D，使得2D标注能映射到特定3D点上。 +def generate_3d_prompts(xyz, viewpoint_camera, prompts_2d): + w2c_matrix = viewpoint_camera.world_view_transform + full_matrix = viewpoint_camera.full_proj_transform + # project to image plane + xyz = F.pad(input=xyz, pad=(0, 1), mode='constant', value=1) + p_hom = (xyz @ full_matrix).transpose(0, 1) # N, 4 -> 4, N + p_w = 1.0 / (p_hom[-1, :] + 0.0000001) + p_proj = p_hom[:3, :] * p_w + # project to camera space + p_view = (xyz @ w2c_matrix[:, :3]).transpose(0, 1) # N, 3 -> 3, N + depth = p_view[-1, :].detach().clone() + valid_depth = depth >= 0 + + h = viewpoint_camera.image_height + w = viewpoint_camera.image_width + + point_image = 0.5 * ((p_proj[:2] + 1) * torch.tensor([w, h]).unsqueeze(-1).to(p_proj.device) - 1) + point_image = point_image.detach().clone() + point_image = torch.round(point_image.transpose(0, 1)).long() + + prompts_2d = torch.tensor(prompts_2d).to("cuda") + prompts_3d = [] + for i in range(prompts_2d.shape[0]): # 对每个标点，获取prompt，然后融合 + prompts_3d.append(get_3d_prompts(prompts_2d[i], point_image, xyz, depth)) + prompts_3D = torch.cat(prompts_3d, dim=0) + return prompts_3D.detach().cpu().numpy() + +def mask_inverse(xyz, viewpoint_camera, sam_mask): + w2c_matrix = viewpoint_camera.world_view_transform + # project to camera space + xyz = F.pad(input=xyz, pad=(0, 1), mode='constant', value=1) + p_view = (xyz @ w2c_matrix[:, :3]).transpose(0, 1) # N, 3 -> 3, N + depth = p_view[-1, :].detach().clone() + valid_depth = depth >= 0 + + h = viewpoint_camera.image_height + w = viewpoint_camera.image_width + + + if sam_mask.shape[0] != h or sam_mask.shape[1] != w: + sam_mask = func.resize(sam_mask.unsqueeze(0), (h, w), antialias=True).squeeze(0).long() + else: + sam_mask = sam_mask.long() + + point_image = project_to_2d(viewpoint_camera, xyz) # [N,2] + point_image = point_image.long() + + # 判断x,y是否在图像范围之内 + valid_x = (point_image[:, 0] >= 0) & (point_image[:, 0] < w) + valid_y = (point_image[:, 1] >= 0) & (point_image[:, 1] < h) + valid_mask = valid_x & valid_y & valid_depth + point_mask = torch.full((point_image.shape[0],), -1).to("cuda") # [N]=-1 + # print(f"point_mask : {point_mask.shape} {point_mask.dtype} {point_mask.sum()}") + # print(f"valid_mask : {valid_mask.shape} {valid_mask.dtype} {valid_mask.sum()}") + # print(f"point_image: {point_image.shape} {point_image.dtype} {point_image.sum()}") + + point_mask[valid_mask] = sam_mask[point_image[valid_mask, 1], point_image[valid_mask, 0]] # [N]=sam_mask[x,y] + indices_mask = torch.where(point_mask == 1)[0] + + return point_mask, indices_mask + +def generate_multiview_masks(scene, images, pipeline, background, prompts_3D, mask_id = 0, progress:gr.Progress=None): + """ + sam_mask (cuda) : list[torch.int64(id,H,W)] , 每个视角下的渲染图的sam mask + multiview_masks (cuda) : list[torch.int64(N,1)] , 每个视角下，每个Gaussians点的mask + """ + cameras = scene.getTrainCameras() + gaussians = scene.gaussians + multiview_masks = [] + sam_masks = [] + sam_mask_all_levels = [] + if progress is None: use_tqdm = tqdm(enumerate(cameras), desc="generate multiview masks") + else: use_tqdm = progress.tqdm(enumerate(cameras), desc="generate multiview masks") + for i, view in use_tqdm: + # render_pkg = render(view, gaussians, pipeline, background) + # render_image = render_pkg["render"].permute(1, 2, 0).detach().cpu().numpy() + image_name = view.image_name # added + render_image = images[image_name] # added + render_image = (255 * np.clip(render_image, 0, 1)).astype(np.uint8) + + # sam prediction + # point_base + # project 3d prompts to 2d prompts + prompts_2d = project_to_2d(view, prompts_3D) + sam_mask_all_level = self_prompt_seg(prompts_2d, sam_features[image_name]) # [id,H,W,C=1] + sam_mask_all_levels.append(sam_mask_all_level) + + sam_mask = sam_mask_all_level[mask_id] + if len(sam_mask.shape) != 2: sam_mask = torch.from_numpy(sam_mask).squeeze(-1).to("cuda") + else: sam_mask = torch.from_numpy(sam_mask).to("cuda") + sam_mask = sam_mask.long() # 2D mask image + sam_masks.append(sam_mask) + + # print(f"sam_mask {sam_mask.shape} {sam_mask.dtype}") + # mask assignment to gaussians + point_mask, indices_mask = mask_inverse(gaussians.get_xyz, view, sam_mask) + multiview_masks.append(point_mask.unsqueeze(-1)) + + return sam_mask_all_levels, sam_masks, multiview_masks + +# endregion + + + + +# region 分割 + +## Gaussian Decomposition +def gaussian_decomp(gaussians, viewpoint_camera, input_mask, indices_mask): + xyz = gaussians.get_xyz + point_image = project_to_2d(viewpoint_camera, xyz) + + conv2d = conv2d_matrix(gaussians, viewpoint_camera, indices_mask, device="cuda") + height = viewpoint_camera.image_height + width = viewpoint_camera.image_width + index_in_all, ratios, dir_vector = compute_ratios(conv2d, point_image, indices_mask, input_mask, height, width) + + decomp_gaussians = update(gaussians, viewpoint_camera, index_in_all, ratios, dir_vector) + + return decomp_gaussians + +def save_gs(pc, indices_mask, save_path): + xyz = pc._xyz.detach().cpu()[indices_mask].numpy() + normals = np.zeros_like(xyz) + f_dc = pc._features_dc.detach().transpose(1, 2).flatten(start_dim=1).contiguous().cpu()[indices_mask].numpy() + f_rest = pc._features_rest.detach().transpose(1, 2).flatten(start_dim=1).contiguous().cpu()[indices_mask].numpy() + opacities = pc._opacity.detach().cpu()[indices_mask].numpy() + scale = pc._scaling.detach().cpu()[indices_mask].numpy() + rotation = pc._rotation.detach().cpu()[indices_mask].numpy() + dtype_full = [(attribute, 'f4') for attribute in pc.construct_list_of_attributes()] + elements = np.empty(xyz.shape[0], dtype=dtype_full) + attributes = np.concatenate((xyz, normals, f_dc, f_rest, opacities, scale, rotation), axis=1) + elements[:] = list(map(tuple, attributes)) + el = PlyElement.describe(elements, 'vertex') + PlyData([el]).write(save_path) + +# endregion + + + + + + +class GradioAnnotationTool: + def __init__(self, args, dataset, images: Dict[str, np.ndarray], predictor, sam_features=None, scene=None, pipeline=None, background=None): + self.images = images + self.predictor = predictor + self.args = args + self.dataset = dataset + + # 设置一次，传入图像尺寸等，之后直接改feature + self.current_image = list(images.keys())[0] + self.predictor.set_image(images[self.current_image]) + + self.maskid = 0 # 将maskid移动到类实例变量 + self.seg2d_mark = { + name: { + 'points': [], # 当前点标注 + 'masks': None, # 当前掩码[id,H,W,C=1] + 'history': [], # 历史记录 [(points, masks), ...] + 'history_index': -1, # 历史记录索引，用于撤销/重做 + 'prompts_3D': [] # 存储3D点标注 + } for name in images.keys() + } + self.multiview_mask = { + "records": [], # 每条记录结构如下（见下方）： + "current_index": -1 # 指向当前激活的记录，初始为 -1 表示无记录 + } + # records = { + # "prompts": torch.Tensor([N, 3]), # 保存用于生成该记录的 3D 点 + # "mvmask": { + # maskid1: { + # "multiview": {...}, # multiview_masks（用于3D分割） + # "sam_masks": {...}, # multiview_sam_masks（用于3D分割） + # } + # } + # "sam_all": {img1_name: mask1, img2_name: mask2} # sam_mask_all_levels（用于可视化） + # } + + self.sam_features = sam_features + self.scene = scene # 保存场景信息，用于3D点生成 + self.pipeline = pipeline + self.background = background + self.saved_fg_path = None + self.saved_bg_path = None + + def get_current_state(self): + mark = self.seg2d_mark[self.current_image] + return self.current_image, mark['points'], mark['masks'] + + def add_point(self, evt: gr.SelectData, is_original=True): + """添加点，支持从原图或mask图添加""" + print(f"点击事件: {evt}") + if evt is None: + print("收到空的点击事件") + return self._render_original(), self._render_mask(), self._render_selected_mask() + + # 获取当前图片的标注数据 + mark = self.seg2d_mark[self.current_image] + x, y = evt.index + + # 添加新点 + print(f"add state: {self.current_image}, {mark['history_index']}, {len(mark['history'])}, {len(mark['points'])}") + mark['points'].append([x, y]) + mark["history_index"] += 1 + + # 如果场景存在，更新3D点标注 + if self.scene is not None: + self._update_3d_prompts() + + if mark['points']: self._get_mask() + self._save_state() + + return self._render_original(), self._render_mask(), self._render_selected_mask() + + def undo(self): + """撤销当前图片的最后一次操作""" + mark = self.seg2d_mark[self.current_image] + print(f"undo state: {self.current_image}, {mark['history_index']}, {len(mark['history'])}, {len(mark['points'])}") + + # 检查是否有历史记录可撤销 + if mark['history_index'] > 0: # 此时若刚做了一次，为0 + mark['history_index'] -= 1 + prev_state = mark['history'][mark['history_index']] + mark['points'] = prev_state[0].copy() if prev_state[0] is not None else [] + mark['masks'] = prev_state[1].copy() if prev_state[1] is not None else None + # 恢复3D点标注 + if len(prev_state) > 2 and prev_state[2] is not None: + mark['prompts_3D'] = prev_state[2].copy() if prev_state[2] is not None else [] + else: + mark["points"] = [] + mark["masks"] = None + mark["prompts_3D"] = [] + self._save_state() + + self._get_mask() + + # 如果场景存在，更新3D点标注 + if self.scene is not None and mark['points']: + self._update_3d_prompts() + + return self._render_original(), self._render_mask(), self._render_selected_mask() + + def redo(self): + """重做当前图片的操作""" + mark = self.seg2d_mark[self.current_image] + print(f"redo state: {self.current_image}, {mark['history_index']}, {len(mark['history'])}, {len(mark['points'])}") + + # 检查是否有历史记录可重做 + if mark['history_index'] < len(mark['history']) - 1: + mark['history_index'] += 1 + next_state = mark['history'][mark['history_index']] + mark['points'] = next_state[0].copy() + mark['masks'] = next_state[1].copy() if next_state[1] is not None else None + # 恢复3D点标注 + if len(next_state) > 2 and next_state[2] is not None: + mark['prompts_3D'] = next_state[2].copy() if next_state[2] is not None else [] + + self._get_mask() + + # 如果场景存在，更新3D点标注 + if self.scene is not None and mark['points']: + self._update_3d_prompts() + + return self._render_original(), self._render_mask(), self._render_selected_mask() + + def set_mask_id(self, mask_id): + """设置当前选择的mask索引""" + self.maskid = mask_id + return self._render_selected_mask() + + def clear_current(self): + """清空当前图片的所有标注""" + mark = self.seg2d_mark[self.current_image] + mark['points'] = [] + mark['masks'] = None + mark['prompts_3D'] = [] # 清空3D点标注 + self._save_state() + self._get_mask() + return self._render_original(), self._render_mask(), self._render_selected_mask() + + def clear_all(self): + self.seg2d_mark = { + name: { + 'points': [], # 当前点标注 + 'masks': None, # 当前掩码[id,H,W,C=1] + 'history': [], # 历史记录 [(points, masks), ...] + 'history_index': -1, # 历史记录索引，用于撤销/重做 + 'prompts_3D': [] # 存储3D点标注 + } for name in self.images.keys() + } + self.multiview_mask = { + "records": [], # 每条记录结构如下（见下方）： + "current_index": -1 # 指向当前激活的记录，初始为 -1 表示无记录 + } + return self._render_original(), self._render_mask(), self._render_selected_mask() + + def _update_3d_prompts(self): + """更新当前图像的3D点标注""" + mark = self.seg2d_mark[self.current_image] + if not mark['points'] or self.scene is None: + mark['prompts_3D'] = [] + return + + # 获取当前视角的相机 + current_camera = None + for camera in self.scene.getTrainCameras(): + if camera.image_name == self.current_image: + current_camera = camera + break + + if current_camera is None: + print(f"无法找到相机: {self.current_image}") + return + + # 获取场景中的高斯点 + xyz = self.scene.gaussians.get_xyz + + # 生成3D点标注 + prompts_3D = generate_3d_prompts(xyz, current_camera, mark['points']) + mark['prompts_3D'] = prompts_3D + + def update_image(self, image_name): # 切换图片调用函数 + self.current_image = image_name + return self._render_original(), self._render_mask(), self._render_selected_mask() + + def toggle_mask(self): + if self.masks[self.current_image] is not None: + self.masks[self.current_image] = None + elif self.points[self.current_image]: + self._get_mask() + return self._render_display() + + + def get_current_multiview_mask(self): + idx = self.multiview_mask["current_index"] + if 0 <= idx < len(self.multiview_mask["records"]): + return self.multiview_mask["records"][idx] + return None + + def _get_mask(self, match_mask_id = False, progress:gr.Progress=None): + """ + 根据prompts_3D和maskid作为索引，保存multiview_sam_masks, multiview_masks + 根据prompts_3D作为索引，保存sam_mask_all_level + 其中prompts_3D为[N,3]的3D点集，索引过程中不需要保证点集顺序一致，对于十分相近的点认为是同一个点。 + 历史记录不再依赖栈结构，而是点集匹配。 + + sam_mask_all_level : 用于显示,不需要mask_id(显示时做筛选) + multiview_sam_masks: 是选中的mask,用于3D分割,需要mask_id + multiview_masks : 是3D点的mask,用于3D分割,需要mask_id + """ + if progress is not None: progress(0, desc="prepare Prompt 3D") + # 收集prompts_3D + prompts_3D_list = [] + for img_name in self.images.keys(): + if len(self.seg2d_mark[img_name]["prompts_3D"]): # 检查是否有3D点标注 + points = np.array(self.seg2d_mark[img_name]["prompts_3D"]) + if len(points.shape) == 1: # 如果是(3,)则转为(1,3) + points = points[np.newaxis, :] + prompts_3D_list.append(points) + if prompts_3D_list: + prompts_3D = np.vstack(prompts_3D_list) # 最终形状为(M,3) + prompts_3D_tensor = torch.tensor(prompts_3D, dtype=torch.float32).to("cuda") + else: + prompts_3D = np.zeros((0,3)) + prompts_3D_tensor = torch.empty((0, 3), dtype=torch.float32).to("cuda") + + print("Prompt 3D: ",prompts_3D) + print("Prompt maskid: ",self.maskid) + + if progress is not None: progress(0.1, desc="matching cached multiview mask") + + # 匹配 + def _is_same_prompt(p1, p2, tol=1e-4): + if p1.shape != p2.shape: return False + return torch.allclose(p1, p2, atol=tol) + + matched_index = None + for i, rec in enumerate(self.multiview_mask["records"]): + if _is_same_prompt(rec["prompts"], prompts_3D_tensor): + matched_index = i + break + + # --- 若找到记录且包含当前 maskid，直接复用 --- + if matched_index is not None and (not match_mask_id or self.maskid in self.multiview_mask["records"][matched_index]["mvmask"]): + self.multiview_mask["current_index"] = matched_index + print(f"Reusing cached mask at index {matched_index} for maskid {self.maskid}") + # 显示 2D mask + for img_name in self.images.keys(): + mask = self.multiview_mask["records"][matched_index]["sam_all"].get(img_name) + self.seg2d_mark[img_name]["masks"] = mask + return + + # 没有命中，生成新的 + sam_alls, sam_masks, multiviews = generate_multiview_masks( + self.scene, self.images, None, None, prompts_3D_tensor, self.maskid, progress=progress) + print("multiview_masks generated\n") + + # 刷新所有展示图片 + for sam_mask_level, img_name in zip(sam_alls, self.images.keys()): + self.seg2d_mark[img_name]["masks"] = sam_mask_level.squeeze(-1) if sam_mask_level is not None else None + + # 组装 sam_all 字典 + sam_all_dict = { + img: m.squeeze(-1) if m is not None else None + for img, m in zip(self.images.keys(), sam_alls) + } + + # --- 写入记录 --- + if matched_index is not None: + record = self.multiview_mask["records"][matched_index] + else: + record = {"prompts": prompts_3D_tensor, "mvmask": {}, "sam_all": sam_all_dict} + self.multiview_mask["records"].append(record) + matched_index = len(self.multiview_mask["records"]) - 1 + + record["mvmask"][self.maskid] = { + "multiview": multiviews, + "sam_masks": sam_masks, + } + record["sam_all"] = sam_all_dict + self.multiview_mask["current_index"] = matched_index + + def _save_state(self): + """保存当前状态到历史记录""" + mark = self.seg2d_mark[self.current_image] + + # 创建当前状态的副本，不再包含maskid + current_state = ( + mark['points'].copy() if mark['points'] else [], + mark['masks'].copy() if mark['masks'] is not None else None, + mark['prompts_3D'].copy() if 'prompts_3D' in mark and mark['prompts_3D'] is not None else [] + ) + + # 如果当前不是在历史记录的最后，则截断历史记录 + if mark['history_index'] < len(mark['history']) - 1: + mark['history'] = mark['history'][:mark['history_index'] + 1] + + # 添加当前状态到历史记录 + mark['history'].append(current_state) + mark['history_index'] = len(mark['history']) - 1 + + def _render_original(self): + """渲染原始图像，只显示点标注""" + img = self.images[self.current_image].copy() + mark = self.seg2d_mark[self.current_image] + + # 确保img是3通道图像 + if len(img.shape) == 2: + img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR) + + # 绘制点 + for i, (x, y) in enumerate(mark['points']): + # 先绘制黑色边框增加对比度 + cv2.circle(img, (x, y), 8, (0, 0, 0), -1) + # 再绘制亮色内部 + cv2.circle(img, (x, y), 6, (0, 255, 255), -1) + # 添加数字标签，带黑色边框增加可读性 + cv2.putText(img, str(i+1), (x+10, y+10), + cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 0), 3) + cv2.putText(img, str(i+1), (x+10, y+10), + cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 1) + + return img + + def _render_mask(self): + """渲染带有mask的图像，不包含图例""" + img = self.images[self.current_image].copy() + mark = self.seg2d_mark[self.current_image] + + # 确保img是3通道图像 + if len(img.shape) == 2: + img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR) + + # 绘制mask + if mark['masks'] is not None and len(mark['masks']) > 0: + # 定义三种颜色 - 使用更鲜艳的颜色 + mask_colors = [ + np.array([255, 50, 50]), # 红色 + np.array([50, 255, 50]), # 绿色 + np.array([50, 50, 255]) # 蓝色 + ] + mask_color_strength = 0.6 # [0,1] + + # 创建一个合并所有mask的图像 + combined_mask = np.zeros_like(img) + + # 创建一个优先级掩码，用于处理重叠区域 + # 值越小，优先级越高（小的mask优先显示） + priority_mask = np.ones(img.shape[:2], dtype=np.int32) * 999 + + # 从小到大处理mask，确保小的mask优先显示 + masks_count = min(len(mark['masks']), len(mask_colors)) + for i in range(masks_count): + mask = mark['masks'][i] + mask_area = mask > 0.5 + + # 只处理优先级更高的区域（即尚未被更小的mask覆盖的区域） + valid_area = np.logical_and(mask_area, priority_mask > i) + if np.any(valid_area): + # 更新优先级掩码 + priority_mask[valid_area] = i + # 将mask区域的颜色设置为mask_color和原图的加权平均 + combined_mask[valid_area] = mask_colors[i] * mask_color_strength + img[valid_area] * (1-mask_color_strength) + + # 将mask区域替换到原图中 + mask_any = np.any(combined_mask > 0, axis=2) + img[mask_any] = combined_mask[mask_any] + else: print(f"Mask invalid: {mark['masks']}") + # 绘制点 (后绘制点，确保在最上层) + for i, (x, y) in enumerate(mark['points']): + # 先绘制黑色边框增加对比度 + cv2.circle(img, (x, y), 8, (0, 0, 0), -1) + # 再绘制亮色内部 + cv2.circle(img, (x, y), 6, (0, 255, 255), -1) + # 添加数字标签，带黑色边框增加可读性 + cv2.putText(img, str(i+1), (x+10, y+10), + cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 0), 3) + cv2.putText(img, str(i+1), (x+10, y+10), + cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 1) + + return img + + def _render_selected_mask(self): + """渲染选中的单个mask应用到原图的效果""" + img = self.images[self.current_image].copy() + mark = self.seg2d_mark[self.current_image] + + # 确保img是3通道图像 + if len(img.shape) == 2: + img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR) + + # 绘制选中的mask + if mark['masks'] is not None and len(mark['masks']) > 0: + mask_id = self.maskid # 使用类实例变量 + if mask_id < len(mark['masks']): + # 获取选中的mask + mask = mark['masks'][mask_id] + mask_area = mask > 0.5 + + # 定义mask颜色 + mask_colors = [ + np.array([255, 50, 50]), # 红色 + np.array([50, 255, 50]), # 绿色 + np.array([50, 50, 255]) # 蓝色 + ] + mask_color = mask_colors[mask_id % len(mask_colors)] + mask_color_strength = 0.6 + + # 应用mask到原图 + if np.any(mask_area): + img[mask_area] = mask_color * mask_color_strength + img[mask_area] * (1-mask_color_strength) + + # 添加mask标题 + # mask_names = ["small", "middle", "large"] + # title = f"选中的Mask: {mask_names[mask_id]}" + # cv2.putText(img, title, (10, 30), + # cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 0), 2) + # cv2.putText(img, title, (10, 30), + # cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 1) + else: print(f"mask invalid: {mark['masks']}") + return img + + ## Multi-view label voting 多视角（multi-view）标签投票融合 + def ensemble(self, threshold=0.7): + multiview_masks = self.multiview_mask["records"][self.multiview_mask["current_index"]]["mvmask"][self.maskid]["multiview"] + multiview_masks = torch.cat(multiview_masks, dim=1) + vote_labels,_ = torch.mode(multiview_masks, dim=1) + # # select points with score > threshold + matches = torch.eq(multiview_masks, vote_labels.unsqueeze(1)) + ratios = torch.sum(matches, dim=1) / multiview_masks.shape[1] + ratios_mask = ratios > threshold + labels_mask = (vote_labels == 1) & ratios_mask + indices_mask = torch.where(labels_mask)[0].detach().cpu() + + return vote_labels, indices_mask + + def seg_gaussian(self, threshold, object_name, progress:gr.Progress = None): + if progress is not None: progress(0, desc="load gaussians and mask") + self._get_mask(match_mask_id=True, progress=progress) # 需要match maskid + model_path = self.scene.model_path + gaussians = self.scene.gaussians + pipeline = self.pipeline + background = self.background + _, final_mask = self.ensemble(threshold) + cameras = self.scene.getTrainCameras() + if progress is not None: progress(0.1, desc="gaussian multiview decomp") + + self.saved_fg_path = os.path.join(model_path, f'objects/{object_name}/fg.ply') + save_gs(gaussians, final_mask, self.saved_fg_path) + if progress is not None: progress(0.3, desc="gaussian multiview decomp") + + # if gaussian decomposition as a post-process module + if progress is None: use_tqdm = tqdm(enumerate(cameras), desc="gaussian multiview decomp") + else:use_tqdm = progress.tqdm(enumerate(cameras), desc="gaussian multiview decomp") + for i, view in use_tqdm: + if self.args.gd_interval != -1 and i % self.args.gd_interval == 0: + input_mask = self.multiview_mask["records"][self.multiview_mask["current_index"]]["mvmask"][self.maskid]["sam_masks"][i] + gaussians = gaussian_decomp(gaussians, view, input_mask, final_mask.to('cuda')) + if progress is not None: progress(0.5, desc="render segged gaussian") + + # save after gaussian decomposition + # self.saved_bg_path = os.path.join(model_path, f'objects/{object_name}/bg.ply') + save_gs(gaussians, final_mask, self.saved_fg_path) + if progress is not None: progress(0.7, desc="render segged gaussian") + + # render object images + seg_gaussians = GaussianModel(self.dataset.sh_degree) + seg_gaussians.load_ply(self.saved_fg_path) + if progress is not None: progress(0.8, desc="render segged gaussian") + + obj_save_path = os.path.join(model_path, f'objects/{object_name}/images') + os.makedirs(obj_save_path, exist_ok=True) + + if not os.path.exists(obj_save_path): os.mkdir(obj_save_path) + if progress is None: use_tqdm = tqdm(range(len(cameras)), desc="render segged gaussian") + else: use_tqdm = progress.tqdm(range(len(cameras)), desc="render segged gaussian") + for idx in use_tqdm: + image_name = cameras[idx].image_name + view = cameras[idx] + + render_pkg = render(view, seg_gaussians, pipeline, background) + # get sam output mask + render_image = render_pkg["render"].permute(1, 2, 0).detach().cpu().numpy() + render_image = (255 * np.clip(render_image, 0, 1)).astype(np.uint8) + render_image = cv2.cvtColor(render_image, cv2.COLOR_RGB2BGR) + cv2.imwrite(os.path.join(obj_save_path, '{}.jpg'.format(image_name)), render_image) + seg_gaussians.save_ply(os.path.join(model_path, f'objects/{object_name}/seg.ply')) + if progress is not None: progress(1, desc="Finished") + + + +def create_gradio_interface(args, dataset, images, predictor, scene=None, sam_features=None, pipeline=None, background=None): + tool = GradioAnnotationTool(args, dataset, images, predictor, sam_features, scene, pipeline=pipeline, background=background) + + with gr.Blocks() as demo: + with gr.Row(): + with gr.Column(scale=2): + with gr.Row(): + with gr.Column(scale=1): + original_display = gr.Image(label="Origin", interactive=True) + with gr.Column(scale=1): + mask_display = gr.Image(label="Layer Mask", interactive=True) + + with gr.Row(): + with gr.Column(scale=2): + with gr.Row(): + undo_btn = gr.Button("Undo") + redo_btn = gr.Button("Redo") + cls_cur_btn = gr.Button("Clear Curr View Marks") + cls_all_btn = gr.Button("Clear All Views Marks") + # save_btn = gr.Button("保存分割") + + with gr.Column(scale=1): + with gr.Row(): + selected_mask_display = gr.Image(label="Mask Result", interactive=False) + with gr.Row(): + mask_selector = gr.Radio( + choices=["S", "M", "L"], + label="Select Mask", + value="S", + interactive=True # 确保交互性 + ) + with gr.Row() as prompt_col: + object_name_input = gr.Textbox(placeholder="Your Object Name", show_label=False, interactive=True, submit_btn="Seg!") + + with gr.Row(): + with gr.Column(scale=2): + gallery = gr.Gallery( + label="Gallery", + value=list(images.values()), + columns=4, + object_fit="contain", + height="auto" + ) + with gr.Column(scale=1): + with gr.Row(): fg_gs = LitModel3D(label="Foreground", exposure=10.0, height=300) + with gr.Row(): download_fg_gs = gr.DownloadButton(label="Download", interactive=False) + # with gr.Column(scale=1): + # with gr.Row(): bg_gs = LitModel3D(label="Background", exposure=10.0, height=300) + # with gr.Row(): download_bg_gs = gr.DownloadButton(label="Download", interactive=False) + + # 处理mask选择 + def on_mask_select(choice): + mask_id = 0 + if choice == "M": mask_id = 1 + elif choice == "L": mask_id = 2 + + # 调用set_mask_id方法并返回最右侧图像 + selected_mask = tool.set_mask_id(mask_id) + return selected_mask + + # 获取可用的mask选项 + def get_available_mask_choices(tool): + # mark = tool.seg2d_mark[tool.current_image] + # if mark['masks'] is None: return ["S"] + # mask_names = ["S", "M", "L"] + # return mask_names[:len(mark['masks'])] + return ["S", "M", "L"] + + # 修改add_point方法的返回值，使用新的API更新Radio组件 + def add_point_from_original(evt: gr.SelectData): + orig, mask, selected = tool.add_point(evt, is_original=True) + # 获取当前可用的mask选项，保持mask选择 + available_masks = get_available_mask_choices(tool) + mask_id = tool.maskid # 使用类实例变量 + if mask_id >= len(available_masks): mask_id = len(available_masks)-1 + return orig, mask, selected, gr.update(choices=available_masks, value=available_masks[mask_id] if available_masks else None) + + def add_point_from_mask(evt: gr.SelectData): + orig, mask, selected = tool.add_point(evt, is_original=False) + # 获取当前可用的mask选项，保持mask选择 + available_masks = get_available_mask_choices(tool) + mask_id = tool.maskid # 使用类实例变量 + if mask_id >= len(available_masks): mask_id = len(available_masks)-1 + return orig, mask, selected, gr.update(choices=available_masks, value=available_masks[mask_id] if available_masks else None) + + # 使用select事件，更新输出包含mask选择器 + original_display.select( + fn=add_point_from_original, + outputs=[original_display, mask_display, selected_mask_display, mask_selector] + ) + + mask_display.select( + fn=add_point_from_mask, + outputs=[original_display, mask_display, selected_mask_display, mask_selector] + ) + + # Mask选择事件 + mask_selector.change( + fn=on_mask_select, + inputs=[mask_selector], + outputs=[selected_mask_display] + ) + + # 其他按钮事件 + undo_btn.click(fn=lambda: tool.undo(), outputs=[original_display, mask_display, selected_mask_display]) + redo_btn.click(fn=lambda: tool.redo(), outputs=[original_display, mask_display, selected_mask_display]) + cls_cur_btn.click(fn=tool.clear_current, outputs=[original_display, mask_display, selected_mask_display]) + cls_all_btn.click(fn=tool.clear_all, outputs=[original_display, mask_display, selected_mask_display]) + + + # 添加弹出窗口和状态提示功能 + def seg_gaussian_with_prompt(object_name, progress=gr.Progress(track_tqdm=True)): + # 更新文本框状态为处理中 + yield gr.update(value=f"正在处理 '{object_name}'...", interactive=False) + tool.seg_gaussian(threshold=0.7, object_name=object_name, progress=None) + yield gr.update(value="", placeholder="请输入对象名称", interactive=True) + + # 修改保存按钮事件 + object_name_input.submit( + fn=seg_gaussian_with_prompt, + inputs=object_name_input, + outputs=[object_name_input] + # ).then( + # fn=lambda:(tool.saved_fg_path, tool.saved_fg_path, tool.saved_bg_path, tool.saved_bg_path), + # outputs=[fg_gs, download_fg_gs, bg_gs, download_bg_gs] + # ).then( + # fn = lambda: (gr.Button(interactive=True),gr.Button(interactive=True)), + # outputs=[download_fg_gs, download_bg_gs], + ).then( + fn=lambda:(tool.saved_fg_path, tool.saved_fg_path), + outputs=[fg_gs, download_fg_gs] + ).then( + fn = lambda: gr.Button(interactive=True), + outputs=[download_fg_gs], + ) + + # Gallery选择事件处理 + def on_gallery_select(evt: gr.SelectData): + try: + index = evt.index + image_name = list(images.keys())[index] + orig, mask, selected = tool.update_image(image_name) + # 获取当前可用的mask选项，保持mask选择 + available_masks = get_available_mask_choices(tool) + mask_id = tool.maskid # 使用类实例变量 + if mask_id >= len(available_masks): mask_id = len(available_masks)-1 + return orig, mask, selected, gr.update(choices=available_masks, value=available_masks[mask_id] if available_masks else None) + except Exception as e: + print(f"Error while select in gallery: {e}") + orig = tool._render_original() + mask = tool._render_mask() + selected = tool._render_selected_mask() + return orig, mask, selected, gr.update(choices=["S"]) + + gallery.select(fn=on_gallery_select, outputs=[original_display, mask_display, selected_mask_display, mask_selector]) + + # 初始显示 + def init_display(): + orig = tool._render_original() + mask = tool._render_mask() + selected = tool._render_selected_mask() + available_masks = get_available_mask_choices(tool) + return orig, mask, selected, gr.update(choices=available_masks, value=available_masks[0] if available_masks else None) + + demo.load(fn=init_display, outputs=[original_display, mask_display, selected_mask_display, mask_selector]) + + return demo + + + +# python app.py --model_path + +if __name__ == "__main__": + model_path = '../TRELLIS/results/squirrel/25_04_27-12_22_04/model' + + predictor = load_sam() + + + for i in range(1, len(sys.argv)): + if sys.argv[i] == "--model_path" and i+1 < len(sys.argv): + model_path = sys.argv[i+1] + break + + scene, args, dataset, pipeline, background = load_gaussian_scene(model_path) + + render_images = {} + for view in scene.getTrainCameras(): + render_pkg = render(view, scene.gaussians, pipeline, background) + render_image = render_pkg["render"].permute(1, 2, 0).detach().cpu().numpy() + render_image = (255 * np.clip(render_image, 0, 1)).astype(np.uint8) + render_images[view.image_name] = render_image + + sam_features = extract_sam_features_pt(model_path, predictor, scene.getTrainCameras(), + scene.gaussians, pipeline, background) + + # 创建并启动Gradio界面，传入预先提取的特征和场景 + demo = create_gradio_interface(args, dataset, render_images, predictor, scene, sam_features, pipeline, background) + demo.launch(server_name="0.0.0.0", server_port=None, + allowed_paths = ["./", "../TRELLIS"]) + # I'm using this for trellis model segmentation + # As it's a Y-Up generation model + # output model would be lying down. diff --git a/seg_utils.py b/seg_utils.py index f073052..67ad882 100644 --- a/seg_utils.py +++ b/seg_utils.py @@ -26,7 +26,7 @@ def image_transform(image) -> torch.Tensor: def grounding_dino_prompt(image, text): image_tensor = image_transform(Image.fromarray(image)) - model_root = 'dependencies/GroundingDINO' + model_root = 'gaussiansplatting/dependencies/GroundingDINO' model = load_model(os.path.join(model_root, "groundingdino/config/GroundingDINO_SwinT_OGC.py"), os.path.join(model_root, "weights/groundingdino_swint_ogc.pth")) diff --git a/segmentation.ipynb b/segmentation.ipynb index 87c3f69..12d7301 100644 --- a/segmentation.ipynb +++ b/segmentation.ipynb @@ -1,18 +1,43 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 参数" + ] + }, { "cell_type": "code", "execution_count": 1, "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"2\"\n", + "model_path = '../TRELLIS/results/squirrel/25_04_27-12_22_04/model'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 初始化" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Looking for config file in /home/xu_hu/projects/GS/SA-GS/outputs/pinecone/cfg_args\n", - "Config file found: /home/xu_hu/projects/GS/SA-GS/outputs/pinecone/cfg_args\n", + "Looking for config file in ../TRELLIS/results/squirrel/25_04_27-12_22_04/model/cfg_args\n", + "Config file found: ../TRELLIS/results/squirrel/25_04_27-12_22_04/model/cfg_args\n", "Loading trained model at iteration 30000\n", - "Reading camera 99/99\n", + "Reading camera 90/90\n", "Loading Training Cameras\n", "Loading Test Cameras\n" ] @@ -30,7 +55,6 @@ "\n", "from argparse import ArgumentParser, Namespace\n", "\n", - "import os\n", "\n", "def get_combined_args(parser : ArgumentParser, model_path):\n", " # cmdlne_string = sys.argv[1:]\n", @@ -69,7 +93,6 @@ "parser.add_argument(\"--gd_interval\", default=20, type=int, help='interval of performing gaussian decomposition')\n", "\n", "## choose your trained 3D-GS model path\n", - "model_path = '/home/xu_hu/projects/GS/SA-GS/outputs/pinecone'\n", "args = get_combined_args(parser, model_path)\n", "\n", "# Initialize system state (RNG)\n", @@ -92,15 +115,15 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/home/xu_hu/anaconda3/envs/seg_gs/lib/python3.8/site-packages/tqdm/auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", - " from .autonotebook import tqdm as notebook_tqdm\n" + "TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + "FutureWarning: Importing from timm.models.layers is deprecated, please import via timm.layers\n" ] } ], @@ -110,6 +133,7 @@ "\n", "from seg_utils import conv2d_matrix, compute_ratios, update\n", "\n", + "# 给定单视角2Dprompt，创建3Dprompt\n", "def get_3d_prompts(prompts_2d, point_image, xyz, depth=None):\n", " r = 4\n", " x_range = torch.arange(prompts_2d[0] - r, prompts_2d[0] + r)\n", @@ -130,6 +154,8 @@ " return xyz[valid_indexs][:3].unsqueeze(0)\n", "\n", "## Given 1st view point prompts, find corresponding 3D Gaussian point prompts\n", + "# 将3D点投影到2D，使得2D标注能映射到特定3D点上。\n", + "# prompts_3D: torch[N,3], N个点的三维坐标\n", "def generate_3d_prompts(xyz, viewpoint_camera, prompts_2d):\n", " w2c_matrix = viewpoint_camera.world_view_transform\n", " full_matrix = viewpoint_camera.full_proj_transform\n", @@ -152,14 +178,53 @@ "\n", " prompts_2d = torch.tensor(prompts_2d).to(\"cuda\")\n", " prompts_3d = []\n", - " for i in range(prompts_2d.shape[0]):\n", + " for i in range(prompts_2d.shape[0]): # 对每个标点，获取prompt，然后融合\n", " prompts_3d.append(get_3d_prompts(prompts_2d[i], point_image, xyz, depth))\n", " prompts_3D = torch.cat(prompts_3d, dim=0)\n", "\n", " return prompts_3D\n", "\n", + "def generate_3d_prompts_mul_view(xyz, viewpoint_cameras, prompts_2ds):\n", + " prompts_3Ds = []\n", + " for viewpoint_camera, prompts_2d in zip(viewpoint_cameras, prompts_2ds):\n", + " w2c_matrix = viewpoint_camera.world_view_transform\n", + " full_matrix = viewpoint_camera.full_proj_transform\n", + " # project to image plane\n", + " xyz_padded = F.pad(input=xyz, pad=(0, 1), mode='constant', value=1)\n", + " p_hom = (xyz_padded @ full_matrix).transpose(0, 1) # N, 4 -> 4, N\n", + " p_w = 1.0 / (p_hom[-1, :] + 0.0000001)\n", + " p_proj = p_hom[:3, :] * p_w\n", + " # project to camera space\n", + " p_view = (xyz_padded @ w2c_matrix[:, :3]).transpose(0, 1) # N, 3 -> 3, N\n", + " depth = p_view[-1, :].detach().clone()\n", + " valid_depth = depth >= 0\n", + "\n", + " h = viewpoint_camera.image_height\n", + " w = viewpoint_camera.image_width\n", + "\n", + " point_image = 0.5 * ((p_proj[:2] + 1) * torch.tensor([w, h]).unsqueeze(-1).to(p_proj.device) - 1)\n", + " point_image = point_image.detach().clone()\n", + " point_image = torch.round(point_image.transpose(0, 1)).long()\n", + "\n", + " prompts_2d = torch.tensor(prompts_2d).to(\"cuda\")\n", + " prompts_3d = []\n", + " for i in range(prompts_2d.shape[0]): # 对每个标点，获取prompt，然后融合\n", + " prompts_3d.append(get_3d_prompts(prompts_2d[i], point_image, xyz, depth))\n", + " \n", + " if len(prompts_3d) > 0:\n", + " prompts_3D = torch.cat(prompts_3d, dim=0)\n", + " prompts_3Ds.append(prompts_3D)\n", + " \n", + " if len(prompts_3Ds) > 0: return torch.cat(prompts_3Ds, dim=0)\n", + " else: return torch.empty(0, 3, device=\"cuda\")\n", + "\n", + "def generate_3d_prompts2(xyz, view_marks: dict):\n", + " pass\n", + "\n", + "\n", "## Project 3D points to 2D plane\n", - "def porject_to_2d(viewpoint_camera, points3D):\n", + "# 多视角情况下，会有遮挡问题？\n", + "def project_to_2d(viewpoint_camera, points3D):\n", " full_matrix = viewpoint_camera.full_proj_transform # w2c @ K \n", " # project to image plane\n", " if points3D.shape[-1] != 4:\n", @@ -195,7 +260,7 @@ " else:\n", " sam_mask = sam_mask.long()\n", "\n", - " point_image = porject_to_2d(viewpoint_camera, xyz)\n", + " point_image = project_to_2d(viewpoint_camera, xyz)\n", " point_image = point_image.long()\n", "\n", " # 判断x,y是否在图像范围之内\n", @@ -209,7 +274,7 @@ "\n", " return point_mask, indices_mask\n", "\n", - "## Multi-view label voting\n", + "## Multi-view label voting 多视角（multi-view）标签投票融合\n", "def ensemble(multiview_masks, threshold=0.7):\n", " # threshold = 0.7\n", " multiview_masks = torch.cat(multiview_masks, dim=1)\n", @@ -224,9 +289,10 @@ " return vote_labels, indices_mask\n", "\n", "## Gaussian Decomposition\n", + "# 高斯边缘切割？\n", "def gaussian_decomp(gaussians, viewpoint_camera, input_mask, indices_mask):\n", " xyz = gaussians.get_xyz\n", - " point_image = porject_to_2d(viewpoint_camera, xyz)\n", + " point_image = project_to_2d(viewpoint_camera, xyz)\n", "\n", " conv2d = conv2d_matrix(gaussians, viewpoint_camera, indices_mask, device=\"cuda\")\n", " height = viewpoint_camera.image_height\n", @@ -235,20 +301,19 @@ "\n", " decomp_gaussians = update(gaussians, viewpoint_camera, index_in_all, ratios, dir_vector)\n", "\n", - " return decomp_gaussians\n", - " " + " return decomp_gaussians\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Prepare SAM predictor" + "# SAM" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -258,14 +323,14 @@ "from seg_utils import grounding_dino_prompt\n", "\n", "SAM_ARCH = 'vit_h'\n", - "SAM_CKPT_PATH = '../gaussiansplatting/dependencies/sam_ckpt/sam_vit_h_4b8939.pth'\n", + "SAM_CKPT_PATH = './gaussiansplatting/dependencies/sam_ckpt/sam_vit_h_4b8939.pth'\n", "\n", "model_type = SAM_ARCH\n", "sam = sam_model_registry[model_type](checkpoint=SAM_CKPT_PATH).to('cuda')\n", "predictor = SamPredictor(sam)\n", "\n", "# text guided\n", - "def text_prompting(image, text, id):\n", + "def text_prompting(image, text, id=[0,1,2]):\n", " input_boxes = grounding_dino_prompt(image, text)\n", "\n", " boxes = torch.tensor(input_boxes)[0:1].cuda()\n", @@ -278,9 +343,9 @@ " )\n", "\n", " masks = masks[0].cpu().numpy()\n", - " return_mask = (masks[id, :, :, None]*255).astype(np.uint8)\n", - " return return_mask / 255\n", - "\n", + " selected_masks = masks[id]\n", + " return (selected_masks[:, :, :, None]*255).astype(np.uint8) / 255\n", + " \n", "# point guided\n", "def self_prompt(point_prompts, sam_feature, id):\n", " input_point = point_prompts.detach().cpu().numpy()\n", @@ -301,7 +366,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -315,7 +380,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 99/99 [00:42<00:00, 2.31it/s]\n" + "100%|██████████| 90/90 [00:41<00:00, 2.15it/s]\n" ] } ], @@ -342,27 +407,146 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Select point prompts given the first view" + "## 标点" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mark = [\n", + " {\n", + " \"cam_id\": 10,\n", + " \"points\": (np.asarray([\n", + " [500, 400],\n", + " [613, 441],\n", + " [420, 628]\n", + " ])).astype(np.int32)\n", + " },{\n", + " \"cam_id\": 10,\n", + " \"points\": (np.asarray([\n", + " [500, 400],\n", + " [613, 441],\n", + " [420, 628]\n", + " ])).astype(np.int32)\n", + " }\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Cow-man\n", + "mask_id = 2\n", + "\n", + "idx = 10\n", + "object_name = \"man\"\n", + "input_point = (np.asarray([\n", + " [500, 400],\n", + " [613, 441],\n", + " [420, 628]\n", + "])).astype(np.int32)\n", + "\n", + "object_name = \"cow\"\n", + "input_point = (np.asarray([\n", + " [600, 600],\n", + " [400, 500]\n", + "])).astype(np.int32)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Jeep-man\n", + "mask_id = 2\n", + "\n", + "idx = 3\n", + "object_name = \"man\"\n", + "input_point = (np.asarray([\n", + " [649,524],\n", + " [672,470],\n", + " [637,426]\n", + "])).astype(np.int32)\n", + "\n", + "# input_point = (np.asarray([\n", + "# [600, 600],\n", + "# [400, 500]\n", + "# ])).astype(np.int32)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# riding2\n", + "mask_id = 2\n", + "\n", + "idx = 12\n", + "object_name = \"man\"\n", + "input_point = (np.asarray([\n", + " [481,275],\n", + " [543,536],\n", + " [481,392],\n", + " [540,608]\n", + "])).astype(np.int32)\n", + "\n", + "# input_point = (np.asarray([\n", + "# [600, 600],\n", + "# [400, 500]\n", + "# ])).astype(np.int32)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# squirrel\n", + "mask_id = 1\n", + "\n", + "idx = 12\n", + "object_name = \"squirrel_ipynb\"\n", + "input_point = (np.asarray([\n", + " [455,364],\n", + "])).astype(np.int32)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 分割" + ] + }, + { + "cell_type": "code", + "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 5, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -372,10 +556,10 @@ } ], "source": [ + "## can select input points from 1st view\n", "from matplotlib import pyplot as plt\n", "\n", "# first view\n", - "idx = 0\n", "view = cameras[idx]\n", "render_pkg = render(view, gaussians, pipeline, background)\n", "\n", @@ -387,24 +571,24 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 6, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAj8AAACcCAYAAACQu8peAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAAUrVJREFUeJzt3XmcXlV9+PHPuduzzTyzZyYTspFAYtgNEEDcIBARAQV+KgWkyg9bi9iW1lbrVmtbEVvUVtT+rNZat2oVcEERQYtACFsgQEjYQvbZl2e92znn98d9ZshIkITMPuftayTz3DvPc2fu97n3+5zzPecIrbXGMAzDMAxjjrCm+gAMwzAMwzAmk0l+DMMwDMOYU0zyYxiGYRjGnGKSH8MwDMMw5hST/BiGYRiGMaeY5McwDMMwjDnFJD+GYRiGYcwpJvkxDMMwDGNOMcmPYRiGYRhzikl+DMMwDMOYU6Z18nPjjTeyZMkS0uk0a9as4f7775/qQzKmgIkDw8SAYWLAGE/TNvn57//+b6699lo+8YlP8PDDD3Pcccexbt06enp6pvrQjElk4sAwMWCYGDDGm5iuC5uuWbOGk046iS9+8YsAKKVYuHAh11xzDR/60Ide9ueVUuzZs4f6+nqEEBN9uMYh0lpTLBbp7OzEsl7IyQ8lDkwMzCwTEQMj+5s4mBlMDBjw0nEwnpwJedZDFIYhDz30EB/+8IdHH7Msi7Vr17J+/fr9/kwQBARBMPr97t27WbVq1YQfqzG+du7cyWGHHQYcfByYGJgdDiUGwMTBbGBiwICxcTDepmXy09fXh5SS9vb2MY+3t7ezZcuW/f7Mpz/9aT75yU++6PGdO3eSz+cn5DiN8VMoFFi4cCH19fWjjx1sHLxUDJzOm3Fwx/+gjXEVE3E3tx5SDICJg5nMxIAB+4+D8TYtk59X4sMf/jDXXnvt6PcjN9N8Pm+SnxnkUJqkXyoGHFwcYS54016tA/5QuyVMHMxgJgYMGLc4+H2mZfLT2tqKbdt0d3ePeby7u5uOjo79/kwqlSKVSk3G4RmT5GDjwMTA7GOuBYaJAWMiTMvRXp7nsXr1au64447Rx5RS3HHHHZx66qlTeGTGZDJxYJgYMEwMGBNhWrb8AFx77bVcccUVnHjiiZx88sl8/vOfp1wu8+53v3uqD82YRCYODBMDhokBY7xN2+TnHe94B729vXz84x+nq6uL448/nl/84hcvKnozZjcTB4aJAcPEgDHepu08P4eqUCjQ0NDA8PCwKXieASbifI085xu4wBQ5zgCxjvgNt4z7e9bEwcxhYsCAiYuDfU3Lmh/DMAzDMIyJYpIfwzAMwzDmFJP8GIZhGIYxp5jkxzAMwzCMOcUkP4ZhGIZhzCkm+TEMwzAMY04xyY9hGIZhGHOKSX4MwzAMw5hTTPJjGIZhGMacMm2XtzBe3sjk3GEQIITA9TyEEFN8VMbk0wgBGkCb8z93aSw7+ZeSACYW5iIhkvuCNteC38skPzOUUoquvbt5ZsvjfOvfv0hdNsWf/s0/sujwFSYBmjM0ubxiyQqft1zRR7Vs8Z3Pt9O318Xc+OYSTWNbzBHHVDn/3X34FYuvfqqTnl0mDuYOTb5JsmSlz5v+oB+/bPHtz3XQ322W8ngpJvmZgbTW/Pznt/K1L32S/r17KQ6XyDiaf/+nj/DRG75JKpOb6kM0JpzmyOOq/Pk/72TB0oBURqE1NLbE/OOfLCYOzU1vbtCc8NoSf/qZXbQtCHFcDRpSGcWnrlpCFJg4mP2Sa8FffmEH8xeFeOnkWpBvllx39SLiyFS37I/5q8xApXKZr3/93xBhL+VKiNaCONY8eN/dPPvEQ8zStWqNfdgO/MGfdXP4qiqpjAJACFj9xiLLVlWn+OiMyeKlNZdd28X8JUGS+AAIOOH0EiuOr0ztwRmTwnE1l/9lF4uP9PHSL1wLTjqjwPJjzLXgpZjkZ4bRWrNj+3aGBntoaGrBS+dAuCgydA1K/vfWW9BKobU2SdAs1jo/5KiTyy96PJ1WnHZOgVoFkDHLtS8MOfwo/0WPe2nFa88dxsTB7DfvsIhVJ+7nWpBRnHHhYK0GyMTB7zLdXjOMlJJbf/EzfD+gbd5KlL+LZ57ZSTadQWq473/voHn+jeTbOulcvIwlhx9OPp8HMLVAs4QQmrPePkh9Q7yfjbDunf2k0oqhPofND+Z49okM5YKFqf+YXYSlef35Q2Rycr/bX3/BIErC8IDDU49meXpThuKQjYmD2UNYmnXvGCBXv58YEHDG24ZobI3Z9mSGpzdleOqRLIVBEwNgkp8ZRWvNpsce4+ZbbkGSYV77UuanIyjs4YHnfXKZNHFlkM33/pS+4QpOppHWxSt47dpzOe3003Fd1yRAs8DhR1V563v6EC/RbtvUFvO2q3pBQxwJdjyT5gdfmsf//rgRGZvzP1ssP6bK2/5vLy/1lm5qi7nwj5I4kFKw67kU379xHr+5udHUgcwSh7/K5y3veulrQX1TzOvPH+L15w0hpaBrh8f3vzSPX/1PE3E4t2Ngbv/2M4yUkl/fdTfNre286tjVdBdCmtuaOHahIO/4DBcLLGmKIRwgLvYQ9z9N9bm7uP07n+PWW36AlPtpKTBmFMvSXPCePuobD+BcCnA8zeGrksLoi/+4B8syzd+zgWVr3nZlL3X5/bf6jCHAdjSLj/T5s+t38n/+pNfEwSxg25q3X91DXcOBx8CCwwOu+cddXP4X3djO3I4Bk/zMEFprunr7GBgexvU84ljSM1zl6b0xHYs6eduJLuetiulsUNRnbRYsaOaI5fOxF5zCnkoD99/2fbY89rCpA5rhFi4PeM05wwfdau2lFO+8poej1pQx/f8z38LlPqecXTjoOHBTmne8v5tjTilh4mBmO2y5z4lvPPgYcDzN267q5dWvKzKXY8AkPzOE1ppNT2wmjioIYREEVWzHZkDVU1D1LD9mGatfvZimzvk0t7bR0rmYVP08Nm0rctNtGyj7kvW3/4g4jqb6VzFeoaTWZ4DcgXza349sveSiP+rFNp3dM5oQSZ1Hdn91Hgcgk1Nc+N7eF0aHGTOOEJqz3zF4YC1/+5FKK952VS+uN3djwCQ/M4DWmr1dXWzevIl8YzMrjj6B+YctxrIE5WrI070eschQv2Ap2QXLyDa3kK6rR2KxbhX89VVn0Z6L2LNtK/1du0zrzwzVsSjkzIsHX7LG40Acs6bEgsOD8TsoY9Idtiw45Dg49rQyC5ebOJipDlsWcOZFA4dUt/yq1RUOWzZ3Y8AkPzOAUopf/vIXFIcHQKRwHAcvlSZb30AqkyUWacqVCEGE5QiEpUEIpLApD3UR7nqAvXu6UFrz1BMbTfIzA1mW5q3/t5emtkNruavLS95yeZ+p+ZihLEvztv/bS2PLodXvZXOSN1/Wj2WbOJhpRur+mlpNDBwKk/xMY1prlFI8+sjD3H/vXZQrIcVShaofoLXCEhbZdJrWfB0pSyNUGSEr6NhHy5AoCBgcqtBTcSHbQi7fSNfu5+natc0kQDOIEJoT31jk7Lcf2qf95Mlg7dsHa3MEmRiYSYTQnLy2wBkXDh36SGUBZ719gBNOn9t1HzONEJrTzx1m7f85tFaf5MmSGDhmTWlcjm2mMb3/08RIMqK1Jo4jyqUS/X29PP7oI9xzz11EsaJUCXDiIrbroOIIS0lyKZsWT1CfirFUiEZjCxsVKKSMkXaGbHOGXF0dpb4uetMej224g44FSxC2PcW/tbF/GtuBfFPMvMNCXnvuMOsueeU1Hr8rVy9Ze/Egj91nlkGZvjQIcD1NfaOkc0nAaeuGOfudA2TqxicOMjnFuZf38/Bv69FqXJ7SGG9C43qaXL1kweEBp60r8KY/6CeTG58TlskpXvuWYR69t465NvePSX6mkNYaJSXDw4P0du+le+8e+nq7GejrZXBwgEKhQLlapez7xEBUKUKliuO6WEqSdizsVB1CS9LRENgNaJ10k1X9gKG+MkMFHycVkVIBv/r1Qyxa1M3Jb3gLwjKNftODRljQ2BqzcHnA0pVVlh1dpXNJSOfSgHyjxPXUQV2XRhr19tdKpDXseDrNHT9sGp/DN8ZJsiJ7U1vMoiN8lh1VZemrfBYf6dPaGVLfKHEcfXD3p5EGnf39jIauXR6//H6zSXymjeRa0NQas/RVVZas9Fm6KomBlvaIhuY4KVIfrxxFw57tKe76SeM4PeHMYpKfKaC1xverPL3lCbZufoyu3TsJggpSSpRSxLEkVjGhjIhUTKwkUSSJqiG27RBXLZqbGrBRRH6Zqiuw7AgnO48Fr7qQ7n7Jb7/1X/T39NPS1sSipYcxv7OD+pY2LrjiWo5cdayZ7HAacFOK419T4syLBjnmlBKNrfHB3+B+x1Cfw/dvnIfW8NYr+2g/LBzzfEHV4jPvX8Szj2eYa5/0pqtUWvHq1xc586KkO7KhOca2Dy0OSsM2P/nPVmw7GSHY1Da2PiTwLa77k8U8+VAWEwdTTZPKaI47rcTaiwc45pQyDS2HHgMAvXtcdj+XZvkxlRfNBxRFgs/9xUI2rc8xF2PAJD+TTCnF89ue5c7bfkbXnp0InXyqV9S+NMQalLaIESgBsVJEUUAcR8SBRSadQsdZsARhpUycqlJVLp1RD/M7D2PFmjUsO+pEPv+xa/AcaKhzyKQVK49ahEcfpo9/qmmWvsrnD/96L6tfX8RNjd/5CKoW259K88jddWz8bT3X/fezNO5TGOmlNMecUua5JzKYsq8pJjSHr3ohDsZz6HnoWzzzWIb7f5XngTvzfPIb28Z0m7opzcpXV9jycNbEwZTSLFnpc9XH93D8a0rjO/2Aht/+tJFvfGY+J5xe5ENf2j6mu8xxNCtOqPDYfbk5GQMm+ZlESknuW7+en//kZqQMsYRAC9DCRjgOGgEWKCGRKibSglCCRqNUTOj72AJ8FVIActkMaRuwHSoiy+C2rVT+41Kajz4b1dKB5/TTPyDI7ogoDe2i9bAF7Ny9jUzTEjo6l5nWnykghObkMwt84DO7aO2Ixv0DV/vCkI9/7Xk23J5n25PpF83jYdmay/68mx1PpXn4rrnXzz9dCJGsy/XHn9yTjOAb59PQ3B7xoS9u59F76ygX7NHVvkdYlubyv+iiZ7fLPbc2YOJg8gmhOe1Nw1z9D7tpaR//GEDAW67oZ+GygKEB50XXAmHBO6/p5rnNaR76TT1zLQZM8jNJlFLcffc93HTTjwBw3BQIgeU4YNkIKyk+VjJCa4iURCoBCOJYEccxUoYEQYQtIPKrqCCH19xMbKUYqtjooRirMEDXxm9QtzjNsuY8mx6XPP2cwHNhxRG76evuYbi3j3UX/ympdHYK/yJzkWbNWQU++IUdBzYl/SuUSited94Qrztv/9vrm2Iu/uMeHrmnDjVxh2G8FKF5w1uHuObTu17xhJUHwk0lowRfSi4vecf7e7j/jjxRMLdufFMvSXyuvWHnhF4LvJTipDMLL7m9rkHyjqt7ePSeOuJobsWASX4mgdaap55+mu/89/8kIzhcF6VtvFQa7BcSH60lWklkrJBSEscxYeAThj5xGBD5ATIMUShU4CPiACss4Q6EROW9DA2XkEWJDDWNXRXmrwh4x8lZbn0Qnu5SDBerPPHEHt7mtWKbaX4n3aIjA665bteEXuwOhJKCvdtTptB1iixZ4fPej++Z0MTnQGgN3Ts9s9jtFFh0RMD7PrV7yq8FWgm6d3koOfdiwNwBJ0EQBHzz29+nf6iI67rYbkxDUwYlHCzLSSpwtEIphVYSJWO0DFGxTxxWUWEVHQcIGSJUiEAjEBDGBFGR4WiYsFrAKseEVQ3YhPXN6MEG2tIe562BXzzYz8O7Qi5415/w1j+8Ettxp/ivMrfYjubSP++itX1ylheJI8FQn0Np2E768wWkM5ooFNz01VZ+c0sTWs+9C95Uc1zFZX/RTfO8yYkDJQWlgk1hwCYKBY4DdY0xlgU/+68Wfvwfrab1b5LZjuZdH+yibf7kxICMBdWyRbVsEfoWqYzC8TRxKPjxf7Ry67dbUGruXQtM8jPBtNY8+PBG7nvgISwhsG1By7x2YqlwlEIohQC0ikFJUBG2CpBxGSsq4cgyrqygZQUVV9FSYgG20IhQo2VAGJSRfoSILQ47/kTO/sOrWXnK68jmG7EsCxnHnN7dza6uHo457njy+byp95lkh6+qcvIZxQnvVpex4JF76vjx11t58uEs1fILczm5rkZrqJQtMInPlFj56gonn3Hwi1EeLCUFTz6c5Zavt7L5wRylIRspBZalydQpHEfT3+XOyZveVDvi2MorWpD0YMlYsPmBHDd9rZVnH89QLtrEkcBxNZ6nkRKGBxz0HI0Bk/xMMK01P/nJT+neuxvPtWlsaSGKQsIwwHEsBBrHETiWwhExtojQcZW0XSGyy2REmcgqI0WZIVllOBZoDZbQCBVjxQEyCsg2tnDWH36AtZdcRX1jy4uSmyUNzSw+YiWASXwmnWbtxYNkx2lyupd4CXr2eHz3C+3c8cMmgmpSL7av0J+4lzcOhOZ15w2Rykxgf6NOpjv47y+28/PvNlMtWfxuHPgVM7np1NG84YKhcZuk8CVegr5ul//58jx+/p1m/PKLY8Awyc+E6+/v55e/vI2+7j00NjXS2NRYq+2JkLGFaytcLPJuTINTJq2KOG4/Ugwiw0GUU8K3fAIdsF1J4shCIrCVxFGSlC1YefqZXPynn2TZ0asRQrxkcmOSnqmRziqOPa00YdefoGpx988a+M4X2tn1bApzoZuecnnF6te/dAHyoYpCwQN35vmvf+rguSfTpnVvGsrUKVa/YQJjILC45+cNfOcL89i+NY25Frw0k/xMIK01W7ZsYduzz4BW6HyWtGeR8SwyjiZlxWRFTIsT0epVaHSLpCljWwPE/hCxHCTSIRUihiyLrGPRREiswUl5LFp5Am/8gz9m9RvPJ53NmeRmmupcGtK5ZBxWT9bJDE1aC1QM1YrFkw/m+OH/a+Ox++pM4eo0d9gyn3mHjV+dh9ZJwapfsdiyMcstX2vlobvqayO3TCxMR4uP8OlYGI7b843EQLVsseXhLDd/rY2Nv60jCs0M/i/HJD8T7M4776RareA5FsiAOChCmMWRmiwWjSKiRRepCwqkVZmULiNiH1eXiUSIJWKiTJrK4WsJqzZnHHsMhx9+BO2HLaFjyQpSGZP0THerVpcPvatDw/135PnVD5sIqhZDfQ6DvQ79XW5tiKqJgenuiGOqyVIl4yCOBN+6oYOnH83Qvcuja4dHFJo4mO6OPL6KmxqfGAh9i6/9w3x2PZti7w6P7l0esYmBA2aSnwmklGLz5s3IOAbLJqiUGertIm3HuLKeVJ0LGR9dHUJTJJJlVKmCLSRuSmApheMJdMvRFBuPYUEuxVuv+BPS6QxgurFmBs38JcEhr8auNdzz8wb+95ZGzMVtJtIsOPzQ42DE4xty/Oj/tRFUzSf8mUMzf/E4xYCGe2/L87P/ajGtPK+QSX4mkGVZNDU1kXRWKPxqlaHBAWxCVDWLzjvYqQjLrRDqKnahihyKsTW0tgjqW2xEPkd1wWn4QyFvOf0s0umMSXpmmPEoMJVSkK03E/PMZJXS+BQax5HgR19tqxW1GzPJeE0kGIWCW79lEp9DYZKfCdbS0owFaKWJ45hKqYqlJHGlQjhsU/FiCk5Miy1Z2GLTvKoeL5vFwiVOe4h8E8PefBrzIa9aucokPjNOUpNxqHY/l2LTvXNzAcLZYXziAGDH02keW2+WJpl5BIXB8bnlbtmY48mHcuPyXHOVSX4mmBDJBU9rkEoTxZJyNSSKIopF2BZJcragIeXwqjDDYXYjKasDK53HEXU0ScH8aDPZFWeRy5pgn6vqmyTtC0OeedwsSTKnabjn1gYqJfOJfy57/P4coW+S30Nhkp8JZlm15AeNUppYKjQQRGC7GeYvWUnnwkU0NTUT2prnLQvL9rBxcGOPhthjSVBmibWdOI5wXW9qfyHjoMWhSHo+D+Fa1dwWcdIZRdbf1mAmppuhZMwhxwECFhweYNmYmZlnoHGJAWDRET62C3JyJomelczHhwmW1Pwksa61RmmwbJf2xUfw2nPO59Q3nMXSI15FrrEZkW4gdrJUIosQh0okKMUuvVETA7sepTywDa31739BY9rp3eNyyKdNwOnnDrHg8HEYMm9MiaE+l/F4955yVoElK8yMlTPRYO/4xMDq1xdZfnRlHJ5p7jItPxNs5cqVWLaN0hKBwEulWbjsCBYtOxLPdRjo2UMYhoRhiBAWwnFxXI8gcMlkM1Rs6I4Fe1SRge3raZh35FT/SsZB6t7lEYUWXvrQCpbrGiSrTiyz85n0OB2ZMZm6d3rEkcD1Du32l6mTrDqpzHObzSR2M814xUA6ozj2lDJbN2YxMfDKjHvLz9/+7d+OzjI88rVy5crR7b7vc/XVV9PS0kJdXR0XXXQR3d3dY55jx44dnHvuuWSzWebNm8cHP/hB4jge70OdcEIIli9fTl1dUpzo2DaZbAa0ZLBnN3t3PMfu55+lZ/d2Brp309+1m8GeLgr9fRSH+ujv2kXv7ufp2bOD3XsKFHZuQs+ApbhfSQz09PSMeY7ZEgMAPbs9hgcOfaSPELD82CqMy2fHifesfoJf6f8Z83Wvvm10u9SSLXoj/6t/zK/1TTzO/S96jtkUB107PcqF8YmDZUdXx+GIJp6JgbH2bvcoDo1Dm4OA5cdUTd5zCCak5eeoo47iV7/61Qsv4rzwMn/+53/Oz372M37wgx/Q0NDA+9//fi688ELuueceAKSUnHvuuXR0dHDvvfeyd+9e3vWud+G6Lv/4j/84EYc7odra2mhrm0e5VAAhCMOIoYF+quUitm2D1kkXsFYILCzXpSQcXMfBtgWObeHZFvUNPqW+FrSSYE3/tXkONgYuu+yy0e2zLQZKwzZdO1K0dR56B316IteFmgA58rya141+L/a5Wj/Fo/Sxl2M4BQeXLTw85mdnWxwUh2z6ulwaWw/9xt3SHiEsmAGfhUwM7KNcsOnvcmmed+jXgtb5IbZdqyMyDtqE1Pw4jkNHR8foV2trKwDDw8N87Wtf44YbbuCMM85g9erV/Md//Af33nsv9913HwC//OUv2bx5M9/61rc4/vjjOeecc/jUpz7FjTfeSBi+9LTgQRBQKBTGfE0H9fX1LD/ySJQGpSGKIiqlMuVigVJhmHKxQKVYJKqWifwSfmGQsNRPZbiPynA/laE+KkM9lIaGCCohM+VT/8HGwIYNG0Z/drbFgIxhz/PjVKg+wz7pCQQpkR798kQKgFhH7GEbR3IczWIeedHECk4A4IEHHgBmXxyEgWDHU+PTZWnNoGpNEwMvCENRW3/v0FkWCDEz7gfT0YS8hZ5++mk6Ozs5/PDDufTSS9mxYwcADz30EFEUsXbt2tF9V65cyaJFi1i/fj0A69ev55hjjqG9vX10n3Xr1lEoFHjiiSde8jU//elP09DQMPq1cOHCifjVDojWOvlSCgHMnz8fjUBKTRxL4jjC9wOCqk/oB+g4RMYhKgrRMiT2fXTsI4MqcVDFr1TwK1WE24SwnBe/zu98TQcHGwP7nq/ZEAO/a6DHHZfnSdZtmjkqlLhL/5R79M95XG/A10mRZoFBNJpm5o3um6MegPvvT7o+ZlccJAuz9XePTxwMdDszotUHTAy8IImB0jh0fUISS2Y9v1du3Lu91qxZwze+8Q1WrFjB3r17+eQnP8lrX/taHn/8cbq6uvA8j8bGxjE/097eTldXFwBdXV1jAn1k+8i2l/LhD3+Ya6+9dvT7QqEw6QGvtUYpxdBgP3v3bGegdy+9PYOsv/u3KKXRdrJPHEuEAGUJHEsgtAVKYAlwLLCEQEYKoUFb4FoCEWty85aD1sRBkbDSS3V4O9VSL+Cg3RbC2KWl/XAaWtqndDLEVxIDbW1t7Ny5E5jZMfBSZCTQmkOb2l5TW6l5ZmigmaM4iSx1hPg8x2Ye5Decos8ixEdg4YoXt4iN1ADO+DgQmpb2mFUnlln6qiqupzlxnFb0fu7JDAhwHEU6q2ieF+N4Ghknswj7FTtJkKZ4ZXcTA5rmeTFHHlthyUofx9Ucs6Y0Lk/97OMZtAbL0uSbY1rnR9Q3SpRKutqrJZu9270pj4HpatyTn3POOWf038ceeyxr1qxh8eLFfP/73yeTyYz3y41KpVKkUuPTnHiwRpKe7c8/xV2/upme7l6kdCkWfbbt6Gbv3q7ROX4sa2ThuVorjbbQWmIJCwRIDbaV3Cg1GqEFWoGjNP1P3s49X1xPf38XfcODeLk0vYOwp99Fp1px6haw7vyLWXN60r8uhIXjODiuMzrfUPL4xL4Z5mIM/H6CX36/ibPePkD7IazorBlpOZgZF7NWMX/M93ndzN3cSje7sJm4urWpjwNNW2fEOZf2c/Y7BmnpiLCs8W2RPe60EsuOrrLw8IDm9oh8cwxaMNTnsPXRDL/4dgsDPXVT3ks+l2OgdX7EuZf3c+ZFg7R1Rlj2+J6M5cdU+cMPdbFsVZWlq3waWmIcR6M1VEoW3/uXdu68qWl0PqgwsAh9sc8SGzPjOjJRJnyoe2NjI0ceeSTPPPMMZ511FmEYMjQ0NOaTf3d3Nx0dHQB0dHSMNnnuu31k23SjtSYMA+74xf/wg69fT2lgD9WqpOLHFCuawTBNFCVzs0iliGWS/Ag0AkGkFMIRRLHCsUVSxCg1I1MjSkDGEhHb3PbrZ4idFLFjYedySLuD+sYOFh2/nPkLFpPN5bCEy8YND44WUlvCwvOSYfP1+TyNLc3U5euxawXIk9FCdCAx0NvbO/rvmRYDB6J7p8dn3r+Iv/nKdlrnv/Jix1RaIYSmvklSHLSTe9voNXV6X8xc4ZHT9VQp0Uw7GkWkwxd98h/5ZD8T40BYmte8aZj3/u0e5nWGiAmqzTntTcOj/w6qFr++uZFH76njmcez7Nnm1W5w0y8e5kQMCM2aswr80d/uGb+FTPfj9HOHXnJbXV7yB3/WzcXvq11XNVQrFgPdDs9tzrDzmRTbtmTY8VSKwsDUtxBOhQlPfkqlEs8++yyXX345q1evxnVd7rjjDi666CIAtm7dyo4dOzj11FMBOPXUU/mHf/gHenp6mDcv6Qu+/fbbyefzrFq1aqIP96CMJD7f+Ld/4n+++S9Ui0WiUBHFiiBSlEPNcLVCGIMlXljeAgS2JZCxxBYiGf3gCLQWKAuE1jgWKKWRsaLVUXSkYc3xHrlchFaKKoKSLhKk8uze9SANOY+G/Aq0lCghsGwb27IQQhDLmMG+Afq7exHPbiOby9LY0sK8znbq8nms2n4T5UBiYKTLC2ZWDBw4wRMP5Lju6sX88d/tZtlR1YO+KArg7Vf3cPKZRRYd6bPzmRRRYNHf7XDTV9sY7B2fepKJEuuYCiU6WESeJgSCAXpo5zAAKiRdQieffDIw8+LAsjRvvqyfKz+6l2zd5E2/7KUVb3zrEKe9qcD2rWn+/r2LGeqbnrEw22NAWJo3X9rPlR/ZSy4/dVNwCwtyeUmOF46hCehcEnD0mnKy3FIsGOhx2fjbOjbdW8fDv61noNthOibNE2Hck5+//Mu/5LzzzmPx4sXs2bOHT3ziE9i2zSWXXEJDQwNXXnkl1157Lc3NzeTzea655hpOPfVUTjnlFADOPvtsVq1axeWXX871119PV1cXH/3oR7n66qunXZeG1ppvf+MrfOnz19E/UKXWV4XnQDXUhBKUAnQSToIkoYmiGO3YKKUItUa5FrES2AJskVShC6GJIk1OKBo8QbEY8eR9Owi1YE9BsLdiI70+dN0gq45dTaq+FSflYbseI8E7UgAthMB2HWzPIfYDisMFSoUSe3ftJt/YyIIlC2luacay7XFJgl5JDJx88smjn/BmUgwcHMFj9+X46KWHc8VfdbH2/wwc+GRnGpQWzF8ckqtX9O5x6d3jsXe7x8bf1lEYmH7zlT6lH6WNTtJkCajyHJsRCDpYhCNcOvVSnmYTrvZqw5w3AnDSSScBMy0ONK89b4irPraHdG7iK5G1htC3GO536Nrp0bXD44n7c2y8u56h/ukTC3MtBk49u8BVH9tLZrKS35HLx8F+kBLguJp5C0LWvXOAs98+wN4dKX770wZ+8Z2WOVErNO7vkl27dnHJJZfQ399PW1sbp59+Ovfddx9tbW0AfO5zn8OyLC666CKCIGDdunV86UtfGv1527b56U9/yvve9z5OPfVUcrkcV1xxBX/3d3833od6SLTWbH/+Wb78xc+xu7tMJAGdFCwXfIgUyH2ugSPLuWhA6SQBQiQXMT+USeEzSQsRQKw0KJAWbJWwM0zRGDezYOFCFq0+nFctXkLHggU0NrWQravH8Vwsy65V1Gqk0th20qKjtEJLhWVZ2CkP5QdopQiDgL6eHoaHhsg3NbF42RIamxpHJyZ8pV5JDHzmM5/hyCOT2atnSgy8MoLBXpcvfmQBG36V56QzCuTykpUnVGhuj3HdpM++NGyz9ZEsWzZm8VKKwoDD7m0punZ49HW5VMtWsmbYNP6UFlDlMTYQEeKRopEWTuKM0aHOR3IcTyPYxHoUasyoH5hZcVDfKHn7n/QccOKjNSgpUCq5Cb3U200pwVCvw46nU1RKNlEg2LsjxfNb0mzfmqZ3j0ulZO8z18v0ioe5FANN82Ku+OuJT3xC3yKKBL27XToWhaQy6pDPurCSVqF3XN3DmRcP8usfNfE/X2ljqG/2tgQJPV3GRo+zQqFAQ0MDw8PD5PP5cX9+KWM+8ZEPcuO/fIEgStbs0iNfiNrFTNQScz1awFxrHHpJgqQOx3McGurrOGz+fI5euZKjjj6ahYsWUd/QSCqdxnZcLNvGsm1G0yqtUVIli6hKhWXbuJ6TbFV6dDclFZEf1PZNXlVpjeOlmH9YJ4cfcTipdGpSR4xNxPkaec43cAGOmI7dALW/voC6RknnkoDmeTFRKNj5TIq+vd60valNhFhH/IZbxv09O+FxIDTvuLqHP/xQ15jCZhkLenZ77NnmMdDjMtTnEPgWhUGbwoBD316XKExa80bOfSqjiGOB7WiG+xy2PZnm0XvrGOhx0Yp9arxmZzzM1BgQQvMHf97N5X/RNWE1PiPKRRvP01h28jURr6cV7HouxTf/qYP1tzUQBZM7sdRExcG+pk/76Ayitea+++7h29/+L6qhJlZJ0uM5NgvmzWPZkiXk8w1oBOVKmcGhYQaHhyhVKvhBkKzlFUcoNXLzE1iWhefYZFJpWpsaWbZkKUetOpojX7WSeR3zSeeyCASWbdUSGYFWGonCsq2kbgewbIs4jFAyRkYRKrLx0ils20YrSRRGKKmxPRcdxUmNkIyRtVqkXTt20dPdw4pVK+jo7JjSIfOz30j3JBQHHbYOmrfjzKNZutLnwvf2jiY+SiXdmz/5z1Ye+W0d5aK9zwrsL34/bXk4x0t/JDLvv+lPc+RxFd56Zd+EJz4AufqJ71ITFixcHvBXX9jB/Xfm+fdPddYmap098WiutgdJa83g4ACf/vu/pbdngFglMzfnsxnOeM3pnHTSGppaWhHJ9JtUK1UKhWG6u7vp7u5hYLCfoeECQRiglEpaeVyP+ros+Vw9Czo7WLhwEYctXERrezu50ZFZGhnFKCmTyEwmeEArhYyj0eJmx3UQQhEGVRw7hURSKZZqXVlJqw8AkVWrA3KxtIMVx4ha15tfqfLYw5sIg5CFSxYecjeYYcxW2XrFez+xh8aWpIlOK8Gvf9TIjR9dUFvH60DfN+b9NVNlcop3/VUX+abZt86Em0pGLy5aHvDFv1nAI/fWwSypBTLJz0HSWvO97/4X6++5l1Am3V0pz+ONp53OKaecTr6xAdd18dIZXM+joamZ1nnzaGtrZ/HiEqVSiXIlWZRwpAk7nfbIZTLk83kaG/M0NOZJZ3O4qRSO6yTz/0Rx0q2lFJYtEJaF7dgoqYilREqJbVvEYUC1XKBcLFGfb04yM520GCmpku4wxyIOQ+I4ToqcLQvbddFKorXES7n4fsCWJ7ZQrVZZvmI59jgVQxvG7KE586JBjn9NabRL+alHM3z5EwsoF8yldW7QvPFtg7z6teMzceG0JGDhET5/85XtfP6DC1l/W35WFEObd+hB0Fqze/dOvv7vX6FSjYhlUpB38rHHceQRKygXisRRRENDA67rEVZ93JSH63o0NbfQ1NKKUhqlNUrq2vo8AsexyWTTpDwH27ZxPRfLcUaTDRVLhJWM2JK+j4wVtucR+iFohYzjWl1P0hIUBRHpVBYl5Wiyo8LkU4mwkiprgcZ2LGQsqZbKyVxClkBYSRec71dJZ+p5ZsszBH7AUccehe2YBMgwRjS2xrztqt7Ryev27khxw18upDg4/RceNsZHQ7Pkoj/qHfcJDKejhpaYv/z8Dv797zv5+bebZ3wCZJKfg3TzzT/kmWe2EUmN49isWLyElYcvw6/6hH7IwpZm8q2tqFgS+QFxJEnncqTSaVLpVNJbZVsomaz95XgOjm2TSnvYTlJUJiyr1kUlkxYfqM3LEBEEEalMmjiMicMQrRRaaxw3GTovAOEkE4aNtBKp2nIabjpNHAT4fpBMgBhLUtkMrufgVyrEUiIQ2J5LEAQoDTKK2LFtG7YtWHn0KtMCZBgAaN5wwRCdi0PQsHeHxz/92UKefzKN6cKaKzSnrBumc8krn7V9psnlJVd+ZA9BVfDrm5pQaubGukl+DsLAwAA/+tEP8P2IluYmOpoaWb54KbHSlMtl2trmUd/QSBTEeCkX7epaV1OyfEVSdKyxbRtsgdYayxJIGSOEh5YqaX3R4KU8hCWIw4g4iqlWqgR+gJdOEwUhMoqSOXwsgW3bSJlUXQvLIo4ipJRks7kkOVIKYQtcz8XxPKKhISI/BCEJwhClFFJJojhES42tFF4qjUCjdIxWkt7ubjLZDEuXLzPJDxrLJhk5N4Pf/MYrl8kp1l0ygLA0257M8A9/tJidz6Qwic/ckcpozr2sf060+uyrrkHy/k/vZqjf4aHf1DNTY35yx6/NYFprHnvsEbZs3kIul6VzXiu25VAuV+jp7mF4cAgpJWHgI6MALZNuJMe1QSkcNxl2rnWSjFgWWJZAKYmMk1FYMpbYto3tWIS+X2s5ioiCgCgMsSyLsFol8n3iMCDyq8gwIA4CVJzUBCFgYLCXHTufJQxDpErm/IkiSXG4SLVcJgxCAj8gjmOiMCQKAmQcJS1EtoXSkkq5RBhGKK0Jo5BiYZgdzz9Pb0/vtFk5fqq4qWTdHjW3/wxz2tJVPoctCwh9i+9+YZ5JfOagRUf4LF7hT/VhTIlsneR9f7eH+UtCpnwBuVfIJD8H4f77NxAEIR1tzWzbsZvhQpHB4WF83yeOY4pDgwz29VIuFvErFbSMsJ2kMFnGEaARFsRhgIxjQt/HL1dwHDtpDQJCP6BSLFIaGKA4MEBpaIhKqYRf8QkqlWT4upTEYVhLWCKiMEBrRbVa5pmnN1OplmlqakXYdjKcXmikUkRRRKVYRqukxSiOIsIgRKqk1UhridaaKAwJQ58oCvH9apI8SUm5VObxRx+lVCzN2QTIsjVawWCPM2tGPRgHS3PsKSU8T7HjmRT33d6ASXzmGs2xp5ZIZyZ+Nu/pauEynz/9zC6ydTPzb2C6vQ5QHMc8/PCDLJjXyvZd3VjCSoqXlSKKI6SSxEpSrZbJ5bJIGRP5AV4U46U9lAwIKiUc18VJpVBhiF8p47ouSsZUikWSiQqTQFJxnCxPoSR+EKGFhW1boDSWLZLV4bWA2hxBCAvL9Vj+qmPwXA8ZSaIwBAtkDDoOiWtdZbl8PeHgIFEYopTG8RyEY2NrD60VSo0MqdcoKQmCKogMcVQmjCI2P/EEJ518MsKeaxd8zatfV+Tx+3P4ZVPUOldZNhxzSgmtBY9vyBH4c+19YAgLjj21PLdzXgHHnlri7HcMcPPXW2fch0GT/ByggYF+nnv6KZ7f3UUQxjRkswgBURQRxTFSxoRBlaAc4C5IEwQBXsoljgPiQhFhWViWjZtKk0rnSGWy+JUqyo1QcYxlJ0XOWmtsy0JKSRwm3V5Kg+16RDLp2vJsD6U1wnLAsknX1eE4LsKySGXSSKmoloYJfB+7Nrorlc2gSiUq5SrVSoU4TiY2tF0bv1LB8VxcL5XMA2QJAny0itFCo5SN7QpQgigK2LVzB50LOjls4cI5V//z6D11ROHc+p2NsVJpRfthEVs2Zvnx19tm3EXfOHS2o2lsjab6MKac7Wje/v4eHvxNPbueTU/14RwUk/wcAK01zz73LNu276RcDcl63ujjWmjiKKrV0CiEa7Fr2zYsS5Crq0eg0TrCS3sIHFLpgKAakFUKpRVhGBDHIY7jJDM4OzaSZGRXGIaUy2U0Fg0NDcRRBFoRBj7ZfAN1TY1Ylo0Q4Fd8QBNHMYHvUyoUESKpK/JSHq7nUgWkjAiDCKUUGoX0o2T9rwBkJLHdpC7JtgR1TQ2kUin8agXbtclkMvhVHyzBk5ufYH5nJ44zl0JImMTHIN8sqW+K+dxfHsbu572pPhxjCjS2xMxfPHdGef0+LfMiLnxvL//yocNm1AeBuXTnOiQb7ltPsVgenZlQKYVSijiWWGlw3KRQePuzz6KUpKmxkSiKaG5toTRUJI5TOI4HaGSYzBEkbIFWEs9x8DwPsEbX4lJKEUcxUSRxPJtKuZTM7+M65PINpLJZojAilbaJpcQPKslq8JYgikKUTobJC5IuOy2gWq3iVwMAZG1iRMsSpDJJxq6VJgwCNBphayDpIqtrzINORrRJGRNHMYXhYXr7euhonz/nWn+MuW3pyirZeoWb0jPqYm+Mn2VHVcnlJ2nl9ulOwJq1BdoPi+jeOXM+DJjk5wBorXnk0UeIpcKyBKK2EGgoYwaLwyglyaQyDA8X8P0qnutiWzb5hkZ8v0rgR1h2spheLp0BqalWq2gBUbVKvqEOISCdq8NJZ4kDH2FpLMfG81zQCiFcGlqayNTlcFwPy7aSVeGFplIuUSoOk/I8tAC/WkXGEVIpZBgjrJBquUws42RxVaWwbQtLQBxL/EpyLKl0hlgqlIypq6snnc0SxRG246BkjEYxMDhAWBuZ9vzzz9LRPn+Kz45hTCbNEcdWiQJB397puFiuMfE0K06o4Lhzc9DH/rR0RJz4hgI/+68WZkohlEl+DkAQ+GzZshU0WEIglcSxbbTWpFOp2lw9EcPDfrKwndbEMkZpRalQRCpFOp3Csm0K/f2kMilkrJEILARxLInCmHTOBmFRKVewqC1CqqG+qYmm1la8dBqlYuI4GZWlpCSOIfSrpFJebVFTPxk+LyVxlKzXFcdJ37RSivrGRrRW+KUSdsrFQ+BXq1TKFcIgGU6PBelslnQuQxiEKK0oFIcoV5LapXKlTBRGPPPsU5xw/Imk05mpPUGGMYla5kcUBm2G+szlcy4SAhYfGUz1YUwrQsAJryvx82+3oGbI4C/z7j0AVd+nv78PITQg0IDSCillMvpKCIIgRFNbbV2HRHFEsVBARhHpdJpKuYoQEPo+xSFwU2m05ZBOp4mVwFHgpFIElQqh72PbAmE7dMzvJN/UUCtwFmgFUsboWKMUuCmXTC5HGPiEQYhAJ8XTjg0yJo5qkxjWZm8uFYvJZIvJnsmoLjS2bVGt+slCq5kUSmvKpTKxihFCI1XMnq49OJaDEBZ+ENLVtZdisWiSH2POsGxoPyzkgTvztYVLjbnGsiHfPPsWMT1Ur1pdJt8cM9Q3M1pETfJzAGzLJpvNIIRAK43WtVFZto1VW/Hc9VzKlQoAlgfVaoVypYKoFUXr/r6kVUVLLMvBTacRlk7my1ESgaQ8OEAcxWSyGWzLItfQQCqdxq9WieOIKAqxHAfbcbAsKxmWrhUIge16WFE82vIUVQKqgQ8yWTk+jiWOIwiDKrZl46VSybG6NlZUK2USGqUVlm1huzZKK4IwoFQcJggDwijElwEWyUzVA0MD9A/00draZup+jDlBSXh6U4bND+Zm/NpGxisjJex+LsXRJ5fn3OzOv0++SdLWGZnkZzbJ5/PceONXuOrKK3n2mWexajd6rZOWniCIKNsVqr6P6zoQaCxhUamWkxFaw4pMJpMkS5bAcz2EbWN7KQI7ABVSGBDkGxtoam3DTaWRcUy5VGZoaJBiqUhUW4U9V19HJpcjW1dPNpelNFxMZnKWMVEQgEgKqYeHhpBx0j1nWXatRsjCtpNESMgYohjbFiAgnU0TxxGWbVHX2IBUEhlJyuUifujjBz5xJAmDENtKwiYsJ6PRDGPuEPz3F9sJzdw+c5cWfP3T81l0pM9RJ5nr3whLaGxn5iSDJvk5AEIIFnQuYHBwaHQuHikV1SDAc11iYsI4TB5XblIPhGZoaJAwiEilXJTWpNIpVKyI05K4X5Krr0cqRWkIcnV1xHGI1opUJo1GgIYoDhkaHiaKIizHoVQt4zgu+YY8+cZGHMclimPKhQJKScIgQtgCv+onZWdCoGOJ57nJ4qgymWW6WqmQzqTQwsFNZxC2jXAcLNuioamBWEsGBvsolIaRUiXdejpZkV7GIUoqgsjHdV3T6mPMKaa7y7CsZIkb4wVxLKiUZs57wyQ/B0BrzU9/+lMGBgaolf2gkkyCSjXpRrJti5TrEkYxQgiiWOJ5HlolI6rCWu2N49j4frKchBumELZDGEdYlUqyvpeOQVvYrkM2l8WyrWQmZsB2LKRShJUKVb/K0PAw2VwOx3UIfR+tFFJpdFTrThOgVFLrI5XESdloBZYtcC2v1l3nka2vo1qpEEUhtrCJZEQYRQwNDzIw1E86nSEK49rcQJogCInjiEq1TCabnerTYxiGMYk0J76hSJtJfsbwKxalYZP8zBpaa7Zu2cK/fP7z6FoZu1QghEYjCOMY21KkhYdt2URxTCwlmXSaMIppamqkXKniB1UiKbEii0wqhZW1cVwXbEEYvbBEhiopbMcmLTJImcLxXGzXQYYhaIVSEoVGxRLlS4LQT0aSIZBSIYSFEAJhW8goBg3CstBolJJYto0nbBwvjeU4xCqmUiohZZys4+VLlCXBTmaZjuIYESSLoAZ+BALCKKRSKeP7IXW5+ik+Q4ZhGJOnsTXmbVf1mnqf39G72zPJz2wSRREf/vCHeH77dgCUBqu2iq3WIIVCAJGMGSoWEZYgpVyUUpTLFXr7+kilvGQxGK1xbRvXsQjCADeoomQtoZExtmMTyhjHdkln66lrbETYFm4YUQ18KtUKWoGw7aQmRyWjzdA66X6qFVQrLXBsC2FZSYuRlUx0aFkCBwi1QinI5etRSlEoFLAtG8uy8EOf3r5egjjEqq3d5fs+lgVxHBHHMX4YUKqUaKxrobGxcUrOi2EYxuTTvOmSAZYdXZ3qA5l2Hl1fN6Nq4Uzy8zJ27tzJPffck3QjabBq51bVWn+kTObciZXEEha2JVBKJ+mRp6lWfKxqlVw2gyUESjmUKhWiOKJQLNHY2IBtW0ShwnZdXNfG8TwCFdHdvZcoihGORaxjpNQ4rgMWuK5LHERJcpROYds2Mo6RtRXbo9rCqABCJ0tWgJV0sVk2WEkyZts2cRxip9K4nouIkkSpXCljOzbVqk8UJSvSx1FMpepTqVQZGhrknDPOJ52aWeu5GIZhvFKZnOKNbxvElDmO5Zct1t+WZ6ZMcAgm+XlZzzzzDINDQ9TyiKShpbbNIqn90VIlhdCWRimBcAVBFCJVjFIa13GJY4nrOslq7AiCSCIsRawVdXUNRDIkCEKCqk+oJMVKGcd1cFwv6R4TotaSk3RteSkP4SRD7aWMiaKotlyFjevahEFUmxlajL5RpUxWiRfCIooCPM/Fcm2CMMRx3drEicns00orgkpA4Pv4fkAYRURRRLFYolgoUZep5+3/5x1TcEYMwzCmRn2TpLXD1Pr8rkfvrePJh3JTfRgHxSQ/L6NYLKD2mbJS7/NfpcEWoNCgQKlkJJWOwIqTdbNc2yGdSoaTx1KiNWRyWWzHoVAoEuzpolytEEcRdm1ywjrHQqiIULpkbQsVJxmX7TooLbFsB2ELLGERK43Uktp0P9i2he1Y2I7Ar0ajcwF5KQ9Vq+FxbAuBoFAYHm2x0iS/h9KKUrFMLGL8IKBaqRKGSWJWKlcYHipQGi7xRx/6E+Z3mHW9DMOYOzJZheOZWp99lQs2P/x/bcgZNu+jSX5exshQbs0LAb9v6Cc1QMljtTVPk1FRApROJkCMpaJc9ZN1wYSF0ppsLkMQhQSRIuoLcD0X27bx0h4t9W1oqQirIWEU4OIl9TwyRiqBJZN6H9tORpnJMMZ2XYTSRFGUjEQTImkNimOiMESTRVgWwhWEYUQmk6ZQLoHW1Nfn0Wh836dcqVAsFtG2xg8DKuUq1aqPX/UpFEoUhoosX3oE73znJSbxMQxjToljgVLmujdCK/jVD5p4bH0dM6nLC0zy87JaWluxHRspX7xgyUgSpPb53iIZIVbLP4hjSTUIsITAsqxkaQlf40cBkLQUxTImXevOUhrqGutQkcIv9xL4yRoyruclo7lqXV920ntGFEU4jpMkX0pjWxaBX02WwxBJWhbFMfg+mmTNsWwuR6wkpVIZjUpGhsmYcrlCoVSgVC4TIwnDiEqlQrXiU6lUKAwWsXD4+0/9Pa0trRP9pzcMw5hW/IpFFAiom+ojmR52PZvmu//aPiMTQpP8vIz29nZyuRxhMLTf7aMtPjWqNg9QbQ7oJOGI49oQdIWjNQhNLJOfE0A65RLFFq7jICzNQE8fre3t5Fsak5YkmbyKjCXCtrBsG6litNTJMhdCJ+t9KUG2LouM4tqipskyFVEUE0bJDNHVqk/gB9iOTblYRlgC3w9Ip1JEcUTvQB+DQ0NgCWIZUylXKBcrFAtl/ErAR/7mo7zxjWeYVh/DMOac4qBN906PhpYZ1sczAcoFmxs/uoDBnpmZRszMo55Eixct5o1vfCM/+uFNYx4XjE16RozUAtUaZhBag1IIkYyskkqhgqQQ2bYFjm0jlSYMk9FcqUyKgf5B0rkc+cYGPC+drNUVhPjVKkEQUvUDHNeGWJDyPKIwIpVO43oeWmssx8K1XGzXJo4lQRBQKlfQWiVD1QMfqSTVchVhCWzHxkIQxhEDg4NUqhUcz0FKSXG4TLlYplrxOfOMtXzgAx/AtmfOXA6GYRjjJQwEG+7Ic+RxlZnWyzOutIIffGkej9wz87q7Rpjk52W4rsu7Ln8XP/7xj5GxBJL5fV6u5G2k/keqZGFTS1hAMixeQK3+x0bbGqkUOoZISuL+YaSGXGGIIIrI1mVxPRcVSiIZEhOjiIlihdKaMAwQ2sJ2bDQQBn7SvebYRMUQpTW+H+IHAVpJyrUC5jCMCP0AYUFtNVSiOKZYKBPLGNsRBH5EteIT+CHzO+Zz/fWfpb7eTGpoGMZcJXjgznre8f4evNSLSyHmAq1h/S8b+Ok3W9AzsLtrhEl+XoYQgsWLl5DOpKmUyqO1PPr3ZD+1XGI0AUpagxSQzAFk2xZa6dpq68kosZEfCoWFU6nS1zNIfWNIuVrGc10s204KmCM52uUkY0lhsEhDYx6pJF46jQxjEIJU2sWvJktqjAxTj+KQYqFCEISEQYCUChnHtfqgJAkLgqRIOo4lcSyRUlJfV8/nPvd5jjrqKNPdZRjGnNa1I8Vgj0P7wnCqD2XyaXh6U5YbP7KA4tDMTh9m9tFPkiOOPII3vOEN/PwXPwel0VInuYpImv9+10i31xhCjNb4KKWwhIUSyZITwlJJ7ZCGVMpFa4lfrWJ7FqIS4KRsbMdGSY2Mda3LTRP6EQpFqVym6odkMj6j1UYig+VaVIpVyqUqgwNDRFFELBVhGBLX1uqSUiZLX8hk3a4okiilku+1oiHfyGeu/wwXXHCBSXwMw5jzhgdsbvmPVi77827S2aSkYeR+MJtpBVs25rjhLxbSt9ed6sM5ZCb5OQDZTJZ//cIX+eWvfkkYhAR+QKVS5qmntnLHHXcShhEDAwOjMyrDC91iI/nCvtuEEMkcQE5S7yOlQuokARIRlMsB6bo0lXI1WZerAq4rUBKEY6FiNdoCZdk2kZRUKgG+X00mNbQsgtrK65VSBT8IGBgYQimZvFYtsZGxShIdpZIRaoBWKpmvSAiOPHIl//zP/8y6detMnY9hGAaAFtz87208cGeets6QVFqTb47pWBiy4oQK7YeFdCwKsZ3ZMx9QFAru+2UDN35kAYO9DrMh0zPJzwFIur4Wc9WVV415XEpJT08PxWKRr3zly/z7175GqVgas4/WoGvdZMmHAz06zMuyBK7rEkQxURCMLoshKj6D/YJU2sOqJR22bb0wy7RKRn9pRW3B0mRmZssSaKnxMi52wSGOYqIwqhU9+8QjrToqWfVdKYWuNVNp/UKC1tzczLvedQXXXnstCxYsMC0+hmEY+5CxYMdTaXY8te/yPhrLhkxO8vrzh7js2m5a2qMZnSdoJXh6U4YffHke62/LE4Wzp4nLJD8HaH8JgOM4dHZ2orXm+us/y2teczrXfOAauvZ2je6z7+iv0UJppYliSRQrXCep0VGqVvgMhGGMKlQIw2SxU8exRo4CBLXuKkUcSJROWoFeGF4vsCrJLM9K6tGWnaAaja5DNprojPTD6eQn29raWLfuTXzgAx/ghBNOwLIsk/gYhmEckKR1vlxwuPVbLWx+MMfV/7CbY04pzay1wHQymeNzmzPc+q0W7v5ZA8Uhm9mS9Iwwyc84ECJpwbnwwgtpbW3lyiuvZNu254AXEp6RPEOI2lxAKimAlqGqJT8qWTesNpmiCpLuMMexEZYYs0aX0kmNjozVaDIzmvwIUftv8n9CQCwVImWhKiNzBiUcx6G9vZ3Vq1dz9tlnc84557Bo0SJs2zZJj2EYxismeH5Lmn9832L+7PpdnLy2gGVN324wraFStOnd47L+lw08cncdTz2SpVKymG1JzwiT/Iwjy7J4/etfz0033cTVV1/NvffeC6jROYEEL7QCSZV0gSVvh7G1QrKWGOk4SYBGEp+RhOSF2hygVqszZgTavi9IkiwhFSpWWJZFR0cHZ5xxBpdccgnHH3888+bNG63pMUmPYRjGeBAM9jhc/4GFXHZtN+de3k8qM42Gx2sIfItdz6a444dN3Hd7A/1dDn5l9iY8+zLJzzgTQnDMMcdw880388UvfpEvf/nL9PR0j7baWCNJSq0WaHRI/D50bX6gkaUyAIQlaivCA4jkf5YmjmojDWqplB6pG7JB66QGCA11dTnOPu9szj//fM4880zmz59vurUMwzAmlKBccPj3T3XyyN11XPYX3Sw/pjq1rUAa+rtdNvwqz23fa+b5Lek5k/DsyyQ/E0AIQXNzMx/72Me48MIL+fjHP85PfvITpJRj99vnv5okwdGq1hakQdi1kV2qNjGiY6NihbBqXV8j20ank35h6L0eGTsPHH/88XzqU59i3bp1OI4zeoyGYRjGxJNSsOFXeZ54IMc73t/DBe/pm5JWIK1h0/o6vvTRBTy/NT1a7zkXWS+/i/FKiNpCpkcffTTf/OY3ueaaa0in02P22bceCBhNfEYolSxVMbItCiJkLImjGBnJMYmSrs0/9MKTg23bnHrqqXzrW9/i3HPPxXGcWhfa3A14wzCMqSEoDTv8x3Xz+dzIXDmT1QCkoVKyueXrbfzDHy3m+S1zO/EB0/Iz4YQQ1NXVcd1113Hcccfxt3/7CXbs2Dlm3p+XouLf+WSgf+e/tecXtYJp27Jpm9dGU1MTq1ev5rzzzuOss86isbHRJDyGYRjTgJKCX9/cyLYtaa76+B6OO62E6734fpB8qK2N4bX0y48Yq43SkjLZUcWCwV6H57emeXxDjk3r63j2iQxKmnsBmORnUggh8DyPd73rXbz+9a/nq1/9Kj/60Y/Ys2cPAC0tLSxbtozjjjuOJUuWYNs227dv57777uPJJ59kYGBgTJeZ4zq0tbZx4omrectbzmP+/Pl0d3eTz+c57bTTaGhoIJvNmpoewzCMaSkZDfap/7uEVSdWePNl/Sxc7mNZUByy2fZkhiceyDHY66A1NLXFnPDaIkceW2XewpBMVmFZGqUF1ZJFz26P+27P88Cd9ZQLyeCVOBIM9rhUylatHMLcC/Z10MnPXXfdxWc/+1keeugh9u7dy0033cRb3/rW0e1aaz7xiU/w1a9+laGhIV7zmtfw5S9/mSOOOGJ0n4GBAa655hp+8pOfYFkWF110EV/4wheoq6sb3WfTpk1cffXVPPDAA7S1tXHNNdfwV3/1V4f2206hkRaaJUuW8Pd///d88IMfpLu7G0jm16mvr8d1x04ZHoYhXV1dPPLII6xfv549e/aQTqd585vfzOrVq+no6Bit4dn3dSbaRMTAeeed96LXmW0xMJsM6l628xQFBgnxOZZTmScWjG7XWvMcm9nNNmJCGmllJSeQFS8sjBvpkK1spJe9CAStzH/R65gYmN7GOw5GlEol8vn86PezMw4EfsXm4bvq2Hh3HV4qaf2JI4GMk+37+vXNjaQziub2mMMOD2ieF1EtWzy1Kctgr4NfnntFy4fioJOfcrnMcccdx3ve8x4uvPDCF22//vrr+Zd/+Rf+8z//k6VLl/Kxj32MdevWsXnz5tGal0svvZS9e/dy++23E0UR7373u3nve9/Ld77zHQAKhQJnn302a9eu5Stf+QqPPfYY73nPe2hsbOS9733vIf7KU2skCWpqaqKpqen37ptKpVi8eDGLFi3i/PPPT1aEryU3U9miMxExcMUVV4x5jtkcA7OBJKaOBjpZwibWv2j7drayk2dYxUlkyPIsT7CRuzlFn40tkk+mj7OBAJ9X81o0mid4YMxzmBiY/sY7DiIiHuFu/vRP/5Qf/OAHwFyIA4FWEFRf5pquk2RpzzabPdtSk3Nos9hBJz/nnHMO55xzzn63aa35/Oc/z0c/+lEuuOACAL75zW/S3t7OzTffzDvf+U6efPJJfvGLX/DAAw9w4oknAvCv//qvvPnNb+af/umf6Ozs5Nvf/jZhGPL1r38dz/M46qijeOSRR7jhhhtmSbAfnOmQ8OxrImLgs5/9LBdddBF79+4ln8+bGJjmWsX8F1pqfqdcQWvNDp5hKSuZJzoBOFqfzF38hF720MFCyrpAP92czBnkRTMAy/UxPMZ9JgZmkPGOg1hHAPzwhz9kz5495n5gTJhxHe21bds2urq6WLt27ehjDQ0NrFmzhvXrk08F69evp7GxcfSmB7B27Vosy2LDhg2j+7zuda/D87zRfdatW8fWrVsZHBzc72sHQUChUBjzZUy+VxoDb3jDGwB48MEHR/cxMTAzVSkT4tNM++hjjnDJ08ww/QAM0Y+DO5r4ADTRBhxaDICJg+nilcYBYO4HxoQb1+SnqytZ06q9vX3M4+3t7aPburq6mDdv3pjtjuPQ3Nw8Zp/9Pce+r/G7Pv3pT9PQ0DD6tXDhwkP/hYyDdigxAIzWQZkYmLlCfAA8xjbNe6RHt4X4L9pu1S5HhxIDYOJgunilcQDQ1NRk7gfGhJo1o70+/OEPc+21145+Pzw8zKJFi0zGPwkqlcro37lcLgNQLBbJ5XKj+0RRhBCCQqGA7/sopcacm/E4Ty8VAzHR5M2nMUdJ5GiXhSQZmRgTY9ceA9AkC/fGOkKh0OjRn0n2jxgPJg6mzqHGgYkBA16IgwOZEuaVGtfkp6OjA0g+uc2f/8LIje7ubo4//vjRfXp6esb8XBzHDAwMjP58R0fH6Ke/fZ9j39f4XalUilTqhU8QfX19ACbjnwSXXnrpix5bsWLFfve96aabRv/d0NDwou319ckokPGMgbu59fcdvjEOnuD+Fz22ntv2u+9vuGW//x5xKDEAJg6m0njFweDg4ITcD0wMzCzFYnG/94nxMK7Jz9KlS+no6OCOO+4YTXYKhQIbNmzgfe97HwCnnnoqQ0NDPPTQQ6xevRqAO++8E6UUa9asGd3nIx/5CFEUjQ7/vv3221mxYsXLjpAa0dyc9CHv2LFjwv54RpLAfPvb3+Ytb3kLkGTqK1as4JprruGaa64BkhhYvnw5X/rSl7j44ovZunUrJ598Mj/72c8499xz2blzJw888AAXXXTRaCG1iYGZ41Bi4De/+Q3Lli1j4cKFfOtb3+Lyyy8f1xgAEweTZTyuBTt27OCuu+7i8ssvN/eDOaZQKLBw4UJ27txJfX09xWKRzs7OiXtBfZCKxaLeuHGj3rhxowb0DTfcoDdu3Ki3b9+utdb6uuuu042NjfqWW27RmzZt0hdccIFeunSprlaro8/xpje9SZ9wwgl6w4YN+u6779ZHHHGEvuSSS0a3Dw0N6fb2dn355Zfrxx9/XH/ve9/T2WxW/9u//dsBH+fw8LAG9PDw8MH+isbLGK8YOPbYYzWgb7vtNhMDM8x4XgfuvPNODehly5aNewxobeJgIplrgTFeJvscHXTy8+tf/3pkOaoxX1dccYXWWmullP7Yxz6m29vbdSqV0meeeabeunXrmOfo7+/Xl1xyia6rq9P5fF6/+93v1sViccw+jz76qD799NN1KpXSCxYs0Nddd91BHacJ9okzXjFw8cUXa8DEwAw03tcBQF922WXjHgNamziYSOZaYIyXyT5HQusJrCiaQoVCgYaGBoaHh8fMFGpMHxN9jkwMzAwmDgwTA8Zkn6NZu6p7KpXiE5/4xJiiN2N6mehzZGJgZjBxYJgYMCb7HM3alh/DMAzDMIz9mbUtP4ZhGIZhGPtjkh/DMAzDMOYUk/wYhmEYhjGnmOTHMAzDMIw5xSQ/hmEYhmHMKbMy+bnxxhtZsmQJ6XSaNWvWcP/9L15vxhgfd911F+eddx6dnZ0IIbj55pvHbNda8/GPf5z58+eTyWRYu3YtTz/99Jh9BgYGuPTSS8nn8zQ2NnLllVdSKpXG7LNp0yZe+9rXkk6nWbhwIddff/3LHpuJg8kzXePAxMDkma4xACYOJst0joEXmZSpFCfR9773Pe15nv7617+un3jiCX3VVVfpxsZG3d3dPdWHNivdeuut+iMf+Yj+0Y9+pAF90003jdl+3XXX6YaGBn3zzTfrRx99VJ9//vn7nd7+uOOO0/fdd5/+7W9/q5cvXz5mevvh4WHd3t6uL730Uv3444/r7373uzqTyfze6e1NHEyu6RgHJgYm13SMAa1NHEym6RoD+zPrkp+TTz5ZX3311aPfSyl1Z2en/vSnPz2FRzU3/G6wK6V0R0eH/uxnPzv62NDQkE6lUvq73/2u1lrrzZs3a0A/8MADo/v8/Oc/10IIvXv3bq211l/60pd0U1OTDoJgdJ+//uu/1itWrHjJYzFxMHWmSxyYGJg60yUGtDZxMFWmUwzsz6zq9grDkIceeoi1a9eOPmZZFmvXrmX9+vVTeGRz07Zt2+jq6hpzPhoaGlizZs3o+Vi/fj2NjY2ceOKJo/usXbsWy7LYsGHD6D6ve93r8DxvdJ9169axdetWBgcHX/S6Jg6ml6mIAxMD04u5FhhTFQMvZVYlP319fUgpaW9vH/N4e3s7XV1dU3RUc9fI3/z3nY+uri7mzZs3ZrvjODQ3N4/ZZ3/Pse9r7MvEwfQyFXFgYmB6MdcCY6pi4KXMquTHMAzDMAzj5cyq5Ke1tRXbtunu7h7zeHd3Nx0dHVN0VHPXyN/8952Pjo4Oenp6xmyP45iBgYEx++zvOfZ9jX2ZOJhepiIOTAxML+ZaYExVDLyUWZX8eJ7H6tWrueOOO0YfU0pxxx13cOqpp07hkc1NS5cupaOjY8z5KBQKbNiwYfR8nHrqqQwNDfHQQw+N7nPnnXeilGLNmjWj+9x1111EUTS6z+23386KFStoamp60euaOJhepiIOTAxML+ZaYExVDLykV1LFPZ1973vf06lUSn/jG9/Qmzdv1u9973t1Y2Oj7urqmupDm5WKxaLeuHGj3rhxowb0DTfcoDdu3Ki3b9+utU6GNjY2NupbbrlFb9q0SV9wwQX7Hdp4wgkn6A0bNui7775bH3HEEWOGNg4NDen29nZ9+eWX68cff1x/73vf09ls9mWHt5o4mDzTMQ5MDEyu6RgDWps4mEzTNQb2Z9YlP1pr/a//+q960aJF2vM8ffLJJ+v77rtvqg9p1vr1r3+tgRd9XXHFFVrrZHjjxz72Md3e3q5TqZQ+88wz9datW8c8R39/v77kkkt0XV2dzufz+t3vfrcuFotj9nn00Uf16aefrlOplF6wYIG+7rrrXvbYTBxMnukaByYGJs90jQGtTRxMlukcA79LaK31gbcTGYZhGIZhzGyzqubHMAzDMAzj5ZjkxzAMwzCMOcUkP4ZhGIZhzCkm+TEMwzAMY04xyY9hGIZhGHOKSX4MwzAMw5hTTPJjGIZhGMacYpIfwzAMwzDmFJP8GIZhGIYxp5jkxzAMwzCMOcUkP4ZhGIZhzCn/H6ng5IEQZRiKAAAAAElFTkSuQmCC", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -412,8 +596,6 @@ } ], "source": [ - "## can select input points from 1st view\n", - "input_point = (np.asarray([[300, 180]])).astype(np.int32)\n", "# input_point = (np.asarray([[1200, 700]])).astype(np.int32)\n", "input_label = np.ones(len(input_point))\n", "\n", @@ -425,11 +607,31 @@ " multimask_output=True,\n", " )\n", "\n", - "plt.subplot(1,3,1)\n", + "plt.subplot(1,4,1)\n", + "plt.imshow(render_image)\n", + "plt.subplot(1,4,2)\n", + "plt.imshow(masks[0])\n", + "plt.subplot(1,4,3)\n", + "plt.imshow(masks[1])\n", + "plt.subplot(1,4,4)\n", + "plt.imshow(masks[2])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "text_prompt = \"a squirrel\"\n", + "masks = text_prompting(render_image, text_prompt)\n", + "plt.subplot(1,4,1)\n", + "plt.imshow(render_image)\n", + "plt.subplot(1,4,2)\n", "plt.imshow(masks[0])\n", - "plt.subplot(1,3,2)\n", + "plt.subplot(1,4,3)\n", "plt.imshow(masks[1])\n", - "plt.subplot(1,3,3)\n", + "plt.subplot(1,4,4)\n", "plt.imshow(masks[2])" ] }, @@ -437,27 +639,179 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Start Segmentation" + "# 分割Gaussian" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 单视角Prompt" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "metadata": {}, "outputs": [ { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - "Start Segmentation...\n" + "UserWarning: torch.meshgrid: in an upcoming release, it will be required to pass the indexing argument. (Triggered internally at /opt/conda/conda-bld/pytorch_1682343970094/work/aten/src/ATen/native/TensorShape.cpp:3483.)\n" ] - }, + } + ], + "source": [ + "# generate 3D prompts 传入Gaussian的xyz，单视角，和该视角下的input_point\n", + "text_prompt = None\n", + "prompts_3d = generate_3d_prompts(gaussians.get_xyz, cameras[idx], input_point)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 多视角Prompt" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# generate 3D prompts 传入Gaussian的xyz，单视角，和该视角下的input_point\n", + "text_prompt = None\n", + "prompts_3d = generate_3d_prompts(gaussians.get_xyz, cameras[idx], input_point)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "text_prompt = None\n", + "prompts_3d = generate_3d_prompts_(gaussians.get_xyz, data)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 文本Prompt" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "text_prompt = \"a squirrel\"" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - "/home/xu_hu/anaconda3/envs/seg_gs/lib/python3.8/site-packages/torch/functional.py:504: UserWarning: torch.meshgrid: in an upcoming release, it will be required to pass the indexing argument. (Triggered internally at ../aten/src/ATen/native/TensorShape.cpp:3526.)\n", - " return _VF.meshgrid(tensors, **kwargs) # type: ignore[attr-defined]\n" + "Start Segmentation...\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n", + "sam_mask torch.Size([1024, 1024]) torch.int64\n" ] } ], @@ -485,13 +839,6 @@ " el = PlyElement.describe(elements, 'vertex')\n", " PlyData([el]).write(save_path)\n", "\n", - "mask_id = 2\n", - "\n", - "# generate 3D prompts\n", - "xyz = gaussians.get_xyz\n", - "prompts_3d = generate_3d_prompts(xyz, cameras[idx], input_point)\n", - "\n", - "\n", "multiview_masks = []\n", "sam_masks = []\n", "for i, view in enumerate(cameras):\n", @@ -501,20 +848,24 @@ " render_image = render_pkg[\"render\"].permute(1, 2, 0).detach().cpu().numpy()\n", " render_image = (255 * np.clip(render_image, 0, 1)).astype(np.uint8)\n", "\n", - " # project 3d prompts to 2d prompts\n", - " prompts_2d = porject_to_2d(view, prompts_3d)\n", - "\n", " # sam prediction\n", - " sam_mask = self_prompt(prompts_2d, sam_features[image_name], mask_id)\n", - " if len(sam_mask.shape) != 2:\n", - " sam_mask = torch.from_numpy(sam_mask).squeeze(-1).to(\"cuda\")\n", - " else:\n", - " sam_mask = torch.from_numpy(sam_mask).to(\"cuda\")\n", - " sam_mask = sam_mask.long()\n", + " # point_base\n", + " if text_prompt is None:\n", + " # project 3d prompts to 2d prompts\n", + " prompts_2d = project_to_2d(view, prompts_3d)\n", + " sam_mask = self_prompt(prompts_2d, sam_features[image_name], mask_id)\n", + " if len(sam_mask.shape) != 2:\n", + " sam_mask = torch.from_numpy(sam_mask).squeeze(-1).to(\"cuda\")\n", + " else:\n", + " sam_mask = torch.from_numpy(sam_mask).to(\"cuda\")\n", + " else: \n", + " sam_mask = text_prompting(render_image, \"\")\n", + " sam_mask = sam_mask.long() # 2D mask image\n", " sam_masks.append(sam_mask)\n", " \n", " # mask assignment to gaussians\n", - " point_mask, indices_mask = mask_inverse(xyz, view, sam_mask)\n", + " print(f\"sam_mask {sam_mask.shape} {sam_mask.dtype}\")\n", + " point_mask, indices_mask = mask_inverse(gaussians.get_xyz, view, sam_mask)\n", "\n", " multiview_masks.append(point_mask.unsqueeze(-1))\n", "\n", @@ -533,10 +884,11 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ + "os.makedirs(f\"{model_path}/objects/{object_name}\", exist_ok=True)\n", "# if gaussian decomposition as a post-process module\n", "for i, view in enumerate(cameras):\n", " if args.gd_interval != -1 and i % args.gd_interval == 0:\n", @@ -544,22 +896,22 @@ " gaussians = gaussian_decomp(gaussians, view, input_mask, final_mask.to('cuda'))\n", "\n", "# save after gaussian decomposition\n", - "save_gd_path = os.path.join(model_path, 'point_cloud/iteration_30000/point_cloud_seg_gd.ply')\n", + "save_gd_path = os.path.join(model_path, f'objects/{object_name}/seg_gd.ply')\n", "save_gs(gaussians, final_mask, save_gd_path)" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "# render object images\n", - "\n", "seg_gaussians = GaussianModel(dataset.sh_degree)\n", "seg_gaussians.load_ply(save_gd_path)\n", "\n", - "obj_save_path = os.path.join(model_path, 'obj_images')\n", + "obj_save_path = os.path.join(model_path, f'objects/{object_name}/images')\n", + "os.makedirs(obj_save_path, exist_ok=True)\n", "\n", "if not os.path.exists(obj_save_path):\n", " os.mkdir(obj_save_path)\n", @@ -573,13 +925,14 @@ " render_image = render_pkg[\"render\"].permute(1, 2, 0).detach().cpu().numpy()\n", " render_image = (255 * np.clip(render_image, 0, 1)).astype(np.uint8)\n", " render_image = cv2.cvtColor(render_image, cv2.COLOR_RGB2BGR)\n", - " cv2.imwrite(os.path.join(obj_save_path, '{}.jpg'.format(image_name)), render_image)\n" + " cv2.imwrite(os.path.join(obj_save_path, '{}.jpg'.format(image_name)), render_image)\n", + "seg_gaussians.save_ply(os.path.join(model_path, f'objects/{object_name}/seg.ply'))" ] } ], "metadata": { "kernelspec": { - "display_name": "seg_gs", + "display_name": "sags", "language": "python", "name": "python3" }, @@ -593,7 +946,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.18" + "version": "3.11.12" } }, "nbformat": 4, From 4cfbef644f3c9123f5821665f2d237ab5fa779f5 Mon Sep 17 00:00:00 2001 From: MrHandsomeljn <1205197328@qq.com> Date: Tue, 29 Apr 2025 22:34:52 +0800 Subject: [PATCH 2/9] updated --- README.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/README.md b/README.md index c417de5..7a60c10 100644 --- a/README.md +++ b/README.md @@ -6,6 +6,9 @@ Use it to segment any gaussian easily, capable with multiview annotation ability Text prompt would be release when I'm available. Undo and Redo might incur additional GPU Memory cost. +Gradio版本的SAGS，支持多视角标注，背面也可以加约束了。 +有空想整一个文本提示版本。 +每次的撤消和重做的结果都保存了，不会重复存，但是反复折腾可能会占点显存。 ## Introduction 3D Gaussian Splatting has emerged as an alternative 3D representation for novel view synthesis, benefiting from its high-quality rendering results and real-time rendering speed. However, the 3D Gaussians learned by 3D-GS have ambiguous structures without any geometry constraints. This inherent issue in 3D-GS leads to a rough boundary when segmenting individual objects. To remedy these problems, we propose SAGD, a conceptually simple yet effective boundary-enhanced segmentation pipeline for 3D-GS to improve segmentation accuracy while preserving segmentation speed. Specifically, we introduce a Gaussian Decomposition scheme, which ingeniously utilizes the special structure of 3D Gaussian, finds out, and then decomposes the boundary Gaussians. Moreover, to achieve fast interactive 3D segmentation, we introduce a novel training-free pipeline by lifting a 2D foundation model to 3D-GS. Extensive experiments demonstrate that our approach achieves high-quality 3D segmentation without rough boundary issues, which can be easily applied to other scene editing tasks. From 8103590740be3f044e755524004c1dfab0d480e7 Mon Sep 17 00:00:00 2001 From: MrHandsomeljn <1205197328@qq.com> Date: Wed, 30 Apr 2025 16:30:12 +0800 Subject: [PATCH 3/9] debug, support reload scene --- README.md | 1 + app.py | 429 ++++++++++++++++++++++++++------------------- segmentation.ipynb | 157 +++++++++++------ 3 files changed, 358 insertions(+), 229 deletions(-) diff --git a/README.md b/README.md index 7a60c10..54e500d 100644 --- a/README.md +++ b/README.md @@ -5,6 +5,7 @@ Use it to segment any gaussian easily, capable with multiview annotation ability. Text prompt would be release when I'm available. Undo and Redo might incur additional GPU Memory cost. +Requires gradio>=5 Gradio版本的SAGS，支持多视角标注，背面也可以加约束了。 有空想整一个文本提示版本。 diff --git a/app.py b/app.py index a2fe144..f5dcc08 100644 --- a/app.py +++ b/app.py @@ -32,6 +32,21 @@ from gradio_litmodel3d import LitModel3D +pipeline, background = None, None + +# 递归查找所有名为"model"的文件夹 +def find_model_folders(base_path, relative_to="."): + model_paths = [] + if os.path.exists(base_path): + # 如果relative_to是None,则相对于当前目录 + if relative_to is None: relative_to = "." + for root, dirs, files in os.walk(base_path): + if os.path.basename(root) == "model": + # 获取相对于relative_to的路径 + rel_path = os.path.relpath(root, relative_to) + model_paths.append(rel_path) + return model_paths + # region 加载Gaussian def get_combined_args(parser : ArgumentParser, model_path): @@ -58,28 +73,7 @@ def get_combined_args(parser : ArgumentParser, model_path): merged_dict[k] = v return Namespace(**merged_dict) -def load_gaussian_scene(model_path): - parser = ArgumentParser(description="Testing script parameters") - model = ModelParams(parser, sentinel=True) - pipeline = PipelineParams(parser) # 渲染用 - parser.add_argument("--iteration", default=-1, type=int) - parser.add_argument("--skip_train", action="store_true") - parser.add_argument("--skip_test", action="store_true") - parser.add_argument("--quiet", action="store_true") - parser.add_argument("--threshold", default=0.7, type=float, help='threshold of label voting') - parser.add_argument("--gd_interval", default=20, type=int, help='interval of performing gaussian decomposition') - args = get_combined_args(parser, model_path) - - dataset = model.extract(args) - dataset.model_path = args.model_path - gaussians = GaussianModel(dataset.sh_degree) - scene = Scene(dataset, gaussians, load_iteration=args.iteration, shuffle=False) - cameras = scene.getTrainCameras() - dataset.white_background = True - bg_color = [1,1,1] if dataset.white_background else [0, 0, 0] - background = torch.tensor(bg_color, dtype=torch.float32, device="cuda") - - return scene, args, dataset, pipeline, background + # endregion @@ -99,7 +93,7 @@ def load_sam( return predictor # extract and use sam features -def extract_sam_features(predictor, cameras, gaussians, pipeline, background): +def extract_sam_features(predictor, cameras, gaussians): sam_features = {} render_images = {} print("Prepocessing: extracting SAM features...") @@ -114,7 +108,7 @@ def extract_sam_features(predictor, cameras, gaussians, pipeline, background): sam_features[image_name] = predictor.features return sam_features -def extract_sam_features_pt(scene_path, predictor, cameras, gaussians, pipeline, background): +def extract_sam_features_pt(scene_path, predictor, cameras, gaussians): # 检查路径是否存在 if scene_path and os.path.exists(scene_path): sam_path = os.path.join(scene_path,"sam_pt") @@ -126,7 +120,7 @@ def extract_sam_features_pt(scene_path, predictor, cameras, gaussians, pipeline, print(f" Failed: {e}") print("Extract sam feature ...") - sam_features = extract_sam_features(predictor, cameras, gaussians, pipeline, background) + sam_features = extract_sam_features(predictor, cameras, gaussians) if scene_path: sam_path = os.path.join(scene_path,"sam_pt") @@ -136,54 +130,7 @@ def extract_sam_features_pt(scene_path, predictor, cameras, gaussians, pipeline, return sam_features -# text guided, masks[id,H,W,C=1] -def text_prompt_seg(image, text): - input_boxes = grounding_dino_prompt(image, text) - - boxes = torch.tensor(input_boxes)[0:1].cuda() - transformed_boxes = predictor.transform.apply_boxes_torch(boxes, image.shape[:2]) - masks, _, _ = predictor.predict_torch( - point_coords=None, - point_labels=None, - boxes=transformed_boxes, - multimask_output=True, - ) - masks = masks[0].cpu().numpy() - return (masks[:, :, :, None]*255).astype(np.uint8) / 255 # id,H,W,1 - -# point guided, masks[id,H,W,C=1], 2D点标注 -def self_prompt_seg(point_prompts, sam_feature): - input_point = point_prompts.detach().cpu().numpy() - # input_point = input_point[::-1] - input_label = np.ones(len(input_point)) - - predictor.features = sam_feature - masks, _, _ = predictor.predict( - point_coords=input_point, - point_labels=input_label, - multimask_output=True, - ) - # return_mask = (masks[ :, :, 0]*255).astype(np.uint8) - # return_mask = (masks[id, :, :, None]*255).astype(np.uint8) # id,H,W,C=1 - return_mask = (masks[:, :, :, None]*255).astype(np.uint8) # id,H,W,C=1 - - return return_mask / 255 - -def self_prompt(point_prompts, sam_feature, id): - input_point = point_prompts.detach().cpu().numpy() - # input_point = input_point[::-1] - input_label = np.ones(len(input_point)) - - predictor.features = sam_feature - masks, _, _ = predictor.predict( - point_coords=input_point, - point_labels=input_label, - multimask_output=True, - ) - # return_mask = (masks[ :, :, 0]*255).astype(np.uint8) - return_mask = (masks[id, :, :, None]*255).astype(np.uint8) - - return return_mask / 255 + # endregion @@ -294,44 +241,7 @@ def mask_inverse(xyz, viewpoint_camera, sam_mask): return point_mask, indices_mask -def generate_multiview_masks(scene, images, pipeline, background, prompts_3D, mask_id = 0, progress:gr.Progress=None): - """ - sam_mask (cuda) : list[torch.int64(id,H,W)] , 每个视角下的渲染图的sam mask - multiview_masks (cuda) : list[torch.int64(N,1)] , 每个视角下，每个Gaussians点的mask - """ - cameras = scene.getTrainCameras() - gaussians = scene.gaussians - multiview_masks = [] - sam_masks = [] - sam_mask_all_levels = [] - if progress is None: use_tqdm = tqdm(enumerate(cameras), desc="generate multiview masks") - else: use_tqdm = progress.tqdm(enumerate(cameras), desc="generate multiview masks") - for i, view in use_tqdm: - # render_pkg = render(view, gaussians, pipeline, background) - # render_image = render_pkg["render"].permute(1, 2, 0).detach().cpu().numpy() - image_name = view.image_name # added - render_image = images[image_name] # added - render_image = (255 * np.clip(render_image, 0, 1)).astype(np.uint8) - # sam prediction - # point_base - # project 3d prompts to 2d prompts - prompts_2d = project_to_2d(view, prompts_3D) - sam_mask_all_level = self_prompt_seg(prompts_2d, sam_features[image_name]) # [id,H,W,C=1] - sam_mask_all_levels.append(sam_mask_all_level) - - sam_mask = sam_mask_all_level[mask_id] - if len(sam_mask.shape) != 2: sam_mask = torch.from_numpy(sam_mask).squeeze(-1).to("cuda") - else: sam_mask = torch.from_numpy(sam_mask).to("cuda") - sam_mask = sam_mask.long() # 2D mask image - sam_masks.append(sam_mask) - - # print(f"sam_mask {sam_mask.shape} {sam_mask.dtype}") - # mask assignment to gaussians - point_mask, indices_mask = mask_inverse(gaussians.get_xyz, view, sam_mask) - multiview_masks.append(point_mask.unsqueeze(-1)) - - return sam_mask_all_levels, sam_masks, multiview_masks # endregion @@ -377,16 +287,20 @@ def save_gs(pc, indices_mask, save_path): class GradioAnnotationTool: - def __init__(self, args, dataset, images: Dict[str, np.ndarray], predictor, sam_features=None, scene=None, pipeline=None, background=None): - self.images = images + def __init__(self, model_path, predictor): self.predictor = predictor - self.args = args - self.dataset = dataset + if model_path is not None: self.load_gaussian_scene(model_path) + else: + self.scene = None + self.args = None + self.dataset = None + self.images = {} + self.sam_features = {} + self.current_image = None + + self.saved_fg_path = None + self.saved_bg_path = None - # 设置一次，传入图像尺寸等，之后直接改feature - self.current_image = list(images.keys())[0] - self.predictor.set_image(images[self.current_image]) - self.maskid = 0 # 将maskid移动到类实例变量 self.seg2d_mark = { name: { @@ -395,7 +309,7 @@ def __init__(self, args, dataset, images: Dict[str, np.ndarray], predictor, sam_ 'history': [], # 历史记录 [(points, masks), ...] 'history_index': -1, # 历史记录索引，用于撤销/重做 'prompts_3D': [] # 存储3D点标注 - } for name in images.keys() + } for name in self.images.keys() } self.multiview_mask = { "records": [], # 每条记录结构如下（见下方）： @@ -412,13 +326,77 @@ def __init__(self, args, dataset, images: Dict[str, np.ndarray], predictor, sam_ # "sam_all": {img1_name: mask1, img2_name: mask2} # sam_mask_all_levels（用于可视化） # } - self.sam_features = sam_features - self.scene = scene # 保存场景信息，用于3D点生成 - self.pipeline = pipeline - self.background = background - self.saved_fg_path = None - self.saved_bg_path = None + def load_gaussian_scene(self, model_path, progress:gr.Progress=None): + global pipeline + global background + if self.scene is not None: del self.scene + if self.seg2d_mark is not None: del self.seg2d_mark + if self.multiview_mask is not None: del self.multiview_mask + + print("Loading Gaussian Scene") + if progress is not None: progress(0, desc="Get Args") + + parser = ArgumentParser(description="Testing script parameters") + model = ModelParams(parser, sentinel=True) + pipeline = PipelineParams(parser) # 渲染用 + + parser.add_argument("--iteration", default=-1, type=int) + parser.add_argument("--skip_train", action="store_true") + parser.add_argument("--skip_test", action="store_true") + parser.add_argument("--quiet", action="store_true") + parser.add_argument("--threshold", default=0.7, type=float, help='threshold of label voting') + parser.add_argument("--gd_interval", default=20, type=int, help='interval of performing gaussian decomposition') + self.args = get_combined_args(parser, model_path) + + self.dataset = model.extract(self.args) + self.dataset.model_path = self.args.model_path + + if progress is not None: progress(0.1, desc="Load Gaussian Scenes") + gaussians = GaussianModel(self.dataset.sh_degree) + self.scene = Scene(self.dataset, gaussians, load_iteration=self.args.iteration, shuffle=False) + self.dataset.white_background = True + bg_color = [1,1,1] if self.dataset.white_background else [0, 0, 0] + background = torch.tensor(bg_color, dtype=torch.float32, device="cuda") + + if progress is not None: progress(0.4, desc="Rendering Images") + self.images = {} + for view in self.scene.getTrainCameras(): + render_pkg = render(view, self.scene.gaussians, pipeline, background) + render_image = render_pkg["render"].permute(1, 2, 0).detach().cpu().numpy() + render_image = (255 * np.clip(render_image, 0, 1)).astype(np.uint8) + self.images[view.image_name] = render_image + + if progress is not None: progress(0.7, desc="Get Sam Features") + # SAM_Features烂了 + self.sam_features = extract_sam_features_pt(model_path, self.predictor, self.scene.getTrainCameras(), self.scene.gaussians) + self.current_image = list(self.images.keys())[0] + self.predictor.set_image(self.images[self.current_image]) + self.seg2d_mark = { + name: { + 'points': [], + 'masks': None, + 'history': [], + 'history_index': -1, + 'prompts_3D': [] + } for name in self.images.keys() + } + self.multiview_mask = { + "records": [], + "current_index": -1 + } + print("加载完成") + if progress is not None: progress(1, desc="Finished") + + def load_scene_gaussians(self): + gaussians = GaussianModel(self.dataset.sh_degree) + gaussians.load_ply( + os.path.join(self.scene.model_path, + "point_cloud", + "iteration_" + str(self.scene.loaded_iter), + "point_cloud.ply")) + return gaussians + def get_current_state(self): mark = self.seg2d_mark[self.current_image] return self.current_image, mark['points'], mark['masks'] @@ -435,7 +413,7 @@ def add_point(self, evt: gr.SelectData, is_original=True): x, y = evt.index # 添加新点 - print(f"add state: {self.current_image}, {mark['history_index']}, {len(mark['history'])}, {len(mark['points'])}") + print(f"add state: {self.current_image}, {mark['history_index']}, {len(mark['history'])}, {len(mark['points'])}, ({x},{y})") mark['points'].append([x, y]) mark["history_index"] += 1 @@ -567,11 +545,77 @@ def toggle_mask(self): return self._render_display() - def get_current_multiview_mask(self): - idx = self.multiview_mask["current_index"] - if 0 <= idx < len(self.multiview_mask["records"]): - return self.multiview_mask["records"][idx] - return None + def generate_multiview_masks(self, prompts_3D, text_prompt = None, progress:gr.Progress=None): + """ + sam_mask (cuda) : list[torch.int64(id,H,W)] , 每个视角下的渲染图的sam mask + multiview_masks (cuda) : list[torch.int64(N,1)] , 每个视角下，每个Gaussians点的mask + """ + # text guided, masks[id,H,W,C=1] + def text_prompt_seg(image, text): + input_boxes = grounding_dino_prompt(image, text) + + boxes = torch.tensor(input_boxes)[0:1].cuda() + transformed_boxes = predictor.transform.apply_boxes_torch(boxes, image.shape[:2]) + masks, _, _ = predictor.predict_torch( + point_coords=None, + point_labels=None, + boxes=transformed_boxes, + multimask_output=True, + ) + masks = masks[0].cpu().numpy() + return (masks[:, :, :, None]*255).astype(np.uint8) / 255 # id,H,W,1 + + # point guided, masks[id,H,W,C=1], 2D点标注 + def self_prompt_seg(point_prompts, sam_feature): + input_point = point_prompts.detach().cpu().numpy() + # input_point = input_point[::-1] + input_label = np.ones(len(input_point)) + + predictor.features = sam_feature + masks, _, _ = predictor.predict( + point_coords=input_point, + point_labels=input_label, + multimask_output=True, + ) + # return_mask = (masks[ :, :, 0]*255).astype(np.uint8) + # return_mask = (masks[id, :, :, None]*255).astype(np.uint8) # id,H,W,C=1 + return_mask = (masks[:, :, :, None]*255).astype(np.uint8) # id,H,W,C=1 + + return return_mask / 255 + + + scene = self.scene + images = self.images + mask_id = self.maskid + cameras = scene.getTrainCameras() + gaussians = scene.gaussians + sam_masks = [] + multiview_masks = [] + sam_mask_all_levels = [] + for i, view in tqdm(enumerate(cameras), desc="generate multiview masks"): + image_name = view.image_name # added + if text_prompt is not None: + render_image = images[image_name] # added + render_image = (255 * np.clip(render_image, 0, 1)).astype(np.uint8) + sam_mask_all_level = text_prompt_seg(render_image, text_prompt) + else: + prompts_2d = project_to_2d(view, prompts_3D) + sam_mask_all_level = self_prompt_seg(prompts_2d, self.sam_features[image_name]) # [id,H,W,C=1] + + sam_mask_all_levels.append(sam_mask_all_level) + + sam_mask = sam_mask_all_level[mask_id] + if len(sam_mask.shape) != 2: sam_mask = torch.from_numpy(sam_mask).squeeze(-1).to("cuda") + else: sam_mask = torch.from_numpy(sam_mask).to("cuda") + sam_mask = sam_mask.long() # 2D mask image + sam_masks.append(sam_mask) + + # print(f"sam_mask {sam_mask.shape} {sam_mask.dtype}") + # mask assignment to gaussians + point_mask, indices_mask = mask_inverse(gaussians.get_xyz, view, sam_mask) + multiview_masks.append(point_mask.unsqueeze(-1)) + + return sam_mask_all_levels, sam_masks, multiview_masks def _get_mask(self, match_mask_id = False, progress:gr.Progress=None): """ @@ -619,7 +663,7 @@ def _is_same_prompt(p1, p2, tol=1e-4): # --- 若找到记录且包含当前 maskid，直接复用 --- if matched_index is not None and (not match_mask_id or self.maskid in self.multiview_mask["records"][matched_index]["mvmask"]): self.multiview_mask["current_index"] = matched_index - print(f"Reusing cached mask at index {matched_index} for maskid {self.maskid}") + print(f"Reusing cached mask at index {matched_index} for maskid {self.maskid}, {len(self.multiview_mask['records'][matched_index]['prompts'])}") # 显示 2D mask for img_name in self.images.keys(): mask = self.multiview_mask["records"][matched_index]["sam_all"].get(img_name) @@ -627,8 +671,7 @@ def _is_same_prompt(p1, p2, tol=1e-4): return # 没有命中，生成新的 - sam_alls, sam_masks, multiviews = generate_multiview_masks( - self.scene, self.images, None, None, prompts_3D_tensor, self.maskid, progress=progress) + sam_alls, sam_masks, multiviews = self.generate_multiview_masks(prompts_3D_tensor, progress=progress) print("multiview_masks generated\n") # 刷新所有展示图片 @@ -815,28 +858,26 @@ def seg_gaussian(self, threshold, object_name, progress:gr.Progress = None): self._get_mask(match_mask_id=True, progress=progress) # 需要match maskid model_path = self.scene.model_path gaussians = self.scene.gaussians - pipeline = self.pipeline - background = self.background _, final_mask = self.ensemble(threshold) cameras = self.scene.getTrainCameras() if progress is not None: progress(0.1, desc="gaussian multiview decomp") self.saved_fg_path = os.path.join(model_path, f'objects/{object_name}/fg.ply') + os.makedirs(os.path.dirname(self.saved_fg_path), exist_ok=True) save_gs(gaussians, final_mask, self.saved_fg_path) if progress is not None: progress(0.3, desc="gaussian multiview decomp") # if gaussian decomposition as a post-process module - if progress is None: use_tqdm = tqdm(enumerate(cameras), desc="gaussian multiview decomp") - else:use_tqdm = progress.tqdm(enumerate(cameras), desc="gaussian multiview decomp") - for i, view in use_tqdm: + de_gaussian = self.load_scene_gaussians() + for i, view in tqdm(enumerate(cameras), desc="gaussian multiview decomp"): if self.args.gd_interval != -1 and i % self.args.gd_interval == 0: input_mask = self.multiview_mask["records"][self.multiview_mask["current_index"]]["mvmask"][self.maskid]["sam_masks"][i] - gaussians = gaussian_decomp(gaussians, view, input_mask, final_mask.to('cuda')) + de_gaussian = gaussian_decomp(de_gaussian, view, input_mask, final_mask.to('cuda')) if progress is not None: progress(0.5, desc="render segged gaussian") # save after gaussian decomposition - # self.saved_bg_path = os.path.join(model_path, f'objects/{object_name}/bg.ply') - save_gs(gaussians, final_mask, self.saved_fg_path) + self.saved_bg_path = os.path.join(model_path, f'objects/{object_name}/bg.ply') + save_gs(de_gaussian, final_mask, self.saved_fg_path+"2.ply") if progress is not None: progress(0.7, desc="render segged gaussian") # render object images @@ -848,9 +889,7 @@ def seg_gaussian(self, threshold, object_name, progress:gr.Progress = None): os.makedirs(obj_save_path, exist_ok=True) if not os.path.exists(obj_save_path): os.mkdir(obj_save_path) - if progress is None: use_tqdm = tqdm(range(len(cameras)), desc="render segged gaussian") - else: use_tqdm = progress.tqdm(range(len(cameras)), desc="render segged gaussian") - for idx in use_tqdm: + for idx in tqdm(range(len(cameras)), desc="render segged gaussian"): image_name = cameras[idx].image_name view = cameras[idx] @@ -865,8 +904,8 @@ def seg_gaussian(self, threshold, object_name, progress:gr.Progress = None): -def create_gradio_interface(args, dataset, images, predictor, scene=None, sam_features=None, pipeline=None, background=None): - tool = GradioAnnotationTool(args, dataset, images, predictor, sam_features, scene, pipeline=pipeline, background=background) +def create_gradio_interface(default_model_paths, predictor): + tool = GradioAnnotationTool(model_path=None, predictor=predictor) with gr.Blocks() as demo: with gr.Row(): @@ -897,13 +936,24 @@ def create_gradio_interface(args, dataset, images, predictor, scene=None, sam_fe interactive=True # 确保交互性 ) with gr.Row() as prompt_col: - object_name_input = gr.Textbox(placeholder="Your Object Name", show_label=False, interactive=True, submit_btn="Seg!") + with gr.Column(scale=1): + model_path_input = gr.Dropdown( + choices=default_model_paths, + allow_custom_value=True, + value="", + show_label=False, + interactive=True, + ) + with gr.Column(scale=0.5): + model_path_btn = gr.Button("Open Model") + with gr.Column(scale=1): + object_name_input = gr.Textbox(placeholder="Your Object Name", show_label=False, interactive=True, submit_btn="Seg!") with gr.Row(): with gr.Column(scale=2): gallery = gr.Gallery( label="Gallery", - value=list(images.values()), + value=list(tool.images.values()), columns=4, object_fit="contain", height="auto" @@ -917,8 +967,8 @@ def create_gradio_interface(args, dataset, images, predictor, scene=None, sam_fe # 处理mask选择 def on_mask_select(choice): - mask_id = 0 - if choice == "M": mask_id = 1 + if choice == "S": mask_id = 0 + elif choice == "M": mask_id = 1 elif choice == "L": mask_id = 2 # 调用set_mask_id方法并返回最右侧图像 @@ -949,7 +999,25 @@ def add_point_from_mask(evt: gr.SelectData): mask_id = tool.maskid # 使用类实例变量 if mask_id >= len(available_masks): mask_id = len(available_masks)-1 return orig, mask, selected, gr.update(choices=available_masks, value=available_masks[mask_id] if available_masks else None) - + + def load_with_progress(model_path, progress=gr.Progress(track_tqdm=True)): + torch.cuda.empty_cache() + tool.load_gaussian_scene(model_path, progress=progress) + orig = tool._render_original() + mask = tool._render_mask() + selected = tool._render_selected_mask() + available_masks = get_available_mask_choices(tool) + return \ + gr.update(value = list(tool.images.values())),\ + orig, mask, selected, \ + gr.update(choices=available_masks, value=available_masks[0] if available_masks else None) + + model_path_btn.click( + fn=load_with_progress, + inputs=model_path_input, + outputs=[gallery, original_display, mask_display, selected_mask_display, mask_selector], + ) + # 使用select事件，更新输出包含mask选择器 original_display.select( fn=add_point_from_original, @@ -978,9 +1046,9 @@ def add_point_from_mask(evt: gr.SelectData): # 添加弹出窗口和状态提示功能 def seg_gaussian_with_prompt(object_name, progress=gr.Progress(track_tqdm=True)): # 更新文本框状态为处理中 - yield gr.update(value=f"正在处理 '{object_name}'...", interactive=False) + yield gr.update(value=f"Processing: '{object_name}'...", interactive=False) tool.seg_gaussian(threshold=0.7, object_name=object_name, progress=None) - yield gr.update(value="", placeholder="请输入对象名称", interactive=True) + yield gr.update(value="", placeholder="Your Object Name", interactive=True) # 修改保存按钮事件 object_name_input.submit( @@ -1005,7 +1073,7 @@ def seg_gaussian_with_prompt(object_name, progress=gr.Progress(track_tqdm=True)) def on_gallery_select(evt: gr.SelectData): try: index = evt.index - image_name = list(images.keys())[index] + image_name = list(tool.images.keys())[index] orig, mask, selected = tool.update_image(image_name) # 获取当前可用的mask选项，保持mask选择 available_masks = get_available_mask_choices(tool) @@ -1023,9 +1091,10 @@ def on_gallery_select(evt: gr.SelectData): # 初始显示 def init_display(): - orig = tool._render_original() - mask = tool._render_mask() - selected = tool._render_selected_mask() + # orig = tool._render_original() + # mask = tool._render_mask() + # selected = tool._render_selected_mask() + orig, mask, selected = None, None, None available_masks = get_available_mask_choices(tool) return orig, mask, selected, gr.update(choices=available_masks, value=available_masks[0] if available_masks else None) @@ -1036,34 +1105,38 @@ def init_display(): # python app.py --model_path +# I'm using this for trellis model segmentation +# As it's a Y-Up generation model +# output model would be lying down. if __name__ == "__main__": - model_path = '../TRELLIS/results/squirrel/25_04_27-12_22_04/model' + + base_dir = "../TRELLIS/results" + default_model_paths = find_model_folders(base_dir) predictor = load_sam() - for i in range(1, len(sys.argv)): - if sys.argv[i] == "--model_path" and i+1 < len(sys.argv): - model_path = sys.argv[i+1] - break + # model_path = '../TRELLIS/results/squirrel/25_04_27-12_22_04/model' + # for i in range(1, len(sys.argv)): + # if sys.argv[i] == "--model_path" and i+1 < len(sys.argv): + # model_path = sys.argv[i+1] + # break - scene, args, dataset, pipeline, background = load_gaussian_scene(model_path) + # scene, args, dataset, pipeline, background = load_gaussian_scene(model_path) - render_images = {} - for view in scene.getTrainCameras(): - render_pkg = render(view, scene.gaussians, pipeline, background) - render_image = render_pkg["render"].permute(1, 2, 0).detach().cpu().numpy() - render_image = (255 * np.clip(render_image, 0, 1)).astype(np.uint8) - render_images[view.image_name] = render_image - - sam_features = extract_sam_features_pt(model_path, predictor, scene.getTrainCameras(), - scene.gaussians, pipeline, background) + # render_images = {} + # for view in scene.getTrainCameras(): + # render_pkg = render(view, scene.gaussians, pipeline, background) + # render_image = render_pkg["render"].permute(1, 2, 0).detach().cpu().numpy() + # render_image = (255 * np.clip(render_image, 0, 1)).astype(np.uint8) + # render_images[view.image_name] = render_image + + # sam_features = extract_sam_features_pt(model_path, predictor, scene.getTrainCameras(), + # scene.gaussians, pipeline, background) # 创建并启动Gradio界面，传入预先提取的特征和场景 - demo = create_gradio_interface(args, dataset, render_images, predictor, scene, sam_features, pipeline, background) + demo = create_gradio_interface(default_model_paths, predictor) demo.launch(server_name="0.0.0.0", server_port=None, - allowed_paths = ["./", "../TRELLIS"]) - # I'm using this for trellis model segmentation - # As it's a Y-Up generation model - # output model would be lying down. + allowed_paths = ["./", base_dir]) + diff --git a/segmentation.ipynb b/segmentation.ipynb index 12d7301..da6868d 100644 --- a/segmentation.ipynb +++ b/segmentation.ipynb @@ -9,33 +9,35 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 53, "metadata": {}, "outputs": [], "source": [ "import os\n", "os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"2\"\n", - "model_path = '../TRELLIS/results/squirrel/25_04_27-12_22_04/model'" + "model_path = '../TRELLIS/results/squirrel/25_04_27-12_22_04/model'\n", + "model_path = \"../TRELLIS/results/cow1-man/25_04_27-12_22_04/model\"\n", + "model_path = \"../TRELLIS/results/horse-man2/25_04_27-12_22_04/model\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# 初始化" + "# 读取高斯" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 54, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Looking for config file in ../TRELLIS/results/squirrel/25_04_27-12_22_04/model/cfg_args\n", - "Config file found: ../TRELLIS/results/squirrel/25_04_27-12_22_04/model/cfg_args\n", + "Looking for config file in ../TRELLIS/results/horse-man2/25_04_27-12_22_04/model/cfg_args\n", + "Config file found: ../TRELLIS/results/horse-man2/25_04_27-12_22_04/model/cfg_args\n", "Loading trained model at iteration 30000\n", "Reading camera 90/90\n", "Loading Training Cameras\n", @@ -115,18 +117,9 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 55, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", - "FutureWarning: Importing from timm.models.layers is deprecated, please import via timm.layers\n" - ] - } - ], + "outputs": [], "source": [ "import torch.nn.functional as F\n", "import torchvision.transforms.functional as func\n", @@ -313,7 +306,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 56, "metadata": {}, "outputs": [], "source": [ @@ -366,7 +359,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 57, "metadata": {}, "outputs": [ { @@ -380,7 +373,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 90/90 [00:41<00:00, 2.15it/s]\n" + "100%|██████████| 90/90 [00:41<00:00, 2.16it/s]\n" ] } ], @@ -452,11 +445,11 @@ " [420, 628]\n", "])).astype(np.int32)\n", "\n", - "object_name = \"cow\"\n", - "input_point = (np.asarray([\n", - " [600, 600],\n", - " [400, 500]\n", - "])).astype(np.int32)" + "# object_name = \"cow\"\n", + "# input_point = (np.asarray([\n", + "# [600, 600],\n", + "# [400, 500]\n", + "# ])).astype(np.int32)" ] }, { @@ -484,7 +477,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 58, "metadata": {}, "outputs": [], "source": [ @@ -508,7 +501,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -531,22 +524,22 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 59, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 7, + "execution_count": 59, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -571,22 +564,22 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 60, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 8, + "execution_count": 60, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -619,9 +612,60 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 61, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "final text_encoder_type: bert-base-uncased\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "FutureWarning: `resume_download` is deprecated and will be removed in version 1.0.0. Downloads always resume when possible. If you want to force a new download, use `force_download=True`.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "boxes device cpu\n", + "[[188.7009 129.15247 770.03394 899.53296]]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "FutureWarning: The `device` argument is deprecated and will be removed in v5 of Transformers.\n", + "UserWarning: None of the inputs have requires_grad=True. Gradients will be None\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 61, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "text_prompt = \"a squirrel\"\n", "masks = text_prompting(render_image, text_prompt)\n", @@ -639,7 +683,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# 分割Gaussian" + "# 分割Prompt" ] }, { @@ -651,17 +695,9 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 62, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "UserWarning: torch.meshgrid: in an upcoming release, it will be required to pass the indexing argument. (Triggered internally at /opt/conda/conda-bld/pytorch_1682343970094/work/aten/src/ATen/native/TensorShape.cpp:3483.)\n" - ] - } - ], + "outputs": [], "source": [ "# generate 3D prompts 传入Gaussian的xyz，单视角，和该视角下的input_point\n", "text_prompt = None\n", @@ -712,9 +748,16 @@ "text_prompt = \"a squirrel\"" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 执行分割" + ] + }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 63, "metadata": {}, "outputs": [ { @@ -821,6 +864,16 @@ "from plyfile import PlyData, PlyElement\n", "import copy\n", "\n", + "def reload_gaussian(scene):\n", + " gaussians = GaussianModel(dataset.sh_degree)\n", + " gaussians.load_ply(\n", + " os.path.join(scene.model_path,\n", + " \"point_cloud\",\n", + " \"iteration_\" + str(scene.loaded_iter),\n", + " \"point_cloud.ply\"))\n", + " scene.gaussians = gaussians\n", + " return gaussians\n", + "\n", "def save_gs(pc, indices_mask, save_path):\n", " \n", " xyz = pc._xyz.detach().cpu()[indices_mask].numpy()\n", @@ -884,11 +937,13 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 64, "metadata": {}, "outputs": [], "source": [ + "\n", "os.makedirs(f\"{model_path}/objects/{object_name}\", exist_ok=True)\n", + "gaussians = reload_gaussian(scene)\n", "# if gaussian decomposition as a post-process module\n", "for i, view in enumerate(cameras):\n", " if args.gd_interval != -1 and i % args.gd_interval == 0:\n", @@ -902,7 +957,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 65, "metadata": {}, "outputs": [], "source": [ From 5d74513fff4c35492bfec5c4d40862242a92ee25 Mon Sep 17 00:00:00 2001 From: MrHandsomeljn <1205197328@qq.com> Date: Wed, 30 Apr 2025 17:50:42 +0800 Subject: [PATCH 4/9] =?UTF-8?q?=E6=9B=B4=E6=96=B0=E4=BA=86readme?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 54e500d..8deba4c 100644 --- a/README.md +++ b/README.md @@ -8,9 +8,14 @@ Undo and Redo might incur additional GPU Memory cost. Requires gradio>=5 Gradio版本的SAGS，支持多视角标注，背面也可以加约束了。 -有空想整一个文本提示版本。 +发现背面加约束这个事情有点鸡肋，猜测是3D投票过程并不能很好支持复杂的遮挡关系 +计划： +1. 改为进行多次单视角GS分割，将多个视角得到的GS结果直接组合得到最终结果 +2. 有空想整一个文本提示版本。 + 每次的撤消和重做的结果都保存了，不会重复存，但是反复折腾可能会占点显存。 + ## Introduction 3D Gaussian Splatting has emerged as an alternative 3D representation for novel view synthesis, benefiting from its high-quality rendering results and real-time rendering speed. However, the 3D Gaussians learned by 3D-GS have ambiguous structures without any geometry constraints. This inherent issue in 3D-GS leads to a rough boundary when segmenting individual objects. To remedy these problems, we propose SAGD, a conceptually simple yet effective boundary-enhanced segmentation pipeline for 3D-GS to improve segmentation accuracy while preserving segmentation speed. Specifically, we introduce a Gaussian Decomposition scheme, which ingeniously utilizes the special structure of 3D Gaussian, finds out, and then decomposes the boundary Gaussians. Moreover, to achieve fast interactive 3D segmentation, we introduce a novel training-free pipeline by lifting a 2D foundation model to 3D-GS. Extensive experiments demonstrate that our approach achieves high-quality 3D segmentation without rough boundary issues, which can be easily applied to other scene editing tasks. From da68feac4801dc7a8568c0a17ca9c512a6e0fc79 Mon Sep 17 00:00:00 2001 From: MrHandsomeljn <1205197328@qq.com> Date: Thu, 1 May 2025 23:54:37 +0800 Subject: [PATCH 5/9] speedup x10 by change np to torch --- README.md | 7 +- app.py | 295 +++++++++++++++++++++++++++--------------------------- 2 files changed, 155 insertions(+), 147 deletions(-) diff --git a/README.md b/README.md index 8deba4c..813df68 100644 --- a/README.md +++ b/README.md @@ -2,10 +2,15 @@ > [**Segment Anything in 3D Gaussians**](https://arxiv.org/abs/2401.17857) ## SAGS with a Gradio Interface + +#### 25.05.01 +Speedup x10 by change some numpy operator to torch, see app.py + +#### 25.04.30 Use it to segment any gaussian easily, capable with multiview annotation ability. Text prompt would be release when I'm available. Undo and Redo might incur additional GPU Memory cost. -Requires gradio>=5 +Requires gradio==5 Gradio版本的SAGS，支持多视角标注，背面也可以加约束了。 发现背面加约束这个事情有点鸡肋，猜测是3D投票过程并不能很好支持复杂的遮挡关系 diff --git a/app.py b/app.py index f5dcc08..806d18f 100644 --- a/app.py +++ b/app.py @@ -30,9 +30,11 @@ from segment_anything import (SamAutomaticMaskGenerator, SamPredictor, sam_model_registry) from gradio_litmodel3d import LitModel3D +from torch.profiler import profile, record_function, ProfilerActivity pipeline, background = None, None +empty_3D = torch.zeros((0,3),device='cuda') # 递归查找所有名为"model"的文件夹 def find_model_folders(base_path, relative_to="."): @@ -140,8 +142,8 @@ def extract_sam_features_pt(scene_path, predictor, cameras, gaussians): # region 3D投影操作 ## Project 3D points to 2D plane -def project_to_2d(viewpoint_camera, points3D): - full_matrix = viewpoint_camera.full_proj_transform # w2c @ K +def project_to_2d(viewpoint_camera, points3D): # TODO: 做一个batch版本的 + full_matrix = viewpoint_camera.full_proj_transform # torch.cuda, w2c @ K # project to image plane if points3D.shape[-1] != 4: points3D = F.pad(input=points3D, pad=(0, 1), mode='constant', value=1) @@ -180,7 +182,7 @@ def get_3d_prompts(prompts_2d, point_image, xyz, depth=None): ## Given 1st view point prompts, find corresponding 3D Gaussian point prompts # 将3D点投影到2D，使得2D标注能映射到特定3D点上。 -def generate_3d_prompts(xyz, viewpoint_camera, prompts_2d): +def generate_3d_prompts(xyz, viewpoint_camera, prompts_2d) -> torch.Tensor: w2c_matrix = viewpoint_camera.world_view_transform full_matrix = viewpoint_camera.full_proj_transform # project to image plane @@ -190,22 +192,22 @@ def generate_3d_prompts(xyz, viewpoint_camera, prompts_2d): p_proj = p_hom[:3, :] * p_w # project to camera space p_view = (xyz @ w2c_matrix[:, :3]).transpose(0, 1) # N, 3 -> 3, N - depth = p_view[-1, :].detach().clone() + depth = p_view[-1, :] valid_depth = depth >= 0 h = viewpoint_camera.image_height w = viewpoint_camera.image_width point_image = 0.5 * ((p_proj[:2] + 1) * torch.tensor([w, h]).unsqueeze(-1).to(p_proj.device) - 1) - point_image = point_image.detach().clone() point_image = torch.round(point_image.transpose(0, 1)).long() prompts_2d = torch.tensor(prompts_2d).to("cuda") - prompts_3d = [] - for i in range(prompts_2d.shape[0]): # 对每个标点，获取prompt，然后融合 - prompts_3d.append(get_3d_prompts(prompts_2d[i], point_image, xyz, depth)) - prompts_3D = torch.cat(prompts_3d, dim=0) - return prompts_3D.detach().cpu().numpy() + prompts_3d = torch.stack([ + get_3d_prompts(prompts_2d[i], point_image, xyz, depth) + for i in range(prompts_2d.shape[0]) + ]) + prompts_3D = prompts_3d.reshape(-1, prompts_3d.shape[-1]) + return prompts_3D def mask_inverse(xyz, viewpoint_camera, sam_mask): w2c_matrix = viewpoint_camera.world_view_transform @@ -215,27 +217,23 @@ def mask_inverse(xyz, viewpoint_camera, sam_mask): depth = p_view[-1, :].detach().clone() valid_depth = depth >= 0 - h = viewpoint_camera.image_height - w = viewpoint_camera.image_width + h = viewpoint_camera.image_height # int + w = viewpoint_camera.image_width # int - if sam_mask.shape[0] != h or sam_mask.shape[1] != w: + if sam_mask.shape[0] != h or sam_mask.shape[1] != w: # false sam_mask = func.resize(sam_mask.unsqueeze(0), (h, w), antialias=True).squeeze(0).long() else: sam_mask = sam_mask.long() - point_image = project_to_2d(viewpoint_camera, xyz) # [N,2] + point_image = project_to_2d(viewpoint_camera, xyz) # torch([N,2]) point_image = point_image.long() # 判断x,y是否在图像范围之内 valid_x = (point_image[:, 0] >= 0) & (point_image[:, 0] < w) valid_y = (point_image[:, 1] >= 0) & (point_image[:, 1] < h) - valid_mask = valid_x & valid_y & valid_depth - point_mask = torch.full((point_image.shape[0],), -1).to("cuda") # [N]=-1 - # print(f"point_mask : {point_mask.shape} {point_mask.dtype} {point_mask.sum()}") - # print(f"valid_mask : {valid_mask.shape} {valid_mask.dtype} {valid_mask.sum()}") - # print(f"point_image: {point_image.shape} {point_image.dtype} {point_image.sum()}") - + valid_mask = valid_x & valid_y & valid_depth # [N]=bool + point_mask = torch.full((point_image.shape[0],), -1, device="cuda") # [N]=-1 point_mask[valid_mask] = sam_mask[point_image[valid_mask, 1], point_image[valid_mask, 0]] # [N]=sam_mask[x,y] indices_mask = torch.where(point_mask == 1)[0] @@ -304,11 +302,11 @@ def __init__(self, model_path, predictor): self.maskid = 0 # 将maskid移动到类实例变量 self.seg2d_mark = { name: { - 'points': [], # 当前点标注 - 'masks': None, # 当前掩码[id,H,W,C=1] - 'history': [], # 历史记录 [(points, masks), ...] - 'history_index': -1, # 历史记录索引，用于撤销/重做 - 'prompts_3D': [] # 存储3D点标注 + 'points': [], # 当前点标注 + 'masks': None, # 当前掩码[id,H,W,C=1] + 'history': [], # 历史记录 [(points, masks), ...] + 'history_index': -1, # 历史记录索引，用于撤销/重做 + 'prompts_3D': empty_3D.clone() # 存储3D点标注 } for name in self.images.keys() } self.multiview_mask = { @@ -378,7 +376,7 @@ def load_gaussian_scene(self, model_path, progress:gr.Progress=None): 'masks': None, 'history': [], 'history_index': -1, - 'prompts_3D': [] + 'prompts_3D': empty_3D.clone() } for name in self.images.keys() } self.multiview_mask = { @@ -421,7 +419,7 @@ def add_point(self, evt: gr.SelectData, is_original=True): if self.scene is not None: self._update_3d_prompts() - if mark['points']: self._get_mask() + if len(mark['points']): self._get_mask() self._save_state() return self._render_original(), self._render_mask(), self._render_selected_mask() @@ -436,20 +434,20 @@ def undo(self): mark['history_index'] -= 1 prev_state = mark['history'][mark['history_index']] mark['points'] = prev_state[0].copy() if prev_state[0] is not None else [] - mark['masks'] = prev_state[1].copy() if prev_state[1] is not None else None + mark['masks'] = prev_state[1].copy() if prev_state[1] is not None else None # 恢复3D点标注 if len(prev_state) > 2 and prev_state[2] is not None: - mark['prompts_3D'] = prev_state[2].copy() if prev_state[2] is not None else [] + mark['prompts_3D'] = prev_state[2].copy() if prev_state[2] is not None else empty_3D.clone() else: mark["points"] = [] mark["masks"] = None - mark["prompts_3D"] = [] + mark["prompts_3D"] = empty_3D.clone() self._save_state() self._get_mask() # 如果场景存在，更新3D点标注 - if self.scene is not None and mark['points']: + if self.scene is not None and len(mark['points']): self._update_3d_prompts() return self._render_original(), self._render_mask(), self._render_selected_mask() @@ -463,12 +461,11 @@ def redo(self): if mark['history_index'] < len(mark['history']) - 1: mark['history_index'] += 1 next_state = mark['history'][mark['history_index']] - mark['points'] = next_state[0].copy() - mark['masks'] = next_state[1].copy() if next_state[1] is not None else None + mark['points'] = next_state[0][:] + mark['masks'] = next_state[1].clone() if next_state[1] is not None else None # 恢复3D点标注 if len(next_state) > 2 and next_state[2] is not None: - mark['prompts_3D'] = next_state[2].copy() if next_state[2] is not None else [] - + mark['prompts_3D'] = next_state[2].clone() if next_state[2] is not None else empty_3D.clone() self._get_mask() # 如果场景存在，更新3D点标注 @@ -487,7 +484,7 @@ def clear_current(self): mark = self.seg2d_mark[self.current_image] mark['points'] = [] mark['masks'] = None - mark['prompts_3D'] = [] # 清空3D点标注 + mark['prompts_3D'] = empty_3D.clone() # 清空3D点标注 self._save_state() self._get_mask() return self._render_original(), self._render_mask(), self._render_selected_mask() @@ -495,11 +492,11 @@ def clear_current(self): def clear_all(self): self.seg2d_mark = { name: { - 'points': [], # 当前点标注 - 'masks': None, # 当前掩码[id,H,W,C=1] - 'history': [], # 历史记录 [(points, masks), ...] - 'history_index': -1, # 历史记录索引，用于撤销/重做 - 'prompts_3D': [] # 存储3D点标注 + 'points': [], # 当前点标注 + 'masks': None, # 当前掩码[id,H,W,C=1] + 'history': [], # 历史记录 [(points, masks), ...] + 'history_index': -1, # 历史记录索引，用于撤销/重做 + 'prompts_3D': empty_3D.clone() # 存储3D点标注 } for name in self.images.keys() } self.multiview_mask = { @@ -512,7 +509,7 @@ def _update_3d_prompts(self): """更新当前图像的3D点标注""" mark = self.seg2d_mark[self.current_image] if not mark['points'] or self.scene is None: - mark['prompts_3D'] = [] + mark['prompts_3D'] = empty_3D.clone() return # 获取当前视角的相机 @@ -547,42 +544,83 @@ def toggle_mask(self): def generate_multiview_masks(self, prompts_3D, text_prompt = None, progress:gr.Progress=None): """ - sam_mask (cuda) : list[torch.int64(id,H,W)] , 每个视角下的渲染图的sam mask - multiview_masks (cuda) : list[torch.int64(N,1)] , 每个视角下，每个Gaussians点的mask + sam_mask_all_levels (cuda) : list[torch.int64(id,H,W)] , 每个视角下的渲染图的sam mask + sam_masks (cuda) : list[torch.int64(H,W)] , 每个视角下的渲染图的sam mask + multiview_masks (cuda) : list[torch.int64(N,1)] , 每个视角下，每个Gaussians点的mask """ - # text guided, masks[id,H,W,C=1] - def text_prompt_seg(image, text): - input_boxes = grounding_dino_prompt(image, text) - - boxes = torch.tensor(input_boxes)[0:1].cuda() - transformed_boxes = predictor.transform.apply_boxes_torch(boxes, image.shape[:2]) - masks, _, _ = predictor.predict_torch( - point_coords=None, - point_labels=None, - boxes=transformed_boxes, - multimask_output=True, - ) - masks = masks[0].cpu().numpy() - return (masks[:, :, :, None]*255).astype(np.uint8) / 255 # id,H,W,1 # point guided, masks[id,H,W,C=1], 2D点标注 - def self_prompt_seg(point_prompts, sam_feature): - input_point = point_prompts.detach().cpu().numpy() - # input_point = input_point[::-1] - input_label = np.ones(len(input_point)) + def self_prompt_seg_torch(point_prompts, sam_feature): # point_prompts: torch([N,2]) + input_point = point_prompts[None, :, :] # Batch, N, 2 + input_label = torch.ones((input_point.shape[0],input_point.shape[1]), device=self.predictor.device) predictor.features = sam_feature - masks, _, _ = predictor.predict( - point_coords=input_point, - point_labels=input_label, + masks_torch_batch, _, _ = predictor.predict_torch( + point_coords=input_point, # [1,N,2] + point_labels=input_label, # [1,N] multimask_output=True, ) - # return_mask = (masks[ :, :, 0]*255).astype(np.uint8) - # return_mask = (masks[id, :, :, None]*255).astype(np.uint8) # id,H,W,C=1 - return_mask = (masks[:, :, :, None]*255).astype(np.uint8) # id,H,W,C=1 - + masks_torch = masks_torch_batch[0] # [batch, id, H, W, C] + return_mask = (masks_torch[:, :, :, None]*255).to(torch.uint8) # [id,H,W,C=1] return return_mask / 255 + scene = self.scene + images = self.images + mask_id = self.maskid + cameras = scene.getTrainCameras() + gaussians = scene.gaussians + sam_masks = [] + multiview_masks = [] + sam_mask_all_levels = [] + for i, view in tqdm(enumerate(cameras), desc="generate multiview masks"): + image_name = view.image_name # added + prompts_2d = project_to_2d(view, prompts_3D) + sam_mask_all_level = self_prompt_seg_torch(prompts_2d, self.sam_features[image_name]) # torch([id=3,H,W,C=1]) + sam_mask_all_levels.append(sam_mask_all_level) + sam_mask = sam_mask_all_level[mask_id].long()[:,:,0] # torch[H,W] + sam_masks.append(sam_mask) + point_mask, indices_mask = mask_inverse(gaussians.get_xyz, view, sam_mask) # TODO: gaussians.get_xyz.require_grad=True; cuda,cuda,cuda + multiview_masks.append(point_mask.unsqueeze(-1)) + return sam_mask_all_levels, sam_masks, multiview_masks + + # def generate_multiview_masks(self, prompts_3D, text_prompt = None, progress:gr.Progress=None): + # """ + # sam_mask (cuda) : list[torch.int64(id,H,W)] , 每个视角下的渲染图的sam mask + # multiview_masks (cuda) : list[torch.int64(N,1)] , 每个视角下，每个Gaussians点的mask + # """ + # # text guided, masks[id,H,W,C=1] + # def text_prompt_seg(image, text): + # input_boxes = grounding_dino_prompt(image, text) + + # boxes = torch.tensor(input_boxes)[0:1].cuda() + # transformed_boxes = predictor.transform.apply_boxes_torch(boxes, image.shape[:2]) + # masks, _, _ = predictor.predict_torch( + # point_coords=None, + # point_labels=None, + # boxes=transformed_boxes, + # multimask_output=True, + # ) + # masks = masks[0].cpu().numpy() + # return (masks[:, :, :, None]*255).astype(np.uint8) / 255 # id,H,W,1 + + # # point guided, masks[id,H,W,C=1], 2D点标注 + # def self_prompt_seg(point_prompts, sam_feature): + # input_point = point_prompts.detach().cpu().numpy() + # # input_point = input_point[::-1] + # input_label = np.ones(len(input_point)) + + # predictor.features = sam_feature + # masks, _, _ = predictor.predict( + # point_coords=input_point, + # point_labels=input_label, + # multimask_output=True, + # ) + # # return_mask = (masks[ :, :, 0]*255).astype(np.uint8) + # # return_mask = (masks[id, :, :, None]*255).astype(np.uint8) # id,H,W,C=1 + # return_mask = (masks[:, :, :, None]*255).astype(np.uint8) # id,H,W,C=1 + + # return return_mask / 255 + scene = self.scene images = self.images @@ -592,6 +630,7 @@ def self_prompt_seg(point_prompts, sam_feature): sam_masks = [] multiview_masks = [] sam_mask_all_levels = [] + for i, view in tqdm(enumerate(cameras), desc="generate multiview masks"): image_name = view.image_name # added if text_prompt is not None: @@ -607,14 +646,11 @@ def self_prompt_seg(point_prompts, sam_feature): sam_mask = sam_mask_all_level[mask_id] if len(sam_mask.shape) != 2: sam_mask = torch.from_numpy(sam_mask).squeeze(-1).to("cuda") else: sam_mask = torch.from_numpy(sam_mask).to("cuda") - sam_mask = sam_mask.long() # 2D mask image + sam_mask = sam_mask.long() # 2D mask image [H,W] -> value sam_masks.append(sam_mask) - # print(f"sam_mask {sam_mask.shape} {sam_mask.dtype}") - # mask assignment to gaussians point_mask, indices_mask = mask_inverse(gaussians.get_xyz, view, sam_mask) multiview_masks.append(point_mask.unsqueeze(-1)) - return sam_mask_all_levels, sam_masks, multiview_masks def _get_mask(self, match_mask_id = False, progress:gr.Progress=None): @@ -632,27 +668,24 @@ def _get_mask(self, match_mask_id = False, progress:gr.Progress=None): # 收集prompts_3D prompts_3D_list = [] for img_name in self.images.keys(): - if len(self.seg2d_mark[img_name]["prompts_3D"]): # 检查是否有3D点标注 - points = np.array(self.seg2d_mark[img_name]["prompts_3D"]) - if len(points.shape) == 1: # 如果是(3,)则转为(1,3) - points = points[np.newaxis, :] - prompts_3D_list.append(points) - if prompts_3D_list: - prompts_3D = np.vstack(prompts_3D_list) # 最终形状为(M,3) - prompts_3D_tensor = torch.tensor(prompts_3D, dtype=torch.float32).to("cuda") - else: - prompts_3D = np.zeros((0,3)) - prompts_3D_tensor = torch.empty((0, 3), dtype=torch.float32).to("cuda") + prompts_3D = self.seg2d_mark[img_name]["prompts_3D"] # torch.Tensor[N,3] + if prompts_3D.shape[0] > 0: # 检查是否有3D点标注 + prompts_3D_list.append(prompts_3D) + + if prompts_3D_list: prompts_3D_tensor = torch.cat(prompts_3D_list, dim=0) # [M,3] + else: prompts_3D_tensor = torch.empty((0, 3), dtype=torch.float32, device="cuda") - print("Prompt 3D: ",prompts_3D) + print("Prompt 3D: ",prompts_3D_tensor) print("Prompt maskid: ",self.maskid) if progress is not None: progress(0.1, desc="matching cached multiview mask") # 匹配 - def _is_same_prompt(p1, p2, tol=1e-4): + def _is_same_prompt(p1, p2, tol=1e-5): if p1.shape != p2.shape: return False - return torch.allclose(p1, p2, atol=tol) + p1_sorted = torch.sort(p1, dim=0)[0] + p2_sorted = torch.sort(p2, dim=0)[0] + return torch.allclose(p1_sorted, p2_sorted, atol=tol) matched_index = None for i, rec in enumerate(self.multiview_mask["records"]): @@ -705,9 +738,9 @@ def _save_state(self): # 创建当前状态的副本，不再包含maskid current_state = ( - mark['points'].copy() if mark['points'] else [], - mark['masks'].copy() if mark['masks'] is not None else None, - mark['prompts_3D'].copy() if 'prompts_3D' in mark and mark['prompts_3D'] is not None else [] + mark['points'][:] if mark['points'] else [], # list[N,2] -> int + mark['masks'].clone() if mark['masks'] is not None else None, # list[nImage] -> Tensor[3,H,W] + mark['prompts_3D'].clone() if 'prompts_3D' in mark else empty_3D.clone() # Tensor[N,3] ) # 如果当前不是在历史记录的最后，则截断历史记录 @@ -752,6 +785,7 @@ def _render_mask(self): # 绘制mask if mark['masks'] is not None and len(mark['masks']) > 0: + mask_multilayer = mark['masks'].cpu().numpy() # 定义三种颜色 - 使用更鲜艳的颜色 mask_colors = [ np.array([255, 50, 50]), # 红色 @@ -768,9 +802,9 @@ def _render_mask(self): priority_mask = np.ones(img.shape[:2], dtype=np.int32) * 999 # 从小到大处理mask，确保小的mask优先显示 - masks_count = min(len(mark['masks']), len(mask_colors)) + masks_count = min(len(mask_multilayer), len(mask_colors)) for i in range(masks_count): - mask = mark['masks'][i] + mask = mask_multilayer[i] mask_area = mask > 0.5 # 只处理优先级更高的区域（即尚未被更小的mask覆盖的区域） @@ -810,10 +844,11 @@ def _render_selected_mask(self): # 绘制选中的mask if mark['masks'] is not None and len(mark['masks']) > 0: + mask_multilayer = mark['masks'].cpu().numpy() mask_id = self.maskid # 使用类实例变量 - if mask_id < len(mark['masks']): + if mask_id < len(mask_multilayer): # 获取选中的mask - mask = mark['masks'][mask_id] + mask = mask_multilayer[mask_id] mask_area = mask > 0.5 # 定义mask颜色 @@ -828,14 +863,7 @@ def _render_selected_mask(self): # 应用mask到原图 if np.any(mask_area): img[mask_area] = mask_color * mask_color_strength + img[mask_area] * (1-mask_color_strength) - - # 添加mask标题 - # mask_names = ["small", "middle", "large"] - # title = f"选中的Mask: {mask_names[mask_id]}" - # cv2.putText(img, title, (10, 30), - # cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 0), 2) - # cv2.putText(img, title, (10, 30), - # cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 1) + else: print(f"mask invalid: {mark['masks']}") return img @@ -909,22 +937,18 @@ def create_gradio_interface(default_model_paths, predictor): with gr.Blocks() as demo: with gr.Row(): - with gr.Column(scale=2): + with gr.Column(scale=1): with gr.Row(): - with gr.Column(scale=1): - original_display = gr.Image(label="Origin", interactive=True) - with gr.Column(scale=1): - mask_display = gr.Image(label="Layer Mask", interactive=True) - + original_display = gr.Image(label="Origin", interactive=False) with gr.Row(): - with gr.Column(scale=2): - with gr.Row(): - undo_btn = gr.Button("Undo") - redo_btn = gr.Button("Redo") - cls_cur_btn = gr.Button("Clear Curr View Marks") - cls_all_btn = gr.Button("Clear All Views Marks") - # save_btn = gr.Button("保存分割") - + undo_btn = gr.Button("Undo") + redo_btn = gr.Button("Redo") + with gr.Column(scale=1): + with gr.Row(): + mask_display = gr.Image(label="Layer Mask", interactive=False) + with gr.Row(): + cls_cur_btn = gr.Button("Clear Curr View Marks") + cls_all_btn = gr.Button("Clear All Views Marks") with gr.Column(scale=1): with gr.Row(): selected_mask_display = gr.Image(label="Mask Result", interactive=False) @@ -933,7 +957,7 @@ def create_gradio_interface(default_model_paths, predictor): choices=["S", "M", "L"], label="Select Mask", value="S", - interactive=True # 确保交互性 + interactive=True ) with gr.Row() as prompt_col: with gr.Column(scale=1): @@ -1091,9 +1115,6 @@ def on_gallery_select(evt: gr.SelectData): # 初始显示 def init_display(): - # orig = tool._render_original() - # mask = tool._render_mask() - # selected = tool._render_selected_mask() orig, mask, selected = None, None, None available_masks = get_available_mask_choices(tool) return orig, mask, selected, gr.update(choices=available_masks, value=available_masks[0] if available_masks else None) @@ -1111,32 +1132,14 @@ def init_display(): if __name__ == "__main__": - base_dir = "../TRELLIS/results" - default_model_paths = find_model_folders(base_dir) - - predictor = load_sam() + # with profile(on_trace_ready=torch.profiler.tensorboard_trace_handler('./log')) as prof: + base_dir = "../TRELLIS/results" + default_model_paths = find_model_folders(base_dir) + predictor = load_sam() - # model_path = '../TRELLIS/results/squirrel/25_04_27-12_22_04/model' - # for i in range(1, len(sys.argv)): - # if sys.argv[i] == "--model_path" and i+1 < len(sys.argv): - # model_path = sys.argv[i+1] - # break - - # scene, args, dataset, pipeline, background = load_gaussian_scene(model_path) - - # render_images = {} - # for view in scene.getTrainCameras(): - # render_pkg = render(view, scene.gaussians, pipeline, background) - # render_image = render_pkg["render"].permute(1, 2, 0).detach().cpu().numpy() - # render_image = (255 * np.clip(render_image, 0, 1)).astype(np.uint8) - # render_images[view.image_name] = render_image - - # sam_features = extract_sam_features_pt(model_path, predictor, scene.getTrainCameras(), - # scene.gaussians, pipeline, background) - - # 创建并启动Gradio界面，传入预先提取的特征和场景 - demo = create_gradio_interface(default_model_paths, predictor) - demo.launch(server_name="0.0.0.0", server_port=None, - allowed_paths = ["./", base_dir]) + # 创建并启动Gradio界面，传入预先提取的特征和场景 + demo = create_gradio_interface(default_model_paths, predictor) + demo.launch(server_name="0.0.0.0", server_port=None, + allowed_paths = ["./", base_dir]) From 51b610eef859284ccde94edfe08bd14b8a059639 Mon Sep 17 00:00:00 2001 From: MrHandsomeljn <1205197328@qq.com> Date: Fri, 2 May 2025 01:28:50 +0800 Subject: [PATCH 6/9] update, speedup in mvmask generation --- README.md | 3 +- app.py | 176 ++++++++++++++++++++++++++++++++++++------------------ 2 files changed, 121 insertions(+), 58 deletions(-) diff --git a/README.md b/README.md index 813df68..e480d3e 100644 --- a/README.md +++ b/README.md @@ -4,7 +4,8 @@ ## SAGS with a Gradio Interface #### 25.05.01 -Speedup x10 by change some numpy operator to torch, see app.py +Speedup x10 (in multi view segment) by change some numpy operator to torch, see app.py +every single click need 1800MB GPU Memory. I will fix it. #### 25.04.30 Use it to segment any gaussian easily, capable with multiview annotation ability. diff --git a/app.py b/app.py index 806d18f..b3acfcd 100644 --- a/app.py +++ b/app.py @@ -32,6 +32,17 @@ from gradio_litmodel3d import LitModel3D from torch.profiler import profile, record_function, ProfilerActivity +from time import time +import datetime + +# 获取当前时间字符串的lambda函数 +current_time = lambda: datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") + +def log(): + with open(".log", "a+") as f: + f.write(f"{[current_time()]}") + f.write(torch.cuda.memory_summary()) + f.write("\n\n##########\n\n") pipeline, background = None, None empty_3D = torch.zeros((0,3),device='cuda') @@ -142,6 +153,19 @@ def extract_sam_features_pt(scene_path, predictor, cameras, gaussians): # region 3D投影操作 ## Project 3D points to 2D plane +def project_to_2d_batch(viewpoint_cameras, points3D) -> torch.Tensor: # C,N,2 + full_matrices = torch.stack([camera.full_proj_transform for camera in viewpoint_cameras]) # [C, 4, 4] + if points3D.shape[-1] != 4: points3D = F.pad(input=points3D, pad=(0, 1), mode='constant', value=1) # [N, 4] + p_hom = torch.bmm(points3D.unsqueeze(0).expand(len(viewpoint_cameras), -1, -1), full_matrices) # [C, N, 4] + p_w = 1.0 / (p_hom[..., 3:] + 0.0000001) # [C, N, 1] + p_proj = p_hom[..., :3] * p_w # [C, N, 3] + heights = torch.tensor([camera.image_height for camera in viewpoint_cameras], device=points3D.device) # [C] + widths = torch.tensor([camera.image_width for camera in viewpoint_cameras], device=points3D.device) # [C] + sizes = torch.stack([widths, heights], dim=1).unsqueeze(1) # [C, 1, 2] + point_image = 0.5 * ((p_proj[..., :2] + 1) * sizes - 1) # [C, N, 2] + point_image = torch.round(point_image) + return point_image # 返回[C, N, 2]张量，C为相机数量，N为点数量 + def project_to_2d(viewpoint_camera, points3D): # TODO: 做一个batch版本的 full_matrix = viewpoint_camera.full_proj_transform # torch.cuda, w2c @ K # project to image plane @@ -300,29 +324,8 @@ def __init__(self, model_path, predictor): self.saved_bg_path = None self.maskid = 0 # 将maskid移动到类实例变量 - self.seg2d_mark = { - name: { - 'points': [], # 当前点标注 - 'masks': None, # 当前掩码[id,H,W,C=1] - 'history': [], # 历史记录 [(points, masks), ...] - 'history_index': -1, # 历史记录索引，用于撤销/重做 - 'prompts_3D': empty_3D.clone() # 存储3D点标注 - } for name in self.images.keys() - } - self.multiview_mask = { - "records": [], # 每条记录结构如下（见下方）： - "current_index": -1 # 指向当前激活的记录，初始为 -1 表示无记录 - } - # records = { - # "prompts": torch.Tensor([N, 3]), # 保存用于生成该记录的 3D 点 - # "mvmask": { - # maskid1: { - # "multiview": {...}, # multiview_masks（用于3D分割） - # "sam_masks": {...}, # multiview_sam_masks（用于3D分割） - # } - # } - # "sam_all": {img1_name: mask1, img2_name: mask2} # sam_mask_all_levels（用于可视化） - # } + self.clear_all_mark() + def load_gaussian_scene(self, model_path, progress:gr.Progress=None): global pipeline @@ -366,23 +369,10 @@ def load_gaussian_scene(self, model_path, progress:gr.Progress=None): self.images[view.image_name] = render_image if progress is not None: progress(0.7, desc="Get Sam Features") - # SAM_Features烂了 self.sam_features = extract_sam_features_pt(model_path, self.predictor, self.scene.getTrainCameras(), self.scene.gaussians) self.current_image = list(self.images.keys())[0] self.predictor.set_image(self.images[self.current_image]) - self.seg2d_mark = { - name: { - 'points': [], - 'masks': None, - 'history': [], - 'history_index': -1, - 'prompts_3D': empty_3D.clone() - } for name in self.images.keys() - } - self.multiview_mask = { - "records": [], - "current_index": -1 - } + self.clear_all_mark() print("加载完成") if progress is not None: progress(1, desc="Finished") @@ -394,10 +384,6 @@ def load_scene_gaussians(self): "iteration_" + str(self.scene.loaded_iter), "point_cloud.ply")) return gaussians - - def get_current_state(self): - mark = self.seg2d_mark[self.current_image] - return self.current_image, mark['points'], mark['masks'] def add_point(self, evt: gr.SelectData, is_original=True): """添加点，支持从原图或mask图添加""" @@ -433,15 +419,15 @@ def undo(self): if mark['history_index'] > 0: # 此时若刚做了一次，为0 mark['history_index'] -= 1 prev_state = mark['history'][mark['history_index']] - mark['points'] = prev_state[0].copy() if prev_state[0] is not None else [] - mark['masks'] = prev_state[1].copy() if prev_state[1] is not None else None + mark['points'] = prev_state[0][:] + mark['masks'] = prev_state[1].clone() if prev_state[1] is not None else None # 恢复3D点标注 if len(prev_state) > 2 and prev_state[2] is not None: - mark['prompts_3D'] = prev_state[2].copy() if prev_state[2] is not None else empty_3D.clone() + mark['prompts_3D'] = prev_state[2].clone() if prev_state[2] is not None else empty_3D.clone() else: mark["points"] = [] - mark["masks"] = None - mark["prompts_3D"] = empty_3D.clone() + mark['masks'] = None + mark['prompts_3D'] = empty_3D.clone() self._save_state() self._get_mask() @@ -489,11 +475,11 @@ def clear_current(self): self._get_mask() return self._render_original(), self._render_mask(), self._render_selected_mask() - def clear_all(self): + def clear_all_mark(self): self.seg2d_mark = { name: { - 'points': [], # 当前点标注 - 'masks': None, # 当前掩码[id,H,W,C=1] + 'points': [], # 当前视角的点标注 + 'masks': None, # 当前视角的masks[id,H,W,C=1] 'history': [], # 历史记录 [(points, masks), ...] 'history_index': -1, # 历史记录索引，用于撤销/重做 'prompts_3D': empty_3D.clone() # 存储3D点标注 @@ -503,6 +489,19 @@ def clear_all(self): "records": [], # 每条记录结构如下（见下方）： "current_index": -1 # 指向当前激活的记录，初始为 -1 表示无记录 } + # records = { # 每次点击，根据不同的点击组合，会创建一个records结构。 + # "prompts": torch.Tensor([N, 3]), # 保存用于生成该记录的 3D 点 + # "mvmask": { + # maskid1: { + # "multiview": {...}, # multiview_masks (用于3D分割) + # "sam_masks": {...}, # multiview_sam_masks (用于3D分割) + # } + # } + # "sam_all": {img1_name: mask1, img2_name: mask2} # sam_mask_all_levels（用于可视化） + # } + + def clear_all(self): + self.clear_all_mark() return self._render_original(), self._render_mask(), self._render_selected_mask() def _update_3d_prompts(self): @@ -541,6 +540,67 @@ def toggle_mask(self): self._get_mask() return self._render_display() + def generate_multiview_masks_batch(self, prompts_3D, text_prompt = None, progress:gr.Progress=None): + """ + sam_mask_all_levels (cuda) : list[torch.int64(id,H,W)] , 每个视角下的渲染图的sam mask + sam_masks (cuda) : list[torch.int64(H,W)] , 每个视角下的渲染图的sam mask + multiview_masks (cuda) : list[torch.int64(N,1)] , 每个视角下，每个Gaussians点的mask + """ + + # point guided, masks[id,H,W,C=1], 2D点标注 + def self_prompt_seg_torch(point_prompts, sam_feature): # point_prompts: torch([N,2]) + input_point = point_prompts[None, :, :] # Batch, N, 2 + input_label = torch.ones((input_point.shape[0],input_point.shape[1]), device=self.predictor.device) + + predictor.features = sam_feature + masks_torch_batch, _, _ = predictor.predict_torch( + point_coords=input_point, # [1,N,2] + point_labels=input_label, # [1,N] + multimask_output=True, + ) + masks_torch = masks_torch_batch[0] # [batch, id, H, W, C] + return_mask = (masks_torch[:, :, :, None]*255).to(torch.uint8) # [id,H,W,C=1] + return return_mask / 255 + + # point guided, masks[id,H,W,C=1], 2D点标注 + def self_prompt_seg_batch(point_prompts, sam_feature): + # point_prompts: torch([nCam, N,2]) + # sam_features : torch([nCam, C,H,W]) + input_point = point_prompts[None, :, :] # Batch, N, 2 + input_label = torch.ones((input_point.shape[0],input_point.shape[1]), device=self.predictor.device) + + predictor.features = sam_feature + masks_torch_batch, _, _ = predictor.predict_torch( + point_coords=input_point, # [1,N,2] + point_labels=input_label, # [1,N] + multimask_output=True, + ) + masks_torch = masks_torch_batch[0] # [batch, id, H, W, C] + return_mask = (masks_torch[:, :, :, None]*255).to(torch.uint8) # [id,H,W,C=1] + return return_mask / 255 + + scene = self.scene + images = self.images + mask_id = self.maskid + cameras = scene.getTrainCameras() + gaussians = scene.gaussians + sam_masks = [] + multiview_masks = [] + sam_mask_all_levels = [] + prompts_2ds = project_to_2d_batch(cameras, prompts_3D) # [nCameras, N, 2] + sam_features = torch.stack([self.sam_features[v.image_name] for v in cameras]) # [nCameras, C, H, W] + sam_mask_all_level = self_prompt_seg_torch(prompts_2d, self.sam_features[image_name]) + + for i, view in tqdm(enumerate(cameras), desc="generate multiview masks"): + image_name = view.image_name # added + prompts_2d = project_to_2d(view, prompts_3D) + sam_mask_all_level = self_prompt_seg_torch(prompts_2d, self.sam_features[image_name]) # torch([id=3,H,W,C=1]) + sam_mask_all_levels.append(sam_mask_all_level) + sam_mask = sam_mask_all_level[mask_id].long()[:,:,0] # torch[H,W] + sam_masks.append(sam_mask) + point_mask, indices_mask = mask_inverse(gaussians.get_xyz, view, sam_mask) # TODO: gaussians.get_xyz.require_grad=True; cuda,cuda,cuda + multiview_masks.append(point_mask.unsqueeze(-1)) + return sam_mask_all_levels, sam_masks, multiview_masks def generate_multiview_masks(self, prompts_3D, text_prompt = None, progress:gr.Progress=None): """ @@ -668,7 +728,7 @@ def _get_mask(self, match_mask_id = False, progress:gr.Progress=None): # 收集prompts_3D prompts_3D_list = [] for img_name in self.images.keys(): - prompts_3D = self.seg2d_mark[img_name]["prompts_3D"] # torch.Tensor[N,3] + prompts_3D = self.seg2d_mark[img_name]['prompts_3D'] # torch.Tensor[N,3] if prompts_3D.shape[0] > 0: # 检查是否有3D点标注 prompts_3D_list.append(prompts_3D) @@ -700,7 +760,7 @@ def _is_same_prompt(p1, p2, tol=1e-5): # 显示 2D mask for img_name in self.images.keys(): mask = self.multiview_mask["records"][matched_index]["sam_all"].get(img_name) - self.seg2d_mark[img_name]["masks"] = mask + self.seg2d_mark[img_name]['masks'] = mask return # 没有命中，生成新的 @@ -709,12 +769,12 @@ def _is_same_prompt(p1, p2, tol=1e-5): # 刷新所有展示图片 for sam_mask_level, img_name in zip(sam_alls, self.images.keys()): - self.seg2d_mark[img_name]["masks"] = sam_mask_level.squeeze(-1) if sam_mask_level is not None else None + self.seg2d_mark[img_name]['masks'] = sam_mask_level.squeeze(-1) if sam_mask_level is not None else None # 组装 sam_all 字典 sam_all_dict = { img: m.squeeze(-1) if m is not None else None - for img, m in zip(self.images.keys(), sam_alls) + for img, m in zip(self.images.keys(), sam_alls) # img_name -> torch.tensor(id,H,W), 仅显示时转numpy } # --- 写入记录 --- @@ -731,7 +791,8 @@ def _is_same_prompt(p1, p2, tol=1e-5): } record["sam_all"] = sam_all_dict self.multiview_mask["current_index"] = matched_index - + log() + def _save_state(self): """保存当前状态到历史记录""" mark = self.seg2d_mark[self.current_image] @@ -739,7 +800,7 @@ def _save_state(self): # 创建当前状态的副本，不再包含maskid current_state = ( mark['points'][:] if mark['points'] else [], # list[N,2] -> int - mark['masks'].clone() if mark['masks'] is not None else None, # list[nImage] -> Tensor[3,H,W] + mark['masks'].clone() if mark['masks'] is not None else None, # Tensor[3,H,W] mark['prompts_3D'].clone() if 'prompts_3D' in mark else empty_3D.clone() # Tensor[N,3] ) @@ -786,6 +847,7 @@ def _render_mask(self): # 绘制mask if mark['masks'] is not None and len(mark['masks']) > 0: mask_multilayer = mark['masks'].cpu().numpy() + # print(f"mask_multilayer: {mask_multilayer.shape}") # 定义三种颜色 - 使用更鲜艳的颜色 mask_colors = [ np.array([255, 50, 50]), # 红色 @@ -977,7 +1039,7 @@ def create_gradio_interface(default_model_paths, predictor): with gr.Column(scale=2): gallery = gr.Gallery( label="Gallery", - value=list(tool.images.values()), + value=[tool.images[k] for k in sorted(tool.images.keys(), key=lambda x: int(x) if x.isdigit() else x)], columns=4, object_fit="contain", height="auto" @@ -1072,7 +1134,7 @@ def seg_gaussian_with_prompt(object_name, progress=gr.Progress(track_tqdm=True)) # 更新文本框状态为处理中 yield gr.update(value=f"Processing: '{object_name}'...", interactive=False) tool.seg_gaussian(threshold=0.7, object_name=object_name, progress=None) - yield gr.update(value="", placeholder="Your Object Name", interactive=True) + yield gr.update(value=object_name, placeholder="Your Object Name", interactive=True) # 修改保存按钮事件 object_name_input.submit( From daa808ab2c2eea22cf084ce19c4fc825b99cc789 Mon Sep 17 00:00:00 2001 From: MrHandsomeljn <1205197328@qq.com> Date: Fri, 2 May 2025 12:49:03 +0800 Subject: [PATCH 7/9] Fixed Large GPU Memory Usage --- README.md | 5 +- app.py | 299 +++----- app_cached_result(deprecated).py | 1119 ++++++++++++++++++++++++++++++ 3 files changed, 1209 insertions(+), 214 deletions(-) create mode 100644 app_cached_result(deprecated).py diff --git a/README.md b/README.md index e480d3e..e9a4f84 100644 --- a/README.md +++ b/README.md @@ -3,9 +3,12 @@ ## SAGS with a Gradio Interface +#### 25.05.02 +No Cached Result of SAM. Now the GPU Memory Usage is stable. + #### 25.05.01 Speedup x10 (in multi view segment) by change some numpy operator to torch, see app.py -every single click need 1800MB GPU Memory. I will fix it. +every single click need 1800MB GPU Memory(with 90pic dataset). I will fix it. #### 25.04.30 Use it to segment any gaussian easily, capable with multiview annotation ability. diff --git a/app.py b/app.py index b3acfcd..88c1adf 100644 --- a/app.py +++ b/app.py @@ -1,7 +1,3 @@ -""" - -""" - import gradio as gr from typing import List, Tuple, Dict @@ -47,18 +43,6 @@ def log(): pipeline, background = None, None empty_3D = torch.zeros((0,3),device='cuda') -# 递归查找所有名为"model"的文件夹 -def find_model_folders(base_path, relative_to="."): - model_paths = [] - if os.path.exists(base_path): - # 如果relative_to是None,则相对于当前目录 - if relative_to is None: relative_to = "." - for root, dirs, files in os.walk(base_path): - if os.path.basename(root) == "model": - # 获取相对于relative_to的路径 - rel_path = os.path.relpath(root, relative_to) - model_paths.append(rel_path) - return model_paths # region 加载Gaussian @@ -326,14 +310,12 @@ def __init__(self, model_path, predictor): self.maskid = 0 # 将maskid移动到类实例变量 self.clear_all_mark() - def load_gaussian_scene(self, model_path, progress:gr.Progress=None): global pipeline global background if self.scene is not None: del self.scene if self.seg2d_mark is not None: del self.seg2d_mark - if self.multiview_mask is not None: del self.multiview_mask print("Loading Gaussian Scene") if progress is not None: progress(0, desc="Get Args") @@ -384,6 +366,10 @@ def load_scene_gaussians(self): "iteration_" + str(self.scene.loaded_iter), "point_cloud.ply")) return gaussians + + def get_current_state(self): + mark = self.seg2d_mark[self.current_image] + return self.current_image, mark['points'] def add_point(self, evt: gr.SelectData, is_original=True): """添加点，支持从原图或mask图添加""" @@ -405,9 +391,9 @@ def add_point(self, evt: gr.SelectData, is_original=True): if self.scene is not None: self._update_3d_prompts() - if len(mark['points']): self._get_mask() + self._get_mask() self._save_state() - + self._new_loaded = False return self._render_original(), self._render_mask(), self._render_selected_mask() def undo(self): @@ -420,22 +406,18 @@ def undo(self): mark['history_index'] -= 1 prev_state = mark['history'][mark['history_index']] mark['points'] = prev_state[0][:] - mark['masks'] = prev_state[1].clone() if prev_state[1] is not None else None # 恢复3D点标注 if len(prev_state) > 2 and prev_state[2] is not None: mark['prompts_3D'] = prev_state[2].clone() if prev_state[2] is not None else empty_3D.clone() else: mark["points"] = [] - mark['masks'] = None mark['prompts_3D'] = empty_3D.clone() self._save_state() self._get_mask() # 如果场景存在，更新3D点标注 - if self.scene is not None and len(mark['points']): - self._update_3d_prompts() - + if self.scene is not None and len(mark['points']): self._update_3d_prompts() return self._render_original(), self._render_mask(), self._render_selected_mask() def redo(self): @@ -448,16 +430,13 @@ def redo(self): mark['history_index'] += 1 next_state = mark['history'][mark['history_index']] mark['points'] = next_state[0][:] - mark['masks'] = next_state[1].clone() if next_state[1] is not None else None # 恢复3D点标注 if len(next_state) > 2 and next_state[2] is not None: mark['prompts_3D'] = next_state[2].clone() if next_state[2] is not None else empty_3D.clone() self._get_mask() # 如果场景存在，更新3D点标注 - if self.scene is not None and mark['points']: - self._update_3d_prompts() - + if self.scene is not None and len(mark['points']): self._update_3d_prompts() return self._render_original(), self._render_mask(), self._render_selected_mask() def set_mask_id(self, mask_id): @@ -469,7 +448,6 @@ def clear_current(self): """清空当前图片的所有标注""" mark = self.seg2d_mark[self.current_image] mark['points'] = [] - mark['masks'] = None mark['prompts_3D'] = empty_3D.clone() # 清空3D点标注 self._save_state() self._get_mask() @@ -479,26 +457,22 @@ def clear_all_mark(self): self.seg2d_mark = { name: { 'points': [], # 当前视角的点标注 - 'masks': None, # 当前视角的masks[id,H,W,C=1] 'history': [], # 历史记录 [(points, masks), ...] 'history_index': -1, # 历史记录索引，用于撤销/重做 'prompts_3D': empty_3D.clone() # 存储3D点标注 } for name in self.images.keys() } - self.multiview_mask = { - "records": [], # 每条记录结构如下（见下方）： - "current_index": -1 # 指向当前激活的记录，初始为 -1 表示无记录 + self.record = { # 每次点击，根据不同的点击组合，会创建一个record结构。 + "prompts": None, # torch.Tensor([N, 3]), 保存用于生成该记录的 3D 点 + "mvmask": { + # maskid1: { + # "multiview": {...}, # multiview_masks (用于3D分割) + # "sam_masks": {...}, # multiview_sam_masks (用于3D分割) + # } + }, + "sam_all": {} # {img1_name: mask1, ...}（用于可视化） } - # records = { # 每次点击，根据不同的点击组合，会创建一个records结构。 - # "prompts": torch.Tensor([N, 3]), # 保存用于生成该记录的 3D 点 - # "mvmask": { - # maskid1: { - # "multiview": {...}, # multiview_masks (用于3D分割) - # "sam_masks": {...}, # multiview_sam_masks (用于3D分割) - # } - # } - # "sam_all": {img1_name: mask1, img2_name: mask2} # sam_mask_all_levels（用于可视化） - # } + self._new_loaded = True def clear_all(self): self.clear_all_mark() @@ -539,7 +513,7 @@ def toggle_mask(self): elif self.points[self.current_image]: self._get_mask() return self._render_display() - + def generate_multiview_masks_batch(self, prompts_3D, text_prompt = None, progress:gr.Progress=None): """ sam_mask_all_levels (cuda) : list[torch.int64(id,H,W)] , 每个视角下的渲染图的sam mask @@ -643,45 +617,6 @@ def self_prompt_seg_torch(point_prompts, sam_feature): # point_prompts: torch([N multiview_masks.append(point_mask.unsqueeze(-1)) return sam_mask_all_levels, sam_masks, multiview_masks - # def generate_multiview_masks(self, prompts_3D, text_prompt = None, progress:gr.Progress=None): - # """ - # sam_mask (cuda) : list[torch.int64(id,H,W)] , 每个视角下的渲染图的sam mask - # multiview_masks (cuda) : list[torch.int64(N,1)] , 每个视角下，每个Gaussians点的mask - # """ - # # text guided, masks[id,H,W,C=1] - # def text_prompt_seg(image, text): - # input_boxes = grounding_dino_prompt(image, text) - - # boxes = torch.tensor(input_boxes)[0:1].cuda() - # transformed_boxes = predictor.transform.apply_boxes_torch(boxes, image.shape[:2]) - # masks, _, _ = predictor.predict_torch( - # point_coords=None, - # point_labels=None, - # boxes=transformed_boxes, - # multimask_output=True, - # ) - # masks = masks[0].cpu().numpy() - # return (masks[:, :, :, None]*255).astype(np.uint8) / 255 # id,H,W,1 - - # # point guided, masks[id,H,W,C=1], 2D点标注 - # def self_prompt_seg(point_prompts, sam_feature): - # input_point = point_prompts.detach().cpu().numpy() - # # input_point = input_point[::-1] - # input_label = np.ones(len(input_point)) - - # predictor.features = sam_feature - # masks, _, _ = predictor.predict( - # point_coords=input_point, - # point_labels=input_label, - # multimask_output=True, - # ) - # # return_mask = (masks[ :, :, 0]*255).astype(np.uint8) - # # return_mask = (masks[id, :, :, None]*255).astype(np.uint8) # id,H,W,C=1 - # return_mask = (masks[:, :, :, None]*255).astype(np.uint8) # id,H,W,C=1 - - # return return_mask / 255 - - scene = self.scene images = self.images mask_id = self.maskid @@ -713,7 +648,11 @@ def self_prompt_seg_torch(point_prompts, sam_feature): # point_prompts: torch([N multiview_masks.append(point_mask.unsqueeze(-1)) return sam_mask_all_levels, sam_masks, multiview_masks - def _get_mask(self, match_mask_id = False, progress:gr.Progress=None): + def _get_multilayer_mask(self, img_name): + if self._new_loaded: return None + return self.record["sam_all"].get(img_name) + + def _get_mask(self, progress:gr.Progress=None): """ 根据prompts_3D和maskid作为索引，保存multiview_sam_masks, multiview_masks 根据prompts_3D作为索引，保存sam_mask_all_level @@ -724,7 +663,6 @@ def _get_mask(self, match_mask_id = False, progress:gr.Progress=None): multiview_sam_masks: 是选中的mask,用于3D分割,需要mask_id multiview_masks : 是3D点的mask,用于3D分割,需要mask_id """ - if progress is not None: progress(0, desc="prepare Prompt 3D") # 收集prompts_3D prompts_3D_list = [] for img_name in self.images.keys(): @@ -735,64 +673,22 @@ def _get_mask(self, match_mask_id = False, progress:gr.Progress=None): if prompts_3D_list: prompts_3D_tensor = torch.cat(prompts_3D_list, dim=0) # [M,3] else: prompts_3D_tensor = torch.empty((0, 3), dtype=torch.float32, device="cuda") - print("Prompt 3D: ",prompts_3D_tensor) - print("Prompt maskid: ",self.maskid) - - if progress is not None: progress(0.1, desc="matching cached multiview mask") - - # 匹配 - def _is_same_prompt(p1, p2, tol=1e-5): - if p1.shape != p2.shape: return False - p1_sorted = torch.sort(p1, dim=0)[0] - p2_sorted = torch.sort(p2, dim=0)[0] - return torch.allclose(p1_sorted, p2_sorted, atol=tol) - - matched_index = None - for i, rec in enumerate(self.multiview_mask["records"]): - if _is_same_prompt(rec["prompts"], prompts_3D_tensor): - matched_index = i - break - - # --- 若找到记录且包含当前 maskid，直接复用 --- - if matched_index is not None and (not match_mask_id or self.maskid in self.multiview_mask["records"][matched_index]["mvmask"]): - self.multiview_mask["current_index"] = matched_index - print(f"Reusing cached mask at index {matched_index} for maskid {self.maskid}, {len(self.multiview_mask['records'][matched_index]['prompts'])}") - # 显示 2D mask - for img_name in self.images.keys(): - mask = self.multiview_mask["records"][matched_index]["sam_all"].get(img_name) - self.seg2d_mark[img_name]['masks'] = mask - return - - # 没有命中，生成新的 + if progress is not None: progress(0, desc="prepare Prompt 3D") sam_alls, sam_masks, multiviews = self.generate_multiview_masks(prompts_3D_tensor, progress=progress) print("multiview_masks generated\n") - - # 刷新所有展示图片 - for sam_mask_level, img_name in zip(sam_alls, self.images.keys()): - self.seg2d_mark[img_name]['masks'] = sam_mask_level.squeeze(-1) if sam_mask_level is not None else None - - # 组装 sam_all 字典 - sam_all_dict = { + sam_all_dict = { # img_name -> torch.tensor(id,H,W), 仅显示时转numpy img: m.squeeze(-1) if m is not None else None - for img, m in zip(self.images.keys(), sam_alls) # img_name -> torch.tensor(id,H,W), 仅显示时转numpy + for img, m in zip(self.images.keys(), sam_alls) } - - # --- 写入记录 --- - if matched_index is not None: - record = self.multiview_mask["records"][matched_index] - else: - record = {"prompts": prompts_3D_tensor, "mvmask": {}, "sam_all": sam_all_dict} - self.multiview_mask["records"].append(record) - matched_index = len(self.multiview_mask["records"]) - 1 - - record["mvmask"][self.maskid] = { + self.record["prompts"] = prompts_3D_tensor + self.record["sam_all"] = sam_all_dict + self.record["mvmask"][self.maskid] = { "multiview": multiviews, "sam_masks": sam_masks, } - record["sam_all"] = sam_all_dict - self.multiview_mask["current_index"] = matched_index log() - + return + def _save_state(self): """保存当前状态到历史记录""" mark = self.seg2d_mark[self.current_image] @@ -800,7 +696,6 @@ def _save_state(self): # 创建当前状态的副本，不再包含maskid current_state = ( mark['points'][:] if mark['points'] else [], # list[N,2] -> int - mark['masks'].clone() if mark['masks'] is not None else None, # Tensor[3,H,W] mark['prompts_3D'].clone() if 'prompts_3D' in mark else empty_3D.clone() # Tensor[N,3] ) @@ -840,98 +735,70 @@ def _render_mask(self): img = self.images[self.current_image].copy() mark = self.seg2d_mark[self.current_image] - # 确保img是3通道图像 - if len(img.shape) == 2: - img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR) - - # 绘制mask - if mark['masks'] is not None and len(mark['masks']) > 0: - mask_multilayer = mark['masks'].cpu().numpy() - # print(f"mask_multilayer: {mask_multilayer.shape}") - # 定义三种颜色 - 使用更鲜艳的颜色 + if len(img.shape) == 2: img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR) + try: + mask_multilayer = self._get_multilayer_mask(self.current_image).cpu().numpy() mask_colors = [ - np.array([255, 50, 50]), # 红色 - np.array([50, 255, 50]), # 绿色 - np.array([50, 50, 255]) # 蓝色 + np.array([255, 50, 50]), # R + np.array([50, 255, 50]), # G + np.array([50, 50, 255]) # B ] mask_color_strength = 0.6 # [0,1] - - # 创建一个合并所有mask的图像 combined_mask = np.zeros_like(img) - - # 创建一个优先级掩码，用于处理重叠区域 - # 值越小，优先级越高（小的mask优先显示） priority_mask = np.ones(img.shape[:2], dtype=np.int32) * 999 - - # 从小到大处理mask，确保小的mask优先显示 masks_count = min(len(mask_multilayer), len(mask_colors)) for i in range(masks_count): mask = mask_multilayer[i] mask_area = mask > 0.5 - - # 只处理优先级更高的区域（即尚未被更小的mask覆盖的区域） valid_area = np.logical_and(mask_area, priority_mask > i) if np.any(valid_area): - # 更新优先级掩码 priority_mask[valid_area] = i - # 将mask区域的颜色设置为mask_color和原图的加权平均 combined_mask[valid_area] = mask_colors[i] * mask_color_strength + img[valid_area] * (1-mask_color_strength) - - # 将mask区域替换到原图中 mask_any = np.any(combined_mask > 0, axis=2) img[mask_any] = combined_mask[mask_any] - else: print(f"Mask invalid: {mark['masks']}") - # 绘制点 (后绘制点，确保在最上层) + + except Exception as e: + if not self._new_loaded: + print(f"Mask invalid: {self.current_image}") + print(e) + for i, (x, y) in enumerate(mark['points']): - # 先绘制黑色边框增加对比度 cv2.circle(img, (x, y), 8, (0, 0, 0), -1) - # 再绘制亮色内部 cv2.circle(img, (x, y), 6, (0, 255, 255), -1) - # 添加数字标签，带黑色边框增加可读性 - cv2.putText(img, str(i+1), (x+10, y+10), - cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 0), 3) - cv2.putText(img, str(i+1), (x+10, y+10), - cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 1) + cv2.putText(img, str(i+1), (x+10, y+10), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 0), 3) + cv2.putText(img, str(i+1), (x+10, y+10), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 1) return img def _render_selected_mask(self): """渲染选中的单个mask应用到原图的效果""" img = self.images[self.current_image].copy() - mark = self.seg2d_mark[self.current_image] - - # 确保img是3通道图像 - if len(img.shape) == 2: - img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR) - - # 绘制选中的mask - if mark['masks'] is not None and len(mark['masks']) > 0: - mask_multilayer = mark['masks'].cpu().numpy() - mask_id = self.maskid # 使用类实例变量 + if len(img.shape) == 2: img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR) + try: + mask_multilayer = self._get_multilayer_mask(self.current_image).cpu().numpy() + mask_id = self.maskid if mask_id < len(mask_multilayer): - # 获取选中的mask mask = mask_multilayer[mask_id] mask_area = mask > 0.5 - - # 定义mask颜色 mask_colors = [ - np.array([255, 50, 50]), # 红色 - np.array([50, 255, 50]), # 绿色 - np.array([50, 50, 255]) # 蓝色 + np.array([255, 50, 50]), # R + np.array([50, 255, 50]), # G + np.array([50, 50, 255]) # B ] mask_color = mask_colors[mask_id % len(mask_colors)] mask_color_strength = 0.6 - # 应用mask到原图 if np.any(mask_area): img[mask_area] = mask_color * mask_color_strength + img[mask_area] * (1-mask_color_strength) - - else: print(f"mask invalid: {mark['masks']}") + except Exception as e: + if not self._new_loaded: + print(f"Mask invalid: {self.current_image}") + print(e) return img ## Multi-view label voting 多视角（multi-view）标签投票融合 def ensemble(self, threshold=0.7): - multiview_masks = self.multiview_mask["records"][self.multiview_mask["current_index"]]["mvmask"][self.maskid]["multiview"] + multiview_masks = self.record["mvmask"][self.maskid]["multiview"] multiview_masks = torch.cat(multiview_masks, dim=1) vote_labels,_ = torch.mode(multiview_masks, dim=1) # # select points with score > threshold @@ -945,7 +812,7 @@ def ensemble(self, threshold=0.7): def seg_gaussian(self, threshold, object_name, progress:gr.Progress = None): if progress is not None: progress(0, desc="load gaussians and mask") - self._get_mask(match_mask_id=True, progress=progress) # 需要match maskid + self._get_mask(progress=progress) # 需要match maskid model_path = self.scene.model_path gaussians = self.scene.gaussians _, final_mask = self.ensemble(threshold) @@ -961,7 +828,7 @@ def seg_gaussian(self, threshold, object_name, progress:gr.Progress = None): de_gaussian = self.load_scene_gaussians() for i, view in tqdm(enumerate(cameras), desc="gaussian multiview decomp"): if self.args.gd_interval != -1 and i % self.args.gd_interval == 0: - input_mask = self.multiview_mask["records"][self.multiview_mask["current_index"]]["mvmask"][self.maskid]["sam_masks"][i] + input_mask = self.record["mvmask"][self.maskid]["sam_masks"][i] de_gaussian = gaussian_decomp(de_gaussian, view, input_mask, final_mask.to('cuda')) if progress is not None: progress(0.5, desc="render segged gaussian") @@ -1022,7 +889,7 @@ def create_gradio_interface(default_model_paths, predictor): interactive=True ) with gr.Row() as prompt_col: - with gr.Column(scale=1): + with gr.Column(scale=1.5): model_path_input = gr.Dropdown( choices=default_model_paths, allow_custom_value=True, @@ -1039,10 +906,11 @@ def create_gradio_interface(default_model_paths, predictor): with gr.Column(scale=2): gallery = gr.Gallery( label="Gallery", - value=[tool.images[k] for k in sorted(tool.images.keys(), key=lambda x: int(x) if x.isdigit() else x)], + value=[(tool.images[k],k) for k in sorted(tool.images.keys(), key=lambda x: int(x) if x.isdigit() else x)], columns=4, object_fit="contain", - height="auto" + height="auto", + allow_preview=False, ) with gr.Column(scale=1): with gr.Row(): fg_gs = LitModel3D(label="Foreground", exposure=10.0, height=300) @@ -1064,9 +932,9 @@ def on_mask_select(choice): # 获取可用的mask选项 def get_available_mask_choices(tool): # mark = tool.seg2d_mark[tool.current_image] - # if mark['masks'] is None: return ["S"] + # if tool._get_multilayer_mask() is None: return ["S"] # mask_names = ["S", "M", "L"] - # return mask_names[:len(mark['masks'])] + # return mask_names[:len(tool._get_multilayer_mask())] return ["S", "M", "L"] # 修改add_point方法的返回值，使用新的API更新Radio组件 @@ -1094,7 +962,7 @@ def load_with_progress(model_path, progress=gr.Progress(track_tqdm=True)): selected = tool._render_selected_mask() available_masks = get_available_mask_choices(tool) return \ - gr.update(value = list(tool.images.values())),\ + gr.update(value = [(tool.images[k],k) for k in sorted(tool.images.keys(), key=lambda x: int(x) if x.isdigit() else x)]),\ orig, mask, selected, \ gr.update(choices=available_masks, value=available_masks[0] if available_masks else None) @@ -1136,22 +1004,15 @@ def seg_gaussian_with_prompt(object_name, progress=gr.Progress(track_tqdm=True)) tool.seg_gaussian(threshold=0.7, object_name=object_name, progress=None) yield gr.update(value=object_name, placeholder="Your Object Name", interactive=True) - # 修改保存按钮事件 - object_name_input.submit( + object_name_input.submit( # 保存Gaussian fn=seg_gaussian_with_prompt, inputs=object_name_input, outputs=[object_name_input] - # ).then( - # fn=lambda:(tool.saved_fg_path, tool.saved_fg_path, tool.saved_bg_path, tool.saved_bg_path), - # outputs=[fg_gs, download_fg_gs, bg_gs, download_bg_gs] - # ).then( - # fn = lambda: (gr.Button(interactive=True),gr.Button(interactive=True)), - # outputs=[download_fg_gs, download_bg_gs], - ).then( - fn=lambda:(tool.saved_fg_path, tool.saved_fg_path), - outputs=[fg_gs, download_fg_gs] + ).then( # 显示Gaussian + fn=lambda: tool.saved_fg_path, + outputs=[fg_gs] ).then( - fn = lambda: gr.Button(interactive=True), + fn = lambda: gr.DownloadButton.update(value=tool.saved_fg_path, interactive=True), outputs=[download_fg_gs], ) @@ -1159,7 +1020,7 @@ def seg_gaussian_with_prompt(object_name, progress=gr.Progress(track_tqdm=True)) def on_gallery_select(evt: gr.SelectData): try: index = evt.index - image_name = list(tool.images.keys())[index] + image_name = sorted(tool.images.keys(), key=lambda x: int(x) if x.isdigit() else x)[index] orig, mask, selected = tool.update_image(image_name) # 获取当前可用的mask选项，保持mask选择 available_masks = get_available_mask_choices(tool) @@ -1187,11 +1048,23 @@ def init_display(): -# python app.py --model_path # I'm using this for trellis model segmentation # As it's a Y-Up generation model # output model would be lying down. + +def find_model_folders(base_path, relative_to="."): + model_paths = [] + if os.path.exists(base_path): + # 如果relative_to是None,则相对于当前目录 + if relative_to is None: relative_to = "." + for root, dirs, files in os.walk(base_path): + if os.path.basename(root) == "model": + # 获取相对于relative_to的路径 + rel_path = os.path.relpath(root, relative_to) + model_paths.append(rel_path) + return model_paths + if __name__ == "__main__": # with profile(on_trace_ready=torch.profiler.tensorboard_trace_handler('./log')) as prof: diff --git a/app_cached_result(deprecated).py b/app_cached_result(deprecated).py new file mode 100644 index 0000000..5de7da4 --- /dev/null +++ b/app_cached_result(deprecated).py @@ -0,0 +1,1119 @@ +import gradio as gr +from typing import List, Tuple, Dict + +import os +import sys +import cv2 +import time +import torch + +import numpy as np +import torch.nn.functional as F +import torchvision.transforms.functional as func + +from tqdm import tqdm +from typing import Literal +from plyfile import PlyData, PlyElement +from argparse import ArgumentParser, Namespace + +from gaussiansplatting.scene import Scene +from gaussiansplatting.gaussian_renderer import render +from gaussiansplatting.scene.gaussian_model import GaussianModel +from gaussiansplatting.arguments import ModelParams, PipelineParams + +from seg_utils import grounding_dino_prompt +from seg_utils import conv2d_matrix, compute_ratios, update +from segment_anything import (SamAutomaticMaskGenerator, SamPredictor, + sam_model_registry) +from gradio_litmodel3d import LitModel3D +from torch.profiler import profile, record_function, ProfilerActivity + +from time import time +import datetime + +# 获取当前时间字符串的lambda函数 +current_time = lambda: datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") + +def log(): + with open(".log", "a+") as f: + f.write(f"{[current_time()]}") + f.write(torch.cuda.memory_summary()) + f.write("\n\n##########\n\n") + +pipeline, background = None, None +empty_3D = torch.zeros((0,3),device='cuda') + + +# region 加载Gaussian + +def get_combined_args(parser : ArgumentParser, model_path): + # cmdlne_string = sys.argv[1:] + # cfgfile_string = "Namespace()" + cmdlne_string = ['--model_path', model_path] + cfgfile_string = "Namespace()" + args_cmdline = parser.parse_args(cmdlne_string) + + try: + cfgfilepath = os.path.join(model_path, "cfg_args") + print("Looking for config file in", cfgfilepath) + with open(cfgfilepath) as cfg_file: + print("Config file found: {}".format(cfgfilepath)) + cfgfile_string = cfg_file.read() + except TypeError: + print("Config file not found at") + pass + args_cfgfile = eval(cfgfile_string) + + merged_dict = vars(args_cfgfile).copy() + for k,v in vars(args_cmdline).items(): + if v != None: + merged_dict[k] = v + return Namespace(**merged_dict) + + + +# endregion + + + + +# region 加载Sam & feature + +def load_sam( + SAM_ARCH = 'vit_h', + SAM_CKPT_PATH = './gaussiansplatting/dependencies/sam_ckpt/sam_vit_h_4b8939.pth' + ): + model_type = SAM_ARCH + sam = sam_model_registry[model_type](checkpoint=SAM_CKPT_PATH).to('cuda') + print(f"Loading SAM: {SAM_ARCH} from {SAM_CKPT_PATH}") + predictor = SamPredictor(sam) + return predictor + +# extract and use sam features +def extract_sam_features(predictor, cameras, gaussians): + sam_features = {} + render_images = {} + print("Prepocessing: extracting SAM features...") + for view in tqdm(cameras): + image_name = view.image_name + render_pkg = render(view, gaussians, pipeline, background) + + render_image = render_pkg["render"].permute(1, 2, 0).detach().cpu().numpy() + render_image = (255 * np.clip(render_image, 0, 1)).astype(np.uint8) + + predictor.set_image(render_image) + sam_features[image_name] = predictor.features + return sam_features + +def extract_sam_features_pt(scene_path, predictor, cameras, gaussians): + # 检查路径是否存在 + if scene_path and os.path.exists(scene_path): + sam_path = os.path.join(scene_path,"sam_pt") + try: + print(f"Loading sam feature from {sam_path} ...") + sam_features = torch.load(sam_path) + return sam_features + except Exception as e: + print(f" Failed: {e}") + + print("Extract sam feature ...") + sam_features = extract_sam_features(predictor, cameras, gaussians) + + if scene_path: + sam_path = os.path.join(scene_path,"sam_pt") + os.makedirs(os.path.dirname(sam_path), exist_ok=True) + print(f"保存SAM特征到{sam_path}") + torch.save(sam_features, sam_path) + + return sam_features + + + +# endregion + + + + +# region 3D投影操作 + +## Project 3D points to 2D plane +def project_to_2d_batch(viewpoint_cameras, points3D) -> torch.Tensor: # C,N,2 + full_matrices = torch.stack([camera.full_proj_transform for camera in viewpoint_cameras]) # [C, 4, 4] + if points3D.shape[-1] != 4: points3D = F.pad(input=points3D, pad=(0, 1), mode='constant', value=1) # [N, 4] + p_hom = torch.bmm(points3D.unsqueeze(0).expand(len(viewpoint_cameras), -1, -1), full_matrices) # [C, N, 4] + p_w = 1.0 / (p_hom[..., 3:] + 0.0000001) # [C, N, 1] + p_proj = p_hom[..., :3] * p_w # [C, N, 3] + heights = torch.tensor([camera.image_height for camera in viewpoint_cameras], device=points3D.device) # [C] + widths = torch.tensor([camera.image_width for camera in viewpoint_cameras], device=points3D.device) # [C] + sizes = torch.stack([widths, heights], dim=1).unsqueeze(1) # [C, 1, 2] + point_image = 0.5 * ((p_proj[..., :2] + 1) * sizes - 1) # [C, N, 2] + point_image = torch.round(point_image) + return point_image # 返回[C, N, 2]张量，C为相机数量，N为点数量 + +def project_to_2d(viewpoint_camera, points3D): # TODO: 做一个batch版本的 + full_matrix = viewpoint_camera.full_proj_transform # torch.cuda, w2c @ K + # project to image plane + if points3D.shape[-1] != 4: + points3D = F.pad(input=points3D, pad=(0, 1), mode='constant', value=1) + p_hom = (points3D @ full_matrix).transpose(0, 1) # N, 4 -> 4, N -1 ~ 1 + p_w = 1.0 / (p_hom[-1, :] + 0.0000001) + p_proj = p_hom[:3, :] * p_w + + h = viewpoint_camera.image_height + w = viewpoint_camera.image_width + + point_image = 0.5 * ((p_proj[:2] + 1) * torch.tensor([w, h]).unsqueeze(-1).to(p_proj.device) - 1) # image plane + point_image = point_image.detach().clone() + point_image = torch.round(point_image.transpose(0, 1)) + + return point_image + +# 给定单视角2Dprompt，创建3Dprompt +def get_3d_prompts(prompts_2d, point_image, xyz, depth=None): + r = 4 + x_range = torch.arange(prompts_2d[0] - r, prompts_2d[0] + r) + y_range = torch.arange(prompts_2d[1] - r, prompts_2d[1] + r) + x_grid, y_grid = torch.meshgrid(x_range, y_range) + neighbors = torch.stack([x_grid, y_grid], dim=2).reshape(-1, 2).to("cuda") + prompts_index = [torch.where((point_image == p).all(dim=1))[0] for p in neighbors] + indexs = [] + for index in prompts_index: + if index.nelement() > 0: + indexs.append(index) + indexs = torch.unique(torch.cat(indexs, dim=0)) + indexs_depth = depth[indexs] + valid_depth = indexs_depth[indexs_depth > 0] + _, sorted_indices = torch.sort(valid_depth) + valid_indexs = indexs[depth[indexs] > 0][sorted_indices[0]] + + return xyz[valid_indexs][:3].unsqueeze(0) + +## Given 1st view point prompts, find corresponding 3D Gaussian point prompts +# 将3D点投影到2D，使得2D标注能映射到特定3D点上。 +def generate_3d_prompts(xyz, viewpoint_camera, prompts_2d) -> torch.Tensor: + w2c_matrix = viewpoint_camera.world_view_transform + full_matrix = viewpoint_camera.full_proj_transform + # project to image plane + xyz = F.pad(input=xyz, pad=(0, 1), mode='constant', value=1) + p_hom = (xyz @ full_matrix).transpose(0, 1) # N, 4 -> 4, N + p_w = 1.0 / (p_hom[-1, :] + 0.0000001) + p_proj = p_hom[:3, :] * p_w + # project to camera space + p_view = (xyz @ w2c_matrix[:, :3]).transpose(0, 1) # N, 3 -> 3, N + depth = p_view[-1, :] + valid_depth = depth >= 0 + + h = viewpoint_camera.image_height + w = viewpoint_camera.image_width + + point_image = 0.5 * ((p_proj[:2] + 1) * torch.tensor([w, h]).unsqueeze(-1).to(p_proj.device) - 1) + point_image = torch.round(point_image.transpose(0, 1)).long() + + prompts_2d = torch.tensor(prompts_2d).to("cuda") + prompts_3d = torch.stack([ + get_3d_prompts(prompts_2d[i], point_image, xyz, depth) + for i in range(prompts_2d.shape[0]) + ]) + prompts_3D = prompts_3d.reshape(-1, prompts_3d.shape[-1]) + return prompts_3D + +def mask_inverse(xyz, viewpoint_camera, sam_mask): + w2c_matrix = viewpoint_camera.world_view_transform + # project to camera space + xyz = F.pad(input=xyz, pad=(0, 1), mode='constant', value=1) + p_view = (xyz @ w2c_matrix[:, :3]).transpose(0, 1) # N, 3 -> 3, N + depth = p_view[-1, :].detach().clone() + valid_depth = depth >= 0 + + h = viewpoint_camera.image_height # int + w = viewpoint_camera.image_width # int + + + if sam_mask.shape[0] != h or sam_mask.shape[1] != w: # false + sam_mask = func.resize(sam_mask.unsqueeze(0), (h, w), antialias=True).squeeze(0).long() + else: + sam_mask = sam_mask.long() + + point_image = project_to_2d(viewpoint_camera, xyz) # torch([N,2]) + point_image = point_image.long() + + # 判断x,y是否在图像范围之内 + valid_x = (point_image[:, 0] >= 0) & (point_image[:, 0] < w) + valid_y = (point_image[:, 1] >= 0) & (point_image[:, 1] < h) + valid_mask = valid_x & valid_y & valid_depth # [N]=bool + point_mask = torch.full((point_image.shape[0],), -1, device="cuda") # [N]=-1 + point_mask[valid_mask] = sam_mask[point_image[valid_mask, 1], point_image[valid_mask, 0]] # [N]=sam_mask[x,y] + indices_mask = torch.where(point_mask == 1)[0] + + return point_mask, indices_mask + + + +# endregion + + + + +# region 分割 + +## Gaussian Decomposition +def gaussian_decomp(gaussians, viewpoint_camera, input_mask, indices_mask): + xyz = gaussians.get_xyz + point_image = project_to_2d(viewpoint_camera, xyz) + + conv2d = conv2d_matrix(gaussians, viewpoint_camera, indices_mask, device="cuda") + height = viewpoint_camera.image_height + width = viewpoint_camera.image_width + index_in_all, ratios, dir_vector = compute_ratios(conv2d, point_image, indices_mask, input_mask, height, width) + + decomp_gaussians = update(gaussians, viewpoint_camera, index_in_all, ratios, dir_vector) + + return decomp_gaussians + +def save_gs(pc, indices_mask, save_path): + xyz = pc._xyz.detach().cpu()[indices_mask].numpy() + normals = np.zeros_like(xyz) + f_dc = pc._features_dc.detach().transpose(1, 2).flatten(start_dim=1).contiguous().cpu()[indices_mask].numpy() + f_rest = pc._features_rest.detach().transpose(1, 2).flatten(start_dim=1).contiguous().cpu()[indices_mask].numpy() + opacities = pc._opacity.detach().cpu()[indices_mask].numpy() + scale = pc._scaling.detach().cpu()[indices_mask].numpy() + rotation = pc._rotation.detach().cpu()[indices_mask].numpy() + dtype_full = [(attribute, 'f4') for attribute in pc.construct_list_of_attributes()] + elements = np.empty(xyz.shape[0], dtype=dtype_full) + attributes = np.concatenate((xyz, normals, f_dc, f_rest, opacities, scale, rotation), axis=1) + elements[:] = list(map(tuple, attributes)) + el = PlyElement.describe(elements, 'vertex') + PlyData([el]).write(save_path) + +# endregion + + + + + + +class GradioAnnotationTool: + def __init__(self, model_path, predictor): + self.predictor = predictor + if model_path is not None: self.load_gaussian_scene(model_path) + else: + self.scene = None + self.args = None + self.dataset = None + self.images = {} + self.sam_features = {} + self.current_image = None + + self.saved_fg_path = None + self.saved_bg_path = None + + self.maskid = 0 # 将maskid移动到类实例变量 + self.clear_all_mark() + + def load_gaussian_scene(self, model_path, progress:gr.Progress=None): + global pipeline + global background + + if self.scene is not None: del self.scene + if self.seg2d_mark is not None: del self.seg2d_mark + if self.multiview_mask is not None: del self.multiview_mask + + print("Loading Gaussian Scene") + if progress is not None: progress(0, desc="Get Args") + + parser = ArgumentParser(description="Testing script parameters") + model = ModelParams(parser, sentinel=True) + pipeline = PipelineParams(parser) # 渲染用 + + parser.add_argument("--iteration", default=-1, type=int) + parser.add_argument("--skip_train", action="store_true") + parser.add_argument("--skip_test", action="store_true") + parser.add_argument("--quiet", action="store_true") + parser.add_argument("--threshold", default=0.7, type=float, help='threshold of label voting') + parser.add_argument("--gd_interval", default=20, type=int, help='interval of performing gaussian decomposition') + self.args = get_combined_args(parser, model_path) + + self.dataset = model.extract(self.args) + self.dataset.model_path = self.args.model_path + + if progress is not None: progress(0.1, desc="Load Gaussian Scenes") + gaussians = GaussianModel(self.dataset.sh_degree) + self.scene = Scene(self.dataset, gaussians, load_iteration=self.args.iteration, shuffle=False) + self.dataset.white_background = True + bg_color = [1,1,1] if self.dataset.white_background else [0, 0, 0] + background = torch.tensor(bg_color, dtype=torch.float32, device="cuda") + + if progress is not None: progress(0.4, desc="Rendering Images") + self.images = {} + for view in self.scene.getTrainCameras(): + render_pkg = render(view, self.scene.gaussians, pipeline, background) + render_image = render_pkg["render"].permute(1, 2, 0).detach().cpu().numpy() + render_image = (255 * np.clip(render_image, 0, 1)).astype(np.uint8) + self.images[view.image_name] = render_image + + if progress is not None: progress(0.7, desc="Get Sam Features") + self.sam_features = extract_sam_features_pt(model_path, self.predictor, self.scene.getTrainCameras(), self.scene.gaussians) + self.current_image = list(self.images.keys())[0] + self.predictor.set_image(self.images[self.current_image]) + self.clear_all_mark() + print("加载完成") + if progress is not None: progress(1, desc="Finished") + + def load_scene_gaussians(self): + gaussians = GaussianModel(self.dataset.sh_degree) + gaussians.load_ply( + os.path.join(self.scene.model_path, + "point_cloud", + "iteration_" + str(self.scene.loaded_iter), + "point_cloud.ply")) + return gaussians + + def get_current_state(self): + mark = self.seg2d_mark[self.current_image] + return self.current_image, mark['points'] + + def add_point(self, evt: gr.SelectData, is_original=True): + """添加点，支持从原图或mask图添加""" + print(f"点击事件: {evt}") + if evt is None: + print("收到空的点击事件") + return self._render_original(), self._render_mask(), self._render_selected_mask() + + # 获取当前图片的标注数据 + mark = self.seg2d_mark[self.current_image] + x, y = evt.index + + # 添加新点 + print(f"add state: {self.current_image}, {mark['history_index']}, {len(mark['history'])}, {len(mark['points'])}, ({x},{y})") + mark['points'].append([x, y]) + mark["history_index"] += 1 + + # 如果场景存在，更新3D点标注 + if self.scene is not None: + self._update_3d_prompts() + + if len(mark['points']): self._get_mask() + self._save_state() + self._new_loaded = False + return self._render_original(), self._render_mask(), self._render_selected_mask() + + def undo(self): + """撤销当前图片的最后一次操作""" + mark = self.seg2d_mark[self.current_image] + print(f"undo state: {self.current_image}, {mark['history_index']}, {len(mark['history'])}, {len(mark['points'])}") + + # 检查是否有历史记录可撤销 + if mark['history_index'] > 0: # 此时若刚做了一次，为0 + mark['history_index'] -= 1 + prev_state = mark['history'][mark['history_index']] + mark['points'] = prev_state[0][:] + # 恢复3D点标注 + if len(prev_state) > 2 and prev_state[2] is not None: + mark['prompts_3D'] = prev_state[2].clone() if prev_state[2] is not None else empty_3D.clone() + else: + mark["points"] = [] + mark['prompts_3D'] = empty_3D.clone() + self._new_loaded = True + self._save_state() + + self._get_mask() + + # 如果场景存在，更新3D点标注 + if self.scene is not None and len(mark['points']): + self._update_3d_prompts() + + return self._render_original(), self._render_mask(), self._render_selected_mask() + + def redo(self): + """重做当前图片的操作""" + mark = self.seg2d_mark[self.current_image] + print(f"redo state: {self.current_image}, {mark['history_index']}, {len(mark['history'])}, {len(mark['points'])}") + + # 检查是否有历史记录可重做 + if mark['history_index'] < len(mark['history']) - 1: + mark['history_index'] += 1 + next_state = mark['history'][mark['history_index']] + mark['points'] = next_state[0][:] + # 恢复3D点标注 + if len(next_state) > 2 and next_state[2] is not None: + mark['prompts_3D'] = next_state[2].clone() if next_state[2] is not None else empty_3D.clone() + self._get_mask() + + # 如果场景存在，更新3D点标注 + if self.scene is not None and mark['points']: + self._update_3d_prompts() + + return self._render_original(), self._render_mask(), self._render_selected_mask() + + def set_mask_id(self, mask_id): + """设置当前选择的mask索引""" + self.maskid = mask_id + return self._render_selected_mask() + + def clear_current(self): + """清空当前图片的所有标注""" + mark = self.seg2d_mark[self.current_image] + mark['points'] = [] + mark['prompts_3D'] = empty_3D.clone() # 清空3D点标注 + self._save_state() + self._get_mask() + return self._render_original(), self._render_mask(), self._render_selected_mask() + + def clear_all_mark(self): + self.seg2d_mark = { + name: { + 'points': [], # 当前视角的点标注 + 'history': [], # 历史记录 [(points, masks), ...] + 'history_index': -1, # 历史记录索引，用于撤销/重做 + 'prompts_3D': empty_3D.clone() # 存储3D点标注 + } for name in self.images.keys() + } + self.multiview_mask = { + "records": [], # 每条记录结构如下（见下方）： + "current_index": -1 # 指向当前激活的记录，初始为 -1 表示无记录 + # records = { # 每次点击，根据不同的点击组合，会创建一个records结构。 + # "prompts": torch.Tensor([N, 3]), # 保存用于生成该记录的 3D 点 + # "mvmask": { + # maskid1: { + # "multiview": {...}, # multiview_masks (用于3D分割) + # "sam_masks": {...}, # multiview_sam_masks (用于3D分割) + # } + # } + # "sam_all": {img1_name: mask1, img2_name: mask2} # sam_mask_all_levels（用于可视化） + # } + } + self._new_loaded = True + + def clear_all(self): + self.clear_all_mark() + return self._render_original(), self._render_mask(), self._render_selected_mask() + + def _update_3d_prompts(self): + """更新当前图像的3D点标注""" + mark = self.seg2d_mark[self.current_image] + if not mark['points'] or self.scene is None: + mark['prompts_3D'] = empty_3D.clone() + return + + # 获取当前视角的相机 + current_camera = None + for camera in self.scene.getTrainCameras(): + if camera.image_name == self.current_image: + current_camera = camera + break + + if current_camera is None: + print(f"无法找到相机: {self.current_image}") + return + + # 获取场景中的高斯点 + xyz = self.scene.gaussians.get_xyz + + # 生成3D点标注 + prompts_3D = generate_3d_prompts(xyz, current_camera, mark['points']) + mark['prompts_3D'] = prompts_3D + + def update_image(self, image_name): # 切换图片调用函数 + self.current_image = image_name + return self._render_original(), self._render_mask(), self._render_selected_mask() + + def toggle_mask(self): + if self.masks[self.current_image] is not None: + self.masks[self.current_image] = None + elif self.points[self.current_image]: + self._get_mask() + return self._render_display() + + def generate_multiview_masks_batch(self, prompts_3D, text_prompt = None, progress:gr.Progress=None): + """ + sam_mask_all_levels (cuda) : list[torch.int64(id,H,W)] , 每个视角下的渲染图的sam mask + sam_masks (cuda) : list[torch.int64(H,W)] , 每个视角下的渲染图的sam mask + multiview_masks (cuda) : list[torch.int64(N,1)] , 每个视角下，每个Gaussians点的mask + """ + + # point guided, masks[id,H,W,C=1], 2D点标注 + def self_prompt_seg_torch(point_prompts, sam_feature): # point_prompts: torch([N,2]) + input_point = point_prompts[None, :, :] # Batch, N, 2 + input_label = torch.ones((input_point.shape[0],input_point.shape[1]), device=self.predictor.device) + + predictor.features = sam_feature + masks_torch_batch, _, _ = predictor.predict_torch( + point_coords=input_point, # [1,N,2] + point_labels=input_label, # [1,N] + multimask_output=True, + ) + masks_torch = masks_torch_batch[0] # [batch, id, H, W, C] + return_mask = (masks_torch[:, :, :, None]*255).to(torch.uint8) # [id,H,W,C=1] + return return_mask / 255 + + # point guided, masks[id,H,W,C=1], 2D点标注 + def self_prompt_seg_batch(point_prompts, sam_feature): + # point_prompts: torch([nCam, N,2]) + # sam_features : torch([nCam, C,H,W]) + input_point = point_prompts[None, :, :] # Batch, N, 2 + input_label = torch.ones((input_point.shape[0],input_point.shape[1]), device=self.predictor.device) + + predictor.features = sam_feature + masks_torch_batch, _, _ = predictor.predict_torch( + point_coords=input_point, # [1,N,2] + point_labels=input_label, # [1,N] + multimask_output=True, + ) + masks_torch = masks_torch_batch[0] # [batch, id, H, W, C] + return_mask = (masks_torch[:, :, :, None]*255).to(torch.uint8) # [id,H,W,C=1] + return return_mask / 255 + + scene = self.scene + images = self.images + mask_id = self.maskid + cameras = scene.getTrainCameras() + gaussians = scene.gaussians + sam_masks = [] + multiview_masks = [] + sam_mask_all_levels = [] + prompts_2ds = project_to_2d_batch(cameras, prompts_3D) # [nCameras, N, 2] + sam_features = torch.stack([self.sam_features[v.image_name] for v in cameras]) # [nCameras, C, H, W] + sam_mask_all_level = self_prompt_seg_torch(prompts_2d, self.sam_features[image_name]) + + for i, view in tqdm(enumerate(cameras), desc="generate multiview masks"): + image_name = view.image_name # added + prompts_2d = project_to_2d(view, prompts_3D) + sam_mask_all_level = self_prompt_seg_torch(prompts_2d, self.sam_features[image_name]) # torch([id=3,H,W,C=1]) + sam_mask_all_levels.append(sam_mask_all_level) + sam_mask = sam_mask_all_level[mask_id].long()[:,:,0] # torch[H,W] + sam_masks.append(sam_mask) + point_mask, indices_mask = mask_inverse(gaussians.get_xyz, view, sam_mask) # TODO: gaussians.get_xyz.require_grad=True; cuda,cuda,cuda + multiview_masks.append(point_mask.unsqueeze(-1)) + return sam_mask_all_levels, sam_masks, multiview_masks + + def generate_multiview_masks(self, prompts_3D, text_prompt = None, progress:gr.Progress=None): + """ + sam_mask_all_levels (cuda) : list[torch.int64(id,H,W)] , 每个视角下的渲染图的sam mask + sam_masks (cuda) : list[torch.int64(H,W)] , 每个视角下的渲染图的sam mask + multiview_masks (cuda) : list[torch.int64(N,1)] , 每个视角下，每个Gaussians点的mask + """ + + # point guided, masks[id,H,W,C=1], 2D点标注 + def self_prompt_seg_torch(point_prompts, sam_feature): # point_prompts: torch([N,2]) + input_point = point_prompts[None, :, :] # Batch, N, 2 + input_label = torch.ones((input_point.shape[0],input_point.shape[1]), device=self.predictor.device) + + predictor.features = sam_feature + masks_torch_batch, _, _ = predictor.predict_torch( + point_coords=input_point, # [1,N,2] + point_labels=input_label, # [1,N] + multimask_output=True, + ) + masks_torch = masks_torch_batch[0] # [batch, id, H, W, C] + return_mask = (masks_torch[:, :, :, None]*255).to(torch.uint8) # [id,H,W,C=1] + return return_mask / 255 + + scene = self.scene + images = self.images + mask_id = self.maskid + cameras = scene.getTrainCameras() + gaussians = scene.gaussians + sam_masks = [] + multiview_masks = [] + sam_mask_all_levels = [] + for i, view in tqdm(enumerate(cameras), desc="generate multiview masks"): + image_name = view.image_name # added + prompts_2d = project_to_2d(view, prompts_3D) + sam_mask_all_level = self_prompt_seg_torch(prompts_2d, self.sam_features[image_name]) # torch([id=3,H,W,C=1]) + sam_mask_all_levels.append(sam_mask_all_level) + sam_mask = sam_mask_all_level[mask_id].long()[:,:,0] # torch[H,W] + sam_masks.append(sam_mask) + point_mask, indices_mask = mask_inverse(gaussians.get_xyz, view, sam_mask) # TODO: gaussians.get_xyz.require_grad=True; cuda,cuda,cuda + multiview_masks.append(point_mask.unsqueeze(-1)) + return sam_mask_all_levels, sam_masks, multiview_masks + + scene = self.scene + images = self.images + mask_id = self.maskid + cameras = scene.getTrainCameras() + gaussians = scene.gaussians + sam_masks = [] + multiview_masks = [] + sam_mask_all_levels = [] + + for i, view in tqdm(enumerate(cameras), desc="generate multiview masks"): + image_name = view.image_name # added + if text_prompt is not None: + render_image = images[image_name] # added + render_image = (255 * np.clip(render_image, 0, 1)).astype(np.uint8) + sam_mask_all_level = text_prompt_seg(render_image, text_prompt) + else: + prompts_2d = project_to_2d(view, prompts_3D) + sam_mask_all_level = self_prompt_seg(prompts_2d, self.sam_features[image_name]) # [id,H,W,C=1] + + sam_mask_all_levels.append(sam_mask_all_level) + + sam_mask = sam_mask_all_level[mask_id] + if len(sam_mask.shape) != 2: sam_mask = torch.from_numpy(sam_mask).squeeze(-1).to("cuda") + else: sam_mask = torch.from_numpy(sam_mask).to("cuda") + sam_mask = sam_mask.long() # 2D mask image [H,W] -> value + sam_masks.append(sam_mask) + + point_mask, indices_mask = mask_inverse(gaussians.get_xyz, view, sam_mask) + multiview_masks.append(point_mask.unsqueeze(-1)) + return sam_mask_all_levels, sam_masks, multiview_masks + + def _match_current_index_from_record(self): + # 收集prompts_3D + prompts_3D_list = [] + for img_name in self.images.keys(): + prompts_3D = self.seg2d_mark[img_name]['prompts_3D'] # torch.Tensor[N,3] + if prompts_3D.shape[0] > 0: # 检查是否有3D点标注 + prompts_3D_list.append(prompts_3D) + + if prompts_3D_list: prompts_3D_tensor = torch.cat(prompts_3D_list, dim=0) # [M,3] + else: prompts_3D_tensor = torch.empty((0, 3), dtype=torch.float32, device="cuda") + + def _is_same_prompt(p1, p2, tol=1e-5): + if p1.shape != p2.shape: return False + p1_sorted = torch.sort(p1, dim=0)[0] + p2_sorted = torch.sort(p2, dim=0)[0] + return torch.allclose(p1_sorted, p2_sorted, atol=tol) + + for index, rec in enumerate(self.multiview_mask["records"]): + if _is_same_prompt(rec["prompts"], prompts_3D_tensor): + return prompts_3D_tensor, index + return prompts_3D_tensor, None + + def _get_multilayer_mask(self, img_name): + if self._new_loaded: return None + return self.multiview_mask["records"][self._get_mask()]["sam_all"].get(img_name) + + def _get_mask(self, match_mask_id = False, progress:gr.Progress=None): + """ + 根据prompts_3D和maskid作为索引，保存multiview_sam_masks, multiview_masks + 根据prompts_3D作为索引，保存sam_mask_all_level + 其中prompts_3D为[N,3]的3D点集，索引过程中不需要保证点集顺序一致，对于十分相近的点认为是同一个点。 + 历史记录不再依赖栈结构，而是点集匹配。 + + sam_mask_all_level : 用于显示,不需要mask_id(显示时做筛选) + multiview_sam_masks: 是选中的mask,用于3D分割,需要mask_id + multiview_masks : 是3D点的mask,用于3D分割,需要mask_id + """ + if progress is not None: progress(0, desc="prepare Prompt 3D") + prompts_3D_tensor, matched_index = self._match_current_index_from_record() + + # --- 若找到记录且包含当前 maskid，直接复用 --- + if matched_index is not None and (not match_mask_id or self.maskid in self.multiview_mask["records"][matched_index]["mvmask"]): + self.multiview_mask["current_index"] = matched_index + return matched_index + + # --- 没有命中，生成新的 --- + else: + sam_alls, sam_masks, multiviews = self.generate_multiview_masks(prompts_3D_tensor, progress=progress) + print("multiview_masks generated\n") + + # 组装 sam_all 字典 + sam_all_dict = { + img: m.squeeze(-1) if m is not None else None + for img, m in zip(self.images.keys(), sam_alls) # img_name -> torch.tensor(id,H,W), 仅显示时转numpy + } + + # --- 写入记录 --- + if matched_index is not None: + record = self.multiview_mask["records"][matched_index] + else: + record = {"prompts": prompts_3D_tensor, "mvmask": {}, "sam_all": sam_all_dict} + self.multiview_mask["records"].append(record) + matched_index = len(self.multiview_mask["records"]) - 1 + + record["mvmask"][self.maskid] = { + "multiview": multiviews, + "sam_masks": sam_masks, + } + record["sam_all"] = sam_all_dict + self.multiview_mask["current_index"] = matched_index + log() + return matched_index + + def _save_state(self): + """保存当前状态到历史记录""" + mark = self.seg2d_mark[self.current_image] + + # 创建当前状态的副本，不再包含maskid + current_state = ( + mark['points'][:] if mark['points'] else [], # list[N,2] -> int + mark['prompts_3D'].clone() if 'prompts_3D' in mark else empty_3D.clone() # Tensor[N,3] + ) + + # 如果当前不是在历史记录的最后，则截断历史记录 + if mark['history_index'] < len(mark['history']) - 1: + mark['history'] = mark['history'][:mark['history_index'] + 1] + + # 添加当前状态到历史记录 + mark['history'].append(current_state) + mark['history_index'] = len(mark['history']) - 1 + + def _render_original(self): + """渲染原始图像，只显示点标注""" + img = self.images[self.current_image].copy() + mark = self.seg2d_mark[self.current_image] + + # 确保img是3通道图像 + if len(img.shape) == 2: + img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR) + + # 绘制点 + for i, (x, y) in enumerate(mark['points']): + # 先绘制黑色边框增加对比度 + cv2.circle(img, (x, y), 8, (0, 0, 0), -1) + # 再绘制亮色内部 + cv2.circle(img, (x, y), 6, (0, 255, 255), -1) + # 添加数字标签，带黑色边框增加可读性 + cv2.putText(img, str(i+1), (x+10, y+10), + cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 0), 3) + cv2.putText(img, str(i+1), (x+10, y+10), + cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 1) + + return img + + def _render_mask(self): + """渲染带有mask的图像，不包含图例""" + img = self.images[self.current_image].copy() + mark = self.seg2d_mark[self.current_image] + + if len(img.shape) == 2: img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR) + try: + mask_multilayer = self._get_multilayer_mask(self.current_image).cpu().numpy() + mask_colors = [ + np.array([255, 50, 50]), # R + np.array([50, 255, 50]), # G + np.array([50, 50, 255]) # B + ] + mask_color_strength = 0.6 # [0,1] + combined_mask = np.zeros_like(img) + priority_mask = np.ones(img.shape[:2], dtype=np.int32) * 999 + masks_count = min(len(mask_multilayer), len(mask_colors)) + for i in range(masks_count): + mask = mask_multilayer[i] + mask_area = mask > 0.5 + valid_area = np.logical_and(mask_area, priority_mask > i) + if np.any(valid_area): + priority_mask[valid_area] = i + combined_mask[valid_area] = mask_colors[i] * mask_color_strength + img[valid_area] * (1-mask_color_strength) + mask_any = np.any(combined_mask > 0, axis=2) + img[mask_any] = combined_mask[mask_any] + + except Exception as e: + print(f"Mask invalid: {self.current_image}") + print(e) + + for i, (x, y) in enumerate(mark['points']): + cv2.circle(img, (x, y), 8, (0, 0, 0), -1) + cv2.circle(img, (x, y), 6, (0, 255, 255), -1) + cv2.putText(img, str(i+1), (x+10, y+10), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 0), 3) + cv2.putText(img, str(i+1), (x+10, y+10), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 1) + + return img + + def _render_selected_mask(self): + """渲染选中的单个mask应用到原图的效果""" + img = self.images[self.current_image].copy() + if len(img.shape) == 2: img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR) + try: + mask_multilayer = self._get_multilayer_mask(self.current_image).cpu().numpy() + mask_id = self.maskid + if mask_id < len(mask_multilayer): + mask = mask_multilayer[mask_id] + mask_area = mask > 0.5 + mask_colors = [ + np.array([255, 50, 50]), # R + np.array([50, 255, 50]), # G + np.array([50, 50, 255]) # B + ] + mask_color = mask_colors[mask_id % len(mask_colors)] + mask_color_strength = 0.6 + + if np.any(mask_area): + img[mask_area] = mask_color * mask_color_strength + img[mask_area] * (1-mask_color_strength) + except Exception as e: + print(f"Mask invalid: {self.current_image}") + print(e) + return img + + ## Multi-view label voting 多视角（multi-view）标签投票融合 + def ensemble(self, threshold=0.7): + multiview_masks = self.multiview_mask["records"][self.multiview_mask["current_index"]]["mvmask"][self.maskid]["multiview"] + multiview_masks = torch.cat(multiview_masks, dim=1) + vote_labels,_ = torch.mode(multiview_masks, dim=1) + # # select points with score > threshold + matches = torch.eq(multiview_masks, vote_labels.unsqueeze(1)) + ratios = torch.sum(matches, dim=1) / multiview_masks.shape[1] + ratios_mask = ratios > threshold + labels_mask = (vote_labels == 1) & ratios_mask + indices_mask = torch.where(labels_mask)[0].detach().cpu() + + return vote_labels, indices_mask + + def seg_gaussian(self, threshold, object_name, progress:gr.Progress = None): + if progress is not None: progress(0, desc="load gaussians and mask") + self._get_mask(match_mask_id=True, progress=progress) # 需要match maskid + model_path = self.scene.model_path + gaussians = self.scene.gaussians + _, final_mask = self.ensemble(threshold) + cameras = self.scene.getTrainCameras() + if progress is not None: progress(0.1, desc="gaussian multiview decomp") + + self.saved_fg_path = os.path.join(model_path, f'objects/{object_name}/fg.ply') + os.makedirs(os.path.dirname(self.saved_fg_path), exist_ok=True) + save_gs(gaussians, final_mask, self.saved_fg_path) + if progress is not None: progress(0.3, desc="gaussian multiview decomp") + + # if gaussian decomposition as a post-process module + de_gaussian = self.load_scene_gaussians() + for i, view in tqdm(enumerate(cameras), desc="gaussian multiview decomp"): + if self.args.gd_interval != -1 and i % self.args.gd_interval == 0: + input_mask = self.multiview_mask["records"][self.multiview_mask["current_index"]]["mvmask"][self.maskid]["sam_masks"][i] + de_gaussian = gaussian_decomp(de_gaussian, view, input_mask, final_mask.to('cuda')) + if progress is not None: progress(0.5, desc="render segged gaussian") + + # save after gaussian decomposition + self.saved_bg_path = os.path.join(model_path, f'objects/{object_name}/bg.ply') + save_gs(de_gaussian, final_mask, self.saved_fg_path+"2.ply") + if progress is not None: progress(0.7, desc="render segged gaussian") + + # render object images + seg_gaussians = GaussianModel(self.dataset.sh_degree) + seg_gaussians.load_ply(self.saved_fg_path) + if progress is not None: progress(0.8, desc="render segged gaussian") + + obj_save_path = os.path.join(model_path, f'objects/{object_name}/images') + os.makedirs(obj_save_path, exist_ok=True) + + if not os.path.exists(obj_save_path): os.mkdir(obj_save_path) + for idx in tqdm(range(len(cameras)), desc="render segged gaussian"): + image_name = cameras[idx].image_name + view = cameras[idx] + + render_pkg = render(view, seg_gaussians, pipeline, background) + # get sam output mask + render_image = render_pkg["render"].permute(1, 2, 0).detach().cpu().numpy() + render_image = (255 * np.clip(render_image, 0, 1)).astype(np.uint8) + render_image = cv2.cvtColor(render_image, cv2.COLOR_RGB2BGR) + cv2.imwrite(os.path.join(obj_save_path, '{}.jpg'.format(image_name)), render_image) + seg_gaussians.save_ply(os.path.join(model_path, f'objects/{object_name}/seg.ply')) + if progress is not None: progress(1, desc="Finished") + + + +def create_gradio_interface(default_model_paths, predictor): + tool = GradioAnnotationTool(model_path=None, predictor=predictor) + + with gr.Blocks() as demo: + with gr.Row(): + with gr.Column(scale=1): + with gr.Row(): + original_display = gr.Image(label="Origin", interactive=False) + with gr.Row(): + undo_btn = gr.Button("Undo") + redo_btn = gr.Button("Redo") + with gr.Column(scale=1): + with gr.Row(): + mask_display = gr.Image(label="Layer Mask", interactive=False) + with gr.Row(): + cls_cur_btn = gr.Button("Clear Curr View Marks") + cls_all_btn = gr.Button("Clear All Views Marks") + with gr.Column(scale=1): + with gr.Row(): + selected_mask_display = gr.Image(label="Mask Result", interactive=False) + with gr.Row(): + mask_selector = gr.Radio( + choices=["S", "M", "L"], + label="Select Mask", + value="S", + interactive=True + ) + with gr.Row() as prompt_col: + with gr.Column(scale=1): + model_path_input = gr.Dropdown( + choices=default_model_paths, + allow_custom_value=True, + value="", + show_label=False, + interactive=True, + ) + with gr.Column(scale=0.5): + model_path_btn = gr.Button("Open Model") + with gr.Column(scale=1): + object_name_input = gr.Textbox(placeholder="Your Object Name", show_label=False, interactive=True, submit_btn="Seg!") + + with gr.Row(): + with gr.Column(scale=2): + gallery = gr.Gallery( + label="Gallery", + value=[tool.images[k] for k in sorted(tool.images.keys(), key=lambda x: int(x) if x.isdigit() else x)], + columns=4, + object_fit="contain", + height="auto" + ) + with gr.Column(scale=1): + with gr.Row(): fg_gs = LitModel3D(label="Foreground", exposure=10.0, height=300) + with gr.Row(): download_fg_gs = gr.DownloadButton(label="Download", interactive=False) + # with gr.Column(scale=1): + # with gr.Row(): bg_gs = LitModel3D(label="Background", exposure=10.0, height=300) + # with gr.Row(): download_bg_gs = gr.DownloadButton(label="Download", interactive=False) + + # 处理mask选择 + def on_mask_select(choice): + if choice == "S": mask_id = 0 + elif choice == "M": mask_id = 1 + elif choice == "L": mask_id = 2 + + # 调用set_mask_id方法并返回最右侧图像 + selected_mask = tool.set_mask_id(mask_id) + return selected_mask + + # 获取可用的mask选项 + def get_available_mask_choices(tool): + # mark = tool.seg2d_mark[tool.current_image] + # if tool._get_multilayer_mask() is None: return ["S"] + # mask_names = ["S", "M", "L"] + # return mask_names[:len(tool._get_multilayer_mask())] + return ["S", "M", "L"] + + # 修改add_point方法的返回值，使用新的API更新Radio组件 + def add_point_from_original(evt: gr.SelectData): + orig, mask, selected = tool.add_point(evt, is_original=True) + # 获取当前可用的mask选项，保持mask选择 + available_masks = get_available_mask_choices(tool) + mask_id = tool.maskid # 使用类实例变量 + if mask_id >= len(available_masks): mask_id = len(available_masks)-1 + return orig, mask, selected, gr.update(choices=available_masks, value=available_masks[mask_id] if available_masks else None) + + def add_point_from_mask(evt: gr.SelectData): + orig, mask, selected = tool.add_point(evt, is_original=False) + # 获取当前可用的mask选项，保持mask选择 + available_masks = get_available_mask_choices(tool) + mask_id = tool.maskid # 使用类实例变量 + if mask_id >= len(available_masks): mask_id = len(available_masks)-1 + return orig, mask, selected, gr.update(choices=available_masks, value=available_masks[mask_id] if available_masks else None) + + def load_with_progress(model_path, progress=gr.Progress(track_tqdm=True)): + torch.cuda.empty_cache() + tool.load_gaussian_scene(model_path, progress=progress) + orig = tool._render_original() + mask = tool._render_mask() + selected = tool._render_selected_mask() + available_masks = get_available_mask_choices(tool) + return \ + gr.update(value = list(tool.images.values())),\ + orig, mask, selected, \ + gr.update(choices=available_masks, value=available_masks[0] if available_masks else None) + + model_path_btn.click( + fn=load_with_progress, + inputs=model_path_input, + outputs=[gallery, original_display, mask_display, selected_mask_display, mask_selector], + ) + + # 使用select事件，更新输出包含mask选择器 + original_display.select( + fn=add_point_from_original, + outputs=[original_display, mask_display, selected_mask_display, mask_selector] + ) + + mask_display.select( + fn=add_point_from_mask, + outputs=[original_display, mask_display, selected_mask_display, mask_selector] + ) + + # Mask选择事件 + mask_selector.change( + fn=on_mask_select, + inputs=[mask_selector], + outputs=[selected_mask_display] + ) + + # 其他按钮事件 + undo_btn.click(fn=lambda: tool.undo(), outputs=[original_display, mask_display, selected_mask_display]) + redo_btn.click(fn=lambda: tool.redo(), outputs=[original_display, mask_display, selected_mask_display]) + cls_cur_btn.click(fn=tool.clear_current, outputs=[original_display, mask_display, selected_mask_display]) + cls_all_btn.click(fn=tool.clear_all, outputs=[original_display, mask_display, selected_mask_display]) + + + # 添加弹出窗口和状态提示功能 + def seg_gaussian_with_prompt(object_name, progress=gr.Progress(track_tqdm=True)): + # 更新文本框状态为处理中 + yield gr.update(value=f"Processing: '{object_name}'...", interactive=False) + tool.seg_gaussian(threshold=0.7, object_name=object_name, progress=None) + yield gr.update(value=object_name, placeholder="Your Object Name", interactive=True) + + object_name_input.submit( # 保存Gaussian + fn=seg_gaussian_with_prompt, + inputs=object_name_input, + outputs=[object_name_input] + ).then( # 显示Gaussian + fn=lambda: tool.saved_fg_path, + outputs=[fg_gs] + ).then( + fn = lambda: gr.DownloadButton.update(value=tool.saved_fg_path, interactive=True), + outputs=[download_fg_gs], + ) + + # Gallery选择事件处理 + def on_gallery_select(evt: gr.SelectData): + try: + index = evt.index + image_name = list(tool.images.keys())[index] + orig, mask, selected = tool.update_image(image_name) + # 获取当前可用的mask选项，保持mask选择 + available_masks = get_available_mask_choices(tool) + mask_id = tool.maskid # 使用类实例变量 + if mask_id >= len(available_masks): mask_id = len(available_masks)-1 + return orig, mask, selected, gr.update(choices=available_masks, value=available_masks[mask_id] if available_masks else None) + except Exception as e: + print(f"Error while select in gallery: {e}") + orig = tool._render_original() + mask = tool._render_mask() + selected = tool._render_selected_mask() + return orig, mask, selected, gr.update(choices=["S"]) + + gallery.select(fn=on_gallery_select, outputs=[original_display, mask_display, selected_mask_display, mask_selector]) + + # 初始显示 + def init_display(): + orig, mask, selected = None, None, None + available_masks = get_available_mask_choices(tool) + return orig, mask, selected, gr.update(choices=available_masks, value=available_masks[0] if available_masks else None) + + demo.load(fn=init_display, outputs=[original_display, mask_display, selected_mask_display, mask_selector]) + + return demo + + + +# I'm using this for trellis model segmentation +# As it's a Y-Up generation model +# output model would be lying down. + + +def find_model_folders(base_path, relative_to="."): + model_paths = [] + if os.path.exists(base_path): + # 如果relative_to是None,则相对于当前目录 + if relative_to is None: relative_to = "." + for root, dirs, files in os.walk(base_path): + if os.path.basename(root) == "model": + # 获取相对于relative_to的路径 + rel_path = os.path.relpath(root, relative_to) + model_paths.append(rel_path) + return model_paths + +if __name__ == "__main__": + + # with profile(on_trace_ready=torch.profiler.tensorboard_trace_handler('./log')) as prof: + base_dir = "../TRELLIS/results" + default_model_paths = find_model_folders(base_dir) + + predictor = load_sam() + + # 创建并启动Gradio界面，传入预先提取的特征和场景 + demo = create_gradio_interface(default_model_paths, predictor) + demo.launch(server_name="0.0.0.0", server_port=None, + allowed_paths = ["./", base_dir]) + From d53bca9bb78fdcfe9721f26d347f6b9a59a15605 Mon Sep 17 00:00:00 2001 From: MrHandsomeljn <1205197328@qq.com> Date: Fri, 2 May 2025 13:07:53 +0800 Subject: [PATCH 8/9] fixed large GPUMem usage --- app.py | 79 ++--- app2.py | 978 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 996 insertions(+), 61 deletions(-) create mode 100644 app2.py diff --git a/app.py b/app.py index 88c1adf..988d991 100644 --- a/app.py +++ b/app.py @@ -150,9 +150,8 @@ def project_to_2d_batch(viewpoint_cameras, points3D) -> torch.Tensor: # C,N,2 point_image = torch.round(point_image) return point_image # 返回[C, N, 2]张量，C为相机数量，N为点数量 -def project_to_2d(viewpoint_camera, points3D): # TODO: 做一个batch版本的 +def project_to_2d(viewpoint_camera, points3D): # N,2 full_matrix = viewpoint_camera.full_proj_transform # torch.cuda, w2c @ K - # project to image plane if points3D.shape[-1] != 4: points3D = F.pad(input=points3D, pad=(0, 1), mode='constant', value=1) p_hom = (points3D @ full_matrix).transpose(0, 1) # N, 4 -> 4, N -1 ~ 1 @@ -237,7 +236,6 @@ def mask_inverse(xyz, viewpoint_camera, sam_mask): point_image = project_to_2d(viewpoint_camera, xyz) # torch([N,2]) point_image = point_image.long() - # 判断x,y是否在图像范围之内 valid_x = (point_image[:, 0] >= 0) & (point_image[:, 0] < w) valid_y = (point_image[:, 1] >= 0) & (point_image[:, 1] < h) valid_mask = valid_x & valid_y & valid_depth # [N]=bool @@ -307,7 +305,7 @@ def __init__(self, model_path, predictor): self.saved_fg_path = None self.saved_bg_path = None - self.maskid = 0 # 将maskid移动到类实例变量 + self.maskid = 0 self.clear_all_mark() def load_gaussian_scene(self, model_path, progress:gr.Progress=None): @@ -377,13 +375,9 @@ def add_point(self, evt: gr.SelectData, is_original=True): if evt is None: print("收到空的点击事件") return self._render_original(), self._render_mask(), self._render_selected_mask() - - # 获取当前图片的标注数据 mark = self.seg2d_mark[self.current_image] x, y = evt.index - - # 添加新点 - print(f"add state: {self.current_image}, {mark['history_index']}, {len(mark['history'])}, {len(mark['points'])}, ({x},{y})") + print(f"On Add Point: curr_image={self.current_image}, hist_idx={mark['history_index']}, hist_len={len(mark['history'])}, nPoint={len(mark['points'])}, point=({x},{y})") mark['points'].append([x, y]) mark["history_index"] += 1 @@ -399,7 +393,7 @@ def add_point(self, evt: gr.SelectData, is_original=True): def undo(self): """撤销当前图片的最后一次操作""" mark = self.seg2d_mark[self.current_image] - print(f"undo state: {self.current_image}, {mark['history_index']}, {len(mark['history'])}, {len(mark['points'])}") + print(f"On Undo: {self.current_image}, {mark['history_index']}, {len(mark['history'])}, {len(mark['points'])}") # 检查是否有历史记录可撤销 if mark['history_index'] > 0: # 此时若刚做了一次，为0 @@ -423,7 +417,7 @@ def undo(self): def redo(self): """重做当前图片的操作""" mark = self.seg2d_mark[self.current_image] - print(f"redo state: {self.current_image}, {mark['history_index']}, {len(mark['history'])}, {len(mark['points'])}") + print(f"On Redo: {self.current_image}, {mark['history_index']}, {len(mark['history'])}, {len(mark['points'])}") # 检查是否有历史记录可重做 if mark['history_index'] < len(mark['history']) - 1: @@ -465,7 +459,7 @@ def clear_all_mark(self): self.record = { # 每次点击，根据不同的点击组合，会创建一个record结构。 "prompts": None, # torch.Tensor([N, 3]), 保存用于生成该记录的 3D 点 "mvmask": { - # maskid1: { + # maskid: { # 0, 1, 2 # "multiview": {...}, # multiview_masks (用于3D分割) # "sam_masks": {...}, # multiview_sam_masks (用于3D分割) # } @@ -479,13 +473,11 @@ def clear_all(self): return self._render_original(), self._render_mask(), self._render_selected_mask() def _update_3d_prompts(self): - """更新当前图像的3D点标注""" mark = self.seg2d_mark[self.current_image] if not mark['points'] or self.scene is None: mark['prompts_3D'] = empty_3D.clone() return - # 获取当前视角的相机 current_camera = None for camera in self.scene.getTrainCameras(): if camera.image_name == self.current_image: @@ -493,17 +485,13 @@ def _update_3d_prompts(self): break if current_camera is None: - print(f"无法找到相机: {self.current_image}") + print(f"找不到当前视角对应相机: {self.current_image}") return - - # 获取场景中的高斯点 xyz = self.scene.gaussians.get_xyz - - # 生成3D点标注 prompts_3D = generate_3d_prompts(xyz, current_camera, mark['points']) mark['prompts_3D'] = prompts_3D - def update_image(self, image_name): # 切换图片调用函数 + def update_image(self, image_name): self.current_image = image_name return self._render_original(), self._render_mask(), self._render_selected_mask() @@ -582,7 +570,6 @@ def generate_multiview_masks(self, prompts_3D, text_prompt = None, progress:gr.P sam_masks (cuda) : list[torch.int64(H,W)] , 每个视角下的渲染图的sam mask multiview_masks (cuda) : list[torch.int64(N,1)] , 每个视角下，每个Gaussians点的mask """ - # point guided, masks[id,H,W,C=1], 2D点标注 def self_prompt_seg_torch(point_prompts, sam_feature): # point_prompts: torch([N,2]) input_point = point_prompts[None, :, :] # Batch, N, 2 @@ -667,8 +654,7 @@ def _get_mask(self, progress:gr.Progress=None): prompts_3D_list = [] for img_name in self.images.keys(): prompts_3D = self.seg2d_mark[img_name]['prompts_3D'] # torch.Tensor[N,3] - if prompts_3D.shape[0] > 0: # 检查是否有3D点标注 - prompts_3D_list.append(prompts_3D) + if prompts_3D.shape[0] > 0: prompts_3D_list.append(prompts_3D) # 检查是否有3D点标注 if prompts_3D_list: prompts_3D_tensor = torch.cat(prompts_3D_list, dim=0) # [M,3] else: prompts_3D_tensor = torch.empty((0, 3), dtype=torch.float32, device="cuda") @@ -690,20 +676,14 @@ def _get_mask(self, progress:gr.Progress=None): return def _save_state(self): - """保存当前状态到历史记录""" + """保存当前标注到历史记录""" mark = self.seg2d_mark[self.current_image] - - # 创建当前状态的副本，不再包含maskid current_state = ( mark['points'][:] if mark['points'] else [], # list[N,2] -> int mark['prompts_3D'].clone() if 'prompts_3D' in mark else empty_3D.clone() # Tensor[N,3] ) - - # 如果当前不是在历史记录的最后，则截断历史记录 if mark['history_index'] < len(mark['history']) - 1: mark['history'] = mark['history'][:mark['history_index'] + 1] - - # 添加当前状态到历史记录 mark['history'].append(current_state) mark['history_index'] = len(mark['history']) - 1 @@ -711,23 +691,12 @@ def _render_original(self): """渲染原始图像，只显示点标注""" img = self.images[self.current_image].copy() mark = self.seg2d_mark[self.current_image] - - # 确保img是3通道图像 - if len(img.shape) == 2: - img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR) - - # 绘制点 + if len(img.shape) == 2: img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR) for i, (x, y) in enumerate(mark['points']): - # 先绘制黑色边框增加对比度 cv2.circle(img, (x, y), 8, (0, 0, 0), -1) - # 再绘制亮色内部 cv2.circle(img, (x, y), 6, (0, 255, 255), -1) - # 添加数字标签，带黑色边框增加可读性 - cv2.putText(img, str(i+1), (x+10, y+10), - cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 0), 3) - cv2.putText(img, str(i+1), (x+10, y+10), - cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 1) - + cv2.putText(img, str(i+1), (x+10, y+10), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 0), 3) + cv2.putText(img, str(i+1), (x+10, y+10), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 1) return img def _render_mask(self): @@ -801,7 +770,6 @@ def ensemble(self, threshold=0.7): multiview_masks = self.record["mvmask"][self.maskid]["multiview"] multiview_masks = torch.cat(multiview_masks, dim=1) vote_labels,_ = torch.mode(multiview_masks, dim=1) - # # select points with score > threshold matches = torch.eq(multiview_masks, vote_labels.unsqueeze(1)) ratios = torch.sum(matches, dim=1) / multiview_masks.shape[1] ratios_mask = ratios > threshold @@ -851,7 +819,6 @@ def seg_gaussian(self, threshold, object_name, progress:gr.Progress = None): view = cameras[idx] render_pkg = render(view, seg_gaussians, pipeline, background) - # get sam output mask render_image = render_pkg["render"].permute(1, 2, 0).detach().cpu().numpy() render_image = (255 * np.clip(render_image, 0, 1)).astype(np.uint8) render_image = cv2.cvtColor(render_image, cv2.COLOR_RGB2BGR) @@ -888,6 +855,7 @@ def create_gradio_interface(default_model_paths, predictor): value="S", interactive=True ) + with gr.Row() as prompt_col: with gr.Column(scale=1.5): model_path_input = gr.Dropdown( @@ -929,7 +897,6 @@ def on_mask_select(choice): selected_mask = tool.set_mask_id(mask_id) return selected_mask - # 获取可用的mask选项 def get_available_mask_choices(tool): # mark = tool.seg2d_mark[tool.current_image] # if tool._get_multilayer_mask() is None: return ["S"] @@ -937,20 +904,17 @@ def get_available_mask_choices(tool): # return mask_names[:len(tool._get_multilayer_mask())] return ["S", "M", "L"] - # 修改add_point方法的返回值，使用新的API更新Radio组件 def add_point_from_original(evt: gr.SelectData): orig, mask, selected = tool.add_point(evt, is_original=True) - # 获取当前可用的mask选项，保持mask选择 available_masks = get_available_mask_choices(tool) - mask_id = tool.maskid # 使用类实例变量 + mask_id = tool.maskid if mask_id >= len(available_masks): mask_id = len(available_masks)-1 return orig, mask, selected, gr.update(choices=available_masks, value=available_masks[mask_id] if available_masks else None) def add_point_from_mask(evt: gr.SelectData): orig, mask, selected = tool.add_point(evt, is_original=False) - # 获取当前可用的mask选项，保持mask选择 available_masks = get_available_mask_choices(tool) - mask_id = tool.maskid # 使用类实例变量 + mask_id = tool.maskid if mask_id >= len(available_masks): mask_id = len(available_masks)-1 return orig, mask, selected, gr.update(choices=available_masks, value=available_masks[mask_id] if available_masks else None) @@ -972,7 +936,6 @@ def load_with_progress(model_path, progress=gr.Progress(track_tqdm=True)): outputs=[gallery, original_display, mask_display, selected_mask_display, mask_selector], ) - # 使用select事件，更新输出包含mask选择器 original_display.select( fn=add_point_from_original, outputs=[original_display, mask_display, selected_mask_display, mask_selector] @@ -983,23 +946,18 @@ def load_with_progress(model_path, progress=gr.Progress(track_tqdm=True)): outputs=[original_display, mask_display, selected_mask_display, mask_selector] ) - # Mask选择事件 mask_selector.change( fn=on_mask_select, inputs=[mask_selector], outputs=[selected_mask_display] ) - # 其他按钮事件 undo_btn.click(fn=lambda: tool.undo(), outputs=[original_display, mask_display, selected_mask_display]) redo_btn.click(fn=lambda: tool.redo(), outputs=[original_display, mask_display, selected_mask_display]) cls_cur_btn.click(fn=tool.clear_current, outputs=[original_display, mask_display, selected_mask_display]) cls_all_btn.click(fn=tool.clear_all, outputs=[original_display, mask_display, selected_mask_display]) - - # 添加弹出窗口和状态提示功能 def seg_gaussian_with_prompt(object_name, progress=gr.Progress(track_tqdm=True)): - # 更新文本框状态为处理中 yield gr.update(value=f"Processing: '{object_name}'...", interactive=False) tool.seg_gaussian(threshold=0.7, object_name=object_name, progress=None) yield gr.update(value=object_name, placeholder="Your Object Name", interactive=True) @@ -1012,7 +970,7 @@ def seg_gaussian_with_prompt(object_name, progress=gr.Progress(track_tqdm=True)) fn=lambda: tool.saved_fg_path, outputs=[fg_gs] ).then( - fn = lambda: gr.DownloadButton.update(value=tool.saved_fg_path, interactive=True), + fn = lambda: gr.update(value=tool.saved_fg_path, interactive=True), outputs=[download_fg_gs], ) @@ -1022,9 +980,8 @@ def on_gallery_select(evt: gr.SelectData): index = evt.index image_name = sorted(tool.images.keys(), key=lambda x: int(x) if x.isdigit() else x)[index] orig, mask, selected = tool.update_image(image_name) - # 获取当前可用的mask选项，保持mask选择 available_masks = get_available_mask_choices(tool) - mask_id = tool.maskid # 使用类实例变量 + mask_id = tool.maskid if mask_id >= len(available_masks): mask_id = len(available_masks)-1 return orig, mask, selected, gr.update(choices=available_masks, value=available_masks[mask_id] if available_masks else None) except Exception as e: diff --git a/app2.py b/app2.py new file mode 100644 index 0000000..54f2c27 --- /dev/null +++ b/app2.py @@ -0,0 +1,978 @@ +import gradio as gr +from typing import List, Tuple, Dict + +import os +import sys +import cv2 +import time +import torch + +import numpy as np +import torch.nn.functional as F +import torchvision.transforms.functional as func + +from tqdm import tqdm +from typing import Literal +from plyfile import PlyData, PlyElement +from argparse import ArgumentParser, Namespace + +from gaussiansplatting.scene import Scene +from gaussiansplatting.gaussian_renderer import render +from gaussiansplatting.scene.gaussian_model import GaussianModel +from gaussiansplatting.arguments import ModelParams, PipelineParams + +from seg_utils import grounding_dino_prompt +from seg_utils import conv2d_matrix, compute_ratios, update +from segment_anything import (SamAutomaticMaskGenerator, SamPredictor, + sam_model_registry) +from gradio_litmodel3d import LitModel3D +from torch.profiler import profile, record_function, ProfilerActivity + +from time import time +import datetime + +# 获取当前时间字符串的lambda函数 +current_time = lambda: datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") + +def log(): + with open(".log", "a+") as f: + f.write(f"{[current_time()]}") + f.write(torch.cuda.memory_summary()) + f.write("\n\n##########\n\n") + +pipeline, background = None, None +empty_3D = torch.zeros((0,3),device='cuda') + + +# region 加载Gaussian + +def get_combined_args(parser : ArgumentParser, model_path): + # cmdlne_string = sys.argv[1:] + # cfgfile_string = "Namespace()" + cmdlne_string = ['--model_path', model_path] + cfgfile_string = "Namespace()" + args_cmdline = parser.parse_args(cmdlne_string) + + try: + cfgfilepath = os.path.join(model_path, "cfg_args") + print("Looking for config file in", cfgfilepath) + with open(cfgfilepath) as cfg_file: + print("Config file found: {}".format(cfgfilepath)) + cfgfile_string = cfg_file.read() + except TypeError: + print("Config file not found at") + pass + args_cfgfile = eval(cfgfile_string) + + merged_dict = vars(args_cfgfile).copy() + for k,v in vars(args_cmdline).items(): + if v != None: + merged_dict[k] = v + return Namespace(**merged_dict) + + + +# endregion + + + + +# region 加载Sam & feature + +def load_sam( + SAM_ARCH = 'vit_h', + SAM_CKPT_PATH = './gaussiansplatting/dependencies/sam_ckpt/sam_vit_h_4b8939.pth' + ): + model_type = SAM_ARCH + sam = sam_model_registry[model_type](checkpoint=SAM_CKPT_PATH).to('cuda') + print(f"Loading SAM: {SAM_ARCH} from {SAM_CKPT_PATH}") + predictor = SamPredictor(sam) + return predictor + +# extract and use sam features +def extract_sam_features(predictor, cameras, gaussians): + sam_features = {} + render_images = {} + print("Prepocessing: extracting SAM features...") + for view in tqdm(cameras): + image_name = view.image_name + render_pkg = render(view, gaussians, pipeline, background) + + render_image = render_pkg["render"].permute(1, 2, 0).detach().cpu().numpy() + render_image = (255 * np.clip(render_image, 0, 1)).astype(np.uint8) + + predictor.set_image(render_image) + sam_features[image_name] = predictor.features + return sam_features + +def extract_sam_features_pt(scene_path, predictor, cameras, gaussians): + # 检查路径是否存在 + if scene_path and os.path.exists(scene_path): + sam_path = os.path.join(scene_path,"sam_pt") + try: + print(f"Loading sam feature from {sam_path} ...") + sam_features = torch.load(sam_path) + return sam_features + except Exception as e: + print(f" Failed: {e}") + + print("Extract sam feature ...") + sam_features = extract_sam_features(predictor, cameras, gaussians) + + if scene_path: + sam_path = os.path.join(scene_path,"sam_pt") + os.makedirs(os.path.dirname(sam_path), exist_ok=True) + print(f"保存SAM特征到{sam_path}") + torch.save(sam_features, sam_path) + + return sam_features + + + +# endregion + + + + +# region 3D投影操作 + +## Project 3D points to 2D plane +def project_to_2d_batch(viewpoint_cameras, points3D) -> torch.Tensor: # C,N,2 + full_matrices = torch.stack([camera.full_proj_transform for camera in viewpoint_cameras]) # [C, 4, 4] + if points3D.shape[-1] != 4: points3D = F.pad(input=points3D, pad=(0, 1), mode='constant', value=1) # [N, 4] + p_hom = torch.bmm(points3D.unsqueeze(0).expand(len(viewpoint_cameras), -1, -1), full_matrices) # [C, N, 4] + p_w = 1.0 / (p_hom[..., 3:] + 0.0000001) # [C, N, 1] + p_proj = p_hom[..., :3] * p_w # [C, N, 3] + heights = torch.tensor([camera.image_height for camera in viewpoint_cameras], device=points3D.device) # [C] + widths = torch.tensor([camera.image_width for camera in viewpoint_cameras], device=points3D.device) # [C] + sizes = torch.stack([widths, heights], dim=1).unsqueeze(1) # [C, 1, 2] + point_image = 0.5 * ((p_proj[..., :2] + 1) * sizes - 1) # [C, N, 2] + point_image = torch.round(point_image) + return point_image # 返回[C, N, 2]张量，C为相机数量，N为点数量 + +def project_to_2d(viewpoint_camera, points3D): # N,2 + full_matrix = viewpoint_camera.full_proj_transform # torch.cuda, w2c @ K + if points3D.shape[-1] != 4: + points3D = F.pad(input=points3D, pad=(0, 1), mode='constant', value=1) + p_hom = (points3D @ full_matrix).transpose(0, 1) # N, 4 -> 4, N -1 ~ 1 + p_w = 1.0 / (p_hom[-1, :] + 0.0000001) + p_proj = p_hom[:3, :] * p_w + + h = viewpoint_camera.image_height + w = viewpoint_camera.image_width + + point_image = 0.5 * ((p_proj[:2] + 1) * torch.tensor([w, h]).unsqueeze(-1).to(p_proj.device) - 1) # image plane + point_image = point_image.detach().clone() + point_image = torch.round(point_image.transpose(0, 1)) + + return point_image + +# 给定单视角2Dprompt，创建3Dprompt +def get_3d_prompts(prompts_2d, point_image, xyz, depth=None): + r = 4 + x_range = torch.arange(prompts_2d[0] - r, prompts_2d[0] + r) + y_range = torch.arange(prompts_2d[1] - r, prompts_2d[1] + r) + x_grid, y_grid = torch.meshgrid(x_range, y_range) + neighbors = torch.stack([x_grid, y_grid], dim=2).reshape(-1, 2).to("cuda") + prompts_index = [torch.where((point_image == p).all(dim=1))[0] for p in neighbors] + indexs = [] + for index in prompts_index: + if index.nelement() > 0: + indexs.append(index) + indexs = torch.unique(torch.cat(indexs, dim=0)) + indexs_depth = depth[indexs] + valid_depth = indexs_depth[indexs_depth > 0] + _, sorted_indices = torch.sort(valid_depth) + valid_indexs = indexs[depth[indexs] > 0][sorted_indices[0]] + + return xyz[valid_indexs][:3].unsqueeze(0) + +## Given 1st view point prompts, find corresponding 3D Gaussian point prompts +# 将3D点投影到2D，使得2D标注能映射到特定3D点上。 +def generate_3d_prompts(xyz, viewpoint_camera, prompts_2d) -> torch.Tensor: + w2c_matrix = viewpoint_camera.world_view_transform + full_matrix = viewpoint_camera.full_proj_transform + # project to image plane + xyz = F.pad(input=xyz, pad=(0, 1), mode='constant', value=1) + p_hom = (xyz @ full_matrix).transpose(0, 1) # N, 4 -> 4, N + p_w = 1.0 / (p_hom[-1, :] + 0.0000001) + p_proj = p_hom[:3, :] * p_w + # project to camera space + p_view = (xyz @ w2c_matrix[:, :3]).transpose(0, 1) # N, 3 -> 3, N + depth = p_view[-1, :] + valid_depth = depth >= 0 + + h = viewpoint_camera.image_height + w = viewpoint_camera.image_width + + point_image = 0.5 * ((p_proj[:2] + 1) * torch.tensor([w, h]).unsqueeze(-1).to(p_proj.device) - 1) + point_image = torch.round(point_image.transpose(0, 1)).long() + + prompts_2d = torch.tensor(prompts_2d).to("cuda") + prompts_3d = torch.stack([ + get_3d_prompts(prompts_2d[i], point_image, xyz, depth) + for i in range(prompts_2d.shape[0]) + ]) + prompts_3D = prompts_3d.reshape(-1, prompts_3d.shape[-1]) + return prompts_3D + +def mask_inverse(xyz, viewpoint_camera, sam_mask): + w2c_matrix = viewpoint_camera.world_view_transform + # project to camera space + xyz = F.pad(input=xyz, pad=(0, 1), mode='constant', value=1) + p_view = (xyz @ w2c_matrix[:, :3]).transpose(0, 1) # N, 3 -> 3, N + depth = p_view[-1, :].detach().clone() + valid_depth = depth >= 0 + + h = viewpoint_camera.image_height # int + w = viewpoint_camera.image_width # int + + + if sam_mask.shape[0] != h or sam_mask.shape[1] != w: # false + sam_mask = func.resize(sam_mask.unsqueeze(0), (h, w), antialias=True).squeeze(0).long() + else: + sam_mask = sam_mask.long() + + point_image = project_to_2d(viewpoint_camera, xyz) # torch([N,2]) + point_image = point_image.long() + + valid_x = (point_image[:, 0] >= 0) & (point_image[:, 0] < w) + valid_y = (point_image[:, 1] >= 0) & (point_image[:, 1] < h) + valid_mask = valid_x & valid_y & valid_depth # [N]=bool + point_mask = torch.full((point_image.shape[0],), -1, device="cuda") # [N]=-1 + point_mask[valid_mask] = sam_mask[point_image[valid_mask, 1], point_image[valid_mask, 0]] # [N]=sam_mask[x,y] + indices_mask = torch.where(point_mask == 1)[0] + + return point_mask, indices_mask + + + +# endregion + + + + +# region 分割 + +## Gaussian Decomposition +def gaussian_decomp(gaussians, viewpoint_camera, input_mask, indices_mask): + xyz = gaussians.get_xyz + point_image = project_to_2d(viewpoint_camera, xyz) + + conv2d = conv2d_matrix(gaussians, viewpoint_camera, indices_mask, device="cuda") + height = viewpoint_camera.image_height + width = viewpoint_camera.image_width + index_in_all, ratios, dir_vector = compute_ratios(conv2d, point_image, indices_mask, input_mask, height, width) + + decomp_gaussians = update(gaussians, viewpoint_camera, index_in_all, ratios, dir_vector) + + return decomp_gaussians + +def save_gs(pc, indices_mask, save_path): + xyz = pc._xyz.detach().cpu()[indices_mask].numpy() + normals = np.zeros_like(xyz) + f_dc = pc._features_dc.detach().transpose(1, 2).flatten(start_dim=1).contiguous().cpu()[indices_mask].numpy() + f_rest = pc._features_rest.detach().transpose(1, 2).flatten(start_dim=1).contiguous().cpu()[indices_mask].numpy() + opacities = pc._opacity.detach().cpu()[indices_mask].numpy() + scale = pc._scaling.detach().cpu()[indices_mask].numpy() + rotation = pc._rotation.detach().cpu()[indices_mask].numpy() + dtype_full = [(attribute, 'f4') for attribute in pc.construct_list_of_attributes()] + elements = np.empty(xyz.shape[0], dtype=dtype_full) + attributes = np.concatenate((xyz, normals, f_dc, f_rest, opacities, scale, rotation), axis=1) + elements[:] = list(map(tuple, attributes)) + el = PlyElement.describe(elements, 'vertex') + PlyData([el]).write(save_path) + +# endregion + + + + + + +class GradioAnnotationTool: + def __init__(self, model_path, predictor): + self.predictor = predictor + if model_path is not None: self.load_gaussian_scene(model_path) + else: + self.scene = None + self.args = None + self.dataset = None + self.images = {} + self.sam_features = {} + self.current_image = None + + self.saved_fg_path = None + self.saved_bg_path = None + + self.maskid = 0 + self.clear_all_mark() + + def load_gaussian_scene(self, model_path, progress:gr.Progress=None): + global pipeline + global background + + if self.scene is not None: del self.scene + if self.seg2d_mark is not None: del self.seg2d_mark + + print("Loading Gaussian Scene") + if progress is not None: progress(0, desc="Get Args") + + parser = ArgumentParser(description="Testing script parameters") + model = ModelParams(parser, sentinel=True) + pipeline = PipelineParams(parser) # 渲染用 + + parser.add_argument("--iteration", default=-1, type=int) + parser.add_argument("--skip_train", action="store_true") + parser.add_argument("--skip_test", action="store_true") + parser.add_argument("--quiet", action="store_true") + parser.add_argument("--threshold", default=0.7, type=float, help='threshold of label voting') + parser.add_argument("--gd_interval", default=20, type=int, help='interval of performing gaussian decomposition') + self.args = get_combined_args(parser, model_path) + + self.dataset = model.extract(self.args) + self.dataset.model_path = self.args.model_path + + if progress is not None: progress(0.1, desc="Load Gaussian Scenes") + gaussians = GaussianModel(self.dataset.sh_degree) + self.scene = Scene(self.dataset, gaussians, load_iteration=self.args.iteration, shuffle=False) + self.dataset.white_background = True + bg_color = [1,1,1] if self.dataset.white_background else [0, 0, 0] + background = torch.tensor(bg_color, dtype=torch.float32, device="cuda") + + if progress is not None: progress(0.4, desc="Rendering Images") + self.images = {} + for view in self.scene.getTrainCameras(): + render_pkg = render(view, self.scene.gaussians, pipeline, background) + render_image = render_pkg["render"].permute(1, 2, 0).detach().cpu().numpy() + render_image = (255 * np.clip(render_image, 0, 1)).astype(np.uint8) + self.images[view.image_name] = render_image + + if progress is not None: progress(0.7, desc="Get Sam Features") + self.sam_features = extract_sam_features_pt(model_path, self.predictor, self.scene.getTrainCameras(), self.scene.gaussians) + self.current_image = list(self.images.keys())[0] + self.predictor.set_image(self.images[self.current_image]) + self.clear_all_mark() + print("加载完成") + if progress is not None: progress(1, desc="Finished") + + def load_scene_gaussians(self): + gaussians = GaussianModel(self.dataset.sh_degree) + gaussians.load_ply( + os.path.join(self.scene.model_path, + "point_cloud", + "iteration_" + str(self.scene.loaded_iter), + "point_cloud.ply")) + return gaussians + + def get_current_state(self): + mark = self.seg2d_mark[self.current_image] + return self.current_image, mark['points'] + + def add_point(self, evt: gr.SelectData, is_original=True): + """添加点，支持从原图或mask图添加""" + print(f"点击事件: {evt}") + if evt is None: + print("收到空的点击事件") + return self._render_original(), self._render_mask(), self._render_selected_mask() + mark = self.seg2d_mark[self.current_image] + x, y = evt.index + print(f"On Add Point: curr_image={self.current_image}, hist_idx={mark['history_index']}, hist_len={len(mark['history'])}, nPoint={len(mark['points'])}, point=({x},{y})") + mark['points'].append([x, y]) + mark["history_index"] += 1 + + # 如果场景存在，更新3D点标注 + if self.scene is not None: + self._update_3d_prompts() + + self._get_mask() + self._save_state() + self._new_loaded = False + return self._render_original(), self._render_mask(), self._render_selected_mask() + + def undo(self): + """撤销当前图片的最后一次操作""" + mark = self.seg2d_mark[self.current_image] + print(f"On Undo: {self.current_image}, {mark['history_index']}, {len(mark['history'])}, {len(mark['points'])}") + + # 检查是否有历史记录可撤销 + if mark['history_index'] > 0: # 此时若刚做了一次，为0 + mark['history_index'] -= 1 + prev_state = mark['history'][mark['history_index']] + mark['points'] = prev_state[0][:] + # 恢复3D点标注 + if len(prev_state) > 2 and prev_state[2] is not None: + mark['prompts_3D'] = prev_state[2].clone() if prev_state[2] is not None else empty_3D.clone() + else: + mark["points"] = [] + mark['prompts_3D'] = empty_3D.clone() + self._save_state() + + self._get_mask() + + # 如果场景存在，更新3D点标注 + if self.scene is not None and len(mark['points']): self._update_3d_prompts() + return self._render_original(), self._render_mask(), self._render_selected_mask() + + def redo(self): + """重做当前图片的操作""" + mark = self.seg2d_mark[self.current_image] + print(f"On Redo: {self.current_image}, {mark['history_index']}, {len(mark['history'])}, {len(mark['points'])}") + + # 检查是否有历史记录可重做 + if mark['history_index'] < len(mark['history']) - 1: + mark['history_index'] += 1 + next_state = mark['history'][mark['history_index']] + mark['points'] = next_state[0][:] + # 恢复3D点标注 + if len(next_state) > 2 and next_state[2] is not None: + mark['prompts_3D'] = next_state[2].clone() if next_state[2] is not None else empty_3D.clone() + self._get_mask() + + # 如果场景存在，更新3D点标注 + if self.scene is not None and len(mark['points']): self._update_3d_prompts() + return self._render_original(), self._render_mask(), self._render_selected_mask() + + def set_mask_id(self, mask_id): + """设置当前选择的mask索引""" + self.maskid = mask_id + return self._render_selected_mask() + + def clear_current(self): + """清空当前图片的所有标注""" + mark = self.seg2d_mark[self.current_image] + mark['points'] = [] + mark['prompts_3D'] = empty_3D.clone() # 清空3D点标注 + self._save_state() + self._get_mask() + return self._render_original(), self._render_mask(), self._render_selected_mask() + + def clear_all_mark(self): + self.seg2d_mark = { + name: { + 'points': [], # 当前视角的点标注 + 'history': [], # 历史记录 [(points, masks), ...] + 'history_index': -1, # 历史记录索引，用于撤销/重做 + 'prompts_3D': empty_3D.clone() # 存储3D点标注 + } for name in self.images.keys() + } + self.record = { # 每次点击，根据不同的点击组合，会创建一个record结构。 + "prompts": None, # torch.Tensor([N, 3]), 保存用于生成该记录的 3D 点 + "mvmask": { + # maskid: { # 0, 1, 2 + # "multiview": {...}, # multiview_masks (用于3D分割) + # "sam_masks": {...}, # multiview_sam_masks (用于3D分割) + # } + }, + "sam_all": {} # {img1_name: mask1, ...}（用于可视化） + } + self._new_loaded = True + + def clear_all(self): + self.clear_all_mark() + return self._render_original(), self._render_mask(), self._render_selected_mask() + + def _update_3d_prompts(self): + mark = self.seg2d_mark[self.current_image] + if not mark['points'] or self.scene is None: + mark['prompts_3D'] = empty_3D.clone() + return + + current_camera = None + for camera in self.scene.getTrainCameras(): + if camera.image_name == self.current_image: + current_camera = camera + break + + if current_camera is None: + print(f"找不到当前视角对应相机: {self.current_image}") + return + xyz = self.scene.gaussians.get_xyz + prompts_3D = generate_3d_prompts(xyz, current_camera, mark['points']) + mark['prompts_3D'] = prompts_3D + + def update_image(self, image_name): + self.current_image = image_name + return self._render_original(), self._render_mask(), self._render_selected_mask() + + def toggle_mask(self): + if self.masks[self.current_image] is not None: + self.masks[self.current_image] = None + elif self.points[self.current_image]: + self._get_mask() + return self._render_display() + + def generate_multiview_masks(self, prompts_3D, text_prompt = None, progress:gr.Progress=None): + """ + sam_mask_all_levels (cuda) : list[torch.int64(id,H,W)] , 每个视角下的渲染图的sam mask + sam_masks (cuda) : list[torch.int64(H,W)] , 每个视角下的渲染图的sam mask + multiview_masks (cuda) : list[torch.int64(N,1)] , 每个视角下，每个Gaussians点的mask + """ + # point guided, masks[id,H,W,C=1], 2D点标注 + def self_prompt_seg_torch(point_prompts, sam_feature): # point_prompts: torch([N,2]) + input_point = point_prompts[None, :, :] # Batch, N, 2 + input_label = torch.ones((input_point.shape[0],input_point.shape[1]), device=self.predictor.device) + + predictor.features = sam_feature + masks_torch_batch, _, _ = predictor.predict_torch( + point_coords=input_point, # [1,N,2] + point_labels=input_label, # [1,N] + multimask_output=True, + ) + masks_torch = masks_torch_batch[0] # [batch, id, H, W, C] + return_mask = (masks_torch[:, :, :, None]*255).to(torch.uint8) # [id,H,W,C=1] + return return_mask / 255 + + scene = self.scene + images = self.images + mask_id = self.maskid + cameras = scene.getTrainCameras() + gaussians = scene.gaussians + sam_masks = [] + multiview_masks = [] + sam_mask_all_levels = [] + for i, view in tqdm(enumerate(cameras), desc="generate multiview masks"): + image_name = view.image_name # added + prompts_2d = project_to_2d(view, prompts_3D) + sam_mask_all_level = self_prompt_seg_torch(prompts_2d, self.sam_features[image_name]) # torch([id=3,H,W,C=1]) + sam_mask_all_levels.append(sam_mask_all_level) + sam_mask = sam_mask_all_level[mask_id].long()[:,:,0] # torch[H,W] + sam_masks.append(sam_mask) + point_mask, indices_mask = mask_inverse(gaussians.get_xyz, view, sam_mask) # TODO: gaussians.get_xyz.require_grad=True; cuda,cuda,cuda + multiview_masks.append(point_mask.unsqueeze(-1)) + return sam_mask_all_levels, sam_masks, multiview_masks + + scene = self.scene + images = self.images + mask_id = self.maskid + cameras = scene.getTrainCameras() + gaussians = scene.gaussians + sam_masks = [] + multiview_masks = [] + sam_mask_all_levels = [] + + for i, view in tqdm(enumerate(cameras), desc="generate multiview masks"): + image_name = view.image_name # added + if text_prompt is not None: + render_image = images[image_name] # added + render_image = (255 * np.clip(render_image, 0, 1)).astype(np.uint8) + sam_mask_all_level = text_prompt_seg(render_image, text_prompt) + else: + prompts_2d = project_to_2d(view, prompts_3D) + sam_mask_all_level = self_prompt_seg(prompts_2d, self.sam_features[image_name]) # [id,H,W,C=1] + + sam_mask_all_levels.append(sam_mask_all_level) + + sam_mask = sam_mask_all_level[mask_id] + if len(sam_mask.shape) != 2: sam_mask = torch.from_numpy(sam_mask).squeeze(-1).to("cuda") + else: sam_mask = torch.from_numpy(sam_mask).to("cuda") + sam_mask = sam_mask.long() # 2D mask image [H,W] -> value + sam_masks.append(sam_mask) + + point_mask, indices_mask = mask_inverse(gaussians.get_xyz, view, sam_mask) + multiview_masks.append(point_mask.unsqueeze(-1)) + return sam_mask_all_levels, sam_masks, multiview_masks + + def _get_multilayer_mask(self, img_name): + if self._new_loaded: return None + return self.record["sam_all"].get(img_name) + + def _get_mask(self, progress:gr.Progress=None): + """ + 根据prompts_3D和maskid作为索引，保存multiview_sam_masks, multiview_masks + 根据prompts_3D作为索引，保存sam_mask_all_level + 其中prompts_3D为[N,3]的3D点集，索引过程中不需要保证点集顺序一致，对于十分相近的点认为是同一个点。 + 历史记录不再依赖栈结构，而是点集匹配。 + + sam_mask_all_level : 用于显示,不需要mask_id(显示时做筛选) + multiview_sam_masks: 是选中的mask,用于3D分割,需要mask_id + multiview_masks : 是3D点的mask,用于3D分割,需要mask_id + """ + # 收集prompts_3D + prompts_3D_list = [] + for img_name in self.images.keys(): + prompts_3D = self.seg2d_mark[img_name]['prompts_3D'] # torch.Tensor[N,3] + if prompts_3D.shape[0] > 0: prompts_3D_list.append(prompts_3D) # 检查是否有3D点标注 + + if prompts_3D_list: prompts_3D_tensor = torch.cat(prompts_3D_list, dim=0) # [M,3] + else: prompts_3D_tensor = torch.empty((0, 3), dtype=torch.float32, device="cuda") + + if progress is not None: progress(0, desc="prepare Prompt 3D") + sam_alls, sam_masks, multiviews = self.generate_multiview_masks(prompts_3D_tensor, progress=progress) + print("multiview_masks generated\n") + sam_all_dict = { # img_name -> torch.tensor(id,H,W), 仅显示时转numpy + img: m.squeeze(-1) if m is not None else None + for img, m in zip(self.images.keys(), sam_alls) + } + self.record["prompts"] = prompts_3D_tensor + self.record["sam_all"] = sam_all_dict + self.record["mvmask"][self.maskid] = { + "multiview": multiviews, + "sam_masks": sam_masks, + } + log() + return + + def _save_state(self): + """保存当前标注到历史记录""" + mark = self.seg2d_mark[self.current_image] + current_state = ( + mark['points'][:] if mark['points'] else [], # list[N,2] -> int + mark['prompts_3D'].clone() if 'prompts_3D' in mark else empty_3D.clone() # Tensor[N,3] + ) + if mark['history_index'] < len(mark['history']) - 1: + mark['history'] = mark['history'][:mark['history_index'] + 1] + mark['history'].append(current_state) + mark['history_index'] = len(mark['history']) - 1 + + def _render_original(self): + """渲染原始图像，只显示点标注""" + img = self.images[self.current_image].copy() + mark = self.seg2d_mark[self.current_image] + if len(img.shape) == 2: img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR) + for i, (x, y) in enumerate(mark['points']): + cv2.circle(img, (x, y), 8, (0, 0, 0), -1) + cv2.circle(img, (x, y), 6, (0, 255, 255), -1) + cv2.putText(img, str(i+1), (x+10, y+10), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 0), 3) + cv2.putText(img, str(i+1), (x+10, y+10), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 1) + return img + + def _render_mask(self): + """渲染带有mask的图像，不包含图例""" + img = self.images[self.current_image].copy() + mark = self.seg2d_mark[self.current_image] + + if len(img.shape) == 2: img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR) + try: + mask_multilayer = self._get_multilayer_mask(self.current_image).cpu().numpy() + mask_colors = [ + np.array([255, 50, 50]), # R + np.array([50, 255, 50]), # G + np.array([50, 50, 255]) # B + ] + mask_color_strength = 0.6 # [0,1] + combined_mask = np.zeros_like(img) + priority_mask = np.ones(img.shape[:2], dtype=np.int32) * 999 + masks_count = min(len(mask_multilayer), len(mask_colors)) + for i in range(masks_count): + mask = mask_multilayer[i] + mask_area = mask > 0.5 + valid_area = np.logical_and(mask_area, priority_mask > i) + if np.any(valid_area): + priority_mask[valid_area] = i + combined_mask[valid_area] = mask_colors[i] * mask_color_strength + img[valid_area] * (1-mask_color_strength) + mask_any = np.any(combined_mask > 0, axis=2) + img[mask_any] = combined_mask[mask_any] + + except Exception as e: + if not self._new_loaded: + print(f"Mask invalid: {self.current_image}") + print(e) + + for i, (x, y) in enumerate(mark['points']): + cv2.circle(img, (x, y), 8, (0, 0, 0), -1) + cv2.circle(img, (x, y), 6, (0, 255, 255), -1) + cv2.putText(img, str(i+1), (x+10, y+10), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 0), 3) + cv2.putText(img, str(i+1), (x+10, y+10), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 1) + + return img + + def _render_selected_mask(self): + """渲染选中的单个mask应用到原图的效果""" + img = self.images[self.current_image].copy() + if len(img.shape) == 2: img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR) + try: + mask_multilayer = self._get_multilayer_mask(self.current_image).cpu().numpy() + mask_id = self.maskid + if mask_id < len(mask_multilayer): + mask = mask_multilayer[mask_id] + mask_area = mask > 0.5 + mask_colors = [ + np.array([255, 50, 50]), # R + np.array([50, 255, 50]), # G + np.array([50, 50, 255]) # B + ] + mask_color = mask_colors[mask_id % len(mask_colors)] + mask_color_strength = 0.6 + + if np.any(mask_area): + img[mask_area] = mask_color * mask_color_strength + img[mask_area] * (1-mask_color_strength) + except Exception as e: + if not self._new_loaded: + print(f"Mask invalid: {self.current_image}") + print(e) + return img + + ## Multi-view label voting 多视角（multi-view）标签投票融合 + def ensemble(self, threshold=0.7): + multiview_masks = self.record["mvmask"][self.maskid]["multiview"] + multiview_masks = torch.cat(multiview_masks, dim=1) + vote_labels,_ = torch.mode(multiview_masks, dim=1) + matches = torch.eq(multiview_masks, vote_labels.unsqueeze(1)) + ratios = torch.sum(matches, dim=1) / multiview_masks.shape[1] + ratios_mask = ratios > threshold + labels_mask = (vote_labels == 1) & ratios_mask + indices_mask = torch.where(labels_mask)[0].detach().cpu() + + return vote_labels, indices_mask + + def seg_gaussian(self, threshold, object_name, progress:gr.Progress = None): + if progress is not None: progress(0, desc="load gaussians and mask") + self._get_mask(progress=progress) # 需要match maskid + model_path = self.scene.model_path + gaussians = self.scene.gaussians + _, final_mask = self.ensemble(threshold) + cameras = self.scene.getTrainCameras() + if progress is not None: progress(0.1, desc="gaussian multiview decomp") + + self.saved_fg_path = os.path.join(model_path, f'objects/{object_name}/fg.ply') + os.makedirs(os.path.dirname(self.saved_fg_path), exist_ok=True) + save_gs(gaussians, final_mask, self.saved_fg_path) + if progress is not None: progress(0.3, desc="gaussian multiview decomp") + + # if gaussian decomposition as a post-process module + de_gaussian = self.load_scene_gaussians() + for i, view in tqdm(enumerate(cameras), desc="gaussian multiview decomp"): + if self.args.gd_interval != -1 and i % self.args.gd_interval == 0: + input_mask = self.record["mvmask"][self.maskid]["sam_masks"][i] + de_gaussian = gaussian_decomp(de_gaussian, view, input_mask, final_mask.to('cuda')) + if progress is not None: progress(0.5, desc="render segged gaussian") + + # save after gaussian decomposition + self.saved_bg_path = os.path.join(model_path, f'objects/{object_name}/bg.ply') + save_gs(de_gaussian, final_mask, self.saved_fg_path+"2.ply") + if progress is not None: progress(0.7, desc="render segged gaussian") + + # render object images + seg_gaussians = GaussianModel(self.dataset.sh_degree) + seg_gaussians.load_ply(self.saved_fg_path) + if progress is not None: progress(0.8, desc="render segged gaussian") + + obj_save_path = os.path.join(model_path, f'objects/{object_name}/images') + os.makedirs(obj_save_path, exist_ok=True) + + if not os.path.exists(obj_save_path): os.mkdir(obj_save_path) + for idx in tqdm(range(len(cameras)), desc="render segged gaussian"): + image_name = cameras[idx].image_name + view = cameras[idx] + + render_pkg = render(view, seg_gaussians, pipeline, background) + render_image = render_pkg["render"].permute(1, 2, 0).detach().cpu().numpy() + render_image = (255 * np.clip(render_image, 0, 1)).astype(np.uint8) + render_image = cv2.cvtColor(render_image, cv2.COLOR_RGB2BGR) + cv2.imwrite(os.path.join(obj_save_path, '{}.jpg'.format(image_name)), render_image) + seg_gaussians.save_ply(os.path.join(model_path, f'objects/{object_name}/seg.ply')) + if progress is not None: progress(1, desc="Finished") + + + +def create_gradio_interface(default_model_paths, predictor): + tool = GradioAnnotationTool(model_path=None, predictor=predictor) + + with gr.Blocks() as demo: + with gr.Row(): + original_display = gr.Image(label="Origin", interactive=False) + mask_display = gr.Image(label="Layer Mask", interactive=False) + selected_mask_display = gr.Image(label="Mask Result", interactive=False) + with gr.Row(): + with gr.Column(scale=1): + with gr.Row(): + undo_btn = gr.Button("Undo") + redo_btn = gr.Button("Redo") + with gr.Row(): + seg_view = gr.Button("Seg View") + add_view = gr.Button("Add to Result") + + with gr.Column(scale=1): + with gr.Row(): + cls_cur_btn = gr.Button("Clear Curr View Marks") + cls_all_btn = gr.Button("Clear All Views Marks") + with gr.Row(): + seg_view = gr.Button("Save Checkpoint") + seg_view = gr.Button("Clear Result") + + with gr.Column(scale=1): + with gr.Row(): + mask_selector = gr.Radio( + choices=["S", "M", "L"], + label="Select Mask", + value="S", + interactive=True + ) + + with gr.Row() as prompt_col: + with gr.Column(scale=1.5): + model_path_input = gr.Dropdown( + choices=default_model_paths, + allow_custom_value=True, + value="", + show_label=False, + interactive=True, + ) + with gr.Column(scale=0.5): + model_path_btn = gr.Button("Open Model") + with gr.Column(scale=1): + object_name_input = gr.Textbox(placeholder="Your Object Name", show_label=False, interactive=True, submit_btn="Seg!") + + with gr.Row(): + with gr.Column(scale=2): + gallery = gr.Gallery( + label="Gallery", + value=[(tool.images[k],k) for k in sorted(tool.images.keys(), key=lambda x: int(x) if x.isdigit() else x)], + columns=4, + object_fit="contain", + height="auto", + allow_preview=False, + ) + with gr.Column(scale=1): + with gr.Row(): fg_gs = LitModel3D(label="Current View Segment", exposure=10.0, height=300) + with gr.Row(): download_fg_gs = gr.DownloadButton(label="Download", interactive=False) + with gr.Column(scale=1): + with gr.Row(): bg_gs = LitModel3D(label="Final Segment", exposure=10.0, height=300) + with gr.Row(): download_bg_gs = gr.DownloadButton(label="Download", interactive=False) + + def on_mask_select(choice): + if choice == "S": mask_id = 0 + elif choice == "M": mask_id = 1 + elif choice == "L": mask_id = 2 + selected_mask = tool.set_mask_id(mask_id) + return selected_mask + + def get_available_mask_choices(tool): + # mark = tool.seg2d_mark[tool.current_image] + # if tool._get_multilayer_mask() is None: return ["S"] + # mask_names = ["S", "M", "L"] + # return mask_names[:len(tool._get_multilayer_mask())] + return ["S", "M", "L"] + + def add_point_from_original(evt: gr.SelectData): + orig, mask, selected = tool.add_point(evt, is_original=True) + available_masks = get_available_mask_choices(tool) + mask_id = tool.maskid + if mask_id >= len(available_masks): mask_id = len(available_masks)-1 + return orig, mask, selected, gr.update(choices=available_masks, value=available_masks[mask_id] if available_masks else None) + + def add_point_from_mask(evt: gr.SelectData): + orig, mask, selected = tool.add_point(evt, is_original=False) + available_masks = get_available_mask_choices(tool) + mask_id = tool.maskid + if mask_id >= len(available_masks): mask_id = len(available_masks)-1 + return orig, mask, selected, gr.update(choices=available_masks, value=available_masks[mask_id] if available_masks else None) + + def load_with_progress(model_path, progress=gr.Progress(track_tqdm=True)): + torch.cuda.empty_cache() + tool.load_gaussian_scene(model_path, progress=progress) + orig = tool._render_original() + mask = tool._render_mask() + selected = tool._render_selected_mask() + available_masks = get_available_mask_choices(tool) + return \ + gr.update(value = [(tool.images[k],k) for k in sorted(tool.images.keys(), key=lambda x: int(x) if x.isdigit() else x)]),\ + orig, mask, selected, \ + gr.update(choices=available_masks, value=available_masks[0] if available_masks else None) + + model_path_btn.click( + fn=load_with_progress, + inputs=model_path_input, + outputs=[gallery, original_display, mask_display, selected_mask_display, mask_selector], + ) + + original_display.select( + fn=add_point_from_original, + outputs=[original_display, mask_display, selected_mask_display, mask_selector] + ) + + mask_display.select( + fn=add_point_from_mask, + outputs=[original_display, mask_display, selected_mask_display, mask_selector] + ) + + mask_selector.change( + fn=on_mask_select, + inputs=[mask_selector], + outputs=[selected_mask_display] + ) + + undo_btn.click(fn=lambda: tool.undo(), outputs=[original_display, mask_display, selected_mask_display]) + redo_btn.click(fn=lambda: tool.redo(), outputs=[original_display, mask_display, selected_mask_display]) + cls_cur_btn.click(fn=tool.clear_current, outputs=[original_display, mask_display, selected_mask_display]) + cls_all_btn.click(fn=tool.clear_all, outputs=[original_display, mask_display, selected_mask_display]) + + def seg_gaussian_with_prompt(object_name, progress=gr.Progress(track_tqdm=True)): + yield gr.update(value=f"Processing: '{object_name}'...", interactive=False) + tool.seg_gaussian(threshold=0.7, object_name=object_name, progress=None) + yield gr.update(value=object_name, placeholder="Your Object Name", interactive=True) + + object_name_input.submit( # 保存Gaussian + fn=seg_gaussian_with_prompt, + inputs=object_name_input, + outputs=[object_name_input] + ).then( # 显示Gaussian + fn=lambda: tool.saved_fg_path, + outputs=[fg_gs] + ).then( + fn = lambda: gr.update(value=tool.saved_fg_path, interactive=True), + outputs=[download_fg_gs], + ) + + # Gallery选择事件处理 + def on_gallery_select(evt: gr.SelectData): + try: + index = evt.index + image_name = sorted(tool.images.keys(), key=lambda x: int(x) if x.isdigit() else x)[index] + orig, mask, selected = tool.update_image(image_name) + available_masks = get_available_mask_choices(tool) + mask_id = tool.maskid + if mask_id >= len(available_masks): mask_id = len(available_masks)-1 + return orig, mask, selected, gr.update(choices=available_masks, value=available_masks[mask_id] if available_masks else None) + except Exception as e: + print(f"Error while select in gallery: {e}") + orig = tool._render_original() + mask = tool._render_mask() + selected = tool._render_selected_mask() + return orig, mask, selected, gr.update(choices=["S"]) + + gallery.select(fn=on_gallery_select, outputs=[original_display, mask_display, selected_mask_display, mask_selector]) + + # 初始显示 + def init_display(): + orig, mask, selected = None, None, None + available_masks = get_available_mask_choices(tool) + return orig, mask, selected, gr.update(choices=available_masks, value=available_masks[0] if available_masks else None) + + demo.load(fn=init_display, outputs=[original_display, mask_display, selected_mask_display, mask_selector]) + + return demo + + + +# I'm using this for trellis model segmentation +# As it's a Y-Up generation model +# output model would be lying down. + + +def find_model_folders(base_path, relative_to="."): + model_paths = [] + if os.path.exists(base_path): + # 如果relative_to是None,则相对于当前目录 + if relative_to is None: relative_to = "." + for root, dirs, files in os.walk(base_path): + if os.path.basename(root) == "model": + # 获取相对于relative_to的路径 + rel_path = os.path.relpath(root, relative_to) + model_paths.append(rel_path) + return model_paths + +if __name__ == "__main__": + + # with profile(on_trace_ready=torch.profiler.tensorboard_trace_handler('./log')) as prof: + base_dir = "../TRELLIS/results" + default_model_paths = find_model_folders(base_dir) + + predictor = load_sam() + + # 创建并启动Gradio界面，传入预先提取的特征和场景 + demo = create_gradio_interface(default_model_paths, predictor) + demo.launch(server_name="0.0.0.0", server_port=None, + allowed_paths = ["./", base_dir]) + From 4c020b3290072a26b2b8ce9b023b7e553741b884 Mon Sep 17 00:00:00 2001 From: MrHandsomeljn <1205197328@qq.com> Date: Sat, 3 May 2025 14:55:25 +0800 Subject: [PATCH 9/9] app2.py --- README.md | 35 +- app.py | 32 -- app2.py | 448 +++++++++++++++------- gaussiansplatting/scene/gaussian_model.py | 154 +++++++- seg_utils.py | 2 +- 5 files changed, 477 insertions(+), 194 deletions(-) diff --git a/README.md b/README.md index e9a4f84..42e20e2 100644 --- a/README.md +++ b/README.md @@ -3,14 +3,35 @@ ## SAGS with a Gradio Interface -#### 25.05.02 +SAGS with a Gradio Interface. +Multiview Annotation and Merge. + +Gradio版本的SAGS，支持多视角标注，支持多次标注并合并输出为一个Gaussian Splatting结果 +需要的文件目录：Gaussian训练的数据集文件夹和结果文件夹。结果文件夹中args文件保存了数据集文件夹的目录，因此只需要打开结果文件夹的目录即可。 + +### 25.05.03 app2.py +app2.py：修改用户流程，解决遮挡物体分割不佳的问题 +1. 使用单视角标注，得到单视角的GS结果 +2. 融合多个单视角GS的结果，加入最终的GS分割结果 + +New Pipeline in app2.py: (to solve poor segmentation of occluded objects) +1. Using single perspective annotation to obtain GS results from a single perspective +2. Continuously merging new single perspective results into the final result + +compare to app.py: +1. Directly using multi view annotation to obtain multi view masks +2. Generate the final GS result directly using multi perspective annotation + +### 25.05.02 No Cached Result of SAM. Now the GPU Memory Usage is stable. +不使用计算结果的缓存了。使用缓存的版本是app_cached_result(deprecated).py -#### 25.05.01 +### 25.05.01 Speedup x10 (in multi view segment) by change some numpy operator to torch, see app.py every single click need 1800MB GPU Memory(with 90pic dataset). I will fix it. +分割确实快了，还需要去除保存计算结果缓存的模块 -#### 25.04.30 +### 25.04.30 Use it to segment any gaussian easily, capable with multiview annotation ability. Text prompt would be release when I'm available. Undo and Redo might incur additional GPU Memory cost. @@ -18,11 +39,13 @@ Requires gradio==5 Gradio版本的SAGS，支持多视角标注，背面也可以加约束了。 发现背面加约束这个事情有点鸡肋，猜测是3D投票过程并不能很好支持复杂的遮挡关系 +每次的撤消和重做的结果都保存了，不会重复存，但是反复折腾可能会占点显存。 + 计划： -1. 改为进行多次单视角GS分割，将多个视角得到的GS结果直接组合得到最终结果 -2. 有空想整一个文本提示版本。 +- ✅改为进行多次单视角GS分割，将多个视角得到的GS结果直接组合得到最终结果 +- ✅尝试加快分割，不使用计算结果的缓存，减少GPU内存占用 +- ⭕️有空想整一个文本提示版本 -每次的撤消和重做的结果都保存了，不会重复存，但是反复折腾可能会占点显存。 ## Introduction diff --git a/app.py b/app.py index 988d991..ddde84d 100644 --- a/app.py +++ b/app.py @@ -604,37 +604,6 @@ def self_prompt_seg_torch(point_prompts, sam_feature): # point_prompts: torch([N multiview_masks.append(point_mask.unsqueeze(-1)) return sam_mask_all_levels, sam_masks, multiview_masks - scene = self.scene - images = self.images - mask_id = self.maskid - cameras = scene.getTrainCameras() - gaussians = scene.gaussians - sam_masks = [] - multiview_masks = [] - sam_mask_all_levels = [] - - for i, view in tqdm(enumerate(cameras), desc="generate multiview masks"): - image_name = view.image_name # added - if text_prompt is not None: - render_image = images[image_name] # added - render_image = (255 * np.clip(render_image, 0, 1)).astype(np.uint8) - sam_mask_all_level = text_prompt_seg(render_image, text_prompt) - else: - prompts_2d = project_to_2d(view, prompts_3D) - sam_mask_all_level = self_prompt_seg(prompts_2d, self.sam_features[image_name]) # [id,H,W,C=1] - - sam_mask_all_levels.append(sam_mask_all_level) - - sam_mask = sam_mask_all_level[mask_id] - if len(sam_mask.shape) != 2: sam_mask = torch.from_numpy(sam_mask).squeeze(-1).to("cuda") - else: sam_mask = torch.from_numpy(sam_mask).to("cuda") - sam_mask = sam_mask.long() # 2D mask image [H,W] -> value - sam_masks.append(sam_mask) - - point_mask, indices_mask = mask_inverse(gaussians.get_xyz, view, sam_mask) - multiview_masks.append(point_mask.unsqueeze(-1)) - return sam_mask_all_levels, sam_masks, multiview_masks - def _get_multilayer_mask(self, img_name): if self._new_loaded: return None return self.record["sam_all"].get(img_name) @@ -1030,7 +999,6 @@ def find_model_folders(base_path, relative_to="."): predictor = load_sam() - # 创建并启动Gradio界面，传入预先提取的特征和场景 demo = create_gradio_interface(default_model_paths, predictor) demo.launch(server_name="0.0.0.0", server_port=None, allowed_paths = ["./", base_dir]) diff --git a/app2.py b/app2.py index 54f2c27..b730e98 100644 --- a/app2.py +++ b/app2.py @@ -1,18 +1,14 @@ -import gradio as gr -from typing import List, Tuple, Dict - import os import sys import cv2 -import time import torch import numpy as np +import gradio as gr import torch.nn.functional as F import torchvision.transforms.functional as func from tqdm import tqdm -from typing import Literal from plyfile import PlyData, PlyElement from argparse import ArgumentParser, Namespace @@ -23,12 +19,9 @@ from seg_utils import grounding_dino_prompt from seg_utils import conv2d_matrix, compute_ratios, update -from segment_anything import (SamAutomaticMaskGenerator, SamPredictor, - sam_model_registry) +from segment_anything import (SamAutomaticMaskGenerator, SamPredictor, sam_model_registry) from gradio_litmodel3d import LitModel3D -from torch.profiler import profile, record_function, ProfilerActivity -from time import time import datetime # 获取当前时间字符串的lambda函数 @@ -255,6 +248,9 @@ def mask_inverse(xyz, viewpoint_camera, sam_mask): # region 分割 ## Gaussian Decomposition +# 高斯边缘切割，原位操作，不增加点云数量 +# 做完之后，处于物体边缘的点会被修改 +# 可以作为分割后的后处理进行 def gaussian_decomp(gaussians, viewpoint_camera, input_mask, indices_mask): xyz = gaussians.get_xyz point_image = project_to_2d(viewpoint_camera, xyz) @@ -302,10 +298,15 @@ def __init__(self, model_path, predictor): self.sam_features = {} self.current_image = None - self.saved_fg_path = None - self.saved_bg_path = None + self.has_ckpt = False + self.saved_curr_gs_path = None + self.saved_last_gs_path = None + self.saved_last_ckpt_gs_path = None + self.saved_curr_ckpt_gs_path = None + self.result_gaussian = None self.maskid = 0 + self.segmode = 0 # Single, Multi self.clear_all_mark() def load_gaussian_scene(self, model_path, progress:gr.Progress=None): @@ -352,9 +353,45 @@ def load_gaussian_scene(self, model_path, progress:gr.Progress=None): self.sam_features = extract_sam_features_pt(model_path, self.predictor, self.scene.getTrainCameras(), self.scene.gaussians) self.current_image = list(self.images.keys())[0] self.predictor.set_image(self.images[self.current_image]) + + self.result_gaussian = self.load_scene_gaussians() + + # self.scene.gaussian: 场景的gaussian，每次分割都从此开始，不从中间的分割结果再次分割。 + # self.last_gaussian: 合并后的分割结果，是从curr_gaussian一个个累加的 + # self.saved_curr_gs_path: 保存的当前分割结果的路径 (用于展示) + # self.saved_last_gs_path: 保存的合并分割结果的路径 (用于展示) + # self.saved_curr_ckpt_gs_path: 暂存checkpoint路径 (用于恢复) + # self.saved_last_ckpt_gs_path: 暂存checkpoint路径 (用于恢复) + # self.用户用object名字保存的结果，直接存硬盘，展示路径用self.saved_last_gs_path + + self.last_gaussian = None + self.saved_curr_gs_path = os.path.join(model_path, f'objects/tmp/tmp_curr.ply') + self.saved_last_gs_path = os.path.join(model_path, f'objects/tmp/tmp_last.ply') + self.saved_curr_ckpt_gs_path = os.path.join(model_path, f'objects/tmp/tmp_curr_ckpt.ply') + self.saved_last_ckpt_gs_path = os.path.join(model_path, f'objects/tmp/tmp_last_ckpt.ply') + os.makedirs(os.path.join(model_path, f'objects/tmp'), exist_ok=True) + os.system(f"rm -r {self.saved_curr_gs_path }") + os.system(f"rm -r {self.saved_curr_ckpt_gs_path }") + os.system(f"rm -r {self.saved_last_gs_path }") + os.system(f"rm -r {self.saved_last_ckpt_gs_path }") + self.clear_all_mark() - print("加载完成") if progress is not None: progress(1, desc="Finished") + print("加载完成") + + def load_gaussians(self, path): + gaussians = GaussianModel(self.dataset.sh_degree) + gaussians.load_ply(path) + return gaussians + + def load_curr_gaussians(self): + if os.path.isfile(self.saved_curr_gs_path): + gaussians = GaussianModel(self.dataset.sh_degree) + gaussians.load_ply(self.saved_curr_gs_path) + return gaussians + else: + print(f"Curr Gaussian Not Found at: {self.saved_curr_gs_path}") + return None def load_scene_gaussians(self): gaussians = GaussianModel(self.dataset.sh_degree) @@ -413,6 +450,7 @@ def undo(self): # 如果场景存在，更新3D点标注 if self.scene is not None and len(mark['points']): self._update_3d_prompts() return self._render_original(), self._render_mask(), self._render_selected_mask() + # {i:len(self.seg2d_mark[i]["points"]) for i in self.seg2d_mark.keys()} def redo(self): """重做当前图片的操作""" @@ -438,6 +476,12 @@ def set_mask_id(self, mask_id): self.maskid = mask_id return self._render_selected_mask() + def set_mode_id(self, mask_id): + """设置当前选择的mask索引""" + self.segmode = mask_id + self._get_mask() + return self._render_original(), self._render_mask(), self._render_selected_mask() + def clear_current(self): """清空当前图片的所有标注""" mark = self.seg2d_mark[self.current_image] @@ -466,6 +510,9 @@ def clear_all_mark(self): }, "sam_all": {} # {img1_name: mask1, ...}（用于可视化） } + if self.has_ckpt is False: + self.ckpt_seg2d_mark = { name: {'points': [],'history': [],'history_index': -1,'prompts_3D': empty_3D.clone()} for name in self.images.keys()} + self.ckpt_record = {"prompts": None, "mvmask": {},"sam_all": {}} self._new_loaded = True def clear_all(self): @@ -524,7 +571,6 @@ def self_prompt_seg_torch(point_prompts, sam_feature): # point_prompts: torch([N return return_mask / 255 scene = self.scene - images = self.images mask_id = self.maskid cameras = scene.getTrainCameras() gaussians = scene.gaussians @@ -542,41 +588,27 @@ def self_prompt_seg_torch(point_prompts, sam_feature): # point_prompts: torch([N multiview_masks.append(point_mask.unsqueeze(-1)) return sam_mask_all_levels, sam_masks, multiview_masks - scene = self.scene - images = self.images - mask_id = self.maskid - cameras = scene.getTrainCameras() - gaussians = scene.gaussians - sam_masks = [] - multiview_masks = [] - sam_mask_all_levels = [] - - for i, view in tqdm(enumerate(cameras), desc="generate multiview masks"): - image_name = view.image_name # added - if text_prompt is not None: - render_image = images[image_name] # added - render_image = (255 * np.clip(render_image, 0, 1)).astype(np.uint8) - sam_mask_all_level = text_prompt_seg(render_image, text_prompt) - else: - prompts_2d = project_to_2d(view, prompts_3D) - sam_mask_all_level = self_prompt_seg(prompts_2d, self.sam_features[image_name]) # [id,H,W,C=1] - - sam_mask_all_levels.append(sam_mask_all_level) - - sam_mask = sam_mask_all_level[mask_id] - if len(sam_mask.shape) != 2: sam_mask = torch.from_numpy(sam_mask).squeeze(-1).to("cuda") - else: sam_mask = torch.from_numpy(sam_mask).to("cuda") - sam_mask = sam_mask.long() # 2D mask image [H,W] -> value - sam_masks.append(sam_mask) - - point_mask, indices_mask = mask_inverse(gaussians.get_xyz, view, sam_mask) - multiview_masks.append(point_mask.unsqueeze(-1)) - return sam_mask_all_levels, sam_masks, multiview_masks - def _get_multilayer_mask(self, img_name): if self._new_loaded: return None return self.record["sam_all"].get(img_name) + def _get_single_view_seg(self, progress:gr.Progress=None): + prompts_3D = self.seg2d_mark[img_name]['prompts_3D'] # torch.Tensor[N,3], 单视角 + tmp_sam_masks = self.record["sam_all"].get(img_name)[self.maskid]['sam_masks'].clone() + tmp_multiviews = self.record["sam_all"].get(img_name)[self.maskid]['multiview'].clone() + sam_all, sam_masks, multiview_masks = self.generate_multiview_masks(prompts_3D) + self.record["sam_all"][img_name] = {"sam_masks": sam_masks, "multiview": multiview_masks} + self.saved_curr_gs_path = "tmp/saved_current_gs_single_view" + self.seg_gaussian(threshold=0.7, object_name=self.saved_curr_gs_path, progress=progress) + self.record["sam_all"][img_name] = {"sam_masks": tmp_sam_masks, "multiview": tmp_multiviews} + del sam_masks, multiview_masks + return self.saved_curr_gs_path + + def _get_multi_view_seg(self, progress:gr.Progress=None): + self.saved_curr_gs_path = "tmp/saved_current_gs_multi_view" + self.seg_gaussian(threshold=0.7, object_name=self.saved_curr_gs_path, progress=progress) + return self.saved_curr_gs_path + def _get_mask(self, progress:gr.Progress=None): """ 根据prompts_3D和maskid作为索引，保存multiview_sam_masks, multiview_masks @@ -588,14 +620,16 @@ def _get_mask(self, progress:gr.Progress=None): multiview_sam_masks: 是选中的mask,用于3D分割,需要mask_id multiview_masks : 是3D点的mask,用于3D分割,需要mask_id """ - # 收集prompts_3D - prompts_3D_list = [] - for img_name in self.images.keys(): - prompts_3D = self.seg2d_mark[img_name]['prompts_3D'] # torch.Tensor[N,3] - if prompts_3D.shape[0] > 0: prompts_3D_list.append(prompts_3D) # 检查是否有3D点标注 - - if prompts_3D_list: prompts_3D_tensor = torch.cat(prompts_3D_list, dim=0) # [M,3] - else: prompts_3D_tensor = torch.empty((0, 3), dtype=torch.float32, device="cuda") + if self.segmode == 0: # Single + img_name = self.current_image + prompts_3D_tensor = self.seg2d_mark[img_name]['prompts_3D'] # torch.Tensor[N,3], 单视角 + elif self.segmode == 1: # Multi + prompts_3D_list = [] + for img_name in self.images.keys(): + prompts_3D = self.seg2d_mark[img_name]['prompts_3D'] # torch.Tensor[N,3] + if prompts_3D.shape[0] > 0: prompts_3D_list.append(prompts_3D) # 检查是否有3D点标注 + if prompts_3D_list: prompts_3D_tensor = torch.cat(prompts_3D_list, dim=0) # [M,3] + else: prompts_3D_tensor = torch.empty((0, 3), dtype=torch.float32, device="cuda") if progress is not None: progress(0, desc="prepare Prompt 3D") sam_alls, sam_masks, multiviews = self.generate_multiview_masks(prompts_3D_tensor, progress=progress) @@ -716,104 +750,190 @@ def ensemble(self, threshold=0.7): return vote_labels, indices_mask - def seg_gaussian(self, threshold, object_name, progress:gr.Progress = None): - if progress is not None: progress(0, desc="load gaussians and mask") - self._get_mask(progress=progress) # 需要match maskid - model_path = self.scene.model_path - gaussians = self.scene.gaussians - _, final_mask = self.ensemble(threshold) + # 每次做2D->3D分割，都是从一个新的gaussians开始，分割到curr_gaussian里，保存到saved_curr_gs_path里 + # add_to_result时，把last_gaussian保存到saved_last_gs_path里 + # 用户主动保存时，把last_gaussian保存到object_name里 + # seg_gaussian只处理curr_gaussian + def seg_gaussian(self, threshold, progress:gr.Progress = None): + + if progress is not None: progress(0, desc="Seg3D - Loading Gaussian") cameras = self.scene.getTrainCameras() - if progress is not None: progress(0.1, desc="gaussian multiview decomp") + curr_gaussian = self.load_scene_gaussians() - self.saved_fg_path = os.path.join(model_path, f'objects/{object_name}/fg.ply') - os.makedirs(os.path.dirname(self.saved_fg_path), exist_ok=True) - save_gs(gaussians, final_mask, self.saved_fg_path) - if progress is not None: progress(0.3, desc="gaussian multiview decomp") + if progress is not None: progress(0.2, desc="Seg3D - Get Mask") + self._get_mask(progress=progress) # 需要match maskid + _, final_mask = self.ensemble(threshold) - # if gaussian decomposition as a post-process module - de_gaussian = self.load_scene_gaussians() - for i, view in tqdm(enumerate(cameras), desc="gaussian multiview decomp"): + if progress is not None: progress(0.4, desc="Seg3D - Decomposition") + for i, view in tqdm(enumerate(cameras)): if self.args.gd_interval != -1 and i % self.args.gd_interval == 0: input_mask = self.record["mvmask"][self.maskid]["sam_masks"][i] - de_gaussian = gaussian_decomp(de_gaussian, view, input_mask, final_mask.to('cuda')) - if progress is not None: progress(0.5, desc="render segged gaussian") - - # save after gaussian decomposition - self.saved_bg_path = os.path.join(model_path, f'objects/{object_name}/bg.ply') - save_gs(de_gaussian, final_mask, self.saved_fg_path+"2.ply") - if progress is not None: progress(0.7, desc="render segged gaussian") - - # render object images - seg_gaussians = GaussianModel(self.dataset.sh_degree) - seg_gaussians.load_ply(self.saved_fg_path) - if progress is not None: progress(0.8, desc="render segged gaussian") - - obj_save_path = os.path.join(model_path, f'objects/{object_name}/images') - os.makedirs(obj_save_path, exist_ok=True) - - if not os.path.exists(obj_save_path): os.mkdir(obj_save_path) - for idx in tqdm(range(len(cameras)), desc="render segged gaussian"): - image_name = cameras[idx].image_name - view = cameras[idx] - - render_pkg = render(view, seg_gaussians, pipeline, background) - render_image = render_pkg["render"].permute(1, 2, 0).detach().cpu().numpy() - render_image = (255 * np.clip(render_image, 0, 1)).astype(np.uint8) - render_image = cv2.cvtColor(render_image, cv2.COLOR_RGB2BGR) - cv2.imwrite(os.path.join(obj_save_path, '{}.jpg'.format(image_name)), render_image) - seg_gaussians.save_ply(os.path.join(model_path, f'objects/{object_name}/seg.ply')) - if progress is not None: progress(1, desc="Finished") - - + curr_gaussian = gaussian_decomp(curr_gaussian, view, input_mask, final_mask.to('cuda')) + + if progress is not None: progress(0.6, desc="Seg3D - Segment") + save_gs(curr_gaussian, final_mask, self.saved_curr_gs_path) + + return self.saved_curr_gs_path + + def add_to_result(self): + if self.last_gaussian is None: # 第一次，直接复制给结果 + self.last_gaussian = self.load_curr_gaussians() + if self.last_gaussian is not None: # None即无文件 + os.system(f"cp {self.saved_curr_gs_path} {self.saved_last_gs_path}") + else: # 非第一次，叠加到结果 + curr_gaussian = self.load_curr_gaussians() + if curr_gaussian is not None: # None即无文件 + self.last_gaussian = self.last_gaussian + curr_gaussian + self.last_gaussian.save_ply(self.saved_last_gs_path) + return self.saved_last_gs_path + + def save_object(self, object_name): + if self.last_gaussian is not None: + path = os.path.join(self.scene.model_path, f'objects/{object_name}/fg.ply') + self.last_gaussian.save_ply(path) + return path + else: + print("self.last_gaussian is None.") + return None + + # 标注情况暂存在变量里，Gaussian存为文件 + def save_ckpt(self, progress:gr.Progress = None): + if progress is not None: progress(0, desc="Save Annotation") + self.has_ckpt = True + self.ckpt_seg2d_mask = {} + for key, value in self.seg2d_mark.items(): + self.ckpt_seg2d_mask[key] = { + 'points': value['points'][:], + 'history': [(points[:], prompts_3D.clone() if prompts_3D is not None else None) + for points, prompts_3D in value['history']], + 'history_index': value['history_index'], + 'prompts_3D': value['prompts_3D'].clone() if value['prompts_3D'] is not None else empty_3D.clone() + } + self.ckpt_record = { + "prompts": self.record["prompts"].clone() if self.record["prompts"] is not None else None, + "mvmask": { + mask_id: { + "multiview": [mask.clone() for mask in masks["multiview"]], + "sam_masks": [mask.clone() for mask in masks["sam_masks"]] + } + for mask_id, masks in self.record["mvmask"].items() + }, + "sam_all": { + img_name: mask.clone() if mask is not None else None + for img_name, mask in self.record["sam_all"].items() + } + } + if progress is not None: progress(0.3, desc="Save Current Gaussian") + if os.path.isfile(self.saved_curr_gs_path): os.system(f"cp {self.saved_curr_gs_path} {self.saved_curr_ckpt_gs_path}") + else: os.system(f"rm -f {self.saved_curr_ckpt_gs_path}") + if progress is not None: progress(0.7, desc="Save Result Gaussian") + if os.path.isfile(self.saved_last_gs_path): os.system(f"cp {self.saved_last_gs_path} {self.saved_last_ckpt_gs_path}") + else: os.system(f"rm -f {self.saved_last_ckpt_gs_path}") + if progress is not None: progress(1 , desc="Finished") + print("Checkpoint Saved") + + # 标注情况暂存在变量里，Gaussian存为文件 + def load_ckpt(self, progress:gr.Progress = None): + if progress is not None: progress(0, desc="Load Annotation") + if self.has_ckpt: + self.seg2d_mask = self.ckpt_seg2d_mask + self.record = self.ckpt_record + if progress is not None: progress(0, desc="Load Current Gaussian") + if os.path.isfile(self.saved_curr_ckpt_gs_path): + os.system(f"cp {self.saved_curr_ckpt_gs_path} {self.saved_curr_gs_path}") + if progress is not None: progress(0, desc="Load Result Gaussian") + if os.path.isfile(self.saved_last_ckpt_gs_path): + self.last_gaussian = self.load_gaussians(self.saved_last_ckpt_gs_path) + os.system(f"cp {self.saved_last_ckpt_gs_path} {self.saved_last_gs_path}") + if progress is not None: progress(0, desc="Checkpoint Loaded") + else: + if progress is not None: progress(1, desc="No Checkpoint") + print("No Checkpoint") + return self.saved_curr_gs_path, self.saved_last_gs_path def create_gradio_interface(default_model_paths, predictor): tool = GradioAnnotationTool(model_path=None, predictor=predictor) - with gr.Blocks() as demo: + with gr.Blocks( + css=""" + .no-padding-border { + padding: 0 !important; + height: 40px !important; + } + #model-path-dropdown { + margin: 0 !important; + } + #object-name-input { + margin: 0 !important; + height: 38px !important; + padding: 4px !important; + } + """ + ) as demo: with gr.Row(): - original_display = gr.Image(label="Origin", interactive=False) - mask_display = gr.Image(label="Layer Mask", interactive=False) + original_display = gr.Image(label="Origin", interactive=False) + mask_display = gr.Image(label="Layer Mask", interactive=False) selected_mask_display = gr.Image(label="Mask Result", interactive=False) with gr.Row(): with gr.Column(scale=1): with gr.Row(): - undo_btn = gr.Button("Undo") - redo_btn = gr.Button("Redo") + undo_btn = gr.Button("撤销标注") + redo_btn = gr.Button("重做标注") with gr.Row(): - seg_view = gr.Button("Seg View") - add_view = gr.Button("Add to Result") + seg_curr = gr.Button("分割为3D") + add_curr = gr.Button("加入最终结果") with gr.Column(scale=1): with gr.Row(): - cls_cur_btn = gr.Button("Clear Curr View Marks") - cls_all_btn = gr.Button("Clear All Views Marks") + cls_cur_btn = gr.Button("清空当前视角标注") + cls_all_btn = gr.Button("清空所有视角标注") with gr.Row(): - seg_view = gr.Button("Save Checkpoint") - seg_view = gr.Button("Clear Result") + ckp_save = gr.Button("保存暂存点") + ckp_rest = gr.Button("恢复暂存点") with gr.Column(scale=1): with gr.Row(): mask_selector = gr.Radio( choices=["S", "M", "L"], - label="Select Mask", + label="SAM Mask Layer", value="S", interactive=True ) + mode_selector = gr.Radio( + choices=["Single", "Multi"], + label="Annotation Mode", + value="Single", + interactive=True + ) - with gr.Row() as prompt_col: - with gr.Column(scale=1.5): + with gr.Row(): + with gr.Column(scale=3): model_path_input = gr.Dropdown( choices=default_model_paths, allow_custom_value=True, value="", show_label=False, interactive=True, + scale=1, + min_width=40, + container=False, + elem_classes="no-padding-border", + elem_id="model-path-dropdown" ) - with gr.Column(scale=0.5): - model_path_btn = gr.Button("Open Model") with gr.Column(scale=1): - object_name_input = gr.Textbox(placeholder="Your Object Name", show_label=False, interactive=True, submit_btn="Seg!") - + model_path_btn = gr.Button("打开3D模型") + with gr.Column(scale=2): + object_name_input = gr.Textbox( + placeholder="Your Object Name", + show_label=False, + interactive=True, + submit_btn="Save to Object File", + scale=1, + min_width=38, + # container=False, + # elem_classes="no-padding", + elem_id="object-name-input" # 添加唯一ID以便样式定位 + ) with gr.Row(): with gr.Column(scale=2): gallery = gr.Gallery( @@ -825,11 +945,11 @@ def create_gradio_interface(default_model_paths, predictor): allow_preview=False, ) with gr.Column(scale=1): - with gr.Row(): fg_gs = LitModel3D(label="Current View Segment", exposure=10.0, height=300) - with gr.Row(): download_fg_gs = gr.DownloadButton(label="Download", interactive=False) + with gr.Row(): curr_gs = LitModel3D(label="临时结果", exposure=10.0, height=300) + with gr.Row(): download_curr_gs = gr.DownloadButton(label="下载", interactive=False) with gr.Column(scale=1): - with gr.Row(): bg_gs = LitModel3D(label="Final Segment", exposure=10.0, height=300) - with gr.Row(): download_bg_gs = gr.DownloadButton(label="Download", interactive=False) + with gr.Row(): last_gs = LitModel3D(label="最终结果", exposure=10.0, height=300) + with gr.Row(): download_last_gs = gr.DownloadButton(label="下载", interactive=False) def on_mask_select(choice): if choice == "S": mask_id = 0 @@ -837,7 +957,13 @@ def on_mask_select(choice): elif choice == "L": mask_id = 2 selected_mask = tool.set_mask_id(mask_id) return selected_mask - + + def on_mode_select(choice): + if choice == "Single": mask_id = 0 + elif choice == "Multi": mask_id = 1 + original, mask, selected_mask = tool.set_mode_id(mask_id) + return original, mask, selected_mask + def get_available_mask_choices(tool): # mark = tool.seg2d_mark[tool.current_image] # if tool._get_multilayer_mask() is None: return ["S"] @@ -850,14 +976,14 @@ def add_point_from_original(evt: gr.SelectData): available_masks = get_available_mask_choices(tool) mask_id = tool.maskid if mask_id >= len(available_masks): mask_id = len(available_masks)-1 - return orig, mask, selected, gr.update(choices=available_masks, value=available_masks[mask_id] if available_masks else None) + return orig, mask, selected def add_point_from_mask(evt: gr.SelectData): orig, mask, selected = tool.add_point(evt, is_original=False) available_masks = get_available_mask_choices(tool) mask_id = tool.maskid if mask_id >= len(available_masks): mask_id = len(available_masks)-1 - return orig, mask, selected, gr.update(choices=available_masks, value=available_masks[mask_id] if available_masks else None) + return orig, mask, selected def load_with_progress(model_path, progress=gr.Progress(track_tqdm=True)): torch.cuda.empty_cache() @@ -868,51 +994,88 @@ def load_with_progress(model_path, progress=gr.Progress(track_tqdm=True)): available_masks = get_available_mask_choices(tool) return \ gr.update(value = [(tool.images[k],k) for k in sorted(tool.images.keys(), key=lambda x: int(x) if x.isdigit() else x)]),\ - orig, mask, selected, \ - gr.update(choices=available_masks, value=available_masks[0] if available_masks else None) + orig, mask, selected + + def save_ckpt(progress=gr.Progress(track_tqdm=True)): + tool.save_ckpt(progress) + return gr.update(interactive=True), gr.update(interactive=True) + + def load_ckpt(progress=gr.Progress(track_tqdm=True)): + path1, path2 = tool.load_ckpt(progress) + orig, mask, selected = tool._render_original(), tool._render_mask(), tool._render_selected_mask() + return orig, mask, selected, path1, path1, path2, path2 + + def get_curr_seg(progress=gr.Progress(track_tqdm=True)): + path = tool.seg_gaussian(0.7, progress=progress) + return path, gr.update(value=path, interactive=True) + + def add_curr_seg(): + path = tool.add_to_result() + return path, gr.update(value=path, interactive=True) + # 加载模型 model_path_btn.click( fn=load_with_progress, inputs=model_path_input, - outputs=[gallery, original_display, mask_display, selected_mask_display, mask_selector], + outputs=[gallery, original_display, mask_display, selected_mask_display], ) + # 标点 original_display.select( fn=add_point_from_original, - outputs=[original_display, mask_display, selected_mask_display, mask_selector] + outputs=[original_display, mask_display, selected_mask_display] ) mask_display.select( fn=add_point_from_mask, - outputs=[original_display, mask_display, selected_mask_display, mask_selector] + outputs=[original_display, mask_display, selected_mask_display] ) + # 选择模式 mask_selector.change( fn=on_mask_select, inputs=[mask_selector], outputs=[selected_mask_display] ) - + + mode_selector.change( + fn=on_mode_select, + inputs=[mask_selector], + outputs=[original_display, mask_display, selected_mask_display, selected_mask_display] + ) + + # 操作 undo_btn.click(fn=lambda: tool.undo(), outputs=[original_display, mask_display, selected_mask_display]) redo_btn.click(fn=lambda: tool.redo(), outputs=[original_display, mask_display, selected_mask_display]) cls_cur_btn.click(fn=tool.clear_current, outputs=[original_display, mask_display, selected_mask_display]) cls_all_btn.click(fn=tool.clear_all, outputs=[original_display, mask_display, selected_mask_display]) + seg_curr.click(fn=get_curr_seg, outputs=[curr_gs, download_curr_gs]) + add_curr.click(fn=add_curr_seg, outputs=[last_gs, download_last_gs]) + + ckp_save.click(fn=save_ckpt, outputs=[ckp_save, ckp_rest]) + ckp_rest.click(fn=load_ckpt, outputs=[ + original_display, mask_display, selected_mask_display, + curr_gs, download_curr_gs, last_gs, download_last_gs + ]) + + def save_gaussian(object_name): + tool.save_object(object_name) + def seg_gaussian_with_prompt(object_name, progress=gr.Progress(track_tqdm=True)): yield gr.update(value=f"Processing: '{object_name}'...", interactive=False) - tool.seg_gaussian(threshold=0.7, object_name=object_name, progress=None) + tool.seg_gaussian(threshold=0.7, object_name=object_name, progress=progress) yield gr.update(value=object_name, placeholder="Your Object Name", interactive=True) object_name_input.submit( # 保存Gaussian - fn=seg_gaussian_with_prompt, + fn=save_gaussian, inputs=object_name_input, - outputs=[object_name_input] ).then( # 显示Gaussian - fn=lambda: tool.saved_fg_path, - outputs=[fg_gs] - ).then( - fn = lambda: gr.update(value=tool.saved_fg_path, interactive=True), - outputs=[download_fg_gs], + fn=lambda: (tool.saved_curr_gs_path, gr.update(value=tool.saved_curr_gs_path, interactive=True)), + outputs=[curr_gs, download_curr_gs] + ).then( # 显示Gaussian + fn=lambda: (tool.saved_last_gs_path, gr.update(value=tool.saved_last_gs_path, interactive=True)), + outputs=[last_gs, download_last_gs] ) # Gallery选择事件处理 @@ -965,14 +1128,11 @@ def find_model_folders(base_path, relative_to="."): if __name__ == "__main__": - # with profile(on_trace_ready=torch.profiler.tensorboard_trace_handler('./log')) as prof: - base_dir = "../TRELLIS/results" - default_model_paths = find_model_folders(base_dir) - - predictor = load_sam() + base_dir = "../TRELLIS/results" + default_model_paths = find_model_folders(base_dir) - # 创建并启动Gradio界面，传入预先提取的特征和场景 - demo = create_gradio_interface(default_model_paths, predictor) - demo.launch(server_name="0.0.0.0", server_port=None, - allowed_paths = ["./", base_dir]) + predictor = load_sam() + demo = create_gradio_interface(default_model_paths, predictor) + demo.launch(server_name="0.0.0.0", server_port=None, + allowed_paths = ["./", base_dir]) \ No newline at end of file diff --git a/gaussiansplatting/scene/gaussian_model.py b/gaussiansplatting/scene/gaussian_model.py index 7c48f17..a3f193d 100644 --- a/gaussiansplatting/scene/gaussian_model.py +++ b/gaussiansplatting/scene/gaussian_model.py @@ -58,6 +58,138 @@ def __init__(self, sh_degree : int): self.spatial_lr_scale = 0 self.setup_functions() + def __add__(self, other, threshold = 1e-5): + """将两个GaussianModel点云模型相加""" + if other is None: return self + assert self.max_sh_degree == other.max_sh_degree, f"max_sh_degree {self.max_sh_degree} != {other.max_sh_degree}" + result = GaussianModel(self.max_sh_degree) + + # 合并 + result._xyz = torch.cat([self._xyz .detach(), other._xyz .detach()], dim=0) + result._features_dc = torch.cat([self._features_dc .detach(), other._features_dc .detach()], dim=0) + result._features_rest = torch.cat([self._features_rest.detach(), other._features_rest.detach()], dim=0) + result._opacity = torch.cat([self._opacity .detach(), other._opacity .detach()], dim=0) + result._scaling = torch.cat([self._scaling .detach(), other._scaling .detach()], dim=0) + result._rotation = torch.cat([self._rotation .detach(), other._rotation .detach()], dim=0) + + result.max_radii2D = torch.zeros((result.get_xyz.shape[0]) , device="cuda") + result.xyz_gradient_accum = torch.zeros((result.get_xyz.shape[0], 1), device="cuda") + result.denom = torch.zeros((result.get_xyz.shape[0], 1), device="cuda") + + result.active_sh_degree = max(self.active_sh_degree, other.active_sh_degree) + result.spatial_lr_scale = max(self.spatial_lr_scale, other.spatial_lr_scale) + result.percent_dense = max(self.percent_dense, other.percent_dense) + + if threshold is not None: + # 对合并后的点，计算重复点并删除。默认删除索引更大的点（other来源的点） + sorted_indices = torch.argsort(result._xyz[:, 0]) # 按x坐标排序 + sorted_xyz = result._xyz[sorted_indices] + + # 计算相邻点的距离 + diff_sorted = sorted_xyz[1:] - sorted_xyz[:-1] + dist_sorted = torch.norm(diff_sorted, dim=1) + + # 创建掩码并映射回原始索引 + valid_mask = torch.ones(result._xyz.shape[0], dtype=torch.bool, device=result._xyz.device) + valid_mask[sorted_indices[1:]] = dist_sorted > threshold + + # 应用掩码到result的所有属性 + result.apply_mask(valid_mask) + + result.active_sh_degree = max(self.active_sh_degree, other.active_sh_degree) + result.spatial_lr_scale = max(self.spatial_lr_scale, other.spatial_lr_scale) + result.percent_dense = max(self.percent_dense , other.percent_dense) + + return result + + def deepcopy(self): + """深度复制当前高斯模型,包括所有参数、梯度和优化器状态""" + new_model = GaussianModel(self.max_sh_degree) + + # 复制基本属性 + new_model.active_sh_degree = self.active_sh_degree + new_model.spatial_lr_scale = self.spatial_lr_scale + new_model.percent_dense = self.percent_dense + + # 复制所有张量参数及其梯度 + new_model._xyz = nn.Parameter(self._xyz.detach().clone()) + new_model._features_dc = nn.Parameter(self._features_dc.detach().clone()) + new_model._features_rest = nn.Parameter(self._features_rest.detach().clone()) + new_model._scaling = nn.Parameter(self._scaling.detach().clone()) + new_model._rotation = nn.Parameter(self._rotation.detach().clone()) + new_model._opacity = nn.Parameter(self._opacity.detach().clone()) + + if self._xyz.grad is not None: + new_model._xyz.grad = self._xyz.grad.clone() + if self._features_dc.grad is not None: + new_model._features_dc.grad = self._features_dc.grad.clone() + if self._features_rest.grad is not None: + new_model._features_rest.grad = self._features_rest.grad.clone() + if self._scaling.grad is not None: + new_model._scaling.grad = self._scaling.grad.clone() + if self._rotation.grad is not None: + new_model._rotation.grad = self._rotation.grad.clone() + if self._opacity.grad is not None: + new_model._opacity.grad = self._opacity.grad.clone() + + # 复制其他状态张量 + new_model.max_radii2D = self.max_radii2D.clone() if self.max_radii2D is not None else None + new_model.xyz_gradient_accum = self.xyz_gradient_accum.clone() if self.xyz_gradient_accum is not None else None + new_model.denom = self.denom.clone() if self.denom is not None else None + + # 如果存在优化器,复制优化器状态 + if self.optimizer is not None: + # 设置新模型的优化器参数组 + l = [ + {'params': [new_model._xyz], 'lr': self.optimizer.param_groups[0]['lr'], "name": "xyz"}, + {'params': [new_model._features_dc], 'lr': self.optimizer.param_groups[1]['lr'], "name": "f_dc"}, + {'params': [new_model._features_rest], 'lr': self.optimizer.param_groups[2]['lr'], "name": "f_rest"}, + {'params': [new_model._opacity], 'lr': self.optimizer.param_groups[3]['lr'], "name": "opacity"}, + {'params': [new_model._scaling], 'lr': self.optimizer.param_groups[4]['lr'], "name": "scaling"}, + {'params': [new_model._rotation], 'lr': self.optimizer.param_groups[5]['lr'], "name": "rotation"} + ] + + new_model.optimizer = torch.optim.Adam(l, lr=0.0, eps=1e-15) + + # 复制优化器状态字典 + optimizer_state = self.optimizer.state_dict() + new_model.optimizer.load_state_dict(optimizer_state) + + # 确保优化器状态指向新参数 + for old_param, new_param in zip(self.optimizer.state.keys(), new_model.optimizer.state.keys()): + new_model.optimizer.state[new_param] = { + key: value.clone() if torch.is_tensor(value) else value + for key, value in self.optimizer.state[old_param].items() + } + + return new_model + + def save_gs(pc, indices_mask, save_path): + xyz = pc._xyz.detach().cpu()[indices_mask].numpy() + normals = np.zeros_like(xyz) + f_dc = pc._features_dc.detach().transpose(1, 2).flatten(start_dim=1).contiguous().cpu()[indices_mask].numpy() + f_rest = pc._features_rest.detach().transpose(1, 2).flatten(start_dim=1).contiguous().cpu()[indices_mask].numpy() + opacities = pc._opacity.detach().cpu()[indices_mask].numpy() + scale = pc._scaling.detach().cpu()[indices_mask].numpy() + rotation = pc._rotation.detach().cpu()[indices_mask].numpy() + dtype_full = [(attribute, 'f4') for attribute in pc.construct_list_of_attributes()] + elements = np.empty(xyz.shape[0], dtype=dtype_full) + attributes = np.concatenate((xyz, normals, f_dc, f_rest, opacities, scale, rotation), axis=1) + elements[:] = list(map(tuple, attributes)) + el = PlyElement.describe(elements, 'vertex') + PlyData([el]).write(save_path) + + def apply_mask(self, indices_mask): + self._xyz = nn.Parameter(self._xyz [indices_mask].requires_grad_(False)) + self._features_dc = nn.Parameter(self._features_dc [indices_mask].requires_grad_(False)) + self._features_rest = nn.Parameter(self._features_rest [indices_mask].requires_grad_(False)) + self._scaling = nn.Parameter(self._scaling [indices_mask].requires_grad_(False)) + self._rotation = nn.Parameter(self._rotation [indices_mask].requires_grad_(False)) + self._opacity = nn.Parameter(self._opacity [indices_mask].requires_grad_(False)) + self.max_radii2D = nn.Parameter(self.max_radii2D [indices_mask].requires_grad_(False)) + self.xyz_gradient_accum = nn.Parameter(self.xyz_gradient_accum [indices_mask].requires_grad_(False)) + self.denom = nn.Parameter(self.denom [indices_mask].requires_grad_(False)) + def capture(self): return ( self.active_sh_degree, @@ -246,12 +378,12 @@ def load_ply(self, path): for idx, attr_name in enumerate(rot_names): rots[:, idx] = np.asarray(plydata.elements[0][attr_name]) - self._xyz = nn.Parameter(torch.tensor(xyz, dtype=torch.float, device="cuda").requires_grad_(True)) - self._features_dc = nn.Parameter(torch.tensor(features_dc, dtype=torch.float, device="cuda").transpose(1, 2).contiguous().requires_grad_(True)) - self._features_rest = nn.Parameter(torch.tensor(features_extra, dtype=torch.float, device="cuda").transpose(1, 2).contiguous().requires_grad_(True)) - self._opacity = nn.Parameter(torch.tensor(opacities, dtype=torch.float, device="cuda").requires_grad_(True)) - self._scaling = nn.Parameter(torch.tensor(scales, dtype=torch.float, device="cuda").requires_grad_(True)) - self._rotation = nn.Parameter(torch.tensor(rots, dtype=torch.float, device="cuda").requires_grad_(True)) + self._xyz = nn.Parameter(torch.tensor(xyz , dtype=torch.float, device="cuda") .requires_grad_(False)) + self._features_dc = nn.Parameter(torch.tensor(features_dc , dtype=torch.float, device="cuda").transpose(1, 2).contiguous().requires_grad_(False)) + self._features_rest = nn.Parameter(torch.tensor(features_extra , dtype=torch.float, device="cuda").transpose(1, 2).contiguous().requires_grad_(False)) + self._opacity = nn.Parameter(torch.tensor(opacities , dtype=torch.float, device="cuda") .requires_grad_(False)) + self._scaling = nn.Parameter(torch.tensor(scales , dtype=torch.float, device="cuda") .requires_grad_(False)) + self._rotation = nn.Parameter(torch.tensor(rots , dtype=torch.float, device="cuda") .requires_grad_(False)) self.active_sh_degree = self.max_sh_degree @@ -292,12 +424,12 @@ def prune_points(self, mask): valid_points_mask = ~mask optimizable_tensors = self._prune_optimizer(valid_points_mask) - self._xyz = optimizable_tensors["xyz"] - self._features_dc = optimizable_tensors["f_dc"] + self._xyz = optimizable_tensors["xyz"] + self._features_dc = optimizable_tensors["f_dc"] self._features_rest = optimizable_tensors["f_rest"] - self._opacity = optimizable_tensors["opacity"] - self._scaling = optimizable_tensors["scaling"] - self._rotation = optimizable_tensors["rotation"] + self._opacity = optimizable_tensors["opacity"] + self._scaling = optimizable_tensors["scaling"] + self._rotation = optimizable_tensors["rotation"] self.xyz_gradient_accum = self.xyz_gradient_accum[valid_points_mask] diff --git a/seg_utils.py b/seg_utils.py index 67ad882..23780af 100644 --- a/seg_utils.py +++ b/seg_utils.py @@ -177,7 +177,7 @@ def conv2d_matrix(gaussians, viewpoint_camera, indices_mask, device): return conv2d_matrix - +# 原位操作，不增加点云数量 def update(gaussians, view, selected_index, ratios, dir_vector): ratios = ratios.unsqueeze(-1).to("cuda") selected_xyz = gaussians.get_xyz[selected_index]