init project

app.py

@@ -44,7 +44,7 @@ device = 'cuda' if torch.cuda.is_available() else 'cpu'
 # pe3r = Models(device)
 MAST3R_CKP = 'naver/MASt3R_ViTLarge_BaseDecoder_512_catmlpdpt_metric'
 mast3r = AsymmetricMASt3R.from_pretrained(MAST3R_CKP).to(device)
-
+print(device)
 
 
 def _convert_scene_output_to_glb(outdir, imgs, pts3d, mask, focals, cams2world, cam_size=0.05,
@@ -114,138 +114,138 @@ def get_3D_model_from_scene(outdir, scene, min_conf_thr=3, as_pointcloud=False,
     return _convert_scene_output_to_glb(outdir, rgbimg, pts3d, msk, focals, cams2world, as_pointcloud=as_pointcloud,
                                         transparent_cams=transparent_cams, cam_size=cam_size)
 
-def mask_nms(masks, threshold=0.8):
-    keep = []
-    mask_num = len(masks)
-    suppressed = np.zeros((mask_num), dtype=np.int64)
-    for i in range(mask_num):
-        if suppressed[i] == 1:
-            continue
-        keep.append(i)
-        for j in range(i + 1, mask_num):
-            if suppressed[j] == 1:
-                continue
-            intersection = (masks[i] & masks[j]).sum()
-            if min(intersection / masks[i].sum(), intersection / masks[j].sum()) > threshold:
-                suppressed[j] = 1
-    return keep
-
-def filter(masks, keep):
-    ret = []
-    for i, m in enumerate(masks):
-        if i in keep: ret.append(m)
-    return ret
-
-def mask_to_box(mask):
-    if mask.sum() == 0:
-        return np.array([0, 0, 0, 0])
+# def mask_nms(masks, threshold=0.8):
+#     keep = []
+#     mask_num = len(masks)
+#     suppressed = np.zeros((mask_num), dtype=np.int64)
+#     for i in range(mask_num):
+#         if suppressed[i] == 1:
+#             continue
+#         keep.append(i)
+#         for j in range(i + 1, mask_num):
+#             if suppressed[j] == 1:
+#                 continue
+#             intersection = (masks[i] & masks[j]).sum()
+#             if min(intersection / masks[i].sum(), intersection / masks[j].sum()) > threshold:
+#                 suppressed[j] = 1
+#     return keep
+
+# def filter(masks, keep):
+#     ret = []
+#     for i, m in enumerate(masks):
+#         if i in keep: ret.append(m)
+#     return ret
+
+# def mask_to_box(mask):
+#     if mask.sum() == 0:
+#         return np.array([0, 0, 0, 0])
     
-    # Get the rows and columns where the mask is 1
-    rows = np.any(mask, axis=1)
-    cols = np.any(mask, axis=0)
+#     # Get the rows and columns where the mask is 1
+#     rows = np.any(mask, axis=1)
+#     cols = np.any(mask, axis=0)
     
-    # Get top, bottom, left, right edges
-    top = np.argmax(rows)
-    bottom = len(rows) - 1 - np.argmax(np.flip(rows))
-    left = np.argmax(cols)
-    right = len(cols) - 1 - np.argmax(np.flip(cols))
+#     # Get top, bottom, left, right edges
+#     top = np.argmax(rows)
+#     bottom = len(rows) - 1 - np.argmax(np.flip(rows))
+#     left = np.argmax(cols)
+#     right = len(cols) - 1 - np.argmax(np.flip(cols))
     
-    return np.array([left, top, right, bottom])
-
-def box_xyxy_to_xywh(box_xyxy):
-    box_xywh = deepcopy(box_xyxy)
-    box_xywh[2] = box_xywh[2] - box_xywh[0]
-    box_xywh[3] = box_xywh[3] - box_xywh[1]
-    return box_xywh
-
-def get_seg_img(mask, box, image):
-    image = image.copy()
-    x, y, w, h = box
-    # image[mask == 0] = np.array([0, 0, 0], dtype=np.uint8)
-    box_area = w * h
-    mask_area = mask.sum()
-    if 1 - (mask_area / box_area) < 0.2:
-        image[mask == 0] = np.array([0, 0, 0], dtype=np.uint8)
-    else:
-        random_values = np.random.randint(0, 255, size=image.shape, dtype=np.uint8)
-        image[mask == 0] = random_values[mask == 0]
-    seg_img = image[y:y+h, x:x+w, ...]
-    return seg_img
-
-def pad_img(img):
-    h, w, _ = img.shape
-    l = max(w,h) 
-    pad = np.zeros((l,l,3), dtype=np.uint8) # 
-    if h > w:
-        pad[:,(h-w)//2:(h-w)//2 + w, :] = img
-    else:
-        pad[(w-h)//2:(w-h)//2 + h, :, :] = img
-    return pad
-
-def batch_iterator(batch_size: int, *args) -> Generator[List[Any], None, None]:
-    assert len(args) > 0 and all(
-        len(a) == len(args[0]) for a in args
-    ), "Batched iteration must have inputs of all the same size."
-    n_batches = len(args[0]) // batch_size + int(len(args[0]) % batch_size != 0)
-    for b in range(n_batches):
-        yield [arg[b * batch_size : (b + 1) * batch_size] for arg in args]
-
-def slerp(u1, u2, t):
-    """
-    Perform spherical linear interpolation (Slerp) between two unit vectors.
+#     return np.array([left, top, right, bottom])
+
+# def box_xyxy_to_xywh(box_xyxy):
+#     box_xywh = deepcopy(box_xyxy)
+#     box_xywh[2] = box_xywh[2] - box_xywh[0]
+#     box_xywh[3] = box_xywh[3] - box_xywh[1]
+#     return box_xywh
+
+# def get_seg_img(mask, box, image):
+#     image = image.copy()
+#     x, y, w, h = box
+#     # image[mask == 0] = np.array([0, 0, 0], dtype=np.uint8)
+#     box_area = w * h
+#     mask_area = mask.sum()
+#     if 1 - (mask_area / box_area) < 0.2:
+#         image[mask == 0] = np.array([0, 0, 0], dtype=np.uint8)
+#     else:
+#         random_values = np.random.randint(0, 255, size=image.shape, dtype=np.uint8)
+#         image[mask == 0] = random_values[mask == 0]
+#     seg_img = image[y:y+h, x:x+w, ...]
+#     return seg_img
+
+# def pad_img(img):
+#     h, w, _ = img.shape
+#     l = max(w,h) 
+#     pad = np.zeros((l,l,3), dtype=np.uint8) # 
+#     if h > w:
+#         pad[:,(h-w)//2:(h-w)//2 + w, :] = img
+#     else:
+#         pad[(w-h)//2:(w-h)//2 + h, :, :] = img
+#     return pad
+
+# def batch_iterator(batch_size: int, *args) -> Generator[List[Any], None, None]:
+#     assert len(args) > 0 and all(
+#         len(a) == len(args[0]) for a in args
+#     ), "Batched iteration must have inputs of all the same size."
+#     n_batches = len(args[0]) // batch_size + int(len(args[0]) % batch_size != 0)
+#     for b in range(n_batches):
+#         yield [arg[b * batch_size : (b + 1) * batch_size] for arg in args]
+
+# def slerp(u1, u2, t):
+#     """
+#     Perform spherical linear interpolation (Slerp) between two unit vectors.
     
-    Args:
-    - u1 (torch.Tensor): First unit vector, shape (1024,)
-    - u2 (torch.Tensor): Second unit vector, shape (1024,)
-    - t (float): Interpolation parameter
+#     Args:
+#     - u1 (torch.Tensor): First unit vector, shape (1024,)
+#     - u2 (torch.Tensor): Second unit vector, shape (1024,)
+#     - t (float): Interpolation parameter
     
-    Returns:
-    - torch.Tensor: Interpolated vector, shape (1024,)
-    """
-    # Compute the dot product
-    dot_product = torch.sum(u1 * u2)
+#     Returns:
+#     - torch.Tensor: Interpolated vector, shape (1024,)
+#     """
+#     # Compute the dot product
+#     dot_product = torch.sum(u1 * u2)
     
-    # Ensure the dot product is within the valid range [-1, 1]
-    dot_product = torch.clamp(dot_product, -1.0, 1.0)
+#     # Ensure the dot product is within the valid range [-1, 1]
+#     dot_product = torch.clamp(dot_product, -1.0, 1.0)
     
-    # Compute the angle between the vectors
-    theta = torch.acos(dot_product)
+#     # Compute the angle between the vectors
+#     theta = torch.acos(dot_product)
     
-    # Compute the coefficients for the interpolation
-    sin_theta = torch.sin(theta)
-    if sin_theta == 0:
-        # Vectors are parallel, return a linear interpolation
-        return u1 + t * (u2 - u1)
+#     # Compute the coefficients for the interpolation
+#     sin_theta = torch.sin(theta)
+#     if sin_theta == 0:
+#         # Vectors are parallel, return a linear interpolation
+#         return u1 + t * (u2 - u1)
     
-    s1 = torch.sin((1 - t) * theta) / sin_theta
-    s2 = torch.sin(t * theta) / sin_theta
+#     s1 = torch.sin((1 - t) * theta) / sin_theta
+#     s2 = torch.sin(t * theta) / sin_theta
     
-    # Perform the interpolation
-    return s1 * u1 + s2 * u2
+#     # Perform the interpolation
+#     return s1 * u1 + s2 * u2
 
-def slerp_multiple(vectors, t_values):
-    """
-    Perform spherical linear interpolation (Slerp) for multiple vectors.
+# def slerp_multiple(vectors, t_values):
+#     """
+#     Perform spherical linear interpolation (Slerp) for multiple vectors.
     
-    Args:
-    - vectors (torch.Tensor): Tensor of vectors, shape (n, 1024)
-    - a_values (torch.Tensor): Tensor of values corresponding to each vector, shape (n,)
+#     Args:
+#     - vectors (torch.Tensor): Tensor of vectors, shape (n, 1024)
+#     - a_values (torch.Tensor): Tensor of values corresponding to each vector, shape (n,)
     
-    Returns:
-    - torch.Tensor: Interpolated vector, shape (1024,)
-    """
-    n = vectors.shape[0]
+#     Returns:
+#     - torch.Tensor: Interpolated vector, shape (1024,)
+#     """
+#     n = vectors.shape[0]
     
-    # Initialize the interpolated vector with the first vector
-    interpolated_vector = vectors[0]
+#     # Initialize the interpolated vector with the first vector
+#     interpolated_vector = vectors[0]
     
-    # Perform Slerp iteratively
-    for i in range(1, n):
-        # Perform Slerp between the current interpolated vector and the next vector
-        t = t_values[i] / (t_values[i] + t_values[i-1])
-        interpolated_vector = slerp(interpolated_vector, vectors[i], t)
+#     # Perform Slerp iteratively
+#     for i in range(1, n):
+#         # Perform Slerp between the current interpolated vector and the next vector
+#         t = t_values[i] / (t_values[i] + t_values[i-1])
+#         interpolated_vector = slerp(interpolated_vector, vectors[i], t)
     
-    return interpolated_vector
+#     return interpolated_vector
 
 # @torch.no_grad
 # def get_mask_from_img_sam1(mobilesamv2, yolov8, sam1_image, yolov8_image, original_size, input_size, transform):
@@ -438,7 +438,7 @@ def slerp_multiple(vectors, t_values):
 
 #     return cog_seg_maps, rev_cog_seg_maps, multi_view_clip_feats
 
-@spaces.GPU(duration=180)
+@spaces.GPU(duration=120)
 def get_reconstructed_scene(outdir, filelist, schedule, niter, min_conf_thr,
                             as_pointcloud, mask_sky, clean_depth, transparent_cams, cam_size,
                             scenegraph_type, winsize, refid):