Add files using upload-large-folder tool

RGBD_DINOV3_HouseCat6D_final_copy.py

@@ -0,0 +1,1198 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+import torch
+from custom_utils import ShapeNetCore
+from custom_utils import _compute_fov,_sample_points_from_faces
+from custom_utils import image_grid
+from custom_utils.shapenet_base import HouseCatDataset
+import matplotlib.pyplot as plt
+import numpy as np
+import k3d
+import os
+import json
+import torch
+from PIL import Image
+
+import cv2
+import imageio
+import numpy as np
+from PIL import Image
+import matplotlib.pyplot as plt
+from torchvision import transforms
+from custom_utils.extractor import ViTExtractor
+import torch.nn.functional as F
+from sklearn.decomposition import PCA as sklearnPCA
+import math
+from custom_utils.utils_general import center_crop
+
+from pytorch3d.io import load_objs_as_meshes, load_obj
+from pytorch3d.implicitron.tools.point_cloud_utils import get_rgbd_point_cloud
+from pytorch3d.structures import Meshes
+from pytorch3d.renderer import (
+    PerspectiveCameras,
+    FoVPerspectiveCameras,
+    PointLights,
+    MeshRasterizer,
+    MeshRenderer,
+    RasterizationSettings,
+    HardPhongShader,
+    TexturesVertex,
+    look_at_view_transform,
+    ray_bundle_to_ray_points,
+    NDCMultinomialRaysampler,
+    TexturesUV,
+    BlendParams,
+
+    TexturesVertex
+)
+
+from pytorch3d.implicitron.tools.point_cloud_utils import get_rgbd_point_cloud
+from pytorch3d.structures import Pointclouds
+import torch
+from pytorch3d.ops import sample_farthest_points, knn_points, knn_gather
+
+from matplotlib import cm
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.decomposition import PCA
+from mpl_toolkits.mplot3d import Axes3D
+import open3d as o3d
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from transformers import AutoConfig, AutoModel
+
+class Dinov3PatchExtractor(nn.Module):
+    """
+    Returns patch tokens as [B, C, T] (C=384 for ViT-S/16).
+    Input must be ImageNet-normalized [B,3,H,W].
+    """
+    def __init__(self, model_id="facebook/dinov3-vits16-pretrain-lvd1689m", freeze=True):
+        super().__init__()
+        self.cfg  = AutoConfig.from_pretrained(model_id)
+        self.C    = self.cfg.hidden_size                      # 384
+        self.nreg = getattr(self.cfg, "num_register_tokens", 0)
+        self.backbone = AutoModel.from_pretrained(model_id).eval()
+        self.p = 16  # ViT-S/16 的 patch 大小
+        if freeze:
+            for p in self.backbone.parameters():
+                p.requires_grad = False
+
+    @torch.no_grad()
+    def forward(self, x):                                     # x: [B,3,H,W], normalized
+        B, _, H, W = x.shape
+        out = self.backbone(x)
+        seq = out.last_hidden_state                           # [B, T_all, C]
+        patch_seq = seq[:, 1 + self.nreg :, :]                # drop CLS + registers -> [B, T_patch, C]
+
+
+        # 关键：用输入尺寸和 patch 大小推 H_p, W_p
+        H_p = H // self.p
+        W_p = W // self.p
+        T = patch_seq.shape[1]
+
+        # 若预处理不是整除，或模型内部有 pad/裁剪，做个健壮性兜底
+        if H_p * W_p != T:
+            # 按长宽比从 T 的因子中挑最合理的 (H_p, W_p)
+            aspect = H / W
+            best = None
+            for h in range(1, int(math.sqrt(T)) + 1):
+                if T % h == 0:
+                    w = T // h
+                    for (hh, ww) in [(h, w), (w, h)]:
+                        score = abs((hh / ww) - aspect)
+                        if best is None or score < best[2]:
+                            best = (hh, ww, score)
+            if best is None:
+                raise RuntimeError(f"Cannot factor T={T} into (H_p,W_p).")
+            H_p, W_p, _ = best
+
+        feat = patch_seq.view(B, H_p, W_p, self.C).permute(0, 3, 1, 2)  # [B,C,H_p,W_p]
+        return feat
+
+
+class DINOv3ExtractorAdapter:
+    """
+    Adapter to mimic ViTExtractor.extract_descriptors(batch, layer, facet, bin)
+    Returns descriptors with shape [B, 1, T, d] like ViTExtractor.
+    """
+    def __init__(self, model_id="facebook/dinov3-vits16-pretrain-lvd1689m", device="cuda"):
+        self.device = device
+        self.model = Dinov3PatchExtractor(model_id, freeze=True).to(device)
+        self.p = 16                   # patch size for vits16
+        self.stride = (16, 16)        # nominal stride on tokens
+        self.mean = (0.485, 0.456, 0.406)  # ImageNet normalization
+        self.std  = (0.229, 0.224, 0.225)
+
+    @torch.no_grad()
+    def extract_descriptors(self, batch, layer=11, facet='token', bin=False, include_cls=False):
+        """
+        batch: [B,3,H,W] normalized to ImageNet stats.
+        returns: [B, 1, T, d]（T = H_p*W_p, d=384）
+        """
+        # DINOv3 doesn't expose q/k/v hooks like timm; we just use its final patch tokens.
+        # 先拿到 [B,C,H_p,W_p]
+        feat_map = self.model(batch.to(self.device))        # [B,384,H_p,W_p]
+        B, C, H_p, W_p = feat_map.shape
+        # 再回到 [B,1,T,d] 以兼容你现有代码
+        desc = feat_map.flatten(2).permute(0, 2, 1).unsqueeze(1)  # [B,1,H_p*W_p,384]
+        return desc
+
+
+def sample_points_on_sphere(num_points=80):
+    points = []
+    phi = (1 + math.sqrt(5)) / 2  # golden ratio
+
+    for i in range(num_points):
+        theta = 2 * math.pi * i / phi  # azimuthal angle
+        z = 1 - (2 * i + 1) / num_points  # z-coordinate, uniform from -1 to 1
+        radius = math.sqrt(1 - z * z)  # radius for the xy-plane
+        x = radius * math.cos(theta)
+        y = radius * math.sin(theta)
+        points.append([x, y, z])
+
+    return torch.tensor(points, dtype=torch.float32)
+
+def get_cube_vertices():
+    # Cube vertices (8 vertices)
+    return torch.tensor([[1, 1, 1],
+                         [1, 1, -1],
+                         [1, -1, 1],
+                         [1, -1, -1],
+                         [-1, 1, 1],
+                         [-1, 1, -1],
+                         [-1, -1, 1],
+                         [-1, -1, -1]], dtype=torch.float32)  # Ensure float type
+
+
+def render(meshes,scale=3.0,image_size=(420,420),light=(0.3,0.3,0.3)):
+    # prepare the camera
+    num_views = 8
+    # Get the cube vertices
+    #cube_vertices = get_cube_vertices()*scale
+    cube_vertices = sample_points_on_sphere(num_views)*scale
+    #up = torch.randn(1, 3)
+    up=torch.tensor([[0.0, 0.0, 1.0]], dtype=torch.float32)
+    up = up / torch.norm(up, dim=1)[:, None]
+    R, T = look_at_view_transform(eye=cube_vertices, at=torch.tensor([[0.0, 0.0, 0.0]], dtype=torch.float32), up=up)
+    cam_K= np.array([[572, 0.0, image_size[0]//2], [0.0, 572, image_size[1]//2], [0.0, 0.0, 1.0]])
+    fx,_,cx,_,fy,cy,_,_,_=cam_K.reshape(9)
+    fov_x, fov_y = _compute_fov(cam_K, 420, 420)
+
+    cameras = PerspectiveCameras(device=device, R=R, T=T, image_size=((420,420),),
+                                    focal_length=torch.tensor([[fx, fy]], dtype=torch.float32),
+                                    principal_point=torch.tensor([[cx, cy]], dtype=torch.float32),
+                                    in_ndc=False)
+
+    # prepare the lights
+    raster_settings = RasterizationSettings(image_size=image_size)
+    lights = PointLights(location=torch.tensor([0.0, 1.0, -2.0], device=device)[None], ambient_color=(light,),diffuse_color=(light,),device=device)
+
+    # move the data to the device
+    meshes = meshes.to(device)
+    cameras = cameras.to(device)
+    if len(cameras) != 1 and len(cameras) % len(meshes) != 0:
+        raise ValueError("Mismatch between batch dims of cameras and meshes.")
+    if len(cameras) > 1:
+        meshes = meshes.extend(len(cameras) // len(meshes))
+
+    # prepare the renderer
+    class MeshRendererWithDepth(torch.nn.Module):
+        def __init__(self, rasterizer, shader):
+            super().__init__()
+            self.rasterizer = rasterizer
+            self.shader = shader
+
+        def forward(self, meshes_world, **kwargs) -> torch.Tensor:
+            fragments = self.rasterizer(meshes_world, **kwargs)
+            images = self.shader(fragments, meshes_world, **kwargs)
+            return images, fragments.zbuf
+        
+
+    blend_params = BlendParams(background_color=(0.0, 0.0, 0.0))  # Blue background
+    renderer = MeshRendererWithDepth(
+        rasterizer=MeshRasterizer(
+            cameras=cameras,
+            raster_settings=raster_settings,
+        ),
+    # Set background color to blue [R, G, B]
+
+        shader=HardPhongShader(
+            device=device,
+            cameras=cameras,
+            lights=lights,
+            blend_params=blend_params
+        )
+    )
+
+    images,fragments = renderer(meshes)
+    return images,fragments,cameras
+
+
+def render_batch(meshes,scale=3.0,image_size=(420,420),light=(0.3,0.3,0.3)):
+    # prepare the camera
+    num_views = 8
+    # Get the cube vertices
+    cube_vertices = get_cube_vertices()*scale
+    #cube_vertices = sample_points_on_sphere(num_views)*scale
+    up = torch.randn(1, 3)
+    # up=torch.tensor([[0.0, 0.0, 1.0]], dtype=torch.float32)
+    up = up / torch.norm(up, dim=1)[:, None]
+    R, T = look_at_view_transform(eye=cube_vertices, at=torch.tensor([[0.0, 0.0, 0.0]], dtype=torch.float32), up=up)
+
+    cam_K= np.array([[572, 0.0, image_size[0]//2], [0.0, 572, image_size[1]//2], [0.0, 0.0, 1.0]])
+    fx,_,cx,_,fy,cy,_,_,_=cam_K.reshape(9)
+    fov_x, fov_y = _compute_fov(cam_K, 420, 420)
+
+
+    # prepare the renderer
+    class MeshRendererWithDepth(torch.nn.Module):
+        def __init__(self, rasterizer, shader):
+            super().__init__()
+            self.rasterizer = rasterizer
+            self.shader = shader
+
+        def forward(self, meshes_world, **kwargs) -> torch.Tensor:
+            fragments = self.rasterizer(meshes_world, **kwargs)
+            images = self.shader(fragments, meshes_world, **kwargs)
+            return images, fragments.zbuf
+        
+
+    blend_params = BlendParams(background_color=(0.0, 0.0, 0.0))  # Blue background
+
+    batch_size = 10
+    all_images=[]
+    all_fragments=[]
+
+    # move the data to the device
+    meshes = meshes.extend(batch_size).to(device)
+    for i in range(0,R.shape[0],batch_size):
+        R_batch = R[i:i+batch_size]
+        T_batch = T[i:i+batch_size]
+        cameras_batch = PerspectiveCameras(device=device, R=R_batch, T=T_batch, image_size=((420,420),),
+                                        focal_length=torch.tensor([[fx, fy]], dtype=torch.float32),
+                                        principal_point=torch.tensor([[cx, cy]], dtype=torch.float32),
+                                        in_ndc=False).to(device)
+
+        # prepare the lights
+        raster_settings = RasterizationSettings(image_size=image_size)
+        lights = PointLights(location=torch.tensor([0.0, 1.0, -2.0], device=device)[None], 
+                             ambient_color=(light,),diffuse_color=(light,),device=device)
+
+        renderer = MeshRendererWithDepth(
+            rasterizer=MeshRasterizer(
+                cameras=cameras_batch,
+                raster_settings=raster_settings,
+            ),
+            # Set background color to blue [R, G, B]
+            shader=HardPhongShader(
+                device=device,
+                cameras=cameras_batch,
+                lights=lights,
+                blend_params=blend_params
+            )
+         )
+        images,fragments = renderer(meshes)
+        all_images.append(images)
+        all_fragments.append(fragments)
+    all_images = torch.cat(all_images,dim=0)
+    all_fragments = torch.cat(all_fragments,dim=0)
+    cameras = PerspectiveCameras(device=device, R=R, T=T, image_size=((420,420),),
+                                focal_length=torch.tensor([[fx, fy]], dtype=torch.float32),
+                                principal_point=torch.tensor([[cx, cy]], dtype=torch.float32),
+                                in_ndc=False).to(device)
+    return all_images,all_fragments,cameras
+
+
+def fuse_feature_rgbd(extractor,images,fragments,cameras):
+    dino_feat_masked_list = []
+    feature_point_cloud_list = []
+    for i in range(images.shape[0]):
+        image = images.cpu().numpy()[i, :, :, :3]
+        image_mask = images[i, ..., 3].cpu().numpy()!=0
+        crop_size = (420, 420)
+        crop_image, crop_mask, bbox = center_crop(image, image_mask, crop_size)
+        cropped_image_np = cv2.resize(crop_image, crop_size, interpolation=cv2.INTER_AREA)
+        #cropped_mask = cv2.resize(crop_mask*1.0, crop_size, interpolation=cv2.INTER_NEAREST)!=0  # Use nearest neighbor interpolation for masks
+        orignal_size = (int(bbox[2]-bbox[0]), int(bbox[3]-bbox[1])) #K,K
+
+        to_tensor = transforms.ToTensor()
+        input_image = to_tensor(cropped_image_np).cuda(0)
+        input_image = input_image.unsqueeze(0)
+        #input_image=extractor.preprocess_pil(input_image)
+        mean = torch.tensor([0.485, 0.456, 0.406]).cuda(0)
+        std = torch.tensor([0.229, 0.224, 0.225]).cuda(0)
+        input_image = (input_image - mean[None, :, None, None]) / std[None, :, None, None]
+  
+        _desc_q = extractor.extract_descriptors(input_image,layer=11, facet='key', include_cls=True).squeeze(1) # (1,900,384)
+        # _desc_q = extractor.forward_features(input_image)["x_prenorm"][:, :]   # (1,900,384)
+        #_desc_q = extractor.extract_descriptors(input_image,layer=11,facet='token',include_cls=True).squeeze(1) # B,L,C
+        # _norm_q = torch.linalg.norm(_desc_q, dim=-1)[:, :, None]
+        # _desc_q = _desc_q / (_norm_q)
+
+        desc = _desc_q[:,1:,:][None]
+        #cls_token_q = _desc_q[:,0,:] #B,C`
+
+        input_mask = to_tensor(crop_mask).cuda(0)
+        input_mask = input_mask.unsqueeze(0)
+
+        img_mask = to_tensor(image_mask)
+
+        img_mask = img_mask.permute(1,2,0)
+
+        dino_feat = patch2pixel_feats(desc, original_size=orignal_size) #reize back to K,K =>( K, K, 384)
+        # create dino-feat with orignal size
+        dino_height, dino_width, feat_dim = (image_size[0],image_size[1], desc.shape[-1])
+        dino_feat_orig = torch.zeros(dino_height,dino_width,feat_dim)
+        # Fill the dino features into the original tensor at the specified bounding box
+        dino_feat_orig[bbox[1]:bbox[3], bbox[0]:bbox[2],:] = dino_feat #reize back to K,K =>(420, 420, 384) #gradint is not supported for this operation
+        # Apply the mask
+        dino_feat_masked = dino_feat_orig * img_mask
+        dino_feat_masked = dino_feat_masked.permute(2,0,1).unsqueeze(0)
+        dino_feat_masked_low = F.interpolate(dino_feat_masked, size=(30, 30), mode='bilinear')
+
+        image_mask = images[i, ..., 3][None,None]
+        depth_image = fragments[i, ..., 0][None]*image_mask
+        
+        # # Define the kernel for erosion (3x3 ones kernel)
+        # kernel = torch.ones((1, 1, 5, 5), dtype=torch.float).cuda()
+        # # Number of erosion iterations
+        # iterations = 5
+
+        # # Perform iterative erosion
+        # for i in range(iterations):
+        #     # Apply erosion using 2D convolution
+        #     eroded_mask = F.conv2d(image_mask, kernel, padding=2)
+        #     image_mask = (eroded_mask == kernel.sum()).float()  # Update mask to eroded version
+
+        feature_point_cloud = get_rgbd_point_cloud(cameras[i], dino_feat_masked.to(device), depth_map=depth_image,mask=image_mask)#everthing on GPU
+
+        index = np.random.choice(feature_point_cloud.points_list()[0].shape[0], 4096, replace=True)
+        points = feature_point_cloud.points_list()[0].detach().cpu()[index,:]
+        colors = feature_point_cloud.features_list()[0].detach().cpu()[index,:]
+        # points = feature_point_cloud.points_list()[0].detach().cpu()[:,:]
+        # colors = feature_point_cloud.features_list()[0].detach().cpu()[:,:]
+        feature_point_cloud = torch.cat((points, colors), dim=1)
+
+        dino_feat_masked_list.append(dino_feat_masked_low.detach().cpu())
+        feature_point_cloud_list.append(feature_point_cloud)
+    feature_point_cloud = torch.cat(feature_point_cloud_list, dim=0)
+    dino_feat_masked = torch.cat(dino_feat_masked_list, dim=0)
+    return feature_point_cloud,dino_feat_masked, feature_point_cloud_list
+
+
+def downsample_with_knn_feature_aggregation(feature_point_cloud,num_pts=1024,k_nearest_neighbors=100, instance_points=None):
+    #N_1, C_1 = 2048, 384  # Example number of points and features
+    num_points_to_sample = num_pts
+    k_nearest_neighbors = k_nearest_neighbors
+
+    # Example input pointcloud and features (N_1, C_1), where N_1 is the number of points and C_1 is the feature dimension
+    pointcloud = feature_point_cloud[None,:,:3].cuda()  # Shape (1, N_1, 3) for 3D coordinates
+    features = feature_point_cloud[None,:,3:].cuda()  # Shape (1, N_1, C_1) for features
+
+    # Step 1: FPS to downsample the points
+    # We use sample_farthest_points to select num_points_to_sample points
+    sampled_points, sampled_indices = sample_farthest_points(pointcloud, K=num_points_to_sample)  # Shape: (1, 1024, 3), (1, 1024)
+    if instance_points is not None:
+        sampled_points = instance_points
+
+    # Step 2: KNN to find nearest neighbors
+    # Find the k nearest neighbors for each sampled point in the original pointcloud
+    dists, knn_indices, _ = knn_points(sampled_points, pointcloud, K=k_nearest_neighbors, return_nn=False)
+
+    # Step 3: Gather the features of the k-nearest neighbors using the knn indices
+    # Use knn_gather to get neighbor features for each sampled point
+    neighbor_features = knn_gather(features, knn_indices)  # Shape: (1, 1024, k, C_1)
+
+    # Step 4: Aggregate features from the neighbors (e.g., by averaging)
+    #aggregated_features,_ = torch.max(neighbor_features,dim=-2) # Shape: (1, 1024, C_1)
+    aggregated_features = torch.mean(neighbor_features,dim=-2) # Shape: (1, 1024, C_1)
+    return sampled_points, aggregated_features
+
+
+def vis_pca(feature):
+    n_components=3 # the first component is to seperate the object from the background
+
+    pca = sklearnPCA(n_components=n_components)
+    feature = pca.fit_transform(feature.detach().cpu().numpy())
+    for show_channel in range(n_components):
+        # min max normalize the feature map
+        feature[:, show_channel] = (feature[:, show_channel] - feature[:, show_channel].mean()) / (feature[:, show_channel].std()*10)
+    feature_resized = np.clip(feature[:,:]+0.5,0,1)
+    return feature_resized
+
+
+def patch2pixel_feats(patch_features, original_size):
+    """
+    修改版：自动根据 T（patch 数量）和原图比例推算 (Hp, Wp)
+    """
+    H, W = original_size
+    B = patch_features.shape[0]
+    T = patch_features.shape[2]
+    C = patch_features.shape[3]
+
+    # ✅ 【修改1】自动寻找 (Hp, Wp)，而不是用 sqrt(T)
+    aspect = H / W
+    best = None
+    for h in range(1, int(math.sqrt(T)) + 1):
+        if T % h == 0:
+            w = T // h
+            for hh, ww in [(h, w), (w, h)]:
+                score = abs((hh / ww) - aspect)
+                if best is None or score < best[2]:
+                    best = (hh, ww, score)
+    Hp, Wp, _ = best  # 比如 27, 25
+
+    # ✅ 【修改2】用 Hp, Wp 替代 num_patches
+    patch_features = patch_features.reshape(B, Hp, Wp, C)
+
+    # ✅ 【修改3】后面不变
+    patch_features = patch_features.permute(0, 3, 1, 2)
+    pixel_features = F.interpolate(
+        patch_features, size=(H, W), mode='bilinear', align_corners=False
+    )
+    pixel_features = pixel_features.squeeze().permute(1, 2, 0)
+
+    return pixel_features
+
+
+def vis_pca_pixelwise(feature):
+    n_components = 4  # The number of PCA components to use
+    batch, feat_dim, height,width = feature.shape  
+    
+    # Reshape the feature to (num_pixels, feat_dim)
+    num_pixels = height * width
+    feature_reshaped = np.array(feature).transpose(0,2,3,1).reshape(-1, feat_dim)
+
+
+    # Apply PCA
+    pca = sklearnPCA(n_components=n_components)
+    feature_pca = pca.fit_transform(feature_reshaped)
+
+    # Min-max normalization for each component
+    # for show_channel in range(n_components):
+    #     feature_pca[:, show_channel] = (feature_pca[:, show_channel] - feature_pca[:, show_channel].min()) / \
+    #                                     (feature_pca[:, show_channel].max() - feature_pca[:, show_channel].min() + 1e-8)  # Small epsilon to avoid division by zero
+    for show_channel in range(n_components):
+        feature_pca[:, show_channel] = (feature_pca[:, show_channel] - feature_pca[:, show_channel].mean()) / \
+                                        (feature_pca[:, show_channel].std()*10 + 1e-8) # Small epsilon to avoid division by zero
+
+    feature_pca = np.clip(feature_pca+0.5, 0, 1)
+    # Reshape the PCA result back to (height, width, n_components)
+    feature_resized = feature_pca.reshape(batch,height,width,n_components)[...,1:4]
+    return feature_resized
+
+def normalize_mesh_verts(data):
+    # data [N, 3]
+    min_vals, _ = torch.min(data, dim=0)
+    max_vals, _ = torch.max(data, dim=0)
+    bbox_sizes = max_vals - min_vals
+    scale = torch.norm(bbox_sizes)
+    print("Scale:", scale)
+    normalized_verts = verts / scale
+    return normalized_verts
+
+def plot_pointclouds_with_color_mapping(pc1_f, pc2_f,pc1,pc2, query_points, similarity_threshold=None):
+    """
+    Visualizes two 3D point clouds. The second point cloud (pc2) is color-mapped
+    using the 'viridis' colormap based on its similarity (proximity) to the sampled
+    query points in the first point cloud (pc1).
+    
+    Parameters:
+    - pc1: np.ndarray of shape (N, 3), first point cloud #partial
+    - pc2: np.ndarray of shape (M, 3), second point cloud # global
+    - query_points: list of indices in pc1, representing the query points to compare.
+    - similarity_threshold: float, optional, threshold to cap the similarity distance.
+    """
+        
+
+    pc1_f = pc1_f / np.linalg.norm(pc1_f, axis=1)[:, None]  # Normalize the features
+    pc2_f = pc2_f / np.linalg.norm(pc2_f, axis=1)[:, None]  # Normalize the features
+    # Create a figure with subplots
+    fig = plt.figure(figsize=(12, 10))
+    num_query_points = len(query_points)
+    # Set limits and labels
+    size = pc2.max() - pc2.min()
+    # Plot the first point cloud in the first subplot
+    ax1 = fig.add_subplot(1, num_query_points + 1, 1, projection='3d')
+    ax1.scatter(pc2[:, 0], pc2[:, 1], pc2[:, 2], color='grey', label='Point Cloud 1 (Left)', alpha=0.1,s=10)
+
+    # Define a color list for each query point
+    query_colors = cm.tab10(np.linspace(0, 1, num_query_points))  # Use tab10 colormap for distinct colors
+
+    # Highlight query points in pc1 with different colors
+    for i, idx in enumerate(query_points):
+        ax1.scatter(pc1[idx, 0], pc1[idx, 1], pc1[idx, 2], 
+                    color=query_colors[i], s=100, edgecolor='k', label=f'Query Point {idx}')
+
+    ax1.set_title('Point Cloud 1 with Query Points')
+    ax1.set_xlabel('X')
+    ax1.set_ylabel('Y')
+    ax1.set_zlabel('Z')
+    ax1.set_xlim(-size / 1.4, size / 1.4)
+    ax1.set_ylim(-size / 1.4, size / 1.4)
+    ax1.set_zlim(-size / 1.4, size / 1.4)
+    ax1.view_init(elev=45, azim=-45)
+    ax1.grid(True)
+    ax1.legend()
+
+    # Plot the second point cloud in the subsequent subplots
+    for k in range(num_query_points):
+        
+        ax = fig.add_subplot(1, num_query_points + 1, k + 2, projection='3d')
+        
+        # Calculate distances between query points in pc1 and all points in pc2
+        similarity =(pc1_f[query_points[k]][None]@ pc2_f.T).reshape(-1) # (1, 3) x (M, 3) = (1, M)
+        # For each point in pc2, take the minimum distance to any query point
+        min_similarity = np.min(similarity, axis=0)
+        # Optionally cap the similarity distances to a threshold (to avoid extreme values)
+        similarity_threshold= 0.3
+        if similarity_threshold is not None:
+            similarity = np.clip(similarity, similarity_threshold,1)
+        # Normalize the distances to a range of 0 to 1 for colormap mapping
+        similarity = (similarity - np.min(similarity)) / (np.max(similarity) - np.min(similarity))
+        colors = cm.plasma(similarity)
+
+        # Plot the second point cloud with color mapping based on similarity
+        ax.scatter(pc2[:, 0], pc2[:, 1], pc2[:, 2], color=colors, s=15, alpha=1.0, label='Point Cloud 2 (Right)', edgecolor='k')
+        
+        ax.set_xlim(-size / 1.4, size / 1.4)
+        ax.set_ylim(-size / 1.4, size / 1.4)
+        ax.set_zlim(-size / 1.4, size / 1.4)
+        ax.set_title(f'QP_{query_points[k]}')
+        ax.set_xlabel('X')
+        ax.set_ylabel('Y')
+        ax.set_zlabel('Z')
+        ax.view_init(elev=45, azim=-45)
+        ax.grid(True)
+        ax.legend()
+
+    # Show the plot
+    plt.tight_layout()
+    plt.show()
+
+
+def plot_pointclouds_3d_with_copca_old(global_sem_pcd, partial_sem_pcd, global_pcd, partial_pcd):
+    """
+    Visualizes two point clouds in 3D, coloring them based on their PCA components.
+
+    Parameters:
+    - global_pointcloud: numpy array of shape (N, D) for global point cloud.
+    - partial_pointcloud: numpy array of shape (M, D) for partial point cloud.
+    """
+
+
+    n_components = 3
+    # Step 1: Perform PCA on both global and partial point clouds
+    sem_pca = PCA(n_components=n_components)
+    sem_pca = sem_pca.fit(global_sem_pcd)  # shape (N+M, 3)
+
+    transformed_sem_pcd_list = [sem_pca.transform(pcd) for pcd in [global_sem_pcd,partial_sem_pcd]]
+    sem_pcd_pca = np.concatenate(transformed_sem_pcd_list,axis=0)
+    for show_channel in range(n_components):
+        sem_pcd_pca[:, show_channel] = (sem_pcd_pca[:, show_channel] - sem_pcd_pca[:, show_channel].mean()) / \
+                                        (sem_pcd_pca[:, show_channel].std()*5 + 1e-8) # Small epsilon to avoid division by zero
+
+    # sem_pcd_pca_min = sem_pcd_pca.min()
+    # sem_pcd_pca_max = sem_pcd_pca.max()
+    # sem_pcd_pca = (sem_pcd_pca- sem_pcd_pca_min) / (sem_pcd_pca_max - sem_pcd_pca_min)  # Normalize to [0, 1]
+
+    sem_pcd_pca = np.clip(sem_pcd_pca[:,:]+0.5, 0, 1)
+    global_pca = sem_pcd_pca[:global_sem_pcd.shape[0]]  # shape (N, 3)
+    partial_pca = sem_pcd_pca[-partial_sem_pcd.shape[0]:]  # shape (M, 3)
+
+    # Step 2: Create a 3D scatter plot
+    fig = plt.figure(figsize=(12, 6))
+    ax = fig.add_subplot(121, projection='3d')
+
+
+    # Global point cloud
+    ax.scatter(global_pcd[:, 0], global_pcd[:, 1], global_pcd[:, 2], 
+            c=global_pca,  marker='o', s=100, alpha=1.0, label='Global Point Cloud')
+    
+    # Set labels for each axis
+    # ax.set_xlabel('X axis')
+    # ax.set_ylabel('Y axis')
+    # ax.set_zlabel('Z axis')
+    ax.set_xlim(-0.5, 0.5)
+    ax.set_ylim(-0.5, 0.5)
+    ax.set_zlim(-0.5, 0.5)
+    
+    ax1 = fig.add_subplot(122, projection='3d')
+
+    # Partial point cloud
+    ax1.scatter(partial_pcd[:, 0], partial_pcd[:, 1], partial_pcd[:, 2], 
+            c=partial_pca,  marker='o', s=100, alpha=1.0, label='Partial Point Cloud')
+    
+    # ax1.scatter(global_pcd[:, 0], global_pcd[:, 1], global_pcd[:, 2], 
+    #         marker='o', s=10, alpha=0.1)
+    # Set labels for each axis
+    # ax1.set_xlabel('X axis')
+    # ax1.set_ylabel('Y axis')
+    # ax1.set_zlabel('Z axis')
+
+    
+    ax1.set_xlim(-0.5, 0.5)
+    ax1.set_ylim(-0.5, 0.5)
+    ax1.set_zlim(-0.5, 0.5)
+    plt.tight_layout()
+
+    ax.view_init(120,-95)
+    ax1.view_init(120,-95)
+
+ 
+    ax.set_axis_off()
+    ax.set_facecolor((0, 0, 0, 0))
+    ax1.set_axis_off()
+    ax1.set_facecolor((0, 0, 0, 0))
+
+    plt.show()
+
+
+def plot_pointclouds_3d_with_pca(global_sem_pcd, global_pcd):
+    """
+    Visualizes two point clouds in 3D, coloring them based on their PCA components.
+
+    Parameters:
+    - global_pointcloud: numpy array of shape (N, D) for global point cloud.
+    - partial_pointcloud: numpy array of shape (M, D) for partial point cloud.
+    """
+    #sem_pcd = np.concatenate((global_sem_pcd,partial_sem_pcd), axis=0) # shape (N+M, D)
+
+    # Step 1: Perform PCA on both global and partial point clouds
+    sem_pca = PCA(n_components=3)
+    sem_pcd_pca = sem_pca.fit_transform(global_sem_pcd)  # shape (N+M, 3)
+
+    for i in range(3):  # Iterate over each component (3 in total for RGB)
+        sem_pcd_pca_mean = sem_pcd_pca[:, i].mean()
+        sem_pcd_pca_std = sem_pcd_pca[:, i].std()
+        sem_pcd_pca[:, i] = (sem_pcd_pca[:, i] - sem_pcd_pca_mean) / (sem_pcd_pca_std*5+1e-8)  # Normalize to [0, 1]
+
+
+    global_pca = np.clip(sem_pcd_pca+0.5,0,1)
+    # scatter plot
+    fig = plt.figure(figsize=(6, 6))
+    ax = fig.add_subplot(111, projection='3d')
+
+    # Global point cloud
+    ax.scatter(global_pcd[:, 0], global_pcd[:, 1], global_pcd[:, 2], 
+            c=global_pca,  marker='o', s=50, alpha=1.0, label='Global Point Cloud')
+    
+    # Remove axes and background
+    ax.set_axis_off()
+
+    # Set background color to none
+    ax.set_facecolor((0, 0, 0, 0))
+    # # Set labels for each axis
+    # ax.set_xlabel('X axis')
+    # ax.set_ylabel('Y axis')
+    # ax.set_zlabel('Z axis')
+    ax.set_xlim(-0.5, 0.5)
+    ax.set_ylim(-0.5, 0.5)
+    ax.set_zlim(-0.5, 0.5)
+
+    ax.view_init(-73,102)
+
+    return fig
+    
+
+def plot_pointclouds_3d_with_copca(global_sem_pcd_list, global_pcd_list,co_pca=True):
+    """
+    Visualizes multiple point clouds in 3D, each in a separate subplot, after applying CoPCA.
+    Coloring them based on their PCA components.
+
+    Parameters:
+    - global_sem_pcd_list: list of numpy arrays for semantic point clouds (one per object).
+    - global_pcd_list: list of numpy arrays for global point clouds (one per object).
+    """
+    num_pcds = len(global_sem_pcd_list)  # Number of point clouds
+    print("Number of point clouds to visualize:", num_pcds)
+    # Step 1: Perform CoPCA (Common PCA) on the semantic point clouds
+        # Concatenate all point clouds to perform common PCA
+    if co_pca:
+
+        concatenated_pcds = np.concatenate(global_sem_pcd_list, axis=0)  # shape (N_total, D)
+        copca = PCA(n_components=3, random_state=0)
+        copca.fit(concatenated_pcds[:1024])  # Fit PCA on all point clouds together
+        transformed_sem_pcd_list = [copca.transform(pcd) for pcd in global_sem_pcd_list]
+
+
+        signs = np.sign(np.sum(transformed_sem_pcd_list[0], axis=0))
+        # Post-process to ensure consistent orientation of PCA components
+        for i, transformed_pcd in enumerate(transformed_sem_pcd_list):
+            # For each component (column), align sign based on the sum of values in the column
+            transformed_sem_pcd_list[i] = transformed_pcd * signs
+    else:
+        copca = PCA(n_components=3)
+        transformed_sem_pcd_list = [copca.fit_transform(pcd) for pcd in global_sem_pcd_list]
+        # Post-process to ensure consistent orientation of PCA components
+        for i, transformed_pcd in enumerate(transformed_sem_pcd_list):
+            signs = np.sign(np.sum(transformed_pcd, axis=0))
+            # For each component (column), align sign based on the sum of values in the column
+            transformed_sem_pcd_list[i] = transformed_pcd * signs
+
+
+
+    # Create a figure with subplots arranged in a grid (based on number of point clouds)
+    fig = plt.figure(figsize=(6 * num_pcds, 6))  # Adjust figure size based on the number of subplots
+    
+    # Loop over the point clouds
+    for idx, (sem_pcd_pca, global_pcd) in enumerate(zip(transformed_sem_pcd_list, global_pcd_list)):
+        ax = fig.add_subplot(1, num_pcds, idx + 1, projection='3d')
+
+        # Step 2: Normalize the PCA-transformed data to use as colors
+        for i in range(3):  # Iterate over each component (3 in total for RGB)
+            pca_mean = sem_pcd_pca[:, i].mean()
+            pca_std = sem_pcd_pca[:, i].std()
+            sem_pcd_pca[:, i] = (sem_pcd_pca[:, i] - pca_mean) / (pca_std * 5 + 1e-8)  # Normalize
+
+        global_pca_colors = np.clip(sem_pcd_pca + 0.5, 0, 1)  # Map to [0, 1] for RGB
+
+        # Scatter plot for this point cloud in the current subplot
+        ax.scatter(global_pcd[:, 0], global_pcd[:, 1], global_pcd[:, 2], 
+                   c=global_pca_colors, marker='o', s=50, alpha=1.0)
+
+        # Remove axes and background
+        ax.set_axis_off()
+        ax.set_facecolor((0, 0, 0, 0))
+
+        # Set axis limits for each subplot
+        ax.set_xlim(-0.5, 0.5)
+        ax.set_ylim(-0.5, 0.5)
+        ax.set_zlim(-0.5, 0.5)
+
+        # Set view angle
+        ax.view_init(-55, 102)
+
+    # Adjust spacing between subplots
+    plt.tight_layout()
+
+    return fig
+    
+
+    
+def unnormalize(x):
+    # x.shape : [H,W,3]
+    mean = np.array([0.485, 0.456, 0.406])
+    std = np.array([0.229, 0.224, 0.225])
+    return x * std + mean
+
+
+from custom_utils.housecat6d_dataset import HouseCat6DTrainingDataset
+trainset = HouseCat6DTrainingDataset(image_size=420, sample_num=1024,data_dir='/media/xyz/data1/HouseCat6D')
+
+vis = True
+device = "cuda"
+import matplotlib
+matplotlib.use('TkAgg')
+
+#cat_list = ['bottle','box','can','cup','cutlery','remote','shoe','tube','teapot']
+cat_list = ['cup']
+
+
+sem_global_list = []  
+sem_global_pcd_list = []  
+
+# load semantc feature and show
+########################################
+save_dir = 'Yung/yung_large_files/semantic_feature/test_notebook/8v'
+#save_dir = './80views_textured_token'
+if  True:
+    for cat in cat_list:
+    # # orriginal    
+    #     with open(f'/mnt/4T/Yung/yung_large_files/semantic_feature/test_notebook/housecat_{cat}/raw/housecat1_train.txt', 'r') as f:
+    #         instances = [line.strip() for line in f.readlines()]
+
+    #     print(instances)
+    # revised
+    # instance try cup-grey_handle
+        instances = ['cup-grey_handle']
+        sem_global_list = []  
+        sem_global_pcd_list = []  
+
+        # Load the mean shape point cloud
+        meanshape_path = f'Yung/yung_large_files/semantic_feature/test_notebook/saved_pcd/{cat}/mean_shape/mean_shape_pcd_1.txt'
+        meanshape_pcd_np = np.loadtxt(meanshape_path)
+        meanshape_pcd_tensor = torch.from_numpy(meanshape_pcd_np)
+        M = meanshape_pcd_tensor.shape[0]
+        meanshape_points = meanshape_pcd_tensor.view(1, M, 3).float()
+    #make sure map to cuda0    
+        average_aggregated_features = torch.load(f'//mnt/4T/Yung/yung_large_files/semantic_feature/test_notebook/8v_key/sem_cat_pcd_untex/cup_dino_feature.pt', map_location={"cuda:1": "cuda:0"})
+        sem_global_pcd_list.append(meanshape_points[0])
+        sem_global_list.append(average_aggregated_features[0].detach().cpu())
+        #fig =plot_pointclouds_3d_with_pca(average_aggregated_features[0].detach().cpu(),meanshape_points[0])
+        #fig.savefig('test.png')
+        for j,instance in enumerate(instances):
+            #break
+            print("Processing", instance)
+            #obj_path = f'/media/xyz/data/HouseCat6D/obj_models_small_size_final/{cat}/{instance}.obj'
+            #instance_pcd_tensor = torch.load(f'{save_dir}/saved_pcd_untex/{cat}/{instance}_pcd.pt')[0]
+            #obj_path = f'/media/xyz/data1/HouseCat6D/obj_models_small_size_final/{cat}/{instance}.obj'
+            # if instance != 'cup-grey_handle':
+            # # original pcd
+            instance_pcd_path = f'Yung/yung_large_files/semantic_feature/test_notebook/saved_pcd/{cat}/test/{instance}.txt'
+            # Load the instance point cloud
+            instance_pcd_np = np.loadtxt(instance_pcd_path)
+            reference_scale = np.linalg.norm(instance_pcd_np.max(axis=0) - instance_pcd_np.min(axis=0))
+            
+            # else:
+            #     instance_pcd_path = f'Yung/yung_large_files/pose_can_results/housecat6d_sonata_feature/scene01/000000/cup-grey_handle/normalized_groundtruth_pca.ply'
+            #     pcd = o3d.io.read_point_cloud(instance_pcd_path)
+            #     instance_pcd_np = np.asarray(pcd.points)
+                
+            current_scale = np.linalg.norm(instance_pcd_np.max(axis=0) - instance_pcd_np.min(axis=0))
+            scale_factor = reference_scale / current_scale
+            instance_pcd_np = instance_pcd_np * scale_factor
+
+            scale = np.linalg.norm(instance_pcd_np.max(axis=0) - instance_pcd_np.min(axis=0))
+            print("Scale:", scale)
+
+            instance_pcd_tensor = torch.from_numpy(instance_pcd_np)
+            N = instance_pcd_tensor.shape[0]
+            instance_points = instance_pcd_tensor.view(1, N, 3).float()
+            try:
+                # aggregated_features = torch.load(f'{save_dir}/saved_dino_pcd_untex/{cat}/{instance}_dino_feature.pt')
+                aggregated_features = average_aggregated_features
+            except:
+                print(f"Warning: {instance} not found.")
+                continue
+            # plot_pointclouds_3d_with_pca(aggregated_features[0].detach().cpu(),
+            #                              instance_points[0])
+
+            sem_global_pcd_list.append(instance_points[0].detach().cpu())
+            sem_global_list.append(aggregated_features[0].detach().cpu())
+            if len(sem_global_list)>4:
+                break
+        
+        fig = plot_pointclouds_3d_with_copca(sem_global_list,sem_global_pcd_list,co_pca=True)
+        fig.savefig(f'./{save_dir}/{cat}.png')
+###############################
+
+
+# TODO: Change extractor model to dinov3
+# 1) Build a ViT-S/16 backbone from timm (shape-compatible with your hooks)
+extractor = DINOv3ExtractorAdapter(
+    model_id="facebook/dinov3-vits16-pretrain-lvd1689m",  # ViT-S/16
+    device="cuda"
+)
+extractor.model = extractor.model.cuda(0)
+# extractor = torch.hub.load('facebookresearch/dinov2', model_dict['small'], pretrained=True).cuda()
+
+
+# cat_list = ['bottle','box','can','cup','cutlery','glass','remote','shoe','tube','teapot']
+cat_list = ['cup']
+
+#cat_list = ['teapot']
+#TODO: if condition for tex rendering
+for cat in cat_list:
+    # orriginal    
+    with open(f'/mnt/4T/Yung/yung_large_files/semantic_feature/test_notebook/housecat_{cat}/raw/housecat1_train.txt', 'r') as f:
+        instances = [line.strip() for line in f.readlines()]
+
+    print(instances)
+    # #revised
+    # # instance try cup-grey_handle
+    # instances = ['cup-grey_handle']
+
+    aggregated_features_list = []  # N * [1, 1024, 384]
+    # Load the mean shape point cloud
+    meanshape_path = f'Yung/yung_large_files/semantic_feature/test_notebook/saved_pcd/{cat}/mean_shape/mean_shape_pcd_1.txt'
+    meanshape_pcd_np = np.loadtxt(meanshape_path)
+    meanshape_pcd_tensor = torch.from_numpy(meanshape_pcd_np)
+    M = meanshape_pcd_tensor.shape[0]
+# modify for cuda0
+    meanshape_points = meanshape_pcd_tensor.view(1, M, 3).float().cuda(0)
+
+
+    for j,instance in enumerate(instances):
+        # if instance != 'bottle-85_alcool':
+        #     continue
+        print("Processing", instance)
+        obj_path = f'pose_dataset/HouseCat6D/obj_models_small_size_final/{cat}/{instance}.obj'
+        instance_pcd_path = f'Yung/yung_large_files/semantic_feature/test_notebook/saved_pcd/{cat}/test/{instance}.txt'
+
+        # Load the instance point cloud
+        instance_pcd_np = np.loadtxt(instance_pcd_path)
+        instance_pcd_tensor = torch.from_numpy(instance_pcd_np)
+        N = instance_pcd_tensor.shape[0]
+# modify for cuda0
+        instance_points = instance_pcd_tensor.view(1, N, 3).float().cuda(0)
+
+        try:
+            verts, faces, aux = load_obj(obj_path)
+        except ValueError as e:
+            print(f"Warning: {e}, attempting to load without material.")
+
+            try:
+                verts, faces, aux = load_obj(obj_path, load_textures=True)
+            except ValueError as e2:
+                print(f"Failed to load {obj_path} without material: {e2}")
+                continue
+
+        # 检查 verts_uvs 是否为 None
+        if aux.verts_uvs is not None:
+            verts_uvs = aux.verts_uvs[None, ...]  # (1, V, 2)
+            faces_uvs = faces.textures_idx[None, ...]  # (1, F, 3)
+            tex_maps = aux.texture_images
+
+            # tex_maps is a dictionary of {material name: texture image}.
+            # Take the first image:
+            if tex_maps:
+                texture_image = list(tex_maps.values())[0]
+                texture_image = texture_image[None, ...]  # (1, H, W, 3)
+
+            # Create a textures object
+            tex = TexturesUV(verts_uvs=verts_uvs, faces_uvs=faces_uvs, maps=texture_image)
+            print(f"Loaded texture for {instance}.")
+        else:
+            # 如果 verts_uvs 是 None，直接跳过纹理处理，或者你可以设置默认行为
+            print(f"No UV coordinates for {instance}, skipping texture mapping.")
+            tex = None
+
+        # Initialise the mesh with textures
+        verts = normalize_mesh_verts(verts) # Housecat meshes are absolute scale
+        meshes = Meshes(verts=[verts], faces=[faces.verts_idx], textures=None)
+        # Rotate mesh 180 degrees around Y axis
+        rotation_matrix = torch.tensor([
+            [-1.0, 0.0, 0.0],
+            [0.0, 1.0, 0.0],
+            [0.0, 0.0, -1.0]
+        ], dtype=torch.float32, device="cpu")
+        verts = torch.matmul(verts, rotation_matrix.T)
+        
+        meshes = Meshes(verts=[verts], faces=[faces.verts_idx], textures=tex)
+
+        if meshes.textures is None:
+            meshes.textures = TexturesVertex(
+            verts_features=torch.ones_like(meshes.verts_padded(), device=device)
+            )
+
+        # render the mesh with 8 views, scale means the distance from the object to the camera
+        image_size=(420,420)
+        #images,fragments,cameras = render_batch(meshes,image_size=image_size,scale=1.0)
+        images,fragments,cameras = render(meshes,image_size=image_size,scale=2.0)
+        
+        os.makedirs(f'{save_dir}/{cat}_rgb_dino_untex-try', exist_ok=True)
+        rgb = images.cpu().numpy()[:, :, :, :3]
+        image_grid(rgb, rows=1, cols=8, rgb=True)
+        plt.savefig(f'{save_dir}/{cat}_rgb_dino_untex-try/{instance}_rendering-texture_reverse.png')
+        plt.close()
+
+        # get the feature point cloud
+        feature_point_cloud, dino_feat_masked, feature_point_cloud_list = fuse_feature_rgbd(extractor,images,fragments,cameras)
+
+        # get the downsampled aggregated feature point cloud
+        num_pts= 1024
+        nn_num= 100 # larger nn_num will make the feature more smooth
+        sampled_points,aggregated_features = downsample_with_knn_feature_aggregation(feature_point_cloud,num_pts,nn_num)
+
+        # #Needed
+        # index = np.random.choice(partial_feature_point_cloud.shape[0], 1024, replace=False)
+        # plot_pointclouds_3d_with_copca(average_aggregated_features.squeeze(0).detach().cpu().numpy(), 
+        #                                partial_feature_point_cloud[index,3:], 
+        #                                sampled_points.squeeze(0).detach().cpu().numpy(), 
+        #                                partial_feature_point_cloud[index,:3])
+        
+
+        q=0
+
+        if False:
+            q+=1
+            inputs = trainset[q]
+            rgb = inputs['rgb'][None].cuda()
+            pts = inputs['pts'][None]
+            choose = inputs['choose'][None]
+            model = inputs['model'][None].cuda()
+            rgb = inputs['rgb'][None].cuda()
+
+            _desc_q = extractor.forward_features(rgb)["x_prenorm"][:, :]
+            #_desc_q = extractor.extract_descriptors(rgb,layer=11,facet='token',include_cls=True).squeeze(1) # B,L,C
+            # _norm_q = torch.linalg.norm(_desc_q, dim=-1)[:, :, None]
+            # _desc_q = _desc_q / (_norm_q)
+
+            dino_feature = _desc_q[:,1:,:]
+
+
+            #dino_feature = self.rgb_extractor.forward_features(rgb)["x_prenorm"][:, 1:]
+            #rgb=self.rgb_extractor.preprocess_pil(rgb)
+            #dino_feature = self.rgb_extractor.extract_descriptors(rgb,layer=11,facet='key') # (1,900,384)
+            f_dim = dino_feature.shape[-1]
+            num_patches =int(dino_feature.shape[1]**0.5) # 1
+            b=1
+            dino_feature = dino_feature.reshape(b, num_patches, num_patches, f_dim).permute(0,3,1,2)
+            
+            dino_feature = F.interpolate(dino_feature, size=(num_patches * 14, num_patches * 14), mode='nearest') 
+            dino_feature_2d_vis = dino_feature.detach().cpu()[0] #384, 224,224
+
+            b, d = dino_feature.shape[0:2]
+            dino_feature = dino_feature.reshape(b,d,-1)
+            choose_2 = choose.unsqueeze(1).repeat(1, d, 1).cuda()
+            dino_feature = torch.gather(dino_feature,2,choose_2).contiguous() # b,d,n
+            
+            #dino_feature = dino_feature / torch.std(dino_feature, dim=1, keepdim=True)
+            #dino_feature = torch.norm(dino_feature, dim=1, keepdim=True)
+            #choose_dino = choose.unsqueeze(1).repeat(1, d, 1Z
+            #sem_model = sem_model / torch.std(sem_model, dim=-1, keepdim=True)
+            #visual_global_sem_high = sem_model.detach().cpu().numpy()[0] #1024,384
+            visual_partial_sem_high = dino_feature.permute(0,2,1).detach().cpu().numpy()[0] #1024,128
+
+            #visual_global_sem_low = self.feature_mlp(sem_model.permute(0,2,1)).permute(0,2,1).detach().cpu().numpy()[0]
+            #visual_partial_sem_low = rgb_local.permute(0,2,1).detach().cpu().numpy()[0]
+            # transform the pts with GT 9D Pose into object coordinate
+            translation_gt = inputs['translation_label'][None]
+            rotation_gt = inputs['rotation_label'][None]
+            size_gt = inputs['size_label'][None]
+            pts_obj_frame = (inputs['pts'] - translation_gt.unsqueeze(1)) / (torch.norm(size_gt, dim=1).view(b, 1, 1) + 1e-8) @ rotation_gt
+            #kpt_obj_frame = (kpt_3d - translation_gt.unsqueeze(1)) / (torch.norm(size_gt, dim=1).view(b, 1, 1) + 1e-8) @ rotation_gt
+            
+            # dino_feature_2d_vis_pca = vis_pca_pixelwise(dino_feature_2d_vis[None])[0]
+            # plt.imshow(dino_feature_2d_vis_pca[:,:,:3])
+            # plt.show()
+            # fig =plt.figure()
+            # rgb_unnorm = unnormalize(rgb[0].permute(1,2,0).detach().cpu())
+            # plt.imshow(rgb_unnorm)
+            # plt.show()
+            # image_mask = ((rgb_unnorm.clone().sum(axis=2) >0.1)*1.0)[None,None] # 224,224
+                
+            # rgb_mask = np.array(image_mask[0,0,:,:,None]).repeat(384, axis=2).transpose(2,0,1)
+
+            # dino_feature_2d_vis[rgb_mask==0] = 0
+            # masked_dino_feature_2d_vis_pca = vis_pca_pixelwise(dino_feature_2d_vis[None])[0]
+            # plt.imshow(masked_dino_feature_2d_vis_pca[:,:,:])
+            # plt.show()
+
+
+            # print('self.pca.cateagg-partial')
+            # index = np.random.choice(partial_feature_point_cloud.shape[0], 1024, replace=False)
+            # #average_aggregated_features = torch.load(f'sem_cat_pcd/{cat}_dino_feature.pt')
+            
+            average_aggregated_features = torch.load(f'/home/xyz/anything6d_project/Sem-GCE-AG-Pose/sem_cat_pcd/{cat}_dino_feature.pt')
+            # #plot_pointclouds_3d_with_copca(aggregated_features.squeeze(0).detach().cpu().numpy(), partial_feature_point_cloud[index,3:], sampled_points.squeeze(0).detach().cpu().numpy(), pts_obj_frame)
+           
+            plot_pointclouds_3d_with_copca_old(average_aggregated_features.squeeze(0).detach().cpu().numpy(),
+                                               visual_partial_sem_high,
+                                               sampled_points.squeeze(0).detach().cpu().numpy(),
+                                              pts_obj_frame[0].detach().cpu().numpy())
+            plt.show()
+
+
+            # plot_pointclouds_3d_with_copca(average_aggregated_features.squeeze(0).detach().cpu().numpy(),
+            #                                 visual_partial_sem_high,
+            #                                sampled_points.squeeze(0).detach().cpu().numpy(),
+            #                                 pts_obj_frame[0].detach().cpu().numpy())
+            
+            
+            # #query_points =np.random.choice(1024, 3)
+            # query_points, sampled_indices = sample_farthest_points(pts_obj_frame, K=4)  # Shape: (1, 1024, 3), (1, 1024)
+            # plot_pointclouds_with_color_mapping(visual_partial_sem_high, 
+            #                                     aggregated_features.squeeze(0).detach().cpu().numpy(),
+            #                                     pts_obj_frame[0].detach().cpu().numpy(),
+            #                                     model[0].detach().cpu().numpy(),
+            #                                     sampled_indices[0], similarity_threshold=None)
+
+
+            # # plot_pointclouds_3d_with_copca(average_aggregated_features.squeeze(0).detach().cpu().numpy(), partial_feature_point_cloud[index,3:], sampled_points.squeeze(0).detach().cpu().numpy(), partial_feature_point_cloud[index,:3])
+            # # plot_pointclouds_3d_with_pca(average_aggregated_features.squeeze(0).detach().cpu().numpy(), partial_feature_point_cloud[index,3:], sampled_points.squeeze(0).detach().cpu().numpy(), partial_feature_point_cloud[index,:3])
+            # partial_feature_point_cloud = feature_point_cloud_list[5]
+            # plot_pointclouds_3d_with_copca(visual_partial_sem_high, 
+            #                             partial_feature_point_cloud[index,3:], 
+            #                             pts_obj_frame[0].detach().cpu().numpy(), 
+            #                             partial_feature_point_cloud[index,:3])
+        
+        # plot_pointclouds_3d_with_copca(average_aggregated_features.squeeze(0).detach().cpu().numpy(), aggregated_features.squeeze(0).detach().cpu().numpy(), sampled_points.squeeze(0).detach().cpu().numpy(), sampled_points.squeeze(0).detach().cpu().numpy())
+
+        os.makedirs(f'{save_dir}/saved_dino_pcd_untex-try/{cat}', exist_ok=True)
+        torch.save(aggregated_features, f'{save_dir}/saved_dino_pcd_untex-try/{cat}/{instance}_dinov3_feature-texture_reverse.pt')
+
+        os.makedirs(f'{save_dir}/saved_pcd_untex-try/{cat}', exist_ok=True)
+        torch.save(sampled_points, f'{save_dir}/saved_pcd_untex-try/{cat}/{instance}_pcd-texture_reverse.pt')
+        
+        aggregated_features_list.append(aggregated_features)
+        # #break
+        vis_dino = vis_pca_pixelwise(np.array(dino_feat_masked))
+        vis_img = np.clip(vis_dino[:,:,:,:],a_min=0,a_max=1)
+        image_grid(vis_img, rows=1, cols=8, rgb=True)
+
+        os.makedirs(f'{save_dir}/{cat}_rgb_dino_untex-try', exist_ok=True)
+        plt.savefig(f'{save_dir}/{cat}_rgb_dino_untex-try/{instance}_dinov3-texture_reverse.png')
+        plt.close()
+        if False:
+
+            rgb = images.cpu().numpy()[:, :, :, :3]
+            mask = images[:, ..., 3].cpu().numpy()!=0
+            depth_image = fragments[:, ..., 0].cpu().numpy()*mask
+            image_grid(rgb, rows=1, cols=8, rgb=True)
+            # os.makedirs(f'/home/tulrfpf/code/PointFlowRenderer/{cat}_rgb_dino', exist_ok=True)
+            # plt.savefig(f'/home/tulrfpf/code/PointFlowRenderer/{cat}_rgb_dino/{instance}_rgb.png')
+            # image_grid(depth_image[...,None], rows=2, cols=4, rgb=True)
+            # image_grid(mask[...,None], rows=2, cols=4, rgb=True)
+
+
+
+            fig = plt.figure(figsize=(10, 10))
+            ax = fig.add_subplot(111, projection="3d")
+            #ax.scatter(sampled_points[:, 2], sampled_points[:,0], sampled_points[:, 1], c="b")
+            pca_color =vis_pca(feature_point_cloud[:, 3:])
+            ax.scatter(feature_point_cloud[:, 2], feature_point_cloud[:, 0], feature_point_cloud[:, 1], c=pca_color,s=0.1)
+            #create_camera_geometry_batch(ax=ax,R_batch=R,T_batch=T,order=(2,0,1))
+            ax.set_xlabel("z")
+            ax.set_ylabel("x")
+            ax.set_zlabel("y")
+            ax.set_xlim(-2, 2)
+            ax.set_ylim(-2, 2)
+            ax.set_zlim(-2, 2)
+            plt.title("Sampled Dense Points from Mesh")
+            plt.show()
+
+            fig = plt.figure(figsize=(10, 10))
+            ax = fig.add_subplot(111, projection="3d")
+            pca_color =vis_pca(aggregated_features.squeeze(0))
+            sampled_points= sampled_points.squeeze(0).cpu().detach().numpy()
+            ax.scatter(sampled_points[:, 2], sampled_points[:, 0], sampled_points[:, 1], c=pca_color,s=50)
+            #create_camera_geometry_batch(ax=ax,R_batch=R,T_batch=T,order=(2,0,1))
+            ax.set_xlabel("z")
+            ax.set_ylabel("x")
+            ax.set_zlabel("y")
+            ax.set_xlim(-2, 2)
+            ax.set_ylim(-2, 2)
+            ax.set_zlim(-2, 2)
+            plt.title("Sampled Sparse Points from Mesh")
+            plt.show()
+            #break
+    # Assign the aggregated features to the mean shape point cloud
+    aggregated_features_tensor = torch.cat(aggregated_features_list, dim=0)  #[N, 1024, 384]
+    average_aggregated_features = aggregated_features_tensor.mean(dim=0, keepdim=True)
+    print("Average Aggregated Features Shape:", average_aggregated_features.shape)  # Should be (1, 1024, 384)
+
+    os.makedirs(f'{save_dir}/sem_cat_pcd_untex-try', exist_ok=True)
+    torch.save(average_aggregated_features, f'{save_dir}/sem_cat_pcd_untex-try/{cat}_dinov3_feature.pt')
+
+# fig = plt.figure(figsize=(10, 10))
+# ax = fig.add_subplot(111, projection="3d")
+# pca_color =vis_pca(average_aggregated_features.squeeze(0))
+# # sampled_points= sampled_points.squeeze(0).cpu().detach().numpy()
+# meanshape_points = meanshape_points.squeeze(0).cpu().detach().numpy()
+# ax.scatter(meanshape_points[:, 2], meanshape_points[:, 0], meanshape_points[:, 1], c=pca_color,s=10.0, marker='o')
+# ax.set_xlabel("z")
+# ax.set_ylabel("x")
+# ax.set_zlabel("y")
+# ax.set_xlim(-2, 2)
+# ax.set_ylim(-2, 2)
+# ax.set_zlim(-2, 2)
+# plt.title("Shape Prior Dino")
+# plt.show()
+    

RGBD_DINOV3_HouseCat6D_wlcop.py

@@ -0,0 +1,1467 @@
+import pickle
+import torch
+from custom_utils import ShapeNetCore
+from custom_utils import _compute_fov,_sample_points_from_faces
+from custom_utils import image_grid
+from custom_utils.shapenet_base import HouseCatDataset
+import matplotlib.pyplot as plt
+import numpy as np
+import k3d
+import os
+import json
+import torch
+from PIL import Image
+import numpy as np
+import torch
+from plyfile import PlyData  # pip install plyfile
+from types import SimpleNamespace
+from pathlib import Path
+import open3d as o3d
+import re
+
+import cv2
+import imageio
+import numpy as np
+from PIL import Image
+import matplotlib.pyplot as plt
+from torchvision import transforms
+from custom_utils.extractor import ViTExtractor
+import torch.nn.functional as F
+from sklearn.decomposition import PCA as sklearnPCA
+import math
+from custom_utils.utils_general import center_crop
+
+from pytorch3d.io import load_objs_as_meshes, load_obj
+from pytorch3d.implicitron.tools.point_cloud_utils import get_rgbd_point_cloud
+from pytorch3d.structures import Meshes
+from pytorch3d.renderer import (
+    PerspectiveCameras,
+    FoVPerspectiveCameras,
+    PointLights,
+    MeshRasterizer,
+    MeshRenderer,
+    RasterizationSettings,
+    HardPhongShader,
+    TexturesVertex,
+    look_at_view_transform,
+    ray_bundle_to_ray_points,
+    NDCMultinomialRaysampler,
+    TexturesUV,
+    BlendParams,
+
+    TexturesVertex
+)
+
+from pytorch3d.implicitron.tools.point_cloud_utils import get_rgbd_point_cloud
+from pytorch3d.structures import Pointclouds
+import torch
+from pytorch3d.ops import sample_farthest_points, knn_points, knn_gather
+
+from matplotlib import cm
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.decomposition import PCA
+from mpl_toolkits.mplot3d import Axes3D
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from transformers import AutoConfig, AutoModel
+
+class Dinov3PatchExtractor(nn.Module):
+    """
+    Returns patch tokens as [B, C, T] (C=384 for ViT-S/16).
+    Input must be ImageNet-normalized [B,3,H,W].
+    """
+    def __init__(self, model_id="facebook/dinov3-vits16-pretrain-lvd1689m", freeze=True):
+        super().__init__()
+        self.cfg  = AutoConfig.from_pretrained(model_id)
+        self.C    = self.cfg.hidden_size                      # 384
+        self.nreg = getattr(self.cfg, "num_register_tokens", 0)
+        self.backbone = AutoModel.from_pretrained(model_id).eval()
+        self.p = 16  # ViT-S/16 的 patch 大小
+        if freeze:
+            for p in self.backbone.parameters():
+                p.requires_grad = False
+
+    @torch.no_grad()
+    def forward(self, x):                                     # x: [B,3,H,W], normalized
+        B, _, H, W = x.shape
+        out = self.backbone(x)
+        seq = out.last_hidden_state                           # [B, T_all, C]
+        patch_seq = seq[:, 1 + self.nreg :, :]                # drop CLS + registers -> [B, T_patch, C]
+
+
+        # 关键：用输入尺寸和 patch 大小推 H_p, W_p
+        H_p = H // self.p
+        W_p = W // self.p
+        T = patch_seq.shape[1]
+
+        # 若预处理不是整除，或模型内部有 pad/裁剪，做个健壮性兜底
+        if H_p * W_p != T:
+            # 按长宽比从 T 的因子中挑最合理的 (H_p, W_p)
+            aspect = H / W
+            best = None
+            for h in range(1, int(math.sqrt(T)) + 1):
+                if T % h == 0:
+                    w = T // h
+                    for (hh, ww) in [(h, w), (w, h)]:
+                        score = abs((hh / ww) - aspect)
+                        if best is None or score < best[2]:
+                            best = (hh, ww, score)
+            if best is None:
+                raise RuntimeError(f"Cannot factor T={T} into (H_p,W_p).")
+            H_p, W_p, _ = best
+
+        feat = patch_seq.view(B, H_p, W_p, self.C).permute(0, 3, 1, 2)  # [B,C,H_p,W_p]
+        return feat
+
+
+class DINOv3ExtractorAdapter:
+    """
+    Adapter to mimic ViTExtractor.extract_descriptors(batch, layer, facet, bin)
+    Returns descriptors with shape [B, 1, T, d] like ViTExtractor.
+    """
+    def __init__(self, model_id="facebook/dinov3-vits16-pretrain-lvd1689m", device="cuda"):
+        self.device = device
+        self.model = Dinov3PatchExtractor(model_id, freeze=True).to(device)
+        self.p = 16                   # patch size for vits16
+        self.stride = (16, 16)        # nominal stride on tokens
+        self.mean = (0.485, 0.456, 0.406)  # ImageNet normalization
+        self.std  = (0.229, 0.224, 0.225)
+
+    @torch.no_grad()
+    def extract_descriptors(self, batch, layer=11, facet='token', bin=False, include_cls=False):
+        """
+        batch: [B,3,H,W] normalized to ImageNet stats.
+        returns: [B, 1, T, d]（T = H_p*W_p, d=384）
+        """
+        # DINOv3 doesn't expose q/k/v hooks like timm; we just use its final patch tokens.
+        # 先拿到 [B,C,H_p,W_p]
+        feat_map = self.model(batch.to(self.device))        # [B,384,H_p,W_p]
+        B, C, H_p, W_p = feat_map.shape
+        # 再回到 [B,1,T,d] 以兼容你现有代码
+        desc = feat_map.flatten(2).permute(0, 2, 1).unsqueeze(1)  # [B,1,H_p*W_p,384]
+        return desc
+
+
+def sample_points_on_sphere(num_points=80):
+    points = []
+    phi = (1 + math.sqrt(5)) / 2  # golden ratio
+
+    for i in range(num_points):
+        theta = 2 * math.pi * i / phi  # azimuthal angle
+        z = 1 - (2 * i + 1) / num_points  # z-coordinate, uniform from -1 to 1
+        radius = math.sqrt(1 - z * z)  # radius for the xy-plane
+        x = radius * math.cos(theta)
+        y = radius * math.sin(theta)
+        points.append([x, y, z])
+
+    return torch.tensor(points, dtype=torch.float32)
+
+def get_cube_vertices():
+    # Cube vertices (8 vertices)
+    return torch.tensor([[1, 1, 1],
+                         [1, 1, -1],
+                         [1, -1, 1],
+                         [1, -1, -1],
+                         [-1, 1, 1],
+                         [-1, 1, -1],
+                         [-1, -1, 1],
+                         [-1, -1, -1]], dtype=torch.float32)  # Ensure float type
+
+
+
+def render(meshes,scale=3.0,image_size=(420,420),light=(0.3,0.3,0.3)):
+    # prepare the camera
+    num_views = 8
+    # Get the cube vertices
+    #cube_vertices = get_cube_vertices()*scale
+    cube_vertices = sample_points_on_sphere(num_views)*scale
+    #up = torch.randn(1, 3)
+    up=torch.tensor([[0.0, 0.0, 1.0]], dtype=torch.float32)
+    up = up / torch.norm(up, dim=1)[:, None]
+    R, T = look_at_view_transform(eye=cube_vertices, at=torch.tensor([[0.0, 0.0, 0.0]], dtype=torch.float32), up=up)
+    cam_K= np.array([[572, 0.0, image_size[0]//2], [0.0, 572, image_size[1]//2], [0.0, 0.0, 1.0]])
+    fx,_,cx,_,fy,cy,_,_,_=cam_K.reshape(9)
+    fov_x, fov_y = _compute_fov(cam_K, 420, 420)
+
+    cameras = PerspectiveCameras(device=device, R=R, T=T, image_size=((420,420),),
+                                    focal_length=torch.tensor([[fx, fy]], dtype=torch.float32),
+                                    principal_point=torch.tensor([[cx, cy]], dtype=torch.float32),
+                                    in_ndc=False)
+
+    # prepare the lights
+    raster_settings = RasterizationSettings(image_size=image_size)
+    lights = PointLights(location=torch.tensor([0.0, 1.0, -2.0], device=device)[None], ambient_color=(light,),diffuse_color=(light,),device=device)
+
+    # move the data to the device
+    meshes = meshes.to(device)
+    cameras = cameras.to(device)
+    if len(cameras) != 1 and len(cameras) % len(meshes) != 0:
+        raise ValueError("Mismatch between batch dims of cameras and meshes.")
+    if len(cameras) > 1:
+        meshes = meshes.extend(len(cameras) // len(meshes))
+
+    # prepare the renderer
+    class MeshRendererWithDepth(torch.nn.Module):
+        def __init__(self, rasterizer, shader):
+            super().__init__()
+            self.rasterizer = rasterizer
+            self.shader = shader
+
+        def forward(self, meshes_world, **kwargs) -> torch.Tensor:
+            fragments = self.rasterizer(meshes_world, **kwargs)
+            images = self.shader(fragments, meshes_world, **kwargs)
+            return images, fragments.zbuf
+        
+
+    blend_params = BlendParams(background_color=(0.0, 0.0, 0.0))  # Blue background
+    renderer = MeshRendererWithDepth(
+        rasterizer=MeshRasterizer(
+            cameras=cameras,
+            raster_settings=raster_settings,
+        ),
+    # Set background color to blue [R, G, B]
+
+        shader=HardPhongShader(
+            device=device,
+            cameras=cameras,
+            lights=lights,
+            blend_params=blend_params
+        )
+    )
+
+    images,fragments = renderer(meshes)
+    return images,fragments,cameras
+
+
+def render_batch(meshes,scale=3.0,image_size=(420,420),light=(0.3,0.3,0.3)):
+    # prepare the camera
+    num_views = 8
+    # Get the cube vertices
+    cube_vertices = get_cube_vertices()*scale
+    # cube_vertices = sample_points_on_sphere(num_views)*scale
+    #up = torch.randn(1, 3)
+    up=torch.tensor([[0.0, 0.0, 1.0]], dtype=torch.float32)
+    #up = up / torch.norm(up, dim=1)[:, None]
+    R, T = look_at_view_transform(eye=cube_vertices, at=torch.tensor([[0.0, 0.0, 0.0]], dtype=torch.float32), up=up)
+
+    cam_K= np.array([[572, 0.0, image_size[0]//2], [0.0, 572, image_size[1]//2], [0.0, 0.0, 1.0]])
+    fx,_,cx,_,fy,cy,_,_,_=cam_K.reshape(9)
+    fov_x, fov_y = _compute_fov(cam_K, 420, 420)
+
+
+    # prepare the renderer
+    class MeshRendererWithDepth(torch.nn.Module):
+        def __init__(self, rasterizer, shader):
+            super().__init__()
+            self.rasterizer = rasterizer
+            self.shader = shader
+
+        def forward(self, meshes_world, **kwargs) -> torch.Tensor:
+            fragments = self.rasterizer(meshes_world, **kwargs)
+            images = self.shader(fragments, meshes_world, **kwargs)
+            return images, fragments.zbuf
+        
+
+    blend_params = BlendParams(background_color=(0.0, 0.0, 0.0))  # Blue background
+
+    batch_size = 10
+    all_images=[]
+    all_fragments=[]
+
+    # move the data to the device
+    meshes = meshes.extend(batch_size).to(device)
+    for i in range(0,R.shape[0],batch_size):
+        R_batch = R[i:i+batch_size]
+        T_batch = T[i:i+batch_size]
+        cameras_batch = PerspectiveCameras(device=device, R=R_batch, T=T_batch, image_size=((420,420),),
+                                        focal_length=torch.tensor([[fx, fy]], dtype=torch.float32),
+                                        principal_point=torch.tensor([[cx, cy]], dtype=torch.float32),
+                                        in_ndc=False).to(device)
+
+        # prepare the lights
+        raster_settings = RasterizationSettings(image_size=image_size)
+        lights = PointLights(location=torch.tensor([0.0, 1.0, -2.0], device=device)[None], 
+                             ambient_color=(light,),diffuse_color=(light,),device=device)
+
+        renderer = MeshRendererWithDepth(
+            rasterizer=MeshRasterizer(
+                cameras=cameras_batch,
+                raster_settings=raster_settings,
+            ),
+            # Set background color to blue [R, G, B]
+            shader=HardPhongShader(
+                device=device,
+                cameras=cameras_batch,
+                lights=lights,
+                blend_params=blend_params
+            )
+         )
+        images,fragments = renderer(meshes)
+        all_images.append(images)
+        all_fragments.append(fragments)
+    all_images = torch.cat(all_images,dim=0)
+    all_fragments = torch.cat(all_fragments,dim=0)
+    cameras = PerspectiveCameras(device=device, R=R, T=T, image_size=((420,420),),
+                                focal_length=torch.tensor([[fx, fy]], dtype=torch.float32),
+                                principal_point=torch.tensor([[cx, cy]], dtype=torch.float32),
+                                in_ndc=False).to(device)
+    return all_images,all_fragments,cameras
+
+
+# def fuse_feature_rgbd(extractor,images,fragments,cameras):
+#     dino_feat_masked_list = []
+#     feature_point_cloud_list = []
+#     for i in range(images.shape[0]):
+#         image = images.cpu().numpy()[i, :, :, :3]
+#         image_mask = images[i, ..., 3].cpu().numpy()!=0
+#         crop_size = (420, 420)
+#         crop_image, crop_mask, bbox = center_crop(image, image_mask, crop_size)
+#         cropped_image_np = cv2.resize(crop_image, crop_size, interpolation=cv2.INTER_AREA)
+#         #cropped_mask = cv2.resize(crop_mask*1.0, crop_size, interpolation=cv2.INTER_NEAREST)!=0  # Use nearest neighbor interpolation for masks
+#         orignal_size = (int(bbox[2]-bbox[0]), int(bbox[3]-bbox[1])) #K,K
+
+#         to_tensor = transforms.ToTensor()
+#         input_image = to_tensor(cropped_image_np).cuda(0)
+#         input_image = input_image.unsqueeze(0)
+#         #input_image=extractor.preprocess_pil(input_image)
+#         mean = torch.tensor([0.485, 0.456, 0.406]).cuda(0)
+#         std = torch.tensor([0.229, 0.224, 0.225]).cuda(0)
+#         input_image = (input_image - mean[None, :, None, None]) / std[None, :, None, None]
+  
+#         _desc_q = extractor.extract_descriptors(input_image,layer=11, facet='key', include_cls=True).squeeze(1) # (1,900,384)
+#         # _desc_q = extractor.forward_features(input_image)["x_prenorm"][:, :]   # (1,900,384)
+#         #_desc_q = extractor.extract_descriptors(input_image,layer=11,facet='token',include_cls=True).squeeze(1) # B,L,C
+#         # _norm_q = torch.linalg.norm(_desc_q, dim=-1)[:, :, None]
+#         # _desc_q = _desc_q / (_norm_q)
+
+#         desc = _desc_q[:,1:,:][None]
+#         #cls_token_q = _desc_q[:,0,:] #B,C`
+
+#         input_mask = to_tensor(crop_mask).cuda(0)
+#         input_mask = input_mask.unsqueeze(0)
+
+#         img_mask = to_tensor(image_mask)
+
+#         img_mask = img_mask.permute(1,2,0)
+
+#         dino_feat = patch2pixel_feats(desc, original_size=orignal_size) #reize back to K,K =>( K, K, 384)
+#         # create dino-feat with orignal size
+#         dino_height, dino_width, feat_dim = (image_size[0],image_size[1], desc.shape[-1])
+#         dino_feat_orig = torch.zeros(dino_height,dino_width,feat_dim)
+#         # Fill the dino features into the original tensor at the specified bounding box
+#         dino_feat_orig[bbox[1]:bbox[3], bbox[0]:bbox[2],:] = dino_feat #reize back to K,K =>(420, 420, 384) #gradint is not supported for this operation
+#         # Apply the mask
+#         dino_feat_masked = dino_feat_orig * img_mask
+#         dino_feat_masked = dino_feat_masked.permute(2,0,1).unsqueeze(0)
+#         dino_feat_masked_low = F.interpolate(dino_feat_masked, size=(30, 30), mode='bilinear')
+
+#         image_mask = images[i, ..., 3][None,None]
+#         depth_image = fragments[i, ..., 0][None]*image_mask
+        
+#         # # Define the kernel for erosion (3x3 ones kernel)
+#         # kernel = torch.ones((1, 1, 5, 5), dtype=torch.float).cuda()
+#         # # Number of erosion iterations
+#         # iterations = 5
+
+#         # # Perform iterative erosion
+#         # for i in range(iterations):
+#         #     # Apply erosion using 2D convolution
+#         #     eroded_mask = F.conv2d(image_mask, kernel, padding=2)
+#         #     image_mask = (eroded_mask == kernel.sum()).float()  # Update mask to eroded version
+
+#         feature_point_cloud = get_feature_point_cloud(cameras[i], dino_feat_masked.to(device), depth_map=depth_image,mask=image_mask)#everthing on GPU
+
+#         index = np.random.choice(feature_point_cloud.points_list()[0].shape[0], 4096, replace=True)
+#         points = feature_point_cloud.points_list()[0].detach().cpu()[index,:]
+#         colors = feature_point_cloud.features_list()[0].detach().cpu()[index,:]
+#         # points = feature_point_cloud.points_list()[0].detach().cpu()[:,:]
+#         # colors = feature_point_cloud.features_list()[0].detach().cpu()[:,:]
+#         feature_point_cloud = torch.cat((points, colors), dim=1)
+
+#         dino_feat_masked_list.append(dino_feat_masked_low.detach().cpu())
+#         feature_point_cloud_list.append(feature_point_cloud)
+#     feature_point_cloud = torch.cat(feature_point_cloud_list, dim=0)
+#     dino_feat_masked = torch.cat(dino_feat_masked_list, dim=0)
+#     return feature_point_cloud,dino_feat_masked, feature_point_cloud_list
+def fuse_feature_rgbd(extractor,images,fragments,cameras):
+    dino_feat_masked_list = []
+    feature_point_cloud_list = []
+    for i in range(images.shape[0]):
+        image = images.cpu().numpy()[i, :, :, :3]
+        image_mask = images[i, ..., 3].cpu().numpy()!=0
+        crop_size = (420, 420)
+        crop_image, crop_mask, bbox = center_crop(image, image_mask, crop_size)
+        cropped_image_np = cv2.resize(crop_image, crop_size, interpolation=cv2.INTER_AREA)
+        #cropped_mask = cv2.resize(crop_mask*1.0, crop_size, interpolation=cv2.INTER_NEAREST)!=0  # Use nearest neighbor interpolation for masks
+        orignal_size = (int(bbox[2]-bbox[0]), int(bbox[3]-bbox[1])) #K,K
+
+        to_tensor = transforms.ToTensor()
+        input_image = to_tensor(cropped_image_np).cuda(0)
+        input_image = input_image.unsqueeze(0)
+        #input_image=extractor.preprocess_pil(input_image)
+        mean = torch.tensor([0.485, 0.456, 0.406]).cuda(0)
+        std = torch.tensor([0.229, 0.224, 0.225]).cuda(0)
+        input_image = (input_image - mean[None, :, None, None]) / std[None, :, None, None]
+  
+        _desc_q = extractor.extract_descriptors(input_image,layer=11, facet='key', include_cls=True).squeeze(1) # (1,900,384)
+        # _desc_q = extractor.forward_features(input_image)["x_prenorm"][:, :]   # (1,900,384)
+        #_desc_q = extractor.extract_descriptors(input_image,layer=11,facet='token',include_cls=True).squeeze(1) # B,L,C
+        # _norm_q = torch.linalg.norm(_desc_q, dim=-1)[:, :, None]
+        # _desc_q = _desc_q / (_norm_q)
+
+        desc = _desc_q[:,1:,:][None]
+        #cls_token_q = _desc_q[:,0,:] #B,C`
+
+        input_mask = to_tensor(crop_mask).cuda(0)
+        input_mask = input_mask.unsqueeze(0)
+
+        img_mask = to_tensor(image_mask)
+
+        img_mask = img_mask.permute(1,2,0)
+
+        dino_feat = patch2pixel_feats(desc, original_size=orignal_size) #reize back to K,K =>( K, K, 384)
+        # create dino-feat with orignal size
+        dino_height, dino_width, feat_dim = (image_size[0],image_size[1], desc.shape[-1])
+        dino_feat_orig = torch.zeros(dino_height,dino_width,feat_dim)
+        # Fill the dino features into the original tensor at the specified bounding box
+        dino_feat_orig[bbox[1]:bbox[3], bbox[0]:bbox[2],:] = dino_feat #reize back to K,K =>(420, 420, 384) #gradint is not supported for this operation
+        # Apply the mask
+        dino_feat_masked = dino_feat_orig * img_mask
+        dino_feat_masked = dino_feat_masked.permute(2,0,1).unsqueeze(0)
+        dino_feat_masked_low = F.interpolate(dino_feat_masked, size=(30, 30), mode='bilinear')
+
+        image_mask = images[i, ..., 3][None,None]
+        depth_image = fragments[i, ..., 0][None]*image_mask
+        
+        # # Define the kernel for erosion (3x3 ones kernel)
+        # kernel = torch.ones((1, 1, 5, 5), dtype=torch.float).cuda()
+        # # Number of erosion iterations
+        # iterations = 5
+
+        # # Perform iterative erosion
+        # for i in range(iterations):
+        #     # Apply erosion using 2D convolution
+        #     eroded_mask = F.conv2d(image_mask, kernel, padding=2)
+        #     image_mask = (eroded_mask == kernel.sum()).float()  # Update mask to eroded version
+
+        feature_point_cloud = get_rgbd_point_cloud(cameras[i], dino_feat_masked.to(device), depth_map=depth_image,mask=image_mask)#everthing on GPU
+
+        index = np.random.choice(feature_point_cloud.points_list()[0].shape[0], 4096, replace=True)
+        points = feature_point_cloud.points_list()[0].detach().cpu()[index,:]
+        colors = feature_point_cloud.features_list()[0].detach().cpu()[index,:]
+        # points = feature_point_cloud.points_list()[0].detach().cpu()[:,:]
+        # colors = feature_point_cloud.features_list()[0].detach().cpu()[:,:]
+        feature_point_cloud = torch.cat((points, colors), dim=1)
+
+        dino_feat_masked_list.append(dino_feat_masked_low.detach().cpu())
+        feature_point_cloud_list.append(feature_point_cloud)
+    feature_point_cloud = torch.cat(feature_point_cloud_list, dim=0)
+    dino_feat_masked = torch.cat(dino_feat_masked_list, dim=0)
+    return feature_point_cloud,dino_feat_masked, feature_point_cloud_list
+
+def downsample_with_knn_feature_aggregation(feature_point_cloud,num_pts=1024,k_nearest_neighbors=100, instance_points=None):
+    #N_1, C_1 = 2048, 384  # Example number of points and features
+    num_points_to_sample = num_pts
+    k_nearest_neighbors = k_nearest_neighbors
+
+    # Example input pointcloud and features (N_1, C_1), where N_1 is the number of points and C_1 is the feature dimension
+    pointcloud = feature_point_cloud[None,:,:3].cuda(0)  # Shape (1, N_1, 3) for 3D coordinates
+    features = feature_point_cloud[None,:,3:].cuda(0)  # Shape (1, N_1, C_1) for features
+
+    # Step 1: FPS to downsample the points
+    # We use sample_farthest_points to select num_points_to_sample points
+    sampled_points, sampled_indices = sample_farthest_points(pointcloud, K=num_points_to_sample)  # Shape: (1, 1024, 3), (1, 1024)
+    if instance_points is not None:
+        sampled_points = instance_points
+
+    # Step 2: KNN to find nearest neighbors
+    # Find the k nearest neighbors for each sampled point in the original pointcloud
+    dists, knn_indices, _ = knn_points(sampled_points, pointcloud, K=k_nearest_neighbors, return_nn=False)
+
+    # Step 3: Gather the features of the k-nearest neighbors using the knn indices
+    # Use knn_gather to get neighbor features for each sampled point
+    neighbor_features = knn_gather(features, knn_indices)  # Shape: (1, 1024, k, C_1)
+
+    # Step 4: Aggregate features from the neighbors (e.g., by averaging)
+    #aggregated_features,_ = torch.max(neighbor_features,dim=-2) # Shape: (1, 1024, C_1)
+    aggregated_features = torch.mean(neighbor_features,dim=-2) # Shape: (1, 1024, C_1)
+    return sampled_points, aggregated_features
+
+
+def vis_pca(feature):
+    n_components=3 # the first component is to seperate the object from the background
+
+    pca = sklearnPCA(n_components=n_components)
+    feature = pca.fit_transform(feature.detach().cpu().numpy())
+    for show_channel in range(n_components):
+        # min max normalize the feature map
+        feature[:, show_channel] = (feature[:, show_channel] - feature[:, show_channel].mean()) / (feature[:, show_channel].std()*10)
+    feature_resized = np.clip(feature[:,:]+0.5,0,1)
+    return feature_resized
+
+def patch2pixel_feats(patch_features, original_size):
+    """
+    修改版：自动根据 T（patch 数量）和原图比例推算 (Hp, Wp)
+    """
+    H, W = original_size
+    B = patch_features.shape[0]
+    T = patch_features.shape[2]
+    C = patch_features.shape[3]
+
+    # ✅ 【修改1】自动寻找 (Hp, Wp)，而不是用 sqrt(T)
+    aspect = H / W
+    best = None
+    for h in range(1, int(math.sqrt(T)) + 1):
+        if T % h == 0:
+            w = T // h
+            for hh, ww in [(h, w), (w, h)]:
+                score = abs((hh / ww) - aspect)
+                if best is None or score < best[2]:
+                    best = (hh, ww, score)
+    Hp, Wp, _ = best  # 比如 27, 25
+
+    # ✅ 【修改2】用 Hp, Wp 替代 num_patches
+    patch_features = patch_features.reshape(B, Hp, Wp, C)
+
+    # ✅ 【修改3】后面不变
+    patch_features = patch_features.permute(0, 3, 1, 2)
+    pixel_features = F.interpolate(
+        patch_features, size=(H, W), mode='bilinear', align_corners=False
+    )
+    pixel_features = pixel_features.squeeze().permute(1, 2, 0)
+
+    return pixel_features
+
+def vis_pca_pixelwise(feature):
+    n_components = 4  # The number of PCA components to use
+    batch, feat_dim, height,width = feature.shape  
+    
+    # Reshape the feature to (num_pixels, feat_dim)
+    num_pixels = height * width
+    feature_reshaped = np.array(feature).transpose(0,2,3,1).reshape(-1, feat_dim)
+
+
+    # Apply PCA
+    pca = sklearnPCA(n_components=n_components)
+    feature_pca = pca.fit_transform(feature_reshaped)
+
+    # Min-max normalization for each component
+    # for show_channel in range(n_components):
+    #     feature_pca[:, show_channel] = (feature_pca[:, show_channel] - feature_pca[:, show_channel].min()) / \
+    #                                     (feature_pca[:, show_channel].max() - feature_pca[:, show_channel].min() + 1e-8)  # Small epsilon to avoid division by zero
+    for show_channel in range(n_components):
+        feature_pca[:, show_channel] = (feature_pca[:, show_channel] - feature_pca[:, show_channel].mean()) / \
+                                        (feature_pca[:, show_channel].std()*10 + 1e-8) # Small epsilon to avoid division by zero
+
+    feature_pca = np.clip(feature_pca+0.5, 0, 1)
+    # Reshape the PCA result back to (height, width, n_components)
+    feature_resized = feature_pca.reshape(batch,height,width,n_components)[...,1:4]
+    return feature_resized
+
+def normalize_mesh_verts(data):
+    # data [N, 3]
+    min_vals, _ = torch.min(data, dim=0)
+    max_vals, _ = torch.max(data, dim=0)
+    bbox_sizes = max_vals - min_vals
+    scale = torch.norm(bbox_sizes)
+    # print("Scale:", scale)
+    normalized_verts = verts / scale
+    return normalized_verts
+
+def plot_pointclouds_with_color_mapping(pc1_f, pc2_f,pc1,pc2, query_points, similarity_threshold=None):
+    """
+    Visualizes two 3D point clouds. The second point cloud (pc2) is color-mapped
+    using the 'viridis' colormap based on its similarity (proximity) to the sampled
+    query points in the first point cloud (pc1).
+    
+    Parameters:
+    - pc1: np.ndarray of shape (N, 3), first point cloud #partial
+    - pc2: np.ndarray of shape (M, 3), second point cloud # global
+    - query_points: list of indices in pc1, representing the query points to compare.
+    - similarity_threshold: float, optional, threshold to cap the similarity distance.
+    """
+        
+
+    pc1_f = pc1_f / np.linalg.norm(pc1_f, axis=1)[:, None]  # Normalize the features
+    pc2_f = pc2_f / np.linalg.norm(pc2_f, axis=1)[:, None]  # Normalize the features
+    # Create a figure with subplots
+    fig = plt.figure(figsize=(12, 10))
+    num_query_points = len(query_points)
+    # Set limits and labels
+    size = pc2.max() - pc2.min()
+    # Plot the first point cloud in the first subplot
+    ax1 = fig.add_subplot(1, num_query_points + 1, 1, projection='3d')
+    ax1.scatter(pc2[:, 0], pc2[:, 1], pc2[:, 2], color='grey', label='Point Cloud 1 (Left)', alpha=0.1,s=10)
+
+    # Define a color list for each query point
+    query_colors = cm.tab10(np.linspace(0, 1, num_query_points))  # Use tab10 colormap for distinct colors
+
+    # Highlight query points in pc1 with different colors
+    for i, idx in enumerate(query_points):
+        ax1.scatter(pc1[idx, 0], pc1[idx, 1], pc1[idx, 2], 
+                    color=query_colors[i], s=100, edgecolor='k', label=f'Query Point {idx}')
+
+    ax1.set_title('Point Cloud 1 with Query Points')
+    ax1.set_xlabel('X')
+    ax1.set_ylabel('Y')
+    ax1.set_zlabel('Z')
+    ax1.set_xlim(-size / 1.4, size / 1.4)
+    ax1.set_ylim(-size / 1.4, size / 1.4)
+    ax1.set_zlim(-size / 1.4, size / 1.4)
+    ax1.view_init(elev=45, azim=-45)
+    ax1.grid(True)
+    ax1.legend()
+
+    # Plot the second point cloud in the subsequent subplots
+    for k in range(num_query_points):
+        
+        ax = fig.add_subplot(1, num_query_points + 1, k + 2, projection='3d')
+        
+        # Calculate distances between query points in pc1 and all points in pc2
+        similarity =(pc1_f[query_points[k]][None]@ pc2_f.T).reshape(-1) # (1, 3) x (M, 3) = (1, M)
+        # For each point in pc2, take the minimum distance to any query point
+        min_similarity = np.min(similarity, axis=0)
+        # Optionally cap the similarity distances to a threshold (to avoid extreme values)
+        similarity_threshold= 0.3
+        if similarity_threshold is not None:
+            similarity = np.clip(similarity, similarity_threshold,1)
+        # Normalize the distances to a range of 0 to 1 for colormap mapping
+        similarity = (similarity - np.min(similarity)) / (np.max(similarity) - np.min(similarity))
+        colors = cm.plasma(similarity)
+
+        # Plot the second point cloud with color mapping based on similarity
+        ax.scatter(pc2[:, 0], pc2[:, 1], pc2[:, 2], color=colors, s=15, alpha=1.0, label='Point Cloud 2 (Right)', edgecolor='k')
+        
+        ax.set_xlim(-size / 1.4, size / 1.4)
+        ax.set_ylim(-size / 1.4, size / 1.4)
+        ax.set_zlim(-size / 1.4, size / 1.4)
+        ax.set_title(f'QP_{query_points[k]}')
+        ax.set_xlabel('X')
+        ax.set_ylabel('Y')
+        ax.set_zlabel('Z')
+        ax.view_init(elev=45, azim=-45)
+        ax.grid(True)
+        ax.legend()
+
+    # Show the plot
+    plt.tight_layout()
+    plt.show()
+
+
+def plot_pointclouds_3d_with_copca_old(global_sem_pcd, partial_sem_pcd, global_pcd, partial_pcd):
+    """
+    Visualizes two point clouds in 3D, coloring them based on their PCA components.
+
+    Parameters:
+    - global_pointcloud: numpy array of shape (N, D) for global point cloud.
+    - partial_pointcloud: numpy array of shape (M, D) for partial point cloud.
+    """
+
+
+    n_components = 3
+    # Step 1: Perform PCA on both global and partial point clouds
+    sem_pca = PCA(n_components=n_components)
+    sem_pca = sem_pca.fit(global_sem_pcd)  # shape (N+M, 3)
+
+    transformed_sem_pcd_list = [sem_pca.transform(pcd) for pcd in [global_sem_pcd,partial_sem_pcd]]
+    sem_pcd_pca = np.concatenate(transformed_sem_pcd_list,axis=0)
+    for show_channel in range(n_components):
+        sem_pcd_pca[:, show_channel] = (sem_pcd_pca[:, show_channel] - sem_pcd_pca[:, show_channel].mean()) / \
+                                        (sem_pcd_pca[:, show_channel].std()*5 + 1e-8) # Small epsilon to avoid division by zero
+
+    # sem_pcd_pca_min = sem_pcd_pca.min()
+    # sem_pcd_pca_max = sem_pcd_pca.max()
+    # sem_pcd_pca = (sem_pcd_pca- sem_pcd_pca_min) / (sem_pcd_pca_max - sem_pcd_pca_min)  # Normalize to [0, 1]
+
+    sem_pcd_pca = np.clip(sem_pcd_pca[:,:]+0.5, 0, 1)
+    global_pca = sem_pcd_pca[:global_sem_pcd.shape[0]]  # shape (N, 3)
+    partial_pca = sem_pcd_pca[-partial_sem_pcd.shape[0]:]  # shape (M, 3)
+
+    # Step 2: Create a 3D scatter plot
+    fig = plt.figure(figsize=(12, 6))
+    ax = fig.add_subplot(121, projection='3d')
+
+
+    # Global point cloud
+    ax.scatter(global_pcd[:, 0], global_pcd[:, 1], global_pcd[:, 2], 
+            c=global_pca,  marker='o', s=100, alpha=1.0, label='Global Point Cloud')
+    
+    # Set labels for each axis
+    # ax.set_xlabel('X axis')
+    # ax.set_ylabel('Y axis')
+    # ax.set_zlabel('Z axis')
+    ax.set_xlim(-0.5, 0.5)
+    ax.set_ylim(-0.5, 0.5)
+    ax.set_zlim(-0.5, 0.5)
+    
+    ax1 = fig.add_subplot(122, projection='3d')
+
+    # Partial point cloud
+    ax1.scatter(partial_pcd[:, 0], partial_pcd[:, 1], partial_pcd[:, 2], 
+            c=partial_pca,  marker='o', s=100, alpha=1.0, label='Partial Point Cloud')
+    
+    # ax1.scatter(global_pcd[:, 0], global_pcd[:, 1], global_pcd[:, 2], 
+    #         marker='o', s=10, alpha=0.1)
+    # Set labels for each axis
+    # ax1.set_xlabel('X axis')
+    # ax1.set_ylabel('Y axis')
+    # ax1.set_zlabel('Z axis')
+
+    
+    ax1.set_xlim(-0.5, 0.5)
+    ax1.set_ylim(-0.5, 0.5)
+    ax1.set_zlim(-0.5, 0.5)
+    plt.tight_layout()
+
+    ax.view_init(120,-95)
+    ax1.view_init(120,-95)
+
+ 
+    ax.set_axis_off()
+    ax.set_facecolor((0, 0, 0, 0))
+    ax1.set_axis_off()
+    ax1.set_facecolor((0, 0, 0, 0))
+
+    plt.show()
+
+
+def plot_pointclouds_3d_with_pca(global_sem_pcd, global_pcd):
+    """
+    Visualizes two point clouds in 3D, coloring them based on their PCA components.
+
+    Parameters:
+    - global_pointcloud: numpy array of shape (N, D) for global point cloud.
+    - partial_pointcloud: numpy array of shape (M, D) for partial point cloud.
+    """
+    #sem_pcd = np.concatenate((global_sem_pcd,partial_sem_pcd), axis=0) # shape (N+M, D)
+
+    # Step 1: Perform PCA on both global and partial point clouds
+    sem_pca = PCA(n_components=3)
+    sem_pcd_pca = sem_pca.fit_transform(global_sem_pcd)  # shape (N+M, 3)
+
+    for i in range(3):  # Iterate over each component (3 in total for RGB)
+        sem_pcd_pca_mean = sem_pcd_pca[:, i].mean()
+        sem_pcd_pca_std = sem_pcd_pca[:, i].std()
+        sem_pcd_pca[:, i] = (sem_pcd_pca[:, i] - sem_pcd_pca_mean) / (sem_pcd_pca_std*5+1e-8)  # Normalize to [0, 1]
+
+
+    global_pca = np.clip(sem_pcd_pca+0.5,0,1)
+    # scatter plot
+    fig = plt.figure(figsize=(6, 6))
+    ax = fig.add_subplot(111, projection='3d')
+
+    # Global point cloud
+    ax.scatter(global_pcd[:, 0], global_pcd[:, 1], global_pcd[:, 2], 
+            c=global_pca,  marker='o', s=50, alpha=1.0, label='Global Point Cloud')
+    
+    # Remove axes and background
+    ax.set_axis_off()
+
+    # Set background color to none
+    ax.set_facecolor((0, 0, 0, 0))
+    # # Set labels for each axis
+    # ax.set_xlabel('X axis')
+    # ax.set_ylabel('Y axis')
+    # ax.set_zlabel('Z axis')
+    ax.set_xlim(-0.5, 0.5)
+    ax.set_ylim(-0.5, 0.5)
+    ax.set_zlim(-0.5, 0.5)
+
+    ax.view_init(-73,102)
+
+    return fig
+    
+
+def plot_pointclouds_3d_with_copca(global_sem_pcd_list, global_pcd_list,co_pca=True):
+    """
+    Visualizes multiple point clouds in 3D, each in a separate subplot, after applying CoPCA.
+    Coloring them based on their PCA components.
+
+    Parameters:
+    - global_sem_pcd_list: list of numpy arrays for semantic point clouds (one per object).
+    - global_pcd_list: list of numpy arrays for global point clouds (one per object).
+    """
+    num_pcds = len(global_sem_pcd_list)  # Number of point clouds
+    # Step 1: Perform CoPCA (Common PCA) on the semantic point clouds
+        # Concatenate all point clouds to perform common PCA
+    if co_pca:
+        concatenated_pcds = np.concatenate(global_sem_pcd_list, axis=0)  # shape (N_total, D)
+        copca = PCA(n_components=3, random_state=0)
+        copca.fit(concatenated_pcds[:1024])  # Fit PCA on all point clouds together
+        transformed_sem_pcd_list = [copca.transform(pcd) for pcd in global_sem_pcd_list]
+
+
+        signs = np.sign(np.sum(transformed_sem_pcd_list[0], axis=0))
+        # Post-process to ensure consistent orientation of PCA components
+        for i, transformed_pcd in enumerate(transformed_sem_pcd_list):
+            # For each component (column), align sign based on the sum of values in the column
+            transformed_sem_pcd_list[i] = transformed_pcd * signs
+    else:
+        copca = PCA(n_components=3)
+        transformed_sem_pcd_list = [copca.fit_transform(pcd) for pcd in global_sem_pcd_list]
+        # Post-process to ensure consistent orientation of PCA components
+        for i, transformed_pcd in enumerate(transformed_sem_pcd_list):
+            signs = np.sign(np.sum(transformed_pcd, axis=0))
+            # For each component (column), align sign based on the sum of values in the column
+            transformed_sem_pcd_list[i] = transformed_pcd * signs
+
+
+
+    # Create a figure with subplots arranged in a grid (based on number of point clouds)
+    fig = plt.figure(figsize=(6 * num_pcds, 6))  # Adjust figure size based on the number of subplots
+    
+    # Loop over the point clouds
+    for idx, (sem_pcd_pca, global_pcd) in enumerate(zip(transformed_sem_pcd_list, global_pcd_list)):
+        ax = fig.add_subplot(1, num_pcds, idx + 1, projection='3d')
+
+        # Step 2: Normalize the PCA-transformed data to use as colors
+        for i in range(3):  # Iterate over each component (3 in total for RGB)
+            pca_mean = sem_pcd_pca[:, i].mean()
+            pca_std = sem_pcd_pca[:, i].std()
+            sem_pcd_pca[:, i] = (sem_pcd_pca[:, i] - pca_mean) / (pca_std * 5 + 1e-8)  # Normalize
+
+        global_pca_colors = np.clip(sem_pcd_pca + 0.5, 0, 1)  # Map to [0, 1] for RGB
+
+        # Scatter plot for this point cloud in the current subplot
+        ax.scatter(global_pcd[:, 0], global_pcd[:, 1], global_pcd[:, 2], 
+                   c=global_pca_colors, marker='o', s=10, alpha=1.0)
+
+        # Remove axes and background
+        ax.set_axis_off()
+        ax.set_facecolor((0, 0, 0, 0))
+
+        # Set axis limits for each subplot
+        ax.set_xlim(-0.5, 0.5)
+        ax.set_ylim(-0.5, 0.5)
+        ax.set_zlim(-0.5, 0.5)
+
+        # Set view angle
+        ax.view_init(-73, 102)
+
+    # Adjust spacing between subplots
+    plt.tight_layout()
+
+    return fig
+    
+
+    
+def unnormalize(x):
+    # x.shape : [H,W,3]
+    mean = np.array([0.485, 0.456, 0.406])
+    std = np.array([0.229, 0.224, 0.225])
+    return x * std + mean
+
+def parse_object_name(folder_name):
+    """
+    Parse folder name to extract category and instance name.
+    
+    Examples:
+        google_scan-backpack_0288 -> category: backpack, instance: backpack_0288
+        omniobject3d-hammer_001 -> category: hammer, instance: hammer_001
+    
+    Args:
+        folder_name: Name of the folder containing the mesh
+    
+    Returns:
+        category: Object category
+        instance_name: Full instance name (category_id)
+    """
+    # Split by '-' to remove prefix (google_scan, omniobject3d, etc.)
+    if '-' in folder_name:
+        parts = folder_name.split('-', 1)
+        object_part = parts[1]
+    else:
+        object_part = folder_name
+    
+    # Split by '_' to get category and id
+    parts = object_part.rsplit('_', 1)
+    
+    if len(parts) == 2:
+        category = parts[0]
+        object_id = parts[1]
+        instance_name = f"{category}_{object_id}"
+    else:
+        # Fallback if no underscore found
+        category = object_part
+        instance_name = object_part
+    
+    return category, instance_name
+
+def find_original_folder(instance_name, dirlist):
+    """
+    Find the original folder name that corresponds to the given instance name.
+
+    Args:
+        instance_name (str): e.g. 'backpack_0288'
+        dirlist (list[str]): list of all folder names
+
+    Returns:
+        str or None: matching folder name (e.g. 'google_scan-backpack_0288') or None if not found
+    """
+    for folder in dirlist:
+        if instance_name in folder:
+            return folder
+    return None
+
+def load_ply_as_obj(ply_path, device="cpu"):
+    """
+    Return (verts, faces, aux) in a PyTorch3D-OBJ-like shape for .ply files.
+
+    - faces: .verts_idx (F,3) long, .normals_idx None, .textures_idx (F,3) or None
+    - aux:   .verts_uvs (V,2) float or None,
+             .normals (V,3) float or None,
+             .texture_images {material_name: img_tensor(H,W,3) in [0,1]},
+             .materials [material_name, ...],
+             .material_colors None
+    """
+    ply_path = Path(ply_path)
+    ply = PlyData.read(str(ply_path))
+
+    # ---- vertices ----
+    v = ply["vertex"].data  # structured ndarray
+    verts_np = np.column_stack([v["x"], v["y"], v["z"]]).astype(np.float32)
+    verts = torch.from_numpy(verts_np).to(device)
+
+    # ---- faces (triangles only) ----
+    faces_raw = ply["face"].data["vertex_indices"]  # array of python lists
+    tri = [idx for idx in faces_raw if len(idx) == 3]
+    faces_idx = torch.as_tensor(np.asarray(tri, dtype=np.int64), device=device)
+
+    faces = SimpleNamespace()
+    faces.verts_idx = faces_idx
+    faces.normals_idx = None
+    faces.textures_idx = None  # will mirror verts_idx if UVs exist
+
+    # ---- aux ----
+    aux = SimpleNamespace()
+    names = v.dtype.names
+
+    # per-vertex normals (optional)
+    if {"nx", "ny", "nz"}.issubset(names):
+        normals_np = np.column_stack([v["nx"], v["ny"], v["nz"]]).astype(np.float32)
+        aux.normals = torch.from_numpy(normals_np).to(device)
+    else:
+        aux.normals = None
+
+    # per-vertex UVs (optional)
+    if {"texture_u", "texture_v"}.issubset(names):
+        uvs_np = np.column_stack([v["texture_u"], v["texture_v"]]).astype(np.float32)
+        aux.verts_uvs = torch.from_numpy(uvs_np).to(device)
+        faces.textures_idx = faces.verts_idx.clone()
+    else:
+        aux.verts_uvs = None
+
+    # texture image(s) from header comment like: "comment TextureFile obj_000400.png"
+    texture_images = {}
+    materials = []
+
+    for c in getattr(ply, "comments", []):
+        c = c.strip()
+        if c.lower().startswith("texturefile"):
+            # e.g. "TextureFile obj_000400.png"
+            parts = c.split(None, 1)
+            if len(parts) == 2:
+                tex_name = parts[1].strip()
+                tex_path = (ply_path.parent / tex_name)
+                if tex_path.exists():
+                    try:
+                        img = Image.open(tex_path).convert("RGB")
+                        arr = np.asarray(img, dtype=np.float32) / 255.0  # H,W,3
+                        texture_images["default"] = torch.from_numpy(arr)  # dict value is tensor
+                        materials.append("default")
+                    except Exception:
+                        pass  # if unreadable, just skip
+
+    aux.texture_images = texture_images     # DICT, not list
+    aux.materials = materials               # keep order aligned with dict keys
+    aux.material_colors = None
+
+    return verts, faces, aux
+
+def load_models_info(models_info_path):
+    """
+    Build mapping: index(int) -> (category:str, instance:str)
+
+    Rules:
+      - "clip/002/link1"  -> category="clip-link1", instance="002"
+      - "bottle/003"      -> category="bottle",     instance="003"
+      - "hammer"          -> category="hammer",     instance="unknown"
+    Fallbacks:
+      - If 3+ segments but the 2nd isn't purely digits, we pick the first all-digit token as instance.
+      - If no digit token found, instance="unknown".
+    """
+    with open(models_info_path, "r") as f:
+        data = json.load(f)
+    
+    def is_digits(s: str) -> bool:
+        return re.fullmatch(r"\d+", s) is not None
+    
+    mapping = {}
+    for k, v in data.items():
+        # Keys in JSON might be "0".."1260" (str) or int.
+        try:
+            idx = int(k)
+        except Exception:
+            continue
+
+        identifier = v.get("identifier", "")
+        if "/" in identifier:
+            identifier = (v.get("identifier") or "").strip()
+            parts = [p for p in identifier.split('/') if p]
+            if len(parts) == 3:
+                # first + last for category, middle should be the numeric id
+                cat_first, cat_last = parts[0], parts[-1]
+                category = f"{cat_first}-{cat_last}"
+                mid = parts[1]
+                if is_digits(mid):
+                    instance = mid
+                else:
+                    instance = "unknown"
+            elif len(parts) == 2:
+                category = parts[0]
+                if is_digits(parts[1]):
+                    instance = parts[1]
+                else:
+                    instance = "unknown"
+            mapping[idx] = (category, instance)
+        else:
+            # Fallback: whole identifier as category, instance unknown
+            mapping[idx] = (identifier, "unknown")
+    return mapping
+
+def load_trans2canon(json_path):
+    """
+    Load pace_convert.json and return a mapping:
+      name(str) -> 4x4 numpy array
+    Expects top-level key 'trans2canon'.
+    """
+    with open(json_path, 'r') as f:
+        data = json.load(f)
+    tdict = data.get("trans2canon", {})
+    out = {}
+    for k, v in tdict.items():
+        M = np.asarray(v, dtype=float)
+        if M.shape == (3, 3):
+            out[k] = M
+        else:
+            raise ValueError(f"trans2canon[{k}] is not 3x3, got {M.shape}")
+    return out
+
+def lookup_transform(category, trans_map):
+    """
+    Try several name variants to find a transform for this category.
+    Returns 4x4 np.ndarray if found, else None.
+    """
+    if category in trans_map:
+        return trans_map[category]
+    cat_safe = category.strip().replace(" ", "_")
+    cat_safe = cat_safe.replace("-", "/")
+    if cat_safe in trans_map:
+        return trans_map[cat_safe]
+    cat_lower = category.lower()
+    if cat_lower in trans_map:
+        return trans_map[cat_lower]
+    cat_lower_safe = cat_lower.replace(" ", "_")
+    return trans_map.get(cat_lower_safe, None)
+
+def extract_index_from_fname(path: Path):
+    """
+    From 'obj_000123.ply' -> 123 (int).
+    Works with any digits after 'obj_'.
+    """
+    m = re.match(r"obj_(\d+)\.", path.name)
+    if not m:
+        return None
+    return int(m.group(1))
+
+def load_ply_with_rotation(ply_path, R=None, device="cpu"):
+    """
+    Load a .ply mesh and optionally apply a 3x3 rotation matrix R.
+    Returns (verts, faces, aux) in PyTorch3D-like format.
+
+    - ply_path: str or Path to the .ply file
+    - R: 3x3 rotation tensor or ndarray (optional)
+    - device: CPU or CUDA
+    """
+    # --- 1. Load mesh using your existing loader ---
+    verts, faces, aux = load_ply_as_obj(ply_path, device=device)
+
+    # --- 2. Apply rotation if provided ---
+    if R is not None:
+        if not torch.is_tensor(R):
+            R = torch.as_tensor(R, dtype=torch.float32)
+        R = R.to(device).float()
+
+        # v' = v @ R^T  (if R is column-major, which is the usual math convention)
+        verts = verts @ R.T
+
+        if getattr(aux, "normals", None) is not None:
+            aux.normals = aux.normals @ R.T
+            aux.normals = torch.nn.functional.normalize(aux.normals, dim=1)
+
+    # --- 3. Return transformed mesh ---
+    return verts, faces, aux
+
+from custom_utils.housecat6d_dataset import HouseCat6DTrainingDataset
+# trainset = HouseCat6DTrainingDataset(image_size=420, sample_num=1024,data_dir='/media/hyunjun/NewDisk1/weihang/HouseCat6D')
+
+vis = True
+device = "cuda"
+
+cat = 'glass'
+#cat_list = ['bottle','box','can','cup','cutlery','remote','shoe','tube','teapot']
+#cat_list = ['bottle']
+
+
+#cat_list = ['teapot']
+cat_list = ['bottle','box','can','cup','cutlery','glass','remote','shoe','tube','teapot']
+sem_global_list = []  
+sem_global_pcd_list = []  
+
+save_dir = './wlcop'
+if False:
+    for cat in cat_list:
+        sem_global_list = []  
+        sem_global_pcd_list = []  
+        with open(f'/home/xyz/anything6d_project/Datasets/housecat_{cat}/raw/housecat1_train.txt', 'r') as f:
+            instances = [line.strip() for line in f.readlines()]
+
+        print(instances)
+
+        # Load the mean shape point cloud
+        meanshape_path = f'/home/xyz/anything6d_project/Sem-GCE-AG-Pose/saved_pcd/{cat}/mean_shape/mean_shape_pcd_1.txt'
+        meanshape_pcd_np = np.loadtxt(meanshape_path)
+        meanshape_pcd_tensor = torch.from_numpy(meanshape_pcd_np)
+        M = meanshape_pcd_tensor.shape[0]
+        meanshape_points = meanshape_pcd_tensor.view(1, M, 3).float()
+        average_aggregated_features = torch.load(f'{save_dir}/sem_cat_pcd_tex/{cat}_dino_feature.pt')
+        sem_global_pcd_list.append(meanshape_points[0])
+        sem_global_list.append(average_aggregated_features[0].detach().cpu())
+        #fig =plot_pointclouds_3d_with_pca(average_aggregated_features[0].detach().cpu(),meanshape_points[0])
+        #fig.savefig('test.png')
+        for j,instance in enumerate(instances):
+            
+            
+            print("Processing", instance)
+            obj_path = f'/media/xyz/data/HouseCat6D/obj_models_small_size_final/{cat}/{instance}.obj'
+            instance_pcd_path = f'/home/xyz/anything6d_project/Sem-GCE-AG-Pose/saved_pcd/{cat}/test/{instance}.txt'
+
+            # Load the instance point cloud
+            instance_pcd_np = np.loadtxt(instance_pcd_path)
+            instance_pcd_tensor = torch.from_numpy(instance_pcd_np)
+            N = instance_pcd_tensor.shape[0]
+            instance_points = instance_pcd_tensor.view(1, N, 3).float()
+            try:
+                aggregated_features = torch.load(f'{save_dir}/saved_dino_pcd_tex/{cat}/{instance}_dino_feature.pt')
+            except: 
+                continue
+            # plot_pointclouds_3d_with_pca(aggregated_features[0].detach().cpu(),
+            #                              instance_points[0])
+            sem_global_pcd_list.append(instance_points[0])
+            sem_global_list.append(aggregated_features[0].detach().cpu())
+            if j>6:
+                break
+        
+        plot_pointclouds_3d_with_copca(sem_global_list,sem_global_pcd_list,co_pca=True)
+        plt.show()
+        plt.close()
+    a
+
+
+# model_dict={'small':'dinov2_vits14',
+#             'base':'dinov2_vitb14',
+#             'large':'dinov2_vitl14',
+#             'giant':'dinov2_vitg14'}
+# extractor = ViTExtractor(model_dict['small'],14)
+# extractor.model = extractor.model.cuda(0)  # the stride of first conv control outputs resolution
+
+# TODO: Change extractor model to dinov3
+# 1) Build a ViT-S/16 backbone from timm (shape-compatible with your hooks)
+extractor = DINOv3ExtractorAdapter(
+    model_id="facebook/dinov3-vits16-pretrain-lvd1689m",  # ViT-S/16
+    device="cuda"
+)
+extractor.model = extractor.model.cuda(0)
+# End TODO
+
+# --- 加载元数据 ---
+metadata_path = os.path.join("/media/hyunjun/NewDisk1/Datasets/wlcop/raw", "metadata.json")
+if not os.path.exists(metadata_path):
+    raise FileNotFoundError("metadata.json not found. Please run create_metadata.py first.")
+with open(metadata_path, "r") as f:
+    metadata_dict = json.load(f)
+# --- 构建有序的路径列表 (self.all_paths)，这部分保持不变 ---
+path_to_idx = {path: int(index) for index, path in metadata_dict.items()}
+
+
+# load mean shape
+meanshap_path = "/media/hyunjun/NewDisk1/weihang/deep-linear-shapes/runs/wlcop173_supervisedK173_Affine_3/last_epoch_linearshape_model.pkl"
+# obj = torch.load(meanshap_path, map_location="cpu", weights_only=False) 
+with open(meanshap_path, "rb") as f:
+    pickle_data = pickle.load(f)
+# Convert to tensor dictionary
+id2meanshape_pcd_tensor = {
+    i: torch.tensor(v["pos"]) for i, v in pickle_data.items() if v["pos"] is not None
+}
+
+
+# load id to name mapping
+shape_file = "/media/hyunjun/NewDisk1/Datasets/wlcop/raw/wlcop173_shape_names.txt"
+with open(shape_file, "r") as f:
+    id2name = {i: line.strip() for i, line in enumerate(f) if line.strip()}
+
+cat_list = [name for i, name in id2name.items() if name]
+
+
+# load source dir list of omni6d and pace 
+omni6d_source_dir = "/media/hyunjun/NewDisk1/Omni6DPoseAPI/data/Omni6DPose/PAM/object_meshes"
+pace_source_dir = "/media/hyunjun/4ED38B1B5AFB74D5/PACE/models"
+
+omni6d_dirlist = [
+    os.path.join(omni6d_source_dir, d)
+    for d in os.listdir(omni6d_source_dir)
+    if os.path.isdir(os.path.join(omni6d_source_dir, d))
+]
+
+pace_dirlist = [
+    os.path.join(pace_source_dir, d)
+    for d in os.listdir(pace_source_dir)
+]
+
+# load the transformation matrix from pace to omni6d
+models_info_path = "/media/hyunjun/4ED38B1B5AFB74D5/PACE/models/models_info.json"
+id_map = load_models_info(models_info_path)
+trans_map = load_trans2canon("/media/hyunjun/NewDisk1/Datasets/pace_convert.json")  # adjust path
+
+#TODO: if condition for tex rendering
+for idx, cat in enumerate(cat_list):
+
+    if cat != 'drawing':
+        continue
+
+    instances = [path for path in path_to_idx.keys() if cat == path.split('/')[-2]]
+
+    print(instances)
+
+    aggregated_features_list = []  # N * [1, 1024, 384]
+    # Load the mean shape point cloud
+    meanshape_pcd_tensor = id2meanshape_pcd_tensor[idx]
+    M = meanshape_pcd_tensor.shape[0]
+    meanshape_points = meanshape_pcd_tensor.view(1, M, 3).float().cuda(0)
+
+    
+    for j, instance in enumerate(instances):
+        # if instance != 'bottle-85_alcool':
+        #     continue
+        print("Processing", instance)
+        instance_name = instance.split('/')[-1].replace('.txt','')
+        # quickly check if the instance has been processed
+        target_vis_file = f'{save_dir}/{cat}_rgb_dino/{instance_name}_dino.png'
+        if os.path.exists(target_vis_file):
+            aggregated_features_list.append(torch.load(f'{save_dir}/saved_dino_pcd_tex/{cat}/{instance_name}_dino_feature.pt'))
+            # print(f"Skipping '{instance}', file already exists at: {target_vis_file}")
+            continue # continue 会立即结束本次循环，进入下一次循环
+
+        obj_path = None  # pcd file like .txt or .ply
+        if "obj_" in instance.split('/')[-1]:
+            name = instance.split('/')[-1].replace('.txt','.ply')
+            obj_path =  find_original_folder(name, pace_dirlist)
+        else:
+            name = instance.split('/')[-1].replace('.txt','')
+            obj_path_base = find_original_folder(name, omni6d_dirlist)
+            obj_path_base = Path(obj_path_base)
+            obj_path = obj_path_base / 'Aligned.obj'
+            if os.path.exists(obj_path):
+                obj_path = os.path.join(omni6d_source_dir, obj_path)
+            else:
+                obj_path = list(obj_path_base.glob('*.obj'))[0]
+        # obj_path = f'/media/hyunjun/NewDisk1/Datasets/wlcop/raw/{cat}/{instance}.obj'
+        # instance_pcd_path = f'/media/hyunjun/NewDisk1/Datasets/wlcop/reconstructions/{cat}/{instance}.txt'
+
+        instance_pcd_path = instance.replace('.txt','.ply').replace('/raw/','/reconstructions/') # mesh file, like .obj, .ply
+
+        # Load the instance point cloud
+        # instance_pcd_np = np.loadtxt(instance_pcd_path, delimiter=",")
+        instance_pcd = o3d.io.read_point_cloud(instance_pcd_path)
+        instance_pcd_np = np.asarray(instance_pcd.points)  # shape (N, 3)
+        instance_pcd_tensor = torch.from_numpy(instance_pcd_np)
+        N = instance_pcd_tensor.shape[0]
+        if N != 1024:
+            print(f"Warning: {instance_name} has {N} points, expected 1024. Skipping.")
+            continue
+        instance_points = instance_pcd_tensor.view(1, N, 3).float().cuda(0)
+
+        try:
+            suffix = Path(obj_path).suffix.lower()   # works for both Path and str
+
+            if suffix == ".ply":
+                idx = extract_index_from_fname(Path(obj_path))
+                category, _ = id_map[idx]
+                R = lookup_transform(category, trans_map)
+                verts, faces, aux = load_ply_with_rotation(obj_path, R=R, device=device)
+            elif suffix == ".obj":
+                verts, faces, aux = load_obj(str(obj_path))
+        except ValueError as e:
+            print(f"Warning: {e}, attempting to load without material.")
+
+            try:
+                if suffix == ".ply":
+                    vverts, faces, aux = load_ply_with_rotation(obj_path, R=R, device=device)
+                elif suffix == ".obj":
+                    verts, faces, aux = load_obj(str(obj_path))
+            except ValueError as e2:
+                print(f"Failed to load {obj_path} without material: {e2}")
+                continue
+
+        # 检查 verts_uvs 是否为 None
+        if aux.verts_uvs is not None:
+            verts_uvs = aux.verts_uvs[None, ...]  # (1, V, 2)
+            faces_uvs = faces.textures_idx[None, ...]  # (1, F, 3)
+            tex_maps = aux.texture_images
+
+            # tex_maps is a dictionary of {material name: texture image}.
+            # Take the first image:
+            # if tex_maps:
+            #     texture_image = list(tex_maps.values())[0]
+            #     texture_image = texture_image[None, ...]  # (1, H, W, 3)
+            dev = verts_uvs.device  # the device we want everything on
+            tex_maps = aux.texture_images  # dict[str, Tensor(H,W,3)]
+            if tex_maps:
+                texture_image = list(tex_maps.values())[0]
+                # ensure shape (1,H,W,3), dtype float32, device match
+                if texture_image.dim() == 3:
+                    texture_image = texture_image.unsqueeze(0)
+                texture_image = texture_image.to(dev).float().contiguous()
+
+            # Create a textures object
+            tex = TexturesUV(verts_uvs=verts_uvs, faces_uvs=faces_uvs, maps=texture_image)
+        else:
+            # 如果 verts_uvs 是 None，直接跳过纹理处理，或者你可以设置默认行为
+            print(f"No UV coordinates for {instance_name}, skipping texture mapping.")
+            tex = None
+
+        # Initialise the mesh with textures
+        verts = normalize_mesh_verts(verts) # Housecat meshes are absolute scale
+        #meshes = Meshes(verts=[verts], faces=[faces.verts_idx], textures=None)
+        meshes = Meshes(verts=[verts], faces=[faces.verts_idx], textures=tex)
+
+
+        if meshes.textures is None:
+            meshes.textures = TexturesVertex(
+                verts_features=torch.ones_like(meshes.verts_padded(), device=device)
+            ) 
+
+        # render the mesh with 8 views, scale means the distance from the object to the camera
+        image_size=(420,420)
+        # images,fragments,cameras = render_batch(meshes,image_size=image_size,scale=2.0)
+        images,fragments,cameras = render(meshes,image_size=image_size,scale=2.0)
+
+        # get the feature point cloud
+        feature_point_cloud, dino_feat_masked, feature_point_cloud_list = fuse_feature_rgbd(extractor,images,fragments,cameras)
+
+        # get the downsampled aggregated feature point cloud
+        num_pts= 1024
+        nn_num= 1024 # larger nn_num will make the feature more smooth
+        sampled_points,aggregated_features = downsample_with_knn_feature_aggregation(feature_point_cloud,num_pts,nn_num,instance_points)
+
+        # #Needed
+        # index = np.random.choice(partial_feature_point_cloud.shape[0], 1024, replace=False)
+        # plot_pointclouds_3d_with_copca(average_aggregated_features.squeeze(0).detach().cpu().numpy(), 
+        #                                partial_feature_point_cloud[index,3:], 
+        #                                sampled_points.squeeze(0).detach().cpu().numpy(), 
+        #                                partial_feature_point_cloud[index,:3])
+        
+
+        q=0
+
+        os.makedirs(f'{save_dir}/saved_dino_pcd_tex/{cat}', exist_ok=True)
+        torch.save(aggregated_features, f'{save_dir}/saved_dino_pcd_tex/{cat}/{instance_name}_dino_feature.pt')
+
+        aggregated_features_list.append(aggregated_features)
+        # #break
+        vis_dino = vis_pca_pixelwise(np.array(dino_feat_masked))
+        vis_img = np.clip(vis_dino[:,:,:,:],a_min=0,a_max=1)
+        image_grid(vis_img, rows=2, cols=4, rgb=True)
+
+        os.makedirs(f'{save_dir}/{cat}_rgb_dino', exist_ok=True)
+        plt.savefig(f'{save_dir}/{cat}_rgb_dino/{instance_name}_dino.png')
+        plt.close()
+        if False:
+
+            rgb = images.cpu().numpy()[:, :, :, :3]
+            mask = images[:, ..., 3].cpu().numpy()!=0
+            depth_image = fragments[:, ..., 0].cpu().numpy()*mask
+            image_grid(rgb, rows=1, cols=8, rgb=True)
+            # os.makedirs(f'/home/tulrfpf/code/PointFlowRenderer/{cat}_rgb_dino', exist_ok=True)
+            # plt.savefig(f'/home/tulrfpf/code/PointFlowRenderer/{cat}_rgb_dino/{instance}_rgb.png')
+            # image_grid(depth_image[...,None], rows=2, cols=4, rgb=True)
+            # image_grid(mask[...,None], rows=2, cols=4, rgb=True)
+
+
+
+            fig = plt.figure(figsize=(10, 10))
+            ax = fig.add_subplot(111, projection="3d")
+            #ax.scatter(sampled_points[:, 2], sampled_points[:,0], sampled_points[:, 1], c="b")
+            pca_color =vis_pca(feature_point_cloud[:, 3:])
+            ax.scatter(feature_point_cloud[:, 2], feature_point_cloud[:, 0], feature_point_cloud[:, 1], c=pca_color,s=0.1)
+            #create_camera_geometry_batch(ax=ax,R_batch=R,T_batch=T,order=(2,0,1))
+            ax.set_xlabel("z")
+            ax.set_ylabel("x")
+            ax.set_zlabel("y")
+            ax.set_xlim(-2, 2)
+            ax.set_ylim(-2, 2)
+            ax.set_zlim(-2, 2)
+            plt.title("Sampled Dense Points from Mesh")
+            plt.show()
+
+            fig = plt.figure(figsize=(10, 10))
+            ax = fig.add_subplot(111, projection="3d")
+            pca_color =vis_pca(aggregated_features.squeeze(0))
+            sampled_points= sampled_points.squeeze(0).cpu().detach().numpy()
+            ax.scatter(sampled_points[:, 2], sampled_points[:, 0], sampled_points[:, 1], c=pca_color,s=50)
+            #create_camera_geometry_batch(ax=ax,R_batch=R,T_batch=T,order=(2,0,1))
+            ax.set_xlabel("z")
+            ax.set_ylabel("x")
+            ax.set_zlabel("y")
+            ax.set_xlim(-2, 2)
+            ax.set_ylim(-2, 2)
+            ax.set_zlim(-2, 2)
+            plt.title("Sampled Sparse Points from Mesh")
+            plt.show()
+            #break
+    # Assign the aggregated features to the mean shape point cloud
+    if len(aggregated_features_list) == 0:
+        print(f"No valid instances found for category {cat}, skipping saving average features.")
+        continue    
+
+    # quickly check if the category has been processed
+    # target_feature_file = f'{save_dir}/sem_cat_pcd_tex/{cat}_dino_feature.pt'
+    # if os.path.exists(target_feature_file):
+    #     # print(f"Skipping '{cat}', file already exists at: {target_feature_file}")
+    #     continue # continue 会立即结束本次循环，进入下一次循环
+
+    aggregated_features_tensor = torch.cat(aggregated_features_list, dim=0)  #[N, 1024, 384]
+    average_aggregated_features = aggregated_features_tensor.mean(dim=0, keepdim=True)
+    print("Average Aggregated Features Shape:", average_aggregated_features.shape)  # Should be (1, 1024, 384)
+
+    os.makedirs(f'{save_dir}/sem_cat_pcd_tex', exist_ok=True)
+    torch.save(average_aggregated_features, f'{save_dir}/sem_cat_pcd_tex/{cat}_dino_feature.pt')
+
+# fig = plt.figure(figsize=(10, 10))
+# ax = fig.add_subplot(111, projection="3d")
+# pca_color =vis_pca(average_aggregated_features.squeeze(0))
+# # sampled_points= sampled_points.squeeze(0).cpu().detach().numpy()
+# meanshape_points = meanshape_points.squeeze(0).cpu().detach().numpy()
+# ax.scatter(meanshape_points[:, 2], meanshape_points[:, 0], meanshape_points[:, 1], c=pca_color,s=10.0, marker='o')
+# ax.set_xlabel("z")
+# ax.set_ylabel("x")
+# ax.set_zlabel("y")
+# ax.set_xlim(-2, 2)
+# ax.set_ylim(-2, 2)
+# ax.set_zlim(-2, 2)
+# plt.title("Shape Prior Dino")
+# plt.show()
+    

RGBD_DINO_HouseCat6D_final_copy.py

@@ -0,0 +1,1083 @@
+import torch
+from custom_utils import ShapeNetCore
+from custom_utils import _compute_fov,_sample_points_from_faces
+from custom_utils import image_grid
+from custom_utils.shapenet_base import HouseCatDataset
+import matplotlib.pyplot as plt
+import numpy as np
+import k3d
+import os
+import json
+import torch
+from PIL import Image
+
+import cv2
+import imageio
+import numpy as np
+from PIL import Image
+import matplotlib.pyplot as plt
+from torchvision import transforms
+from custom_utils.extractor import ViTExtractor
+import torch.nn.functional as F
+from sklearn.decomposition import PCA as sklearnPCA
+import math
+from custom_utils.utils_general import center_crop
+
+from pytorch3d.io import load_objs_as_meshes, load_obj
+from pytorch3d.implicitron.tools.point_cloud_utils import get_rgbd_point_cloud
+from pytorch3d.structures import Meshes
+from pytorch3d.renderer import (
+    PerspectiveCameras,
+    FoVPerspectiveCameras,
+    PointLights,
+    MeshRasterizer,
+    MeshRenderer,
+    RasterizationSettings,
+    HardPhongShader,
+    TexturesVertex,
+    look_at_view_transform,
+    ray_bundle_to_ray_points,
+    NDCMultinomialRaysampler,
+    TexturesUV,
+    BlendParams,
+
+    TexturesVertex
+)
+
+from pytorch3d.implicitron.tools.point_cloud_utils import get_rgbd_point_cloud
+from pytorch3d.structures import Pointclouds
+import torch
+from pytorch3d.ops import sample_farthest_points, knn_points, knn_gather
+
+from matplotlib import cm
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.decomposition import PCA
+from mpl_toolkits.mplot3d import Axes3D
+import open3d as o3d
+
+
+def sample_points_on_sphere(num_points=80):
+    points = []
+    phi = (1 + math.sqrt(5)) / 2  # golden ratio
+
+    for i in range(num_points):
+        theta = 2 * math.pi * i / phi  # azimuthal angle
+        z = 1 - (2 * i + 1) / num_points  # z-coordinate, uniform from -1 to 1
+        radius = math.sqrt(1 - z * z)  # radius for the xy-plane
+        x = radius * math.cos(theta)
+        y = radius * math.sin(theta)
+        points.append([x, y, z])
+
+    return torch.tensor(points, dtype=torch.float32)
+
+def get_cube_vertices():
+    # Cube vertices (8 vertices)
+    return torch.tensor([[1, 1, 1],
+                         [1, 1, -1],
+                         [1, -1, 1],
+                         [1, -1, -1],
+                         [-1, 1, 1],
+                         [-1, 1, -1],
+                         [-1, -1, 1],
+                         [-1, -1, -1]], dtype=torch.float32)  # Ensure float type
+
+
+def render(meshes,scale=3.0,image_size=(420,420),light=(0.3,0.3,0.3)):
+    # prepare the camera
+    num_views = 8
+    # Get the cube vertices
+    #cube_vertices = get_cube_vertices()*scale
+    cube_vertices = sample_points_on_sphere(num_views)*scale
+    #up = torch.randn(1, 3)
+    up=torch.tensor([[0.0, 0.0, 1.0]], dtype=torch.float32)
+    up = up / torch.norm(up, dim=1)[:, None]
+    R, T = look_at_view_transform(eye=cube_vertices, at=torch.tensor([[0.0, 0.0, 0.0]], dtype=torch.float32), up=up)
+    cam_K= np.array([[572, 0.0, image_size[0]//2], [0.0, 572, image_size[1]//2], [0.0, 0.0, 1.0]])
+    fx,_,cx,_,fy,cy,_,_,_=cam_K.reshape(9)
+    fov_x, fov_y = _compute_fov(cam_K, 420, 420)
+
+    cameras = PerspectiveCameras(device=device, R=R, T=T, image_size=((420,420),),
+                                    focal_length=torch.tensor([[fx, fy]], dtype=torch.float32),
+                                    principal_point=torch.tensor([[cx, cy]], dtype=torch.float32),
+                                    in_ndc=False)
+
+    # prepare the lights
+    raster_settings = RasterizationSettings(image_size=image_size)
+    lights = PointLights(location=torch.tensor([0.0, 1.0, -2.0], device=device)[None], ambient_color=(light,),diffuse_color=(light,),device=device)
+
+    # move the data to the device
+    meshes = meshes.to(device)
+    cameras = cameras.to(device)
+    if len(cameras) != 1 and len(cameras) % len(meshes) != 0:
+        raise ValueError("Mismatch between batch dims of cameras and meshes.")
+    if len(cameras) > 1:
+        meshes = meshes.extend(len(cameras) // len(meshes))
+
+    # prepare the renderer
+    class MeshRendererWithDepth(torch.nn.Module):
+        def __init__(self, rasterizer, shader):
+            super().__init__()
+            self.rasterizer = rasterizer
+            self.shader = shader
+
+        def forward(self, meshes_world, **kwargs) -> torch.Tensor:
+            fragments = self.rasterizer(meshes_world, **kwargs)
+            images = self.shader(fragments, meshes_world, **kwargs)
+            return images, fragments.zbuf
+        
+
+    blend_params = BlendParams(background_color=(0.0, 0.0, 0.0))  # Blue background
+    renderer = MeshRendererWithDepth(
+        rasterizer=MeshRasterizer(
+            cameras=cameras,
+            raster_settings=raster_settings,
+        ),
+    # Set background color to blue [R, G, B]
+
+        shader=HardPhongShader(
+            device=device,
+            cameras=cameras,
+            lights=lights,
+            blend_params=blend_params
+        )
+    )
+
+    images,fragments = renderer(meshes)
+    return images,fragments,cameras
+
+
+def render_batch(meshes,scale=3.0,image_size=(420,420),light=(0.3,0.3,0.3)):
+    # prepare the camera
+    num_views = 8
+    # Get the cube vertices
+    cube_vertices = get_cube_vertices()*scale
+    #cube_vertices = sample_points_on_sphere(num_views)*scale
+    up = torch.randn(1, 3)
+    # up=torch.tensor([[0.0, 0.0, 1.0]], dtype=torch.float32)
+    up = up / torch.norm(up, dim=1)[:, None]
+    R, T = look_at_view_transform(eye=cube_vertices, at=torch.tensor([[0.0, 0.0, 0.0]], dtype=torch.float32), up=up)
+
+    cam_K= np.array([[572, 0.0, image_size[0]//2], [0.0, 572, image_size[1]//2], [0.0, 0.0, 1.0]])
+    fx,_,cx,_,fy,cy,_,_,_=cam_K.reshape(9)
+    fov_x, fov_y = _compute_fov(cam_K, 420, 420)
+
+
+    # prepare the renderer
+    class MeshRendererWithDepth(torch.nn.Module):
+        def __init__(self, rasterizer, shader):
+            super().__init__()
+            self.rasterizer = rasterizer
+            self.shader = shader
+
+        def forward(self, meshes_world, **kwargs) -> torch.Tensor:
+            fragments = self.rasterizer(meshes_world, **kwargs)
+            images = self.shader(fragments, meshes_world, **kwargs)
+            return images, fragments.zbuf
+        
+
+    blend_params = BlendParams(background_color=(0.0, 0.0, 0.0))  # Blue background
+
+    batch_size = 10
+    all_images=[]
+    all_fragments=[]
+
+    # move the data to the device
+    meshes = meshes.extend(batch_size).to(device)
+    for i in range(0,R.shape[0],batch_size):
+        R_batch = R[i:i+batch_size]
+        T_batch = T[i:i+batch_size]
+        cameras_batch = PerspectiveCameras(device=device, R=R_batch, T=T_batch, image_size=((420,420),),
+                                        focal_length=torch.tensor([[fx, fy]], dtype=torch.float32),
+                                        principal_point=torch.tensor([[cx, cy]], dtype=torch.float32),
+                                        in_ndc=False).to(device)
+
+        # prepare the lights
+        raster_settings = RasterizationSettings(image_size=image_size)
+        lights = PointLights(location=torch.tensor([0.0, 1.0, -2.0], device=device)[None], 
+                             ambient_color=(light,),diffuse_color=(light,),device=device)
+
+        renderer = MeshRendererWithDepth(
+            rasterizer=MeshRasterizer(
+                cameras=cameras_batch,
+                raster_settings=raster_settings,
+            ),
+            # Set background color to blue [R, G, B]
+            shader=HardPhongShader(
+                device=device,
+                cameras=cameras_batch,
+                lights=lights,
+                blend_params=blend_params
+            )
+         )
+        images,fragments = renderer(meshes)
+        all_images.append(images)
+        all_fragments.append(fragments)
+    all_images = torch.cat(all_images,dim=0)
+    all_fragments = torch.cat(all_fragments,dim=0)
+    cameras = PerspectiveCameras(device=device, R=R, T=T, image_size=((420,420),),
+                                focal_length=torch.tensor([[fx, fy]], dtype=torch.float32),
+                                principal_point=torch.tensor([[cx, cy]], dtype=torch.float32),
+                                in_ndc=False).to(device)
+    return all_images,all_fragments,cameras
+
+
+def fuse_feature_rgbd(extractor,images,fragments,cameras):
+    dino_feat_masked_list = []
+    feature_point_cloud_list = []
+    for i in range(images.shape[0]):
+        image = images.cpu().numpy()[i, :, :, :3]
+        image_mask = images[i, ..., 3].cpu().numpy()!=0
+        crop_size = (420, 420)
+        crop_image, crop_mask, bbox = center_crop(image, image_mask, crop_size)
+        cropped_image_np = cv2.resize(crop_image, crop_size, interpolation=cv2.INTER_AREA)
+        #cropped_mask = cv2.resize(crop_mask*1.0, crop_size, interpolation=cv2.INTER_NEAREST)!=0  # Use nearest neighbor interpolation for masks
+        orignal_size = (int(bbox[2]-bbox[0]), int(bbox[3]-bbox[1])) #K,K
+
+        to_tensor = transforms.ToTensor()
+        input_image = to_tensor(cropped_image_np).cuda()
+        input_image = input_image.unsqueeze(0)
+        #input_image=extractor.preprocess_pil(input_image)
+        mean = torch.tensor([0.485, 0.456, 0.406]).cuda()
+        std = torch.tensor([0.229, 0.224, 0.225]).cuda()
+        input_image = (input_image - mean[None, :, None, None]) / std[None, :, None, None]
+  
+        _desc_q = extractor.extract_descriptors(input_image,layer=11,include_cls=True).squeeze(1) # (1,900,384)
+        #_desc_q = extractor.forward_features(input_image)["x_prenorm"][:, :]   # (1,900,384)
+        #_desc_q = extractor.extract_descriptors(input_image,layer=11,facet='token',include_cls=True).squeeze(1) # B,L,C
+        # _norm_q = torch.linalg.norm(_desc_q, dim=-1)[:, :, None]
+        # _desc_q = _desc_q / (_norm_q)
+
+        desc = _desc_q[:,1:,:][None]
+        #cls_token_q = _desc_q[:,0,:] #B,C`
+
+        input_mask = to_tensor(crop_mask).cuda()
+        input_mask = input_mask.unsqueeze(0)
+
+        img_mask = to_tensor(image_mask)
+
+        img_mask = img_mask.permute(1,2,0)
+
+        dino_feat = patch2pixel_feats(desc, original_size=orignal_size) #reize back to K,K =>( K, K, 384)
+        # create dino-feat with orignal size
+        dino_height, dino_width, feat_dim = (image_size[0],image_size[1], desc.shape[-1])
+        dino_feat_orig = torch.zeros(dino_height,dino_width,feat_dim)
+        # Fill the dino features into the original tensor at the specified bounding box
+        dino_feat_orig[bbox[1]:bbox[3], bbox[0]:bbox[2],:] = dino_feat #reize back to K,K =>(420, 420, 384) #gradint is not supported for this operation
+        # Apply the mask
+        dino_feat_masked = dino_feat_orig * img_mask
+        dino_feat_masked = dino_feat_masked.permute(2,0,1).unsqueeze(0)
+        dino_feat_masked_low = F.interpolate(dino_feat_masked, size=(30, 30), mode='bilinear')
+
+        image_mask = images[i, ..., 3][None,None]
+        depth_image = fragments[i, ..., 0][None]*image_mask
+        
+        # # Define the kernel for erosion (3x3 ones kernel)
+        # kernel = torch.ones((1, 1, 5, 5), dtype=torch.float).cuda()
+        # # Number of erosion iterations
+        # iterations = 5
+
+        # # Perform iterative erosion
+        # for i in range(iterations):
+        #     # Apply erosion using 2D convolution
+        #     eroded_mask = F.conv2d(image_mask, kernel, padding=2)
+        #     image_mask = (eroded_mask == kernel.sum()).float()  # Update mask to eroded version
+
+        feature_point_cloud = get_rgbd_point_cloud(cameras[i], dino_feat_masked.to(device), depth_map=depth_image,mask=image_mask)#everthing on GPU
+
+        index = np.random.choice(feature_point_cloud.points_list()[0].shape[0], 4096, replace=True)
+        points = feature_point_cloud.points_list()[0].detach().cpu()[index,:]
+        colors = feature_point_cloud.features_list()[0].detach().cpu()[index,:]
+        # points = feature_point_cloud.points_list()[0].detach().cpu()[:,:]
+        # colors = feature_point_cloud.features_list()[0].detach().cpu()[:,:]
+        feature_point_cloud = torch.cat((points, colors), dim=1)
+
+        dino_feat_masked_list.append(dino_feat_masked_low.detach().cpu())
+        feature_point_cloud_list.append(feature_point_cloud)
+    feature_point_cloud = torch.cat(feature_point_cloud_list, dim=0)
+    dino_feat_masked = torch.cat(dino_feat_masked_list, dim=0)
+    return feature_point_cloud,dino_feat_masked, feature_point_cloud_list
+
+
+def downsample_with_knn_feature_aggregation(feature_point_cloud,num_pts=1024,k_nearest_neighbors=100, instance_points=None):
+    #N_1, C_1 = 2048, 384  # Example number of points and features
+    num_points_to_sample = num_pts
+    k_nearest_neighbors = k_nearest_neighbors
+
+    # Example input pointcloud and features (N_1, C_1), where N_1 is the number of points and C_1 is the feature dimension
+    pointcloud = feature_point_cloud[None,:,:3].cuda()  # Shape (1, N_1, 3) for 3D coordinates
+    features = feature_point_cloud[None,:,3:].cuda()  # Shape (1, N_1, C_1) for features
+
+    # Step 1: FPS to downsample the points
+    # We use sample_farthest_points to select num_points_to_sample points
+    sampled_points, sampled_indices = sample_farthest_points(pointcloud, K=num_points_to_sample)  # Shape: (1, 1024, 3), (1, 1024)
+    if instance_points is not None:
+        sampled_points = instance_points
+
+    # Step 2: KNN to find nearest neighbors
+    # Find the k nearest neighbors for each sampled point in the original pointcloud
+    dists, knn_indices, _ = knn_points(sampled_points, pointcloud, K=k_nearest_neighbors, return_nn=False)
+
+    # Step 3: Gather the features of the k-nearest neighbors using the knn indices
+    # Use knn_gather to get neighbor features for each sampled point
+    neighbor_features = knn_gather(features, knn_indices)  # Shape: (1, 1024, k, C_1)
+
+    # Step 4: Aggregate features from the neighbors (e.g., by averaging)
+    #aggregated_features,_ = torch.max(neighbor_features,dim=-2) # Shape: (1, 1024, C_1)
+    aggregated_features = torch.mean(neighbor_features,dim=-2) # Shape: (1, 1024, C_1)
+    return sampled_points, aggregated_features
+
+
+def vis_pca(feature):
+    n_components=3 # the first component is to seperate the object from the background
+
+    pca = sklearnPCA(n_components=n_components)
+    feature = pca.fit_transform(feature.detach().cpu().numpy())
+    for show_channel in range(n_components):
+        # min max normalize the feature map
+        feature[:, show_channel] = (feature[:, show_channel] - feature[:, show_channel].mean()) / (feature[:, show_channel].std()*10)
+    feature_resized = np.clip(feature[:,:]+0.5,0,1)
+    return feature_resized
+
+
+def patch2pixel_feats(patch_features, original_size):
+    # Calculate the number of patches along each dimension
+    num_patches = int(math.sqrt(patch_features.shape[2]))
+
+    batch_num = patch_features.shape[0]
+    feat_dim = patch_features.shape[3]
+    patch_features = patch_features.reshape(batch_num, num_patches, num_patches, feat_dim)
+    patch_features = patch_features.permute(0,3,1,2)
+
+    pixel_features = F.interpolate(patch_features, size=(original_size[0], original_size[1]), mode='bilinear')
+    pixel_features = pixel_features.squeeze().permute(1,2,0)
+    
+    return pixel_features
+
+def vis_pca_pixelwise(feature):
+    n_components = 4  # The number of PCA components to use
+    batch, feat_dim, height,width = feature.shape  
+    
+    # Reshape the feature to (num_pixels, feat_dim)
+    num_pixels = height * width
+    feature_reshaped = np.array(feature).transpose(0,2,3,1).reshape(-1, feat_dim)
+
+
+    # Apply PCA
+    pca = sklearnPCA(n_components=n_components)
+    feature_pca = pca.fit_transform(feature_reshaped)
+
+    # Min-max normalization for each component
+    # for show_channel in range(n_components):
+    #     feature_pca[:, show_channel] = (feature_pca[:, show_channel] - feature_pca[:, show_channel].min()) / \
+    #                                     (feature_pca[:, show_channel].max() - feature_pca[:, show_channel].min() + 1e-8)  # Small epsilon to avoid division by zero
+    for show_channel in range(n_components):
+        feature_pca[:, show_channel] = (feature_pca[:, show_channel] - feature_pca[:, show_channel].mean()) / \
+                                        (feature_pca[:, show_channel].std()*10 + 1e-8) # Small epsilon to avoid division by zero
+
+    feature_pca = np.clip(feature_pca+0.5, 0, 1)
+    # Reshape the PCA result back to (height, width, n_components)
+    feature_resized = feature_pca.reshape(batch,height,width,n_components)[...,1:4]
+    return feature_resized
+
+def normalize_mesh_verts(data):
+    # data [N, 3]
+    min_vals, _ = torch.min(data, dim=0)
+    max_vals, _ = torch.max(data, dim=0)
+    bbox_sizes = max_vals - min_vals
+    scale = torch.norm(bbox_sizes)
+    print("Scale:", scale)
+    normalized_verts = verts / scale
+    return normalized_verts
+
+def plot_pointclouds_with_color_mapping(pc1_f, pc2_f,pc1,pc2, query_points, similarity_threshold=None):
+    """
+    Visualizes two 3D point clouds. The second point cloud (pc2) is color-mapped
+    using the 'viridis' colormap based on its similarity (proximity) to the sampled
+    query points in the first point cloud (pc1).
+    
+    Parameters:
+    - pc1: np.ndarray of shape (N, 3), first point cloud #partial
+    - pc2: np.ndarray of shape (M, 3), second point cloud # global
+    - query_points: list of indices in pc1, representing the query points to compare.
+    - similarity_threshold: float, optional, threshold to cap the similarity distance.
+    """
+        
+
+    pc1_f = pc1_f / np.linalg.norm(pc1_f, axis=1)[:, None]  # Normalize the features
+    pc2_f = pc2_f / np.linalg.norm(pc2_f, axis=1)[:, None]  # Normalize the features
+    # Create a figure with subplots
+    fig = plt.figure(figsize=(12, 10))
+    num_query_points = len(query_points)
+    # Set limits and labels
+    size = pc2.max() - pc2.min()
+    # Plot the first point cloud in the first subplot
+    ax1 = fig.add_subplot(1, num_query_points + 1, 1, projection='3d')
+    ax1.scatter(pc2[:, 0], pc2[:, 1], pc2[:, 2], color='grey', label='Point Cloud 1 (Left)', alpha=0.1,s=10)
+
+    # Define a color list for each query point
+    query_colors = cm.tab10(np.linspace(0, 1, num_query_points))  # Use tab10 colormap for distinct colors
+
+    # Highlight query points in pc1 with different colors
+    for i, idx in enumerate(query_points):
+        ax1.scatter(pc1[idx, 0], pc1[idx, 1], pc1[idx, 2], 
+                    color=query_colors[i], s=100, edgecolor='k', label=f'Query Point {idx}')
+
+    ax1.set_title('Point Cloud 1 with Query Points')
+    ax1.set_xlabel('X')
+    ax1.set_ylabel('Y')
+    ax1.set_zlabel('Z')
+    ax1.set_xlim(-size / 1.4, size / 1.4)
+    ax1.set_ylim(-size / 1.4, size / 1.4)
+    ax1.set_zlim(-size / 1.4, size / 1.4)
+    ax1.view_init(elev=45, azim=-45)
+    ax1.grid(True)
+    ax1.legend()
+
+    # Plot the second point cloud in the subsequent subplots
+    for k in range(num_query_points):
+        
+        ax = fig.add_subplot(1, num_query_points + 1, k + 2, projection='3d')
+        
+        # Calculate distances between query points in pc1 and all points in pc2
+        similarity =(pc1_f[query_points[k]][None]@ pc2_f.T).reshape(-1) # (1, 3) x (M, 3) = (1, M)
+        # For each point in pc2, take the minimum distance to any query point
+        min_similarity = np.min(similarity, axis=0)
+        # Optionally cap the similarity distances to a threshold (to avoid extreme values)
+        similarity_threshold= 0.3
+        if similarity_threshold is not None:
+            similarity = np.clip(similarity, similarity_threshold,1)
+        # Normalize the distances to a range of 0 to 1 for colormap mapping
+        similarity = (similarity - np.min(similarity)) / (np.max(similarity) - np.min(similarity))
+        colors = cm.plasma(similarity)
+
+        # Plot the second point cloud with color mapping based on similarity
+        ax.scatter(pc2[:, 0], pc2[:, 1], pc2[:, 2], color=colors, s=15, alpha=1.0, label='Point Cloud 2 (Right)', edgecolor='k')
+        
+        ax.set_xlim(-size / 1.4, size / 1.4)
+        ax.set_ylim(-size / 1.4, size / 1.4)
+        ax.set_zlim(-size / 1.4, size / 1.4)
+        ax.set_title(f'QP_{query_points[k]}')
+        ax.set_xlabel('X')
+        ax.set_ylabel('Y')
+        ax.set_zlabel('Z')
+        ax.view_init(elev=45, azim=-45)
+        ax.grid(True)
+        ax.legend()
+
+    # Show the plot
+    plt.tight_layout()
+    plt.show()
+
+
+def plot_pointclouds_3d_with_copca_old(global_sem_pcd, partial_sem_pcd, global_pcd, partial_pcd):
+    """
+    Visualizes two point clouds in 3D, coloring them based on their PCA components.
+
+    Parameters:
+    - global_pointcloud: numpy array of shape (N, D) for global point cloud.
+    - partial_pointcloud: numpy array of shape (M, D) for partial point cloud.
+    """
+
+
+    n_components = 3
+    # Step 1: Perform PCA on both global and partial point clouds
+    sem_pca = PCA(n_components=n_components)
+    sem_pca = sem_pca.fit(global_sem_pcd)  # shape (N+M, 3)
+
+    transformed_sem_pcd_list = [sem_pca.transform(pcd) for pcd in [global_sem_pcd,partial_sem_pcd]]
+    sem_pcd_pca = np.concatenate(transformed_sem_pcd_list,axis=0)
+    for show_channel in range(n_components):
+        sem_pcd_pca[:, show_channel] = (sem_pcd_pca[:, show_channel] - sem_pcd_pca[:, show_channel].mean()) / \
+                                        (sem_pcd_pca[:, show_channel].std()*5 + 1e-8) # Small epsilon to avoid division by zero
+
+    # sem_pcd_pca_min = sem_pcd_pca.min()
+    # sem_pcd_pca_max = sem_pcd_pca.max()
+    # sem_pcd_pca = (sem_pcd_pca- sem_pcd_pca_min) / (sem_pcd_pca_max - sem_pcd_pca_min)  # Normalize to [0, 1]
+
+    sem_pcd_pca = np.clip(sem_pcd_pca[:,:]+0.5, 0, 1)
+    global_pca = sem_pcd_pca[:global_sem_pcd.shape[0]]  # shape (N, 3)
+    partial_pca = sem_pcd_pca[-partial_sem_pcd.shape[0]:]  # shape (M, 3)
+
+    # Step 2: Create a 3D scatter plot
+    fig = plt.figure(figsize=(12, 6))
+    ax = fig.add_subplot(121, projection='3d')
+
+
+    # Global point cloud
+    ax.scatter(global_pcd[:, 0], global_pcd[:, 1], global_pcd[:, 2], 
+            c=global_pca,  marker='o', s=100, alpha=1.0, label='Global Point Cloud')
+    
+    # Set labels for each axis
+    # ax.set_xlabel('X axis')
+    # ax.set_ylabel('Y axis')
+    # ax.set_zlabel('Z axis')
+    ax.set_xlim(-0.5, 0.5)
+    ax.set_ylim(-0.5, 0.5)
+    ax.set_zlim(-0.5, 0.5)
+    
+    ax1 = fig.add_subplot(122, projection='3d')
+
+    # Partial point cloud
+    ax1.scatter(partial_pcd[:, 0], partial_pcd[:, 1], partial_pcd[:, 2], 
+            c=partial_pca,  marker='o', s=100, alpha=1.0, label='Partial Point Cloud')
+    
+    # ax1.scatter(global_pcd[:, 0], global_pcd[:, 1], global_pcd[:, 2], 
+    #         marker='o', s=10, alpha=0.1)
+    # Set labels for each axis
+    # ax1.set_xlabel('X axis')
+    # ax1.set_ylabel('Y axis')
+    # ax1.set_zlabel('Z axis')
+
+    
+    ax1.set_xlim(-0.5, 0.5)
+    ax1.set_ylim(-0.5, 0.5)
+    ax1.set_zlim(-0.5, 0.5)
+    plt.tight_layout()
+
+    ax.view_init(120,-95)
+    ax1.view_init(120,-95)
+
+ 
+    ax.set_axis_off()
+    ax.set_facecolor((0, 0, 0, 0))
+    ax1.set_axis_off()
+    ax1.set_facecolor((0, 0, 0, 0))
+
+    plt.show()
+
+
+def plot_pointclouds_3d_with_pca(global_sem_pcd, global_pcd):
+    """
+    Visualizes two point clouds in 3D, coloring them based on their PCA components.
+
+    Parameters:
+    - global_pointcloud: numpy array of shape (N, D) for global point cloud.
+    - partial_pointcloud: numpy array of shape (M, D) for partial point cloud.
+    """
+    #sem_pcd = np.concatenate((global_sem_pcd,partial_sem_pcd), axis=0) # shape (N+M, D)
+
+    # Step 1: Perform PCA on both global and partial point clouds
+    sem_pca = PCA(n_components=3)
+    sem_pcd_pca = sem_pca.fit_transform(global_sem_pcd)  # shape (N+M, 3)
+
+    for i in range(3):  # Iterate over each component (3 in total for RGB)
+        sem_pcd_pca_mean = sem_pcd_pca[:, i].mean()
+        sem_pcd_pca_std = sem_pcd_pca[:, i].std()
+        sem_pcd_pca[:, i] = (sem_pcd_pca[:, i] - sem_pcd_pca_mean) / (sem_pcd_pca_std*5+1e-8)  # Normalize to [0, 1]
+
+
+    global_pca = np.clip(sem_pcd_pca+0.5,0,1)
+    # scatter plot
+    fig = plt.figure(figsize=(6, 6))
+    ax = fig.add_subplot(111, projection='3d')
+
+    # Global point cloud
+    ax.scatter(global_pcd[:, 0], global_pcd[:, 1], global_pcd[:, 2], 
+            c=global_pca,  marker='o', s=50, alpha=1.0, label='Global Point Cloud')
+    
+    # Remove axes and background
+    ax.set_axis_off()
+
+    # Set background color to none
+    ax.set_facecolor((0, 0, 0, 0))
+    # # Set labels for each axis
+    # ax.set_xlabel('X axis')
+    # ax.set_ylabel('Y axis')
+    # ax.set_zlabel('Z axis')
+    ax.set_xlim(-0.5, 0.5)
+    ax.set_ylim(-0.5, 0.5)
+    ax.set_zlim(-0.5, 0.5)
+
+    ax.view_init(-73,102)
+
+    return fig
+    
+
+def plot_pointclouds_3d_with_copca(global_sem_pcd_list, global_pcd_list,co_pca=True):
+    """
+    Visualizes multiple point clouds in 3D, each in a separate subplot, after applying CoPCA.
+    Coloring them based on their PCA components.
+
+    Parameters:
+    - global_sem_pcd_list: list of numpy arrays for semantic point clouds (one per object).
+    - global_pcd_list: list of numpy arrays for global point clouds (one per object).
+    """
+    num_pcds = len(global_sem_pcd_list)  # Number of point clouds
+    print("Number of point clouds to visualize:", num_pcds)
+    # Step 1: Perform CoPCA (Common PCA) on the semantic point clouds
+        # Concatenate all point clouds to perform common PCA
+    if co_pca:
+
+        concatenated_pcds = np.concatenate(global_sem_pcd_list, axis=0)  # shape (N_total, D)
+        copca = PCA(n_components=3, random_state=0)
+        copca.fit(concatenated_pcds[:1024])  # Fit PCA on all point clouds together
+        transformed_sem_pcd_list = [copca.transform(pcd) for pcd in global_sem_pcd_list]
+
+
+        signs = np.sign(np.sum(transformed_sem_pcd_list[0], axis=0))
+        # Post-process to ensure consistent orientation of PCA components
+        for i, transformed_pcd in enumerate(transformed_sem_pcd_list):
+            # For each component (column), align sign based on the sum of values in the column
+            transformed_sem_pcd_list[i] = transformed_pcd * signs
+    else:
+        copca = PCA(n_components=3)
+        transformed_sem_pcd_list = [copca.fit_transform(pcd) for pcd in global_sem_pcd_list]
+        # Post-process to ensure consistent orientation of PCA components
+        for i, transformed_pcd in enumerate(transformed_sem_pcd_list):
+            signs = np.sign(np.sum(transformed_pcd, axis=0))
+            # For each component (column), align sign based on the sum of values in the column
+            transformed_sem_pcd_list[i] = transformed_pcd * signs
+
+
+
+    # Create a figure with subplots arranged in a grid (based on number of point clouds)
+    fig = plt.figure(figsize=(6 * num_pcds, 6))  # Adjust figure size based on the number of subplots
+    
+    # Loop over the point clouds
+    for idx, (sem_pcd_pca, global_pcd) in enumerate(zip(transformed_sem_pcd_list, global_pcd_list)):
+        ax = fig.add_subplot(1, num_pcds, idx + 1, projection='3d')
+
+        # Step 2: Normalize the PCA-transformed data to use as colors
+        for i in range(3):  # Iterate over each component (3 in total for RGB)
+            pca_mean = sem_pcd_pca[:, i].mean()
+            pca_std = sem_pcd_pca[:, i].std()
+            sem_pcd_pca[:, i] = (sem_pcd_pca[:, i] - pca_mean) / (pca_std * 5 + 1e-8)  # Normalize
+
+        global_pca_colors = np.clip(sem_pcd_pca + 0.5, 0, 1)  # Map to [0, 1] for RGB
+
+        # Scatter plot for this point cloud in the current subplot
+        ax.scatter(global_pcd[:, 0], global_pcd[:, 1], global_pcd[:, 2], 
+                   c=global_pca_colors, marker='o', s=50, alpha=1.0)
+
+        # Remove axes and background
+        ax.set_axis_off()
+        ax.set_facecolor((0, 0, 0, 0))
+
+        # Set axis limits for each subplot
+        ax.set_xlim(-0.5, 0.5)
+        ax.set_ylim(-0.5, 0.5)
+        ax.set_zlim(-0.5, 0.5)
+
+        # Set view angle
+        ax.view_init(-55, 102)
+
+    # Adjust spacing between subplots
+    plt.tight_layout()
+
+    return fig
+    
+
+    
+def unnormalize(x):
+    # x.shape : [H,W,3]
+    mean = np.array([0.485, 0.456, 0.406])
+    std = np.array([0.229, 0.224, 0.225])
+    return x * std + mean
+
+
+from custom_utils.housecat6d_dataset import HouseCat6DTrainingDataset
+trainset = HouseCat6DTrainingDataset(image_size=420, sample_num=1024,data_dir='/media/xyz/data1/HouseCat6D')
+
+vis = True
+device = "cuda"
+import matplotlib
+matplotlib.use('TkAgg')
+
+#cat_list = ['bottle','box','can','cup','cutlery','remote','shoe','tube','teapot']
+cat_list = ['cup']
+
+
+sem_global_list = []  
+sem_global_pcd_list = []  
+
+# load semantc feature and show
+########################################
+save_dir = 'Yung/yung_large_files/semantic_feature/test_notebook/8v'
+#save_dir = './80views_textured_token'
+if  True:
+    for cat in cat_list:
+    # # orriginal    
+    #     with open(f'/mnt/4T/Yung/yung_large_files/semantic_feature/test_notebook/housecat_{cat}/raw/housecat1_train.txt', 'r') as f:
+    #         instances = [line.strip() for line in f.readlines()]
+
+    #     print(instances)
+    # revised
+    # instance try cup-grey_handle
+        instances = ['cup-grey_handle']
+        sem_global_list = []  
+        sem_global_pcd_list = []  
+
+        # Load the mean shape point cloud
+        meanshape_path = f'Yung/yung_large_files/semantic_feature/test_notebook/saved_pcd/{cat}/mean_shape/mean_shape_pcd_1.txt'
+        meanshape_pcd_np = np.loadtxt(meanshape_path)
+        meanshape_pcd_tensor = torch.from_numpy(meanshape_pcd_np)
+        M = meanshape_pcd_tensor.shape[0]
+        meanshape_points = meanshape_pcd_tensor.view(1, M, 3).float()
+    #make sure map to cuda0    
+        average_aggregated_features = torch.load(f'//mnt/4T/Yung/yung_large_files/semantic_feature/test_notebook/8v_key/sem_cat_pcd_untex/cup_dino_feature.pt', map_location={"cuda:1": "cuda:0"})
+        sem_global_pcd_list.append(meanshape_points[0])
+        sem_global_list.append(average_aggregated_features[0].detach().cpu())
+        #fig =plot_pointclouds_3d_with_pca(average_aggregated_features[0].detach().cpu(),meanshape_points[0])
+        #fig.savefig('test.png')
+        for j,instance in enumerate(instances):
+            #break
+            print("Processing", instance)
+            #obj_path = f'/media/xyz/data/HouseCat6D/obj_models_small_size_final/{cat}/{instance}.obj'
+            #instance_pcd_tensor = torch.load(f'{save_dir}/saved_pcd_untex/{cat}/{instance}_pcd.pt')[0]
+            #obj_path = f'/media/xyz/data1/HouseCat6D/obj_models_small_size_final/{cat}/{instance}.obj'
+            # if instance != 'cup-grey_handle':
+            # # original pcd
+            instance_pcd_path = f'Yung/yung_large_files/semantic_feature/test_notebook/saved_pcd/{cat}/test/{instance}.txt'
+            # Load the instance point cloud
+            instance_pcd_np = np.loadtxt(instance_pcd_path)
+            reference_scale = np.linalg.norm(instance_pcd_np.max(axis=0) - instance_pcd_np.min(axis=0))
+            
+            # else:
+            #     instance_pcd_path = f'Yung/yung_large_files/pose_can_results/housecat6d_sonata_feature/scene01/000000/cup-grey_handle/normalized_groundtruth_pca.ply'
+            #     pcd = o3d.io.read_point_cloud(instance_pcd_path)
+            #     instance_pcd_np = np.asarray(pcd.points)
+                
+            current_scale = np.linalg.norm(instance_pcd_np.max(axis=0) - instance_pcd_np.min(axis=0))
+            scale_factor = reference_scale / current_scale
+            instance_pcd_np = instance_pcd_np * scale_factor
+
+            scale = np.linalg.norm(instance_pcd_np.max(axis=0) - instance_pcd_np.min(axis=0))
+            print("Scale:", scale)
+
+            instance_pcd_tensor = torch.from_numpy(instance_pcd_np)
+            N = instance_pcd_tensor.shape[0]
+            instance_points = instance_pcd_tensor.view(1, N, 3).float()
+            try:
+                # aggregated_features = torch.load(f'{save_dir}/saved_dino_pcd_untex/{cat}/{instance}_dino_feature.pt')
+                aggregated_features = average_aggregated_features
+            except:
+                print(f"Warning: {instance} not found.")
+                continue
+            # plot_pointclouds_3d_with_pca(aggregated_features[0].detach().cpu(),
+            #                              instance_points[0])
+
+            sem_global_pcd_list.append(instance_points[0].detach().cpu())
+            sem_global_list.append(aggregated_features[0].detach().cpu())
+            if len(sem_global_list)>4:
+                break
+        
+        fig = plot_pointclouds_3d_with_copca(sem_global_list,sem_global_pcd_list,co_pca=True)
+        fig.savefig(f'./{save_dir}/{cat}.png')
+###############################
+
+
+model_dict={'small':'dinov2_vits14',
+            'base':'dinov2_vitb14',
+            'large':'dinov2_vitl14',
+            'giant':'dinov2_vitg14'}
+extractor = ViTExtractor(model_dict['small'],14)
+# use GPPU0
+extractor.model = extractor.model.cuda(0)  # the stride of first conv control outputs resolution
+
+# extractor = torch.hub.load('facebookresearch/dinov2', model_dict['small'], pretrained=True).cuda()
+
+
+# cat_list = ['bottle','box','can','cup','cutlery','glass','remote','shoe','tube','teapot']
+cat_list = ['cup']
+
+#cat_list = ['teapot']
+#TODO: if condition for tex rendering
+for cat in cat_list:
+    # orriginal    
+    with open(f'/mnt/4T/Yung/yung_large_files/semantic_feature/test_notebook/housecat_{cat}/raw/housecat1_train.txt', 'r') as f:
+        instances = [line.strip() for line in f.readlines()]
+
+    print(instances)
+    # #revised
+    # # instance try cup-grey_handle
+    # instances = ['cup-grey_handle']
+
+    aggregated_features_list = []  # N * [1, 1024, 384]
+    # Load the mean shape point cloud
+    meanshape_path = f'Yung/yung_large_files/semantic_feature/test_notebook/saved_pcd/{cat}/mean_shape/mean_shape_pcd_1.txt'
+    meanshape_pcd_np = np.loadtxt(meanshape_path)
+    meanshape_pcd_tensor = torch.from_numpy(meanshape_pcd_np)
+    M = meanshape_pcd_tensor.shape[0]
+# modify for cuda0
+    meanshape_points = meanshape_pcd_tensor.view(1, M, 3).float().cuda(0)
+
+
+    for j,instance in enumerate(instances):
+        # if instance != 'bottle-85_alcool':
+        #     continue
+        print("Processing", instance)
+        obj_path = f'pose_dataset/HouseCat6D/obj_models_small_size_final/{cat}/{instance}.obj'
+        instance_pcd_path = f'Yung/yung_large_files/semantic_feature/test_notebook/saved_pcd/{cat}/test/{instance}.txt'
+
+        # Load the instance point cloud
+        instance_pcd_np = np.loadtxt(instance_pcd_path)
+        instance_pcd_tensor = torch.from_numpy(instance_pcd_np)
+        N = instance_pcd_tensor.shape[0]
+# modify for cuda0
+        instance_points = instance_pcd_tensor.view(1, N, 3).float().cuda(0)
+
+        try:
+            verts, faces, aux = load_obj(obj_path)
+        except ValueError as e:
+            print(f"Warning: {e}, attempting to load without material.")
+
+            try:
+                verts, faces, aux = load_obj(obj_path, load_textures=True)
+            except ValueError as e2:
+                print(f"Failed to load {obj_path} without material: {e2}")
+                continue
+
+        # 检查 verts_uvs 是否为 None
+        if aux.verts_uvs is not None:
+            verts_uvs = aux.verts_uvs[None, ...]  # (1, V, 2)
+            faces_uvs = faces.textures_idx[None, ...]  # (1, F, 3)
+            tex_maps = aux.texture_images
+
+            # tex_maps is a dictionary of {material name: texture image}.
+            # Take the first image:
+            if tex_maps:
+                texture_image = list(tex_maps.values())[0]
+                texture_image = texture_image[None, ...]  # (1, H, W, 3)
+
+            # Create a textures object
+            tex = TexturesUV(verts_uvs=verts_uvs, faces_uvs=faces_uvs, maps=texture_image)
+            print(f"Loaded texture for {instance}.")
+        else:
+            # 如果 verts_uvs 是 None，直接跳过纹理处理，或者你可以设置默认行为
+            print(f"No UV coordinates for {instance}, skipping texture mapping.")
+            tex = None
+
+        # Initialise the mesh with textures
+        verts = normalize_mesh_verts(verts) # Housecat meshes are absolute scale
+        # meshes = Meshes(verts=[verts], faces=[faces.verts_idx], textures=None)
+        # Rotate mesh 180 degrees around Y axis
+        # rotation_matrix = torch.tensor([
+        #     [-1.0, 0.0, 0.0],
+        #     [0.0, 1.0, 0.0],
+        #     [0.0, 0.0, -1.0]
+        # ], dtype=torch.float32, device="cpu")
+        # verts = torch.matmul(verts, rotation_matrix.T)
+        
+        meshes = Meshes(verts=[verts], faces=[faces.verts_idx], textures=None)
+
+        if meshes.textures is None:
+            meshes.textures = TexturesVertex(
+            verts_features=torch.ones_like(meshes.verts_padded(), device=device)
+            )
+
+        # render the mesh with 8 views, scale means the distance from the object to the camera
+        image_size=(420,420)
+        #images,fragments,cameras = render_batch(meshes,image_size=image_size,scale=1.0)
+        images,fragments,cameras = render(meshes,image_size=image_size,scale=2.0)
+        
+        os.makedirs(f'{save_dir}/{cat}_rgb_dino_untex-try', exist_ok=True)
+        rgb = images.cpu().numpy()[:, :, :, :3]
+        image_grid(rgb, rows=1, cols=8, rgb=True)
+        plt.savefig(f'{save_dir}/{cat}_rgb_dino_untex-try/{instance}_rendering-notexture.png')
+        plt.close()
+
+        # get the feature point cloud
+        feature_point_cloud, dino_feat_masked, feature_point_cloud_list = fuse_feature_rgbd(extractor,images,fragments,cameras)
+
+        # get the downsampled aggregated feature point cloud
+        num_pts= 1024
+        nn_num= 100 # larger nn_num will make the feature more smooth
+        sampled_points,aggregated_features = downsample_with_knn_feature_aggregation(feature_point_cloud,num_pts,nn_num)
+
+        # #Needed
+        # index = np.random.choice(partial_feature_point_cloud.shape[0], 1024, replace=False)
+        # plot_pointclouds_3d_with_copca(average_aggregated_features.squeeze(0).detach().cpu().numpy(), 
+        #                                partial_feature_point_cloud[index,3:], 
+        #                                sampled_points.squeeze(0).detach().cpu().numpy(), 
+        #                                partial_feature_point_cloud[index,:3])
+        
+
+        q=0
+
+        if False:
+            q+=1
+            inputs = trainset[q]
+            rgb = inputs['rgb'][None].cuda()
+            pts = inputs['pts'][None]
+            choose = inputs['choose'][None]
+            model = inputs['model'][None].cuda()
+            rgb = inputs['rgb'][None].cuda()
+
+            _desc_q = extractor.forward_features(rgb)["x_prenorm"][:, :]
+            #_desc_q = extractor.extract_descriptors(rgb,layer=11,facet='token',include_cls=True).squeeze(1) # B,L,C
+            # _norm_q = torch.linalg.norm(_desc_q, dim=-1)[:, :, None]
+            # _desc_q = _desc_q / (_norm_q)
+
+            dino_feature = _desc_q[:,1:,:]
+
+
+            #dino_feature = self.rgb_extractor.forward_features(rgb)["x_prenorm"][:, 1:]
+            #rgb=self.rgb_extractor.preprocess_pil(rgb)
+            #dino_feature = self.rgb_extractor.extract_descriptors(rgb,layer=11,facet='key') # (1,900,384)
+            f_dim = dino_feature.shape[-1]
+            num_patches =int(dino_feature.shape[1]**0.5) # 1
+            b=1
+            dino_feature = dino_feature.reshape(b, num_patches, num_patches, f_dim).permute(0,3,1,2)
+            
+            dino_feature = F.interpolate(dino_feature, size=(num_patches * 14, num_patches * 14), mode='nearest') 
+            dino_feature_2d_vis = dino_feature.detach().cpu()[0] #384, 224,224
+
+            b, d = dino_feature.shape[0:2]
+            dino_feature = dino_feature.reshape(b,d,-1)
+            choose_2 = choose.unsqueeze(1).repeat(1, d, 1).cuda()
+            dino_feature = torch.gather(dino_feature,2,choose_2).contiguous() # b,d,n
+            
+            #dino_feature = dino_feature / torch.std(dino_feature, dim=1, keepdim=True)
+            #dino_feature = torch.norm(dino_feature, dim=1, keepdim=True)
+            #choose_dino = choose.unsqueeze(1).repeat(1, d, 1Z
+            #sem_model = sem_model / torch.std(sem_model, dim=-1, keepdim=True)
+            #visual_global_sem_high = sem_model.detach().cpu().numpy()[0] #1024,384
+            visual_partial_sem_high = dino_feature.permute(0,2,1).detach().cpu().numpy()[0] #1024,128
+
+            #visual_global_sem_low = self.feature_mlp(sem_model.permute(0,2,1)).permute(0,2,1).detach().cpu().numpy()[0]
+            #visual_partial_sem_low = rgb_local.permute(0,2,1).detach().cpu().numpy()[0]
+            # transform the pts with GT 9D Pose into object coordinate
+            translation_gt = inputs['translation_label'][None]
+            rotation_gt = inputs['rotation_label'][None]
+            size_gt = inputs['size_label'][None]
+            pts_obj_frame = (inputs['pts'] - translation_gt.unsqueeze(1)) / (torch.norm(size_gt, dim=1).view(b, 1, 1) + 1e-8) @ rotation_gt
+            #kpt_obj_frame = (kpt_3d - translation_gt.unsqueeze(1)) / (torch.norm(size_gt, dim=1).view(b, 1, 1) + 1e-8) @ rotation_gt
+            
+            # dino_feature_2d_vis_pca = vis_pca_pixelwise(dino_feature_2d_vis[None])[0]
+            # plt.imshow(dino_feature_2d_vis_pca[:,:,:3])
+            # plt.show()
+            # fig =plt.figure()
+            # rgb_unnorm = unnormalize(rgb[0].permute(1,2,0).detach().cpu())
+            # plt.imshow(rgb_unnorm)
+            # plt.show()
+            # image_mask = ((rgb_unnorm.clone().sum(axis=2) >0.1)*1.0)[None,None] # 224,224
+                
+            # rgb_mask = np.array(image_mask[0,0,:,:,None]).repeat(384, axis=2).transpose(2,0,1)
+
+            # dino_feature_2d_vis[rgb_mask==0] = 0
+            # masked_dino_feature_2d_vis_pca = vis_pca_pixelwise(dino_feature_2d_vis[None])[0]
+            # plt.imshow(masked_dino_feature_2d_vis_pca[:,:,:])
+            # plt.show()
+
+
+            # print('self.pca.cateagg-partial')
+            # index = np.random.choice(partial_feature_point_cloud.shape[0], 1024, replace=False)
+            # #average_aggregated_features = torch.load(f'sem_cat_pcd/{cat}_dino_feature.pt')
+            
+            average_aggregated_features = torch.load(f'/home/xyz/anything6d_project/Sem-GCE-AG-Pose/sem_cat_pcd/{cat}_dino_feature.pt')
+            # #plot_pointclouds_3d_with_copca(aggregated_features.squeeze(0).detach().cpu().numpy(), partial_feature_point_cloud[index,3:], sampled_points.squeeze(0).detach().cpu().numpy(), pts_obj_frame)
+           
+            plot_pointclouds_3d_with_copca_old(average_aggregated_features.squeeze(0).detach().cpu().numpy(),
+                                               visual_partial_sem_high,
+                                               sampled_points.squeeze(0).detach().cpu().numpy(),
+                                              pts_obj_frame[0].detach().cpu().numpy())
+            plt.show()
+
+
+            # plot_pointclouds_3d_with_copca(average_aggregated_features.squeeze(0).detach().cpu().numpy(),
+            #                                 visual_partial_sem_high,
+            #                                sampled_points.squeeze(0).detach().cpu().numpy(),
+            #                                 pts_obj_frame[0].detach().cpu().numpy())
+            
+            
+            # #query_points =np.random.choice(1024, 3)
+            # query_points, sampled_indices = sample_farthest_points(pts_obj_frame, K=4)  # Shape: (1, 1024, 3), (1, 1024)
+            # plot_pointclouds_with_color_mapping(visual_partial_sem_high, 
+            #                                     aggregated_features.squeeze(0).detach().cpu().numpy(),
+            #                                     pts_obj_frame[0].detach().cpu().numpy(),
+            #                                     model[0].detach().cpu().numpy(),
+            #                                     sampled_indices[0], similarity_threshold=None)
+
+
+            # # plot_pointclouds_3d_with_copca(average_aggregated_features.squeeze(0).detach().cpu().numpy(), partial_feature_point_cloud[index,3:], sampled_points.squeeze(0).detach().cpu().numpy(), partial_feature_point_cloud[index,:3])
+            # # plot_pointclouds_3d_with_pca(average_aggregated_features.squeeze(0).detach().cpu().numpy(), partial_feature_point_cloud[index,3:], sampled_points.squeeze(0).detach().cpu().numpy(), partial_feature_point_cloud[index,:3])
+            # partial_feature_point_cloud = feature_point_cloud_list[5]
+            # plot_pointclouds_3d_with_copca(visual_partial_sem_high, 
+            #                             partial_feature_point_cloud[index,3:], 
+            #                             pts_obj_frame[0].detach().cpu().numpy(), 
+            #                             partial_feature_point_cloud[index,:3])
+        
+        # plot_pointclouds_3d_with_copca(average_aggregated_features.squeeze(0).detach().cpu().numpy(), aggregated_features.squeeze(0).detach().cpu().numpy(), sampled_points.squeeze(0).detach().cpu().numpy(), sampled_points.squeeze(0).detach().cpu().numpy())
+
+        os.makedirs(f'{save_dir}/saved_dino_pcd_untex-try/{cat}', exist_ok=True)
+        torch.save(aggregated_features, f'{save_dir}/saved_dino_pcd_untex-try/{cat}/{instance}_dino_feature-notexture.pt')
+
+        os.makedirs(f'{save_dir}/saved_pcd_untex-try/{cat}', exist_ok=True)
+        torch.save(sampled_points, f'{save_dir}/saved_pcd_untex-try/{cat}/{instance}_pcd-notexture.pt')
+        
+        aggregated_features_list.append(aggregated_features)
+        # #break
+        vis_dino = vis_pca_pixelwise(np.array(dino_feat_masked))
+        vis_img = np.clip(vis_dino[:,:,:,:],a_min=0,a_max=1)
+        image_grid(vis_img, rows=1, cols=8, rgb=True)
+
+        os.makedirs(f'{save_dir}/{cat}_rgb_dino_untex-try', exist_ok=True)
+        plt.savefig(f'{save_dir}/{cat}_rgb_dino_untex-try/{instance}_dino-notexture.png')
+        plt.close()
+        if False:
+
+            rgb = images.cpu().numpy()[:, :, :, :3]
+            mask = images[:, ..., 3].cpu().numpy()!=0
+            depth_image = fragments[:, ..., 0].cpu().numpy()*mask
+            image_grid(rgb, rows=1, cols=8, rgb=True)
+            # os.makedirs(f'/home/tulrfpf/code/PointFlowRenderer/{cat}_rgb_dino', exist_ok=True)
+            # plt.savefig(f'/home/tulrfpf/code/PointFlowRenderer/{cat}_rgb_dino/{instance}_rgb.png')
+            # image_grid(depth_image[...,None], rows=2, cols=4, rgb=True)
+            # image_grid(mask[...,None], rows=2, cols=4, rgb=True)
+
+
+
+            fig = plt.figure(figsize=(10, 10))
+            ax = fig.add_subplot(111, projection="3d")
+            #ax.scatter(sampled_points[:, 2], sampled_points[:,0], sampled_points[:, 1], c="b")
+            pca_color =vis_pca(feature_point_cloud[:, 3:])
+            ax.scatter(feature_point_cloud[:, 2], feature_point_cloud[:, 0], feature_point_cloud[:, 1], c=pca_color,s=0.1)
+            #create_camera_geometry_batch(ax=ax,R_batch=R,T_batch=T,order=(2,0,1))
+            ax.set_xlabel("z")
+            ax.set_ylabel("x")
+            ax.set_zlabel("y")
+            ax.set_xlim(-2, 2)
+            ax.set_ylim(-2, 2)
+            ax.set_zlim(-2, 2)
+            plt.title("Sampled Dense Points from Mesh")
+            plt.show()
+
+            fig = plt.figure(figsize=(10, 10))
+            ax = fig.add_subplot(111, projection="3d")
+            pca_color =vis_pca(aggregated_features.squeeze(0))
+            sampled_points= sampled_points.squeeze(0).cpu().detach().numpy()
+            ax.scatter(sampled_points[:, 2], sampled_points[:, 0], sampled_points[:, 1], c=pca_color,s=50)
+            #create_camera_geometry_batch(ax=ax,R_batch=R,T_batch=T,order=(2,0,1))
+            ax.set_xlabel("z")
+            ax.set_ylabel("x")
+            ax.set_zlabel("y")
+            ax.set_xlim(-2, 2)
+            ax.set_ylim(-2, 2)
+            ax.set_zlim(-2, 2)
+            plt.title("Sampled Sparse Points from Mesh")
+            plt.show()
+            #break
+    # Assign the aggregated features to the mean shape point cloud
+    aggregated_features_tensor = torch.cat(aggregated_features_list, dim=0)  #[N, 1024, 384]
+    average_aggregated_features = aggregated_features_tensor.mean(dim=0, keepdim=True)
+    print("Average Aggregated Features Shape:", average_aggregated_features.shape)  # Should be (1, 1024, 384)
+
+    os.makedirs(f'{save_dir}/sem_cat_pcd_untex-try', exist_ok=True)
+    torch.save(average_aggregated_features, f'{save_dir}/sem_cat_pcd_untex-try/{cat}_dino_feature.pt')
+
+# fig = plt.figure(figsize=(10, 10))
+# ax = fig.add_subplot(111, projection="3d")
+# pca_color =vis_pca(average_aggregated_features.squeeze(0))
+# # sampled_points= sampled_points.squeeze(0).cpu().detach().numpy()
+# meanshape_points = meanshape_points.squeeze(0).cpu().detach().numpy()
+# ax.scatter(meanshape_points[:, 2], meanshape_points[:, 0], meanshape_points[:, 1], c=pca_color,s=10.0, marker='o')
+# ax.set_xlabel("z")
+# ax.set_ylabel("x")
+# ax.set_zlabel("y")
+# ax.set_xlim(-2, 2)
+# ax.set_ylim(-2, 2)
+# ax.set_zlim(-2, 2)
+# plt.title("Shape Prior Dino")
+# plt.show()
+    

RGBD_DINO_HouseCat6D_final_copy_amodal.py

@@ -0,0 +1,1109 @@
+import torch
+from custom_utils import ShapeNetCore
+from custom_utils import _compute_fov,_sample_points_from_faces
+from custom_utils import image_grid
+from custom_utils.shapenet_base import HouseCatDataset
+import matplotlib.pyplot as plt
+import numpy as np
+import k3d
+import os
+import json
+import torch
+from PIL import Image
+
+import cv2
+import imageio
+import numpy as np
+from PIL import Image
+import matplotlib.pyplot as plt
+from torchvision import transforms
+from custom_utils.extractor import ViTExtractor
+import torch.nn.functional as F
+from sklearn.decomposition import PCA as sklearnPCA
+import math
+from custom_utils.utils_general import center_crop
+
+from pytorch3d.io import load_objs_as_meshes, load_obj
+from pytorch3d.implicitron.tools.point_cloud_utils import get_rgbd_point_cloud
+from pytorch3d.structures import Meshes
+from pytorch3d.renderer import (
+    PerspectiveCameras,
+    FoVPerspectiveCameras,
+    PointLights,
+    MeshRasterizer,
+    MeshRenderer,
+    RasterizationSettings,
+    HardPhongShader,
+    TexturesVertex,
+    look_at_view_transform,
+    ray_bundle_to_ray_points,
+    NDCMultinomialRaysampler,
+    TexturesUV,
+    BlendParams,
+
+    TexturesVertex
+)
+
+from pytorch3d.implicitron.tools.point_cloud_utils import get_rgbd_point_cloud
+from pytorch3d.structures import Pointclouds
+import torch
+from pytorch3d.ops import sample_farthest_points, knn_points, knn_gather
+
+from matplotlib import cm
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.decomposition import PCA
+from mpl_toolkits.mplot3d import Axes3D
+
+
+def sample_points_on_sphere(num_points=80):
+    points = []
+    phi = (1 + math.sqrt(5)) / 2  # golden ratio
+
+    for i in range(num_points):
+        theta = 2 * math.pi * i / phi  # azimuthal angle
+        z = 1 - (2 * i + 1) / num_points  # z-coordinate, uniform from -1 to 1
+        radius = math.sqrt(1 - z * z)  # radius for the xy-plane
+        x = radius * math.cos(theta)
+        y = radius * math.sin(theta)
+        points.append([x, y, z])
+
+    return torch.tensor(points, dtype=torch.float32)
+
+def get_cube_vertices():
+    # Cube vertices (8 vertices)
+    return torch.tensor([[1, 1, 1],
+                         [1, 1, -1],
+                         [1, -1, 1],
+                         [1, -1, -1],
+                         [-1, 1, 1],
+                         [-1, 1, -1],
+                         [-1, -1, 1],
+                         [-1, -1, -1]], dtype=torch.float32)  # Ensure float type
+
+
+def render(meshes,scale=3.0,image_size=(420,420),light=(0.3,0.3,0.3)):
+    # prepare the camera
+    num_views = 8
+    # Get the cube vertices
+    #cube_vertices = get_cube_vertices()*scale
+    cube_vertices = sample_points_on_sphere(num_views)*scale
+    #up = torch.randn(1, 3)
+    up=torch.tensor([[0.0, 0.0, 1.0]], dtype=torch.float32)
+    up = up / torch.norm(up, dim=1)[:, None]
+    R, T = look_at_view_transform(eye=cube_vertices, at=torch.tensor([[0.0, 0.0, 0.0]], dtype=torch.float32), up=up)
+    cam_K= np.array([[572, 0.0, image_size[0]//2], [0.0, 572, image_size[1]//2], [0.0, 0.0, 1.0]])
+    fx,_,cx,_,fy,cy,_,_,_=cam_K.reshape(9)
+    fov_x, fov_y = _compute_fov(cam_K, 420, 420)
+
+    cameras = PerspectiveCameras(device=device, R=R, T=T, image_size=((420,420),),
+                                    focal_length=torch.tensor([[fx, fy]], dtype=torch.float32),
+                                    principal_point=torch.tensor([[cx, cy]], dtype=torch.float32),
+                                    in_ndc=False)
+
+    # prepare the lights
+    raster_settings = RasterizationSettings(image_size=image_size)
+    lights = PointLights(location=torch.tensor([0.0, 1.0, -2.0], device=device)[None], ambient_color=(light,),diffuse_color=(light,),device=device)
+
+    # move the data to the device
+    meshes = meshes.to(device)
+    cameras = cameras.to(device)
+    if len(cameras) != 1 and len(cameras) % len(meshes) != 0:
+        raise ValueError("Mismatch between batch dims of cameras and meshes.")
+    if len(cameras) > 1:
+        meshes = meshes.extend(len(cameras) // len(meshes))
+
+    # prepare the renderer
+    class MeshRendererWithDepth(torch.nn.Module):
+        def __init__(self, rasterizer, shader):
+            super().__init__()
+            self.rasterizer = rasterizer
+            self.shader = shader
+
+        def forward(self, meshes_world, **kwargs) -> torch.Tensor:
+            fragments = self.rasterizer(meshes_world, **kwargs)
+            images = self.shader(fragments, meshes_world, **kwargs)
+            return images, fragments.zbuf
+        
+
+    blend_params = BlendParams(background_color=(0.0, 0.0, 0.0))  # Blue background
+    renderer = MeshRendererWithDepth(
+        rasterizer=MeshRasterizer(
+            cameras=cameras,
+            raster_settings=raster_settings,
+        ),
+    # Set background color to blue [R, G, B]
+
+        shader=HardPhongShader(
+            device=device,
+            cameras=cameras,
+            lights=lights,
+            blend_params=blend_params
+        )
+    )
+
+    images,fragments = renderer(meshes)
+    return images,fragments,cameras
+
+
+def render_batch(meshes,scale=3.0,image_size=(420,420),light=(0.3,0.3,0.3)):
+    # prepare the camera
+    num_views = 8
+    # Get the cube vertices
+    cube_vertices = get_cube_vertices()*scale
+    #cube_vertices = sample_points_on_sphere(num_views)*scale
+    up = torch.randn(1, 3)
+    # up=torch.tensor([[0.0, 0.0, 1.0]], dtype=torch.float32)
+    up = up / torch.norm(up, dim=1)[:, None]
+    R, T = look_at_view_transform(eye=cube_vertices, at=torch.tensor([[0.0, 0.0, 0.0]], dtype=torch.float32), up=up)
+
+    cam_K= np.array([[572, 0.0, image_size[0]//2], [0.0, 572, image_size[1]//2], [0.0, 0.0, 1.0]])
+    fx,_,cx,_,fy,cy,_,_,_=cam_K.reshape(9)
+    fov_x, fov_y = _compute_fov(cam_K, 420, 420)
+
+
+    # prepare the renderer
+    class MeshRendererWithDepth(torch.nn.Module):
+        def __init__(self, rasterizer, shader):
+            super().__init__()
+            self.rasterizer = rasterizer
+            self.shader = shader
+
+        def forward(self, meshes_world, **kwargs) -> torch.Tensor:
+            fragments = self.rasterizer(meshes_world, **kwargs)
+            images = self.shader(fragments, meshes_world, **kwargs)
+            return images, fragments.zbuf
+        
+
+    blend_params = BlendParams(background_color=(0.0, 0.0, 0.0))  # Blue background
+
+    batch_size = 10
+    all_images=[]
+    all_fragments=[]
+
+    # move the data to the device
+    meshes = meshes.extend(batch_size).to(device)
+    for i in range(0,R.shape[0],batch_size):
+        R_batch = R[i:i+batch_size]
+        T_batch = T[i:i+batch_size]
+        cameras_batch = PerspectiveCameras(device=device, R=R_batch, T=T_batch, image_size=((420,420),),
+                                        focal_length=torch.tensor([[fx, fy]], dtype=torch.float32),
+                                        principal_point=torch.tensor([[cx, cy]], dtype=torch.float32),
+                                        in_ndc=False).to(device)
+
+        # prepare the lights
+        raster_settings = RasterizationSettings(image_size=image_size)
+        lights = PointLights(location=torch.tensor([0.0, 1.0, -2.0], device=device)[None], 
+                             ambient_color=(light,),diffuse_color=(light,),device=device)
+
+        renderer = MeshRendererWithDepth(
+            rasterizer=MeshRasterizer(
+                cameras=cameras_batch,
+                raster_settings=raster_settings,
+            ),
+            # Set background color to blue [R, G, B]
+            shader=HardPhongShader(
+                device=device,
+                cameras=cameras_batch,
+                lights=lights,
+                blend_params=blend_params
+            )
+         )
+        images,fragments = renderer(meshes)
+        all_images.append(images)
+        all_fragments.append(fragments)
+    all_images = torch.cat(all_images,dim=0)
+    all_fragments = torch.cat(all_fragments,dim=0)
+    cameras = PerspectiveCameras(device=device, R=R, T=T, image_size=((420,420),),
+                                focal_length=torch.tensor([[fx, fy]], dtype=torch.float32),
+                                principal_point=torch.tensor([[cx, cy]], dtype=torch.float32),
+                                in_ndc=False).to(device)
+    return all_images,all_fragments,cameras
+
+
+def fuse_feature_rgbd(extractor,images,fragments,cameras):
+    dino_feat_masked_list = []
+    feature_point_cloud_list = []
+    for i in range(images.shape[0]):
+        image = images.cpu().numpy()[i, :, :, :3]
+        image_mask = images[i, ..., 3].cpu().numpy()!=0
+        crop_size = (420, 420)
+        crop_image, crop_mask, bbox = center_crop(image, image_mask, crop_size)
+        cropped_image_np = cv2.resize(crop_image, crop_size, interpolation=cv2.INTER_AREA)
+        #cropped_mask = cv2.resize(crop_mask*1.0, crop_size, interpolation=cv2.INTER_NEAREST)!=0  # Use nearest neighbor interpolation for masks
+        orignal_size = (int(bbox[2]-bbox[0]), int(bbox[3]-bbox[1])) #K,K
+
+        to_tensor = transforms.ToTensor()
+        input_image = to_tensor(cropped_image_np).cuda()
+        input_image = input_image.unsqueeze(0)
+        #input_image=extractor.preprocess_pil(input_image)
+        mean = torch.tensor([0.485, 0.456, 0.406]).cuda()
+        std = torch.tensor([0.229, 0.224, 0.225]).cuda()
+        input_image = (input_image - mean[None, :, None, None]) / std[None, :, None, None]
+  
+        _desc_q = extractor.extract_descriptors(input_image,layer=11,include_cls=True).squeeze(1) # (1,900,384)
+        #_desc_q = extractor.forward_features(input_image)["x_prenorm"][:, :]   # (1,900,384)
+        #_desc_q = extractor.extract_descriptors(input_image,layer=11,facet='token',include_cls=True).squeeze(1) # B,L,C
+        # _norm_q = torch.linalg.norm(_desc_q, dim=-1)[:, :, None]
+        # _desc_q = _desc_q / (_norm_q)
+
+        desc = _desc_q[:,1:,:][None]
+        #cls_token_q = _desc_q[:,0,:] #B,C`
+
+        input_mask = to_tensor(crop_mask).cuda()
+        input_mask = input_mask.unsqueeze(0)
+
+        img_mask = to_tensor(image_mask)
+
+        img_mask = img_mask.permute(1,2,0)
+
+        dino_feat = patch2pixel_feats(desc, original_size=orignal_size) #reize back to K,K =>( K, K, 384)
+        # create dino-feat with orignal size
+        dino_height, dino_width, feat_dim = (image_size[0],image_size[1], desc.shape[-1])
+        dino_feat_orig = torch.zeros(dino_height,dino_width,feat_dim)
+        # Fill the dino features into the original tensor at the specified bounding box
+        dino_feat_orig[bbox[1]:bbox[3], bbox[0]:bbox[2],:] = dino_feat #reize back to K,K =>(420, 420, 384) #gradint is not supported for this operation
+        # Apply the mask
+        dino_feat_masked = dino_feat_orig * img_mask
+        dino_feat_masked = dino_feat_masked.permute(2,0,1).unsqueeze(0)
+        dino_feat_masked_low = F.interpolate(dino_feat_masked, size=(30, 30), mode='bilinear')
+
+        image_mask = images[i, ..., 3][None,None]
+        depth_image = fragments[i, ..., 0][None]*image_mask
+        
+        # # Define the kernel for erosion (3x3 ones kernel)
+        # kernel = torch.ones((1, 1, 5, 5), dtype=torch.float).cuda()
+        # # Number of erosion iterations
+        # iterations = 5
+
+        # # Perform iterative erosion
+        # for i in range(iterations):
+        #     # Apply erosion using 2D convolution
+        #     eroded_mask = F.conv2d(image_mask, kernel, padding=2)
+        #     image_mask = (eroded_mask == kernel.sum()).float()  # Update mask to eroded version
+
+        feature_point_cloud = get_rgbd_point_cloud(cameras[i], dino_feat_masked.to(device), depth_map=depth_image,mask=image_mask)#everthing on GPU
+
+        index = np.random.choice(feature_point_cloud.points_list()[0].shape[0], 4096, replace=True)
+        points = feature_point_cloud.points_list()[0].detach().cpu()[index,:]
+        colors = feature_point_cloud.features_list()[0].detach().cpu()[index,:]
+        # points = feature_point_cloud.points_list()[0].detach().cpu()[:,:]
+        # colors = feature_point_cloud.features_list()[0].detach().cpu()[:,:]
+        feature_point_cloud = torch.cat((points, colors), dim=1)
+
+        dino_feat_masked_list.append(dino_feat_masked_low.detach().cpu())
+        feature_point_cloud_list.append(feature_point_cloud)
+    feature_point_cloud = torch.cat(feature_point_cloud_list, dim=0)
+    dino_feat_masked = torch.cat(dino_feat_masked_list, dim=0)
+    return feature_point_cloud,dino_feat_masked, feature_point_cloud_list
+
+
+def downsample_with_knn_feature_aggregation(feature_point_cloud,num_pts=1024,k_nearest_neighbors=100, instance_points=None):
+    #N_1, C_1 = 2048, 384  # Example number of points and features
+    num_points_to_sample = num_pts
+    k_nearest_neighbors = k_nearest_neighbors
+
+    # Example input pointcloud and features (N_1, C_1), where N_1 is the number of points and C_1 is the feature dimension
+    pointcloud = feature_point_cloud[None,:,:3].cuda()  # Shape (1, N_1, 3) for 3D coordinates
+    features = feature_point_cloud[None,:,3:].cuda()  # Shape (1, N_1, C_1) for features
+
+    # Step 1: FPS to downsample the points
+    # We use sample_farthest_points to select num_points_to_sample points
+    sampled_points, sampled_indices = sample_farthest_points(pointcloud, K=num_points_to_sample)  # Shape: (1, 1024, 3), (1, 1024)
+    if instance_points is not None:
+        sampled_points = instance_points
+
+    # Step 2: KNN to find nearest neighbors
+    # Find the k nearest neighbors for each sampled point in the original pointcloud
+    dists, knn_indices, _ = knn_points(sampled_points, pointcloud, K=k_nearest_neighbors, return_nn=False)
+
+    # Step 3: Gather the features of the k-nearest neighbors using the knn indices
+    # Use knn_gather to get neighbor features for each sampled point
+    neighbor_features = knn_gather(features, knn_indices)  # Shape: (1, 1024, k, C_1)
+
+    # Step 4: Aggregate features from the neighbors (e.g., by averaging)
+    #aggregated_features,_ = torch.max(neighbor_features,dim=-2) # Shape: (1, 1024, C_1)
+    aggregated_features = torch.mean(neighbor_features,dim=-2) # Shape: (1, 1024, C_1)
+    return sampled_points, aggregated_features
+
+
+def vis_pca(feature):
+    n_components=3 # the first component is to seperate the object from the background
+
+    pca = sklearnPCA(n_components=n_components)
+    feature = pca.fit_transform(feature.detach().cpu().numpy())
+    for show_channel in range(n_components):
+        # min max normalize the feature map
+        feature[:, show_channel] = (feature[:, show_channel] - feature[:, show_channel].mean()) / (feature[:, show_channel].std()*10)
+    feature_resized = np.clip(feature[:,:]+0.5,0,1)
+    return feature_resized
+
+
+def patch2pixel_feats(patch_features, original_size):
+    # Calculate the number of patches along each dimension
+    num_patches = int(math.sqrt(patch_features.shape[2]))
+
+    batch_num = patch_features.shape[0]
+    feat_dim = patch_features.shape[3]
+    patch_features = patch_features.reshape(batch_num, num_patches, num_patches, feat_dim)
+    patch_features = patch_features.permute(0,3,1,2)
+
+    pixel_features = F.interpolate(patch_features, size=(original_size[0], original_size[1]), mode='bilinear')
+    pixel_features = pixel_features.squeeze().permute(1,2,0)
+    
+    return pixel_features
+
+def vis_pca_pixelwise(feature):
+    n_components = 4  # The number of PCA components to use
+    batch, feat_dim, height,width = feature.shape  
+    
+    # Reshape the feature to (num_pixels, feat_dim)
+    num_pixels = height * width
+    feature_reshaped = np.array(feature).transpose(0,2,3,1).reshape(-1, feat_dim)
+
+
+    # Apply PCA
+    pca = sklearnPCA(n_components=n_components)
+    feature_pca = pca.fit_transform(feature_reshaped)
+
+    # Min-max normalization for each component
+    # for show_channel in range(n_components):
+    #     feature_pca[:, show_channel] = (feature_pca[:, show_channel] - feature_pca[:, show_channel].min()) / \
+    #                                     (feature_pca[:, show_channel].max() - feature_pca[:, show_channel].min() + 1e-8)  # Small epsilon to avoid division by zero
+    for show_channel in range(n_components):
+        feature_pca[:, show_channel] = (feature_pca[:, show_channel] - feature_pca[:, show_channel].mean()) / \
+                                        (feature_pca[:, show_channel].std()*10 + 1e-8) # Small epsilon to avoid division by zero
+
+    feature_pca = np.clip(feature_pca+0.5, 0, 1)
+    # Reshape the PCA result back to (height, width, n_components)
+    feature_resized = feature_pca.reshape(batch,height,width,n_components)[...,1:4]
+    return feature_resized
+
+def normalize_mesh_verts(data):
+    # data [N, 3]
+    min_vals, _ = torch.min(data, dim=0)
+    max_vals, _ = torch.max(data, dim=0)
+    bbox_sizes = max_vals - min_vals
+    scale = torch.norm(bbox_sizes)
+    print("Scale:", scale)
+    normalized_verts = verts / scale
+    return normalized_verts
+
+def plot_pointclouds_with_color_mapping(pc1_f, pc2_f,pc1,pc2, query_points, similarity_threshold=None):
+    """
+    Visualizes two 3D point clouds. The second point cloud (pc2) is color-mapped
+    using the 'viridis' colormap based on its similarity (proximity) to the sampled
+    query points in the first point cloud (pc1).
+    
+    Parameters:
+    - pc1: np.ndarray of shape (N, 3), first point cloud #partial
+    - pc2: np.ndarray of shape (M, 3), second point cloud # global
+    - query_points: list of indices in pc1, representing the query points to compare.
+    - similarity_threshold: float, optional, threshold to cap the similarity distance.
+    """
+        
+
+    pc1_f = pc1_f / np.linalg.norm(pc1_f, axis=1)[:, None]  # Normalize the features
+    pc2_f = pc2_f / np.linalg.norm(pc2_f, axis=1)[:, None]  # Normalize the features
+    # Create a figure with subplots
+    fig = plt.figure(figsize=(12, 10))
+    num_query_points = len(query_points)
+    # Set limits and labels
+    size = pc2.max() - pc2.min()
+    # Plot the first point cloud in the first subplot
+    ax1 = fig.add_subplot(1, num_query_points + 1, 1, projection='3d')
+    ax1.scatter(pc2[:, 0], pc2[:, 1], pc2[:, 2], color='grey', label='Point Cloud 1 (Left)', alpha=0.1,s=10)
+
+    # Define a color list for each query point
+    query_colors = cm.tab10(np.linspace(0, 1, num_query_points))  # Use tab10 colormap for distinct colors
+
+    # Highlight query points in pc1 with different colors
+    for i, idx in enumerate(query_points):
+        ax1.scatter(pc1[idx, 0], pc1[idx, 1], pc1[idx, 2], 
+                    color=query_colors[i], s=100, edgecolor='k', label=f'Query Point {idx}')
+
+    ax1.set_title('Point Cloud 1 with Query Points')
+    ax1.set_xlabel('X')
+    ax1.set_ylabel('Y')
+    ax1.set_zlabel('Z')
+    ax1.set_xlim(-size / 1.4, size / 1.4)
+    ax1.set_ylim(-size / 1.4, size / 1.4)
+    ax1.set_zlim(-size / 1.4, size / 1.4)
+    ax1.view_init(elev=45, azim=-45)
+    ax1.grid(True)
+    ax1.legend()
+
+    # Plot the second point cloud in the subsequent subplots
+    for k in range(num_query_points):
+        
+        ax = fig.add_subplot(1, num_query_points + 1, k + 2, projection='3d')
+        
+        # Calculate distances between query points in pc1 and all points in pc2
+        similarity =(pc1_f[query_points[k]][None]@ pc2_f.T).reshape(-1) # (1, 3) x (M, 3) = (1, M)
+        # For each point in pc2, take the minimum distance to any query point
+        min_similarity = np.min(similarity, axis=0)
+        # Optionally cap the similarity distances to a threshold (to avoid extreme values)
+        similarity_threshold= 0.3
+        if similarity_threshold is not None:
+            similarity = np.clip(similarity, similarity_threshold,1)
+        # Normalize the distances to a range of 0 to 1 for colormap mapping
+        similarity = (similarity - np.min(similarity)) / (np.max(similarity) - np.min(similarity))
+        colors = cm.plasma(similarity)
+
+        # Plot the second point cloud with color mapping based on similarity
+        ax.scatter(pc2[:, 0], pc2[:, 1], pc2[:, 2], color=colors, s=15, alpha=1.0, label='Point Cloud 2 (Right)', edgecolor='k')
+        
+        ax.set_xlim(-size / 1.4, size / 1.4)
+        ax.set_ylim(-size / 1.4, size / 1.4)
+        ax.set_zlim(-size / 1.4, size / 1.4)
+        ax.set_title(f'QP_{query_points[k]}')
+        ax.set_xlabel('X')
+        ax.set_ylabel('Y')
+        ax.set_zlabel('Z')
+        ax.view_init(elev=45, azim=-45)
+        ax.grid(True)
+        ax.legend()
+
+    # Show the plot
+    plt.tight_layout()
+    plt.show()
+
+
+def plot_pointclouds_3d_with_copca_old(global_sem_pcd, partial_sem_pcd, global_pcd, partial_pcd):
+    """
+    Visualizes two point clouds in 3D, coloring them based on their PCA components.
+
+    Parameters:
+    - global_pointcloud: numpy array of shape (N, D) for global point cloud.
+    - partial_pointcloud: numpy array of shape (M, D) for partial point cloud.
+    """
+
+
+    n_components = 3
+    # Step 1: Perform PCA on both global and partial point clouds
+    sem_pca = PCA(n_components=n_components)
+    sem_pca = sem_pca.fit(global_sem_pcd)  # shape (N+M, 3)
+
+    transformed_sem_pcd_list = [sem_pca.transform(pcd) for pcd in [global_sem_pcd,partial_sem_pcd]]
+    sem_pcd_pca = np.concatenate(transformed_sem_pcd_list,axis=0)
+    for show_channel in range(n_components):
+        sem_pcd_pca[:, show_channel] = (sem_pcd_pca[:, show_channel] - sem_pcd_pca[:, show_channel].mean()) / \
+                                        (sem_pcd_pca[:, show_channel].std()*5 + 1e-8) # Small epsilon to avoid division by zero
+
+    # sem_pcd_pca_min = sem_pcd_pca.min()
+    # sem_pcd_pca_max = sem_pcd_pca.max()
+    # sem_pcd_pca = (sem_pcd_pca- sem_pcd_pca_min) / (sem_pcd_pca_max - sem_pcd_pca_min)  # Normalize to [0, 1]
+
+    sem_pcd_pca = np.clip(sem_pcd_pca[:,:]+0.5, 0, 1)
+    global_pca = sem_pcd_pca[:global_sem_pcd.shape[0]]  # shape (N, 3)
+    partial_pca = sem_pcd_pca[-partial_sem_pcd.shape[0]:]  # shape (M, 3)
+
+    # Step 2: Create a 3D scatter plot
+    fig = plt.figure(figsize=(12, 6))
+    ax = fig.add_subplot(121, projection='3d')
+
+
+    # Global point cloud
+    ax.scatter(global_pcd[:, 0], global_pcd[:, 1], global_pcd[:, 2], 
+            c=global_pca,  marker='o', s=100, alpha=1.0, label='Global Point Cloud')
+    
+    # Set labels for each axis
+    # ax.set_xlabel('X axis')
+    # ax.set_ylabel('Y axis')
+    # ax.set_zlabel('Z axis')
+    ax.set_xlim(-0.5, 0.5)
+    ax.set_ylim(-0.5, 0.5)
+    ax.set_zlim(-0.5, 0.5)
+    
+    ax1 = fig.add_subplot(122, projection='3d')
+
+    # Partial point cloud
+    ax1.scatter(partial_pcd[:, 0], partial_pcd[:, 1], partial_pcd[:, 2], 
+            c=partial_pca,  marker='o', s=100, alpha=1.0, label='Partial Point Cloud')
+    
+    # ax1.scatter(global_pcd[:, 0], global_pcd[:, 1], global_pcd[:, 2], 
+    #         marker='o', s=10, alpha=0.1)
+    # Set labels for each axis
+    # ax1.set_xlabel('X axis')
+    # ax1.set_ylabel('Y axis')
+    # ax1.set_zlabel('Z axis')
+
+    
+    ax1.set_xlim(-0.5, 0.5)
+    ax1.set_ylim(-0.5, 0.5)
+    ax1.set_zlim(-0.5, 0.5)
+    plt.tight_layout()
+
+    ax.view_init(120,-95)
+    ax1.view_init(120,-95)
+
+ 
+    ax.set_axis_off()
+    ax.set_facecolor((0, 0, 0, 0))
+    ax1.set_axis_off()
+    ax1.set_facecolor((0, 0, 0, 0))
+
+    plt.show()
+
+
+def plot_pointclouds_3d_with_pca(global_sem_pcd, global_pcd):
+    """
+    Visualizes two point clouds in 3D, coloring them based on their PCA components.
+
+    Parameters:
+    - global_pointcloud: numpy array of shape (N, D) for global point cloud.
+    - partial_pointcloud: numpy array of shape (M, D) for partial point cloud.
+    """
+    #sem_pcd = np.concatenate((global_sem_pcd,partial_sem_pcd), axis=0) # shape (N+M, D)
+
+    # Step 1: Perform PCA on both global and partial point clouds
+    sem_pca = PCA(n_components=3)
+    sem_pcd_pca = sem_pca.fit_transform(global_sem_pcd)  # shape (N+M, 3)
+
+    for i in range(3):  # Iterate over each component (3 in total for RGB)
+        sem_pcd_pca_mean = sem_pcd_pca[:, i].mean()
+        sem_pcd_pca_std = sem_pcd_pca[:, i].std()
+        sem_pcd_pca[:, i] = (sem_pcd_pca[:, i] - sem_pcd_pca_mean) / (sem_pcd_pca_std*5+1e-8)  # Normalize to [0, 1]
+
+
+    global_pca = np.clip(sem_pcd_pca+0.5,0,1)
+    # scatter plot
+    fig = plt.figure(figsize=(6, 6))
+    ax = fig.add_subplot(111, projection='3d')
+
+    # Global point cloud
+    ax.scatter(global_pcd[:, 0], global_pcd[:, 1], global_pcd[:, 2], 
+            c=global_pca,  marker='o', s=50, alpha=1.0, label='Global Point Cloud')
+    
+    # Remove axes and background
+    ax.set_axis_off()
+
+    # Set background color to none
+    ax.set_facecolor((0, 0, 0, 0))
+    # # Set labels for each axis
+    # ax.set_xlabel('X axis')
+    # ax.set_ylabel('Y axis')
+    # ax.set_zlabel('Z axis')
+    ax.set_xlim(-0.5, 0.5)
+    ax.set_ylim(-0.5, 0.5)
+    ax.set_zlim(-0.5, 0.5)
+
+    ax.view_init(-73,102)
+
+    return fig
+    
+
+def plot_pointclouds_3d_with_copca(global_sem_pcd_list, global_pcd_list,co_pca=True):
+    """
+    Visualizes multiple point clouds in 3D, each in a separate subplot, after applying CoPCA.
+    Coloring them based on their PCA components.
+
+    Parameters:
+    - global_sem_pcd_list: list of numpy arrays for semantic point clouds (one per object).
+    - global_pcd_list: list of numpy arrays for global point clouds (one per object).
+    """
+    num_pcds = len(global_sem_pcd_list)  # Number of point clouds
+    print("Number of point clouds to visualize:", num_pcds)
+    # Step 1: Perform CoPCA (Common PCA) on the semantic point clouds
+        # Concatenate all point clouds to perform common PCA
+    if co_pca:
+        concatenated_pcds = np.concatenate(global_sem_pcd_list, axis=0)  # shape (N_total, D)
+        copca = PCA(n_components=3, random_state=0)
+        copca.fit(concatenated_pcds[:1024])  # Fit PCA on all point clouds together
+        transformed_sem_pcd_list = [copca.transform(pcd) for pcd in global_sem_pcd_list]
+
+
+        signs = np.sign(np.sum(transformed_sem_pcd_list[0], axis=0))
+        # Post-process to ensure consistent orientation of PCA components
+        for i, transformed_pcd in enumerate(transformed_sem_pcd_list):
+            # For each component (column), align sign based on the sum of values in the column
+            transformed_sem_pcd_list[i] = transformed_pcd * signs
+    else:
+        copca = PCA(n_components=3)
+        transformed_sem_pcd_list = [copca.fit_transform(pcd) for pcd in global_sem_pcd_list]
+        # Post-process to ensure consistent orientation of PCA components
+        for i, transformed_pcd in enumerate(transformed_sem_pcd_list):
+            signs = np.sign(np.sum(transformed_pcd, axis=0))
+            # For each component (column), align sign based on the sum of values in the column
+            transformed_sem_pcd_list[i] = transformed_pcd * signs
+
+
+
+    # Create a figure with subplots arranged in a grid (based on number of point clouds)
+    fig = plt.figure(figsize=(6 * num_pcds, 6))  # Adjust figure size based on the number of subplots
+    
+    # Loop over the point clouds
+    for idx, (sem_pcd_pca, global_pcd) in enumerate(zip(transformed_sem_pcd_list, global_pcd_list)):
+        ax = fig.add_subplot(1, num_pcds, idx + 1, projection='3d')
+
+        # Step 2: Normalize the PCA-transformed data to use as colors
+        for i in range(3):  # Iterate over each component (3 in total for RGB)
+            pca_mean = sem_pcd_pca[:, i].mean()
+            pca_std = sem_pcd_pca[:, i].std()
+            sem_pcd_pca[:, i] = (sem_pcd_pca[:, i] - pca_mean) / (pca_std * 5 + 1e-8)  # Normalize
+
+        global_pca_colors = np.clip(sem_pcd_pca + 0.5, 0, 1)  # Map to [0, 1] for RGB
+
+        # Scatter plot for this point cloud in the current subplot
+        ax.scatter(global_pcd[:, 0], global_pcd[:, 1], global_pcd[:, 2], 
+                   c=global_pca_colors, marker='o', s=50, alpha=1.0)
+
+        # Remove axes and background
+        ax.set_axis_off()
+        ax.set_facecolor((0, 0, 0, 0))
+
+        # Set axis limits for each subplot
+        ax.set_xlim(-0.5, 0.5)
+        ax.set_ylim(-0.5, 0.5)
+        ax.set_zlim(-0.5, 0.5)
+
+        # Set view angle
+        ax.view_init(-55, 102)
+
+    # Adjust spacing between subplots
+    plt.tight_layout()
+
+    return fig
+    
+
+    
+def unnormalize(x):
+    # x.shape : [H,W,3]
+    mean = np.array([0.485, 0.456, 0.406])
+    std = np.array([0.229, 0.224, 0.225])
+    return x * std + mean
+
+
+from custom_utils.housecat6d_dataset import HouseCat6DTrainingDataset
+trainset = HouseCat6DTrainingDataset(image_size=420, sample_num=1024,data_dir='/media/xyz/data1/HouseCat6D')
+
+vis = True
+device = "cuda"
+import matplotlib
+import open3d as o3d
+from pytorch3d.io import load_objs_as_meshes
+import trimesh
+matplotlib.use('TkAgg')
+
+#cat_list = ['bottle','box','can','cup','cutlery','remote','shoe','tube','teapot']
+cat_list = ['cup']
+
+
+sem_global_list = []  
+sem_global_pcd_list = []  
+
+# # load semantc feature and show
+# ########################################
+save_dir = 'Yung/yung_large_files/semantic_feature/test_notebook/8v'
+# #save_dir = './80views_textured_token'
+# if  True:
+#     for cat in cat_list:
+#     # # orriginal    
+#     #     with open(f'/mnt/4T/Yung/yung_large_files/semantic_feature/test_notebook/housecat_{cat}/raw/housecat1_train.txt', 'r') as f:
+#     #         instances = [line.strip() for line in f.readlines()]
+
+#     #     print(instances)
+#     # revised
+#     # instance try cup-grey_handle
+#         instances = ['cup-grey_handle']
+#         sem_global_list = []  
+#         sem_global_pcd_list = []  
+
+#         # Load the mean shape point cloud
+#         meanshape_path = f'Yung/yung_large_files/semantic_feature/test_notebook/saved_pcd/{cat}/mean_shape/mean_shape_pcd_1.txt'
+#         meanshape_pcd_np = np.loadtxt(meanshape_path)
+        
+#         meanshape_pcd_tensor = torch.from_numpy(meanshape_pcd_np)
+#         M = meanshape_pcd_tensor.shape[0]
+#         meanshape_points = meanshape_pcd_tensor.view(1, M, 3).float()
+#     #make sure map to cuda0    
+#         average_aggregated_features = torch.load(f'/mnt/4T/Yung/yung_large_files/semantic_feature/test_notebook/8v_key/sem_cat_pcd_untex/{cat}_dino_feature.pt', map_location={"cuda:1": "cuda:0"})
+#         sem_global_pcd_list.append(meanshape_points[0])
+#         sem_global_list.append(average_aggregated_features[0].detach().cpu())
+#         #fig =plot_pointclouds_3d_with_pca(average_aggregated_features[0].detach().cpu(),meanshape_points[0])
+#         #fig.savefig('test.png')
+#         for j,instance in enumerate(instances):
+#             #break
+#             print("Processing", instance)
+#             #obj_path = f'/media/xyz/data/HouseCat6D/obj_models_small_size_final/{cat}/{instance}.obj'
+#             #instance_pcd_tensor = torch.load(f'{save_dir}/saved_pcd_untex/{cat}/{instance}_pcd.pt')[0]
+#             #obj_path = f'/media/xyz/data1/HouseCat6D/obj_models_small_size_final/{cat}/{instance}.obj'
+#             # instance_pcd_path = f'Yung/yung_large_files/semantic_feature/test_notebook/saved_pcd/{cat}/test/{instance}.txt'
+#             # instance_pcd_np = np.loadtxt(instance_pcd_path)
+#             instance_pcd_path = f'Yung/yung_large_files/pose_can_results/housecat6d_sonata_feature/scene01/000000/cup-grey_handle/input_pca.ply'
+#             pcd = o3d.io.read_point_cloud(instance_pcd_path)
+#             instance_pcd_np = np.asarray(pcd.points)
+            
+#             # Rotate 180 degrees around y axis
+#             rotation_matrix = np.array([
+#                 [-1, 0, 0],
+#                 [0, 1, 0],
+#                 [0, 0, -1]
+#             ])
+#             instance_pcd_np = instance_pcd_np @ rotation_matrix.T
+
+
+#             # Load the instance point cloud
+#             instance_pcd_tensor = torch.from_numpy(instance_pcd_np)
+#             N = instance_pcd_tensor.shape[0]
+#             instance_points = instance_pcd_tensor.view(1, N, 3).float()
+#             try:
+#                 # aggregated_features = torch.load(f'{save_dir}/saved_dino_pcd_untex/{cat}/{instance}_dino_feature.pt')
+#                 aggregated_features = average_aggregated_features
+#             except:
+#                 print(f"Warning: {instance} not found.")
+#                 continue
+#             # plot_pointclouds_3d_with_pca(aggregated_features[0].detach().cpu(),
+#             #                              instance_points[0])
+#             sem_global_pcd_list.append(instance_points[0].detach().cpu())
+#             sem_global_list.append(aggregated_features[0].detach().cpu())
+#             if len(sem_global_list)>4:
+#                 break
+        
+#         fig = plot_pointclouds_3d_with_copca(sem_global_list,sem_global_pcd_list,co_pca=True)
+#         fig.savefig(f'./{save_dir}/{cat}_amodal.png')
+# ###############################
+
+
+model_dict={'small':'dinov2_vits14',
+            'base':'dinov2_vitb14',
+            'large':'dinov2_vitl14',
+            'giant':'dinov2_vitg14'}
+extractor = ViTExtractor(model_dict['small'],14)
+# use GPPU0
+extractor.model = extractor.model.cuda(0)  # the stride of first conv control outputs resolution
+
+# extractor = torch.hub.load('facebookresearch/dinov2', model_dict['small'], pretrained=True).cuda()
+
+
+# cat_list = ['bottle','box','can','cup','cutlery','glass','remote','shoe','tube','teapot']
+cat_list = ['cup']
+
+#cat_list = ['teapot']
+#TODO: if condition for tex rendering
+for cat in cat_list:
+    # # orriginal    
+    # with open(f'/mnt/4T/Yung/yung_large_files/semantic_feature/test_notebook/housecat_{cat}/raw/housecat1_train.txt', 'r') as f:
+    #     instances = [line.strip() for line in f.readlines()]
+
+        # print(instances)
+    #revised
+    # instance try cup-grey_handle
+    instances = ['cup-grey_handle']
+
+    aggregated_features_list = []  # N * [1, 1024, 384]
+    # Load the mean shape point cloud
+    meanshape_path = f'Yung/yung_large_files/semantic_feature/test_notebook/saved_pcd/{cat}/mean_shape/mean_shape_pcd_1.txt'
+    meanshape_pcd_np = np.loadtxt(meanshape_path)
+    meanshape_pcd_tensor = torch.from_numpy(meanshape_pcd_np)
+    M = meanshape_pcd_tensor.shape[0]
+# modify for cuda0
+    meanshape_points = meanshape_pcd_tensor.view(1, M, 3).float().cuda(0)
+
+
+    for j,instance in enumerate(instances):
+# #original
+#         # if instance != 'bottle-85_alcool':
+#         #     continue
+#         print("Processing", instance)
+#         obj_path = f'pose_dataset/HouseCat6D/obj_models_small_size_final/{cat}/{instance}.obj'
+#         instance_pcd_path = f'Yung/yung_large_files/semantic_feature/test_notebook/saved_pcd/{cat}/test/{instance}.txt'
+
+#         # Load the instance point cloud
+#         instance_pcd_np = np.loadtxt(instance_pcd_path)
+#         try:
+#             verts, faces, aux = load_obj(obj_path)
+#         except ValueError as e:
+#             print(f"Warning: {e}, attempting to load without material.")
+
+#             try:
+#                 verts, faces, aux = load_obj(obj_path, load_textures=True)
+#             except ValueError as e2:
+#                 print(f"Failed to load {obj_path} without material: {e2}")
+#                 continue
+#         meshes = Meshes(verts=[verts], faces=[faces.verts_idx], textures=None)
+
+#modify for amodal
+        print("Processing", instance)
+        obj_path = f'/mnt/4T/Yung/yung_large_files/pose_can_results/output_orientation_Matters/Amodal3r_HouseCat6D_test/scene01/000000/cup-grey_handle/mesh.glb'
+        instance_pcd_path = f"/mnt/4T/Yung/yung_large_files/pose_can_results/output_orientation_Matters/Amodal3r_HouseCat6D_test/scene01/000000/cup-grey_handle/mesh_downsampled.npz"
+        instance_pcd_np = np.load(instance_pcd_path)['coord']
+        instance_pcd_tensor = torch.from_numpy(instance_pcd_np)
+        N = instance_pcd_tensor.shape[0]
+# modify for cuda0
+        instance_points = instance_pcd_tensor.view(1, N, 3).float().cuda(0)
+
+        try:
+            verts, faces, aux = load_obj(obj_path)
+        except Exception as e:
+            print(f"Warning: Failed to load OBJ with load_obj: {e}")
+            try:
+                mesh = trimesh.load(obj_path, force='mesh')
+                verts = torch.from_numpy(mesh.vertices).float()
+                faces = torch.from_numpy(mesh.faces).long()
+                
+                # Extract texture information from trimesh
+                tex = None
+                if isinstance(mesh, trimesh.Scene):
+                    # Extract the first geometry from the scene
+                    if len(mesh.geometry) == 0:
+                        raise ValueError(f"No geometry found in scene for {obj_path}")
+                    mesh = list(mesh.geometry.values())[0]
+                
+                # Extract texture information from the mesh
+                color_visual = mesh.visual.to_color()
+                if hasattr(color_visual, "vertex_colors") and color_visual.vertex_colors is not None:
+                    # Create vertex textures from vertex colors
+                    print("Using vertex colors for texture.")
+                    vertex_colors = torch.from_numpy(color_visual.vertex_colors[:, :3].astype(np.float32)) / 255.0
+                    tex = TexturesVertex(verts_features=vertex_colors[None])
+                elif hasattr(color_visual, "face_colors") and color_visual.face_colors is not None:
+                    # Average face colors to vertices
+                    print("Using face colors to compute vertex colors for texture.")
+                    vertex_colors = np.zeros((len(mesh.vertices), 3))
+                    vertex_counts = np.zeros(len(mesh.vertices))
+                    for face, color in zip(mesh.faces, color_visual.face_colors):
+                        vertex_colors[face] += color[:3]
+                        vertex_counts[face] += 1
+                    vertex_colors = vertex_colors / (vertex_counts[:, None] + 1e-8)
+                    vertex_colors = torch.from_numpy(vertex_colors.astype(np.float32)) / 255.0
+                    tex = TexturesVertex(verts_features=vertex_colors[None])
+                else:
+                    print("No vertex or face colors found; proceeding without texture.")
+                    tex = None
+
+                
+            except Exception as e2:
+                print(f"Warning: Failed to load GLB with trimesh: {e2}")
+                continue
+
+
+        # Initialise the mesh with textures
+        verts = normalize_mesh_verts(verts) # Housecat meshes are absolute scale
+# original
+        # meshes = Meshes(verts=[verts], faces=[faces.verts_idx], textures=tex)
+# revised for amodal
+        meshes = Meshes(verts=[verts], faces=[faces], textures=tex)
+
+        if meshes.textures is None:
+            meshes.textures = TexturesVertex(
+                verts_features=torch.ones_like(meshes.verts_padded(), device=device)
+            ) 
+
+        # render the mesh with 8 views, scale means the distance from the object to the camera
+        image_size=(420,420)
+        #images,fragments,cameras = render_batch(meshes,image_size=image_size,scale=1.0)
+        images,fragments,cameras = render(meshes,image_size=image_size,scale=2.0)
+
+        os.makedirs(f'{save_dir}/{cat}_rgb_dino_untex-try', exist_ok=True)
+        rgb = images.cpu().numpy()[:, :, :, :3]
+        image_grid(rgb, rows=1, cols=8, rgb=True)
+        plt.savefig(f'{save_dir}/{cat}_rgb_dino_untex-try/{instance}_rendering-texture_amodal.png')
+        plt.close()
+
+        # get the feature point cloud
+        feature_point_cloud, dino_feat_masked, feature_point_cloud_list = fuse_feature_rgbd(extractor,images,fragments,cameras)
+
+        # get the downsampled aggregated feature point cloud
+        num_pts= 1024
+        nn_num= 100 # larger nn_num will make the feature more smooth
+        sampled_points,aggregated_features = downsample_with_knn_feature_aggregation(feature_point_cloud,num_pts,nn_num)
+
+        # #Needed
+        # index = np.random.choice(partial_feature_point_cloud.shape[0], 1024, replace=False)
+        # plot_pointclouds_3d_with_copca(average_aggregated_features.squeeze(0).detach().cpu().numpy(), 
+        #                                partial_feature_point_cloud[index,3:], 
+        #                                sampled_points.squeeze(0).detach().cpu().numpy(), 
+        #                                partial_feature_point_cloud[index,:3])
+        
+
+        q=0
+
+        if False:
+            q+=1
+            inputs = trainset[q]
+            rgb = inputs['rgb'][None].cuda()
+            pts = inputs['pts'][None]
+            choose = inputs['choose'][None]
+            model = inputs['model'][None].cuda()
+            rgb = inputs['rgb'][None].cuda()
+
+            _desc_q = extractor.forward_features(rgb)["x_prenorm"][:, :]
+            #_desc_q = extractor.extract_descriptors(rgb,layer=11,facet='token',include_cls=True).squeeze(1) # B,L,C
+            # _norm_q = torch.linalg.norm(_desc_q, dim=-1)[:, :, None]
+            # _desc_q = _desc_q / (_norm_q)
+
+            dino_feature = _desc_q[:,1:,:]
+
+
+            #dino_feature = self.rgb_extractor.forward_features(rgb)["x_prenorm"][:, 1:]
+            #rgb=self.rgb_extractor.preprocess_pil(rgb)
+            #dino_feature = self.rgb_extractor.extract_descriptors(rgb,layer=11,facet='key') # (1,900,384)
+            f_dim = dino_feature.shape[-1]
+            num_patches =int(dino_feature.shape[1]**0.5) # 1
+            b=1
+            dino_feature = dino_feature.reshape(b, num_patches, num_patches, f_dim).permute(0,3,1,2)
+            
+            dino_feature = F.interpolate(dino_feature, size=(num_patches * 14, num_patches * 14), mode='nearest') 
+            dino_feature_2d_vis = dino_feature.detach().cpu()[0] #384, 224,224
+
+            b, d = dino_feature.shape[0:2]
+            dino_feature = dino_feature.reshape(b,d,-1)
+            choose_2 = choose.unsqueeze(1).repeat(1, d, 1).cuda()
+            dino_feature = torch.gather(dino_feature,2,choose_2).contiguous() # b,d,n
+            
+            #dino_feature = dino_feature / torch.std(dino_feature, dim=1, keepdim=True)
+            #dino_feature = torch.norm(dino_feature, dim=1, keepdim=True)
+            #choose_dino = choose.unsqueeze(1).repeat(1, d, 1Z
+            #sem_model = sem_model / torch.std(sem_model, dim=-1, keepdim=True)
+            #visual_global_sem_high = sem_model.detach().cpu().numpy()[0] #1024,384
+            visual_partial_sem_high = dino_feature.permute(0,2,1).detach().cpu().numpy()[0] #1024,128
+
+            #visual_global_sem_low = self.feature_mlp(sem_model.permute(0,2,1)).permute(0,2,1).detach().cpu().numpy()[0]
+            #visual_partial_sem_low = rgb_local.permute(0,2,1).detach().cpu().numpy()[0]
+            # transform the pts with GT 9D Pose into object coordinate
+            translation_gt = inputs['translation_label'][None]
+            rotation_gt = inputs['rotation_label'][None]
+            size_gt = inputs['size_label'][None]
+            pts_obj_frame = (inputs['pts'] - translation_gt.unsqueeze(1)) / (torch.norm(size_gt, dim=1).view(b, 1, 1) + 1e-8) @ rotation_gt
+            #kpt_obj_frame = (kpt_3d - translation_gt.unsqueeze(1)) / (torch.norm(size_gt, dim=1).view(b, 1, 1) + 1e-8) @ rotation_gt
+            
+            # dino_feature_2d_vis_pca = vis_pca_pixelwise(dino_feature_2d_vis[None])[0]
+            # plt.imshow(dino_feature_2d_vis_pca[:,:,:3])
+            # plt.show()
+            # fig =plt.figure()
+            # rgb_unnorm = unnormalize(rgb[0].permute(1,2,0).detach().cpu())
+            # plt.imshow(rgb_unnorm)
+            # plt.show()
+            # image_mask = ((rgb_unnorm.clone().sum(axis=2) >0.1)*1.0)[None,None] # 224,224
+                
+            # rgb_mask = np.array(image_mask[0,0,:,:,None]).repeat(384, axis=2).transpose(2,0,1)
+
+            # dino_feature_2d_vis[rgb_mask==0] = 0
+            # masked_dino_feature_2d_vis_pca = vis_pca_pixelwise(dino_feature_2d_vis[None])[0]
+            # plt.imshow(masked_dino_feature_2d_vis_pca[:,:,:])
+            # plt.show()
+
+
+            # print('self.pca.cateagg-partial')
+            # index = np.random.choice(partial_feature_point_cloud.shape[0], 1024, replace=False)
+            # #average_aggregated_features = torch.load(f'sem_cat_pcd/{cat}_dino_feature.pt')
+            
+            average_aggregated_features = torch.load(f'/home/xyz/anything6d_project/Sem-GCE-AG-Pose/sem_cat_pcd/{cat}_dino_feature.pt')
+            # #plot_pointclouds_3d_with_copca(aggregated_features.squeeze(0).detach().cpu().numpy(), partial_feature_point_cloud[index,3:], sampled_points.squeeze(0).detach().cpu().numpy(), pts_obj_frame)
+           
+            plot_pointclouds_3d_with_copca_old(average_aggregated_features.squeeze(0).detach().cpu().numpy(),
+                                               visual_partial_sem_high,
+                                               sampled_points.squeeze(0).detach().cpu().numpy(),
+                                              pts_obj_frame[0].detach().cpu().numpy())
+            plt.show()
+
+
+            # plot_pointclouds_3d_with_copca(average_aggregated_features.squeeze(0).detach().cpu().numpy(),
+            #                                 visual_partial_sem_high,
+            #                                sampled_points.squeeze(0).detach().cpu().numpy(),
+            #                                 pts_obj_frame[0].detach().cpu().numpy())
+            
+            
+            # #query_points =np.random.choice(1024, 3)
+            # query_points, sampled_indices = sample_farthest_points(pts_obj_frame, K=4)  # Shape: (1, 1024, 3), (1, 1024)
+            # plot_pointclouds_with_color_mapping(visual_partial_sem_high, 
+            #                                     aggregated_features.squeeze(0).detach().cpu().numpy(),
+            #                                     pts_obj_frame[0].detach().cpu().numpy(),
+            #                                     model[0].detach().cpu().numpy(),
+            #                                     sampled_indices[0], similarity_threshold=None)
+
+
+            # # plot_pointclouds_3d_with_copca(average_aggregated_features.squeeze(0).detach().cpu().numpy(), partial_feature_point_cloud[index,3:], sampled_points.squeeze(0).detach().cpu().numpy(), partial_feature_point_cloud[index,:3])
+            # # plot_pointclouds_3d_with_pca(average_aggregated_features.squeeze(0).detach().cpu().numpy(), partial_feature_point_cloud[index,3:], sampled_points.squeeze(0).detach().cpu().numpy(), partial_feature_point_cloud[index,:3])
+            # partial_feature_point_cloud = feature_point_cloud_list[5]
+            # plot_pointclouds_3d_with_copca(visual_partial_sem_high, 
+            #                             partial_feature_point_cloud[index,3:], 
+            #                             pts_obj_frame[0].detach().cpu().numpy(), 
+            #                             partial_feature_point_cloud[index,:3])
+        
+        # plot_pointclouds_3d_with_copca(average_aggregated_features.squeeze(0).detach().cpu().numpy(), aggregated_features.squeeze(0).detach().cpu().numpy(), sampled_points.squeeze(0).detach().cpu().numpy(), sampled_points.squeeze(0).detach().cpu().numpy())
+
+
+
+        os.makedirs(f'{save_dir}/saved_dino_pcd_untex-try/{cat}', exist_ok=True)
+        torch.save(aggregated_features, f'{save_dir}/saved_dino_pcd_untex-try/{cat}/{instance}_dino_feature-texture_amodal.pt')
+
+        os.makedirs(f'{save_dir}/saved_pcd_untex-try/{cat}', exist_ok=True)
+        torch.save(sampled_points, f'{save_dir}/saved_pcd_untex-try/{cat}/{instance}_pcd-texture_amodal.pt')
+        
+        aggregated_features_list.append(aggregated_features)
+        # #break
+        vis_dino = vis_pca_pixelwise(np.array(dino_feat_masked))
+        vis_img = np.clip(vis_dino[:,:,:,:],a_min=0,a_max=1)
+        image_grid(vis_img, rows=1, cols=8, rgb=True)
+
+        os.makedirs(f'{save_dir}/{cat}_rgb_dino_untex-try', exist_ok=True)
+        plt.savefig(f'{save_dir}/{cat}_rgb_dino_untex-try/{instance}_dino-texture_amodal.png')
+        plt.close()
+        if False:
+
+            rgb = images.cpu().numpy()[:, :, :, :3]
+            mask = images[:, ..., 3].cpu().numpy()!=0
+            depth_image = fragments[:, ..., 0].cpu().numpy()*mask
+            image_grid(rgb, rows=1, cols=8, rgb=True)
+            # os.makedirs(f'/home/tulrfpf/code/PointFlowRenderer/{cat}_rgb_dino', exist_ok=True)
+            # plt.savefig(f'/home/tulrfpf/code/PointFlowRenderer/{cat}_rgb_dino/{instance}_rgb.png')
+            # image_grid(depth_image[...,None], rows=2, cols=4, rgb=True)
+            # image_grid(mask[...,None], rows=2, cols=4, rgb=True)
+
+
+
+            fig = plt.figure(figsize=(10, 10))
+            ax = fig.add_subplot(111, projection="3d")
+            #ax.scatter(sampled_points[:, 2], sampled_points[:,0], sampled_points[:, 1], c="b")
+            pca_color =vis_pca(feature_point_cloud[:, 3:])
+            ax.scatter(feature_point_cloud[:, 2], feature_point_cloud[:, 0], feature_point_cloud[:, 1], c=pca_color,s=0.1)
+            #create_camera_geometry_batch(ax=ax,R_batch=R,T_batch=T,order=(2,0,1))
+            ax.set_xlabel("z")
+            ax.set_ylabel("x")
+            ax.set_zlabel("y")
+            ax.set_xlim(-2, 2)
+            ax.set_ylim(-2, 2)
+            ax.set_zlim(-2, 2)
+            plt.title("Sampled Dense Points from Mesh")
+            plt.show()
+
+            fig = plt.figure(figsize=(10, 10))
+            ax = fig.add_subplot(111, projection="3d")
+            pca_color =vis_pca(aggregated_features.squeeze(0))
+            sampled_points= sampled_points.squeeze(0).cpu().detach().numpy()
+            ax.scatter(sampled_points[:, 2], sampled_points[:, 0], sampled_points[:, 1], c=pca_color,s=50)
+            #create_camera_geometry_batch(ax=ax,R_batch=R,T_batch=T,order=(2,0,1))
+            ax.set_xlabel("z")
+            ax.set_ylabel("x")
+            ax.set_zlabel("y")
+            ax.set_xlim(-2, 2)
+            ax.set_ylim(-2, 2)
+            ax.set_zlim(-2, 2)
+            plt.title("Sampled Sparse Points from Mesh")
+            plt.show()
+            #break
+    # Assign the aggregated features to the mean shape point cloud
+    aggregated_features_tensor = torch.cat(aggregated_features_list, dim=0)  #[N, 1024, 384]
+    average_aggregated_features = aggregated_features_tensor.mean(dim=0, keepdim=True)
+    print("Average Aggregated Features Shape:", average_aggregated_features.shape)  # Should be (1, 1024, 384)
+
+    os.makedirs(f'{save_dir}/sem_cat_pcd_untex-try', exist_ok=True)
+    torch.save(average_aggregated_features, f'{save_dir}/sem_cat_pcd_untex-try/{cat}_dino_feature.pt')
+
+# fig = plt.figure(figsize=(10, 10))
+# ax = fig.add_subplot(111, projection="3d")
+# pca_color =vis_pca(average_aggregated_features.squeeze(0))
+# # sampled_points= sampled_points.squeeze(0).cpu().detach().numpy()
+# meanshape_points = meanshape_points.squeeze(0).cpu().detach().numpy()
+# ax.scatter(meanshape_points[:, 2], meanshape_points[:, 0], meanshape_points[:, 1], c=pca_color,s=10.0, marker='o')
+# ax.set_xlabel("z")
+# ax.set_ylabel("x")
+# ax.set_zlabel("y")
+# ax.set_xlim(-2, 2)
+# ax.set_ylim(-2, 2)
+# ax.set_zlim(-2, 2)
+# plt.title("Shape Prior Dino")
+# plt.show()
+    

RGBD_DINO_HouseCat6D_final_copy_sam3d.py

@@ -0,0 +1,1131 @@
+import torch
+from custom_utils import ShapeNetCore
+from custom_utils import _compute_fov,_sample_points_from_faces
+from custom_utils import image_grid
+from custom_utils.shapenet_base import HouseCatDataset
+import matplotlib.pyplot as plt
+import numpy as np
+import k3d
+import os
+import json
+import torch
+from PIL import Image
+
+import cv2
+import imageio
+import numpy as np
+from PIL import Image
+import matplotlib.pyplot as plt
+from torchvision import transforms
+from custom_utils.extractor import ViTExtractor
+import torch.nn.functional as F
+from sklearn.decomposition import PCA as sklearnPCA
+import math
+from custom_utils.utils_general import center_crop
+
+from pytorch3d.io import load_objs_as_meshes, load_obj
+from pytorch3d.implicitron.tools.point_cloud_utils import get_rgbd_point_cloud
+from pytorch3d.structures import Meshes
+from pytorch3d.renderer import (
+    PerspectiveCameras,
+    FoVPerspectiveCameras,
+    PointLights,
+    MeshRasterizer,
+    MeshRenderer,
+    RasterizationSettings,
+    HardPhongShader,
+    TexturesVertex,
+    look_at_view_transform,
+    ray_bundle_to_ray_points,
+    NDCMultinomialRaysampler,
+    TexturesUV,
+    BlendParams,
+
+    TexturesVertex
+)
+
+from pytorch3d.implicitron.tools.point_cloud_utils import get_rgbd_point_cloud
+from pytorch3d.structures import Pointclouds
+import torch
+from pytorch3d.ops import sample_farthest_points, knn_points, knn_gather
+
+from matplotlib import cm
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.decomposition import PCA
+from mpl_toolkits.mplot3d import Axes3D
+
+
+def sample_points_on_sphere(num_points=80):
+    points = []
+    phi = (1 + math.sqrt(5)) / 2  # golden ratio
+
+    for i in range(num_points):
+        theta = 2 * math.pi * i / phi  # azimuthal angle
+        z = 1 - (2 * i + 1) / num_points  # z-coordinate, uniform from -1 to 1
+        radius = math.sqrt(1 - z * z)  # radius for the xy-plane
+        x = radius * math.cos(theta)
+        y = radius * math.sin(theta)
+        points.append([x, y, z])
+
+    return torch.tensor(points, dtype=torch.float32)
+
+def get_cube_vertices():
+    # Cube vertices (8 vertices)
+    return torch.tensor([[1, 1, 1],
+                         [1, 1, -1],
+                         [1, -1, 1],
+                         [1, -1, -1],
+                         [-1, 1, 1],
+                         [-1, 1, -1],
+                         [-1, -1, 1],
+                         [-1, -1, -1]], dtype=torch.float32)  # Ensure float type
+
+
+def render(meshes,scale=3.0,image_size=(420,420),light=(0.3,0.3,0.3)):
+    # prepare the camera
+    num_views = 8
+    # Get the cube vertices
+    #cube_vertices = get_cube_vertices()*scale
+    cube_vertices = sample_points_on_sphere(num_views)*scale
+    #up = torch.randn(1, 3)
+    up=torch.tensor([[0.0, 0.0, 1.0]], dtype=torch.float32)
+    up = up / torch.norm(up, dim=1)[:, None]
+    R, T = look_at_view_transform(eye=cube_vertices, at=torch.tensor([[0.0, 0.0, 0.0]], dtype=torch.float32), up=up)
+    cam_K= np.array([[572, 0.0, image_size[0]//2], [0.0, 572, image_size[1]//2], [0.0, 0.0, 1.0]])
+    fx,_,cx,_,fy,cy,_,_,_=cam_K.reshape(9)
+    fov_x, fov_y = _compute_fov(cam_K, 420, 420)
+
+    cameras = PerspectiveCameras(device=device, R=R, T=T, image_size=((420,420),),
+                                    focal_length=torch.tensor([[fx, fy]], dtype=torch.float32),
+                                    principal_point=torch.tensor([[cx, cy]], dtype=torch.float32),
+                                    in_ndc=False)
+
+    # prepare the lights
+    raster_settings = RasterizationSettings(image_size=image_size)
+    lights = PointLights(location=torch.tensor([0.0, 1.0, -2.0], device=device)[None], ambient_color=(light,),diffuse_color=(light,),device=device)
+
+    # move the data to the device
+    meshes = meshes.to(device)
+    cameras = cameras.to(device)
+    if len(cameras) != 1 and len(cameras) % len(meshes) != 0:
+        raise ValueError("Mismatch between batch dims of cameras and meshes.")
+    if len(cameras) > 1:
+        meshes = meshes.extend(len(cameras) // len(meshes))
+
+    # prepare the renderer
+    class MeshRendererWithDepth(torch.nn.Module):
+        def __init__(self, rasterizer, shader):
+            super().__init__()
+            self.rasterizer = rasterizer
+            self.shader = shader
+
+        def forward(self, meshes_world, **kwargs) -> torch.Tensor:
+            fragments = self.rasterizer(meshes_world, **kwargs)
+            images = self.shader(fragments, meshes_world, **kwargs)
+            return images, fragments.zbuf
+        
+
+    blend_params = BlendParams(background_color=(0.0, 0.0, 0.0))  # Blue background
+    renderer = MeshRendererWithDepth(
+        rasterizer=MeshRasterizer(
+            cameras=cameras,
+            raster_settings=raster_settings,
+        ),
+    # Set background color to blue [R, G, B]
+
+        shader=HardPhongShader(
+            device=device,
+            cameras=cameras,
+            lights=lights,
+            blend_params=blend_params
+        )
+    )
+
+    images,fragments = renderer(meshes)
+    return images,fragments,cameras
+
+
+def render_batch(meshes,scale=3.0,image_size=(420,420),light=(0.3,0.3,0.3)):
+    # prepare the camera
+    num_views = 8
+    # Get the cube vertices
+    cube_vertices = get_cube_vertices()*scale
+    #cube_vertices = sample_points_on_sphere(num_views)*scale
+    up = torch.randn(1, 3)
+    # up=torch.tensor([[0.0, 0.0, 1.0]], dtype=torch.float32)
+    up = up / torch.norm(up, dim=1)[:, None]
+    R, T = look_at_view_transform(eye=cube_vertices, at=torch.tensor([[0.0, 0.0, 0.0]], dtype=torch.float32), up=up)
+
+    cam_K= np.array([[572, 0.0, image_size[0]//2], [0.0, 572, image_size[1]//2], [0.0, 0.0, 1.0]])
+    fx,_,cx,_,fy,cy,_,_,_=cam_K.reshape(9)
+    fov_x, fov_y = _compute_fov(cam_K, 420, 420)
+
+
+    # prepare the renderer
+    class MeshRendererWithDepth(torch.nn.Module):
+        def __init__(self, rasterizer, shader):
+            super().__init__()
+            self.rasterizer = rasterizer
+            self.shader = shader
+
+        def forward(self, meshes_world, **kwargs) -> torch.Tensor:
+            fragments = self.rasterizer(meshes_world, **kwargs)
+            images = self.shader(fragments, meshes_world, **kwargs)
+            return images, fragments.zbuf
+        
+
+    blend_params = BlendParams(background_color=(0.0, 0.0, 0.0))  # Blue background
+
+    batch_size = 10
+    all_images=[]
+    all_fragments=[]
+
+    # move the data to the device
+    meshes = meshes.extend(batch_size).to(device)
+    for i in range(0,R.shape[0],batch_size):
+        R_batch = R[i:i+batch_size]
+        T_batch = T[i:i+batch_size]
+        cameras_batch = PerspectiveCameras(device=device, R=R_batch, T=T_batch, image_size=((420,420),),
+                                        focal_length=torch.tensor([[fx, fy]], dtype=torch.float32),
+                                        principal_point=torch.tensor([[cx, cy]], dtype=torch.float32),
+                                        in_ndc=False).to(device)
+
+        # prepare the lights
+        raster_settings = RasterizationSettings(image_size=image_size)
+        lights = PointLights(location=torch.tensor([0.0, 1.0, -2.0], device=device)[None], 
+                             ambient_color=(light,),diffuse_color=(light,),device=device)
+
+        renderer = MeshRendererWithDepth(
+            rasterizer=MeshRasterizer(
+                cameras=cameras_batch,
+                raster_settings=raster_settings,
+            ),
+            # Set background color to blue [R, G, B]
+            shader=HardPhongShader(
+                device=device,
+                cameras=cameras_batch,
+                lights=lights,
+                blend_params=blend_params
+            )
+         )
+        images,fragments = renderer(meshes)
+        all_images.append(images)
+        all_fragments.append(fragments)
+    all_images = torch.cat(all_images,dim=0)
+    all_fragments = torch.cat(all_fragments,dim=0)
+    cameras = PerspectiveCameras(device=device, R=R, T=T, image_size=((420,420),),
+                                focal_length=torch.tensor([[fx, fy]], dtype=torch.float32),
+                                principal_point=torch.tensor([[cx, cy]], dtype=torch.float32),
+                                in_ndc=False).to(device)
+    return all_images,all_fragments,cameras
+
+
+def fuse_feature_rgbd(extractor,images,fragments,cameras):
+    dino_feat_masked_list = []
+    feature_point_cloud_list = []
+    for i in range(images.shape[0]):
+        image = images.cpu().numpy()[i, :, :, :3]
+        image_mask = images[i, ..., 3].cpu().numpy()!=0
+        crop_size = (420, 420)
+        crop_image, crop_mask, bbox = center_crop(image, image_mask, crop_size)
+        cropped_image_np = cv2.resize(crop_image, crop_size, interpolation=cv2.INTER_AREA)
+        #cropped_mask = cv2.resize(crop_mask*1.0, crop_size, interpolation=cv2.INTER_NEAREST)!=0  # Use nearest neighbor interpolation for masks
+        orignal_size = (int(bbox[2]-bbox[0]), int(bbox[3]-bbox[1])) #K,K
+
+        to_tensor = transforms.ToTensor()
+        input_image = to_tensor(cropped_image_np).cuda()
+        input_image = input_image.unsqueeze(0)
+        #input_image=extractor.preprocess_pil(input_image)
+        mean = torch.tensor([0.485, 0.456, 0.406]).cuda()
+        std = torch.tensor([0.229, 0.224, 0.225]).cuda()
+        input_image = (input_image - mean[None, :, None, None]) / std[None, :, None, None]
+  
+        _desc_q = extractor.extract_descriptors(input_image,layer=11,include_cls=True).squeeze(1) # (1,900,384)
+        #_desc_q = extractor.forward_features(input_image)["x_prenorm"][:, :]   # (1,900,384)
+        #_desc_q = extractor.extract_descriptors(input_image,layer=11,facet='token',include_cls=True).squeeze(1) # B,L,C
+        # _norm_q = torch.linalg.norm(_desc_q, dim=-1)[:, :, None]
+        # _desc_q = _desc_q / (_norm_q)
+
+        desc = _desc_q[:,1:,:][None]
+        #cls_token_q = _desc_q[:,0,:] #B,C`
+
+        input_mask = to_tensor(crop_mask).cuda()
+        input_mask = input_mask.unsqueeze(0)
+
+        img_mask = to_tensor(image_mask)
+
+        img_mask = img_mask.permute(1,2,0)
+
+        dino_feat = patch2pixel_feats(desc, original_size=orignal_size) #reize back to K,K =>( K, K, 384)
+        # create dino-feat with orignal size
+        dino_height, dino_width, feat_dim = (image_size[0],image_size[1], desc.shape[-1])
+        dino_feat_orig = torch.zeros(dino_height,dino_width,feat_dim)
+        # Fill the dino features into the original tensor at the specified bounding box
+        dino_feat_orig[bbox[1]:bbox[3], bbox[0]:bbox[2],:] = dino_feat #reize back to K,K =>(420, 420, 384) #gradint is not supported for this operation
+        # Apply the mask
+        dino_feat_masked = dino_feat_orig * img_mask
+        dino_feat_masked = dino_feat_masked.permute(2,0,1).unsqueeze(0)
+        dino_feat_masked_low = F.interpolate(dino_feat_masked, size=(30, 30), mode='bilinear')
+
+        image_mask = images[i, ..., 3][None,None]
+        depth_image = fragments[i, ..., 0][None]*image_mask
+        
+        # # Define the kernel for erosion (3x3 ones kernel)
+        # kernel = torch.ones((1, 1, 5, 5), dtype=torch.float).cuda()
+        # # Number of erosion iterations
+        # iterations = 5
+
+        # # Perform iterative erosion
+        # for i in range(iterations):
+        #     # Apply erosion using 2D convolution
+        #     eroded_mask = F.conv2d(image_mask, kernel, padding=2)
+        #     image_mask = (eroded_mask == kernel.sum()).float()  # Update mask to eroded version
+
+        feature_point_cloud = get_rgbd_point_cloud(cameras[i], dino_feat_masked.to(device), depth_map=depth_image,mask=image_mask)#everthing on GPU
+
+        index = np.random.choice(feature_point_cloud.points_list()[0].shape[0], 4096, replace=True)
+        points = feature_point_cloud.points_list()[0].detach().cpu()[index,:]
+        colors = feature_point_cloud.features_list()[0].detach().cpu()[index,:]
+        # points = feature_point_cloud.points_list()[0].detach().cpu()[:,:]
+        # colors = feature_point_cloud.features_list()[0].detach().cpu()[:,:]
+        feature_point_cloud = torch.cat((points, colors), dim=1)
+
+        dino_feat_masked_list.append(dino_feat_masked_low.detach().cpu())
+        feature_point_cloud_list.append(feature_point_cloud)
+    feature_point_cloud = torch.cat(feature_point_cloud_list, dim=0)
+    dino_feat_masked = torch.cat(dino_feat_masked_list, dim=0)
+    return feature_point_cloud,dino_feat_masked, feature_point_cloud_list
+
+
+def downsample_with_knn_feature_aggregation(feature_point_cloud,num_pts=1024,k_nearest_neighbors=100, instance_points=None):
+    #N_1, C_1 = 2048, 384  # Example number of points and features
+    num_points_to_sample = num_pts
+    k_nearest_neighbors = k_nearest_neighbors
+
+    # Example input pointcloud and features (N_1, C_1), where N_1 is the number of points and C_1 is the feature dimension
+    pointcloud = feature_point_cloud[None,:,:3].cuda()  # Shape (1, N_1, 3) for 3D coordinates
+    features = feature_point_cloud[None,:,3:].cuda()  # Shape (1, N_1, C_1) for features
+
+    # Step 1: FPS to downsample the points
+    # We use sample_farthest_points to select num_points_to_sample points
+    sampled_points, sampled_indices = sample_farthest_points(pointcloud, K=num_points_to_sample)  # Shape: (1, 1024, 3), (1, 1024)
+    if instance_points is not None:
+        sampled_points = instance_points
+
+    # Step 2: KNN to find nearest neighbors
+    # Find the k nearest neighbors for each sampled point in the original pointcloud
+    dists, knn_indices, _ = knn_points(sampled_points, pointcloud, K=k_nearest_neighbors, return_nn=False)
+
+    # Step 3: Gather the features of the k-nearest neighbors using the knn indices
+    # Use knn_gather to get neighbor features for each sampled point
+    neighbor_features = knn_gather(features, knn_indices)  # Shape: (1, 1024, k, C_1)
+
+    # Step 4: Aggregate features from the neighbors (e.g., by averaging)
+    #aggregated_features,_ = torch.max(neighbor_features,dim=-2) # Shape: (1, 1024, C_1)
+    aggregated_features = torch.mean(neighbor_features,dim=-2) # Shape: (1, 1024, C_1)
+    return sampled_points, aggregated_features
+
+
+def vis_pca(feature):
+    n_components=3 # the first component is to seperate the object from the background
+
+    pca = sklearnPCA(n_components=n_components)
+    feature = pca.fit_transform(feature.detach().cpu().numpy())
+    for show_channel in range(n_components):
+        # min max normalize the feature map
+        feature[:, show_channel] = (feature[:, show_channel] - feature[:, show_channel].mean()) / (feature[:, show_channel].std()*10)
+    feature_resized = np.clip(feature[:,:]+0.5,0,1)
+    return feature_resized
+
+
+def patch2pixel_feats(patch_features, original_size):
+    # Calculate the number of patches along each dimension
+    num_patches = int(math.sqrt(patch_features.shape[2]))
+
+    batch_num = patch_features.shape[0]
+    feat_dim = patch_features.shape[3]
+    patch_features = patch_features.reshape(batch_num, num_patches, num_patches, feat_dim)
+    patch_features = patch_features.permute(0,3,1,2)
+
+    pixel_features = F.interpolate(patch_features, size=(original_size[0], original_size[1]), mode='bilinear')
+    pixel_features = pixel_features.squeeze().permute(1,2,0)
+    
+    return pixel_features
+
+def vis_pca_pixelwise(feature):
+    n_components = 4  # The number of PCA components to use
+    batch, feat_dim, height,width = feature.shape  
+    
+    # Reshape the feature to (num_pixels, feat_dim)
+    num_pixels = height * width
+    feature_reshaped = np.array(feature).transpose(0,2,3,1).reshape(-1, feat_dim)
+
+
+    # Apply PCA
+    pca = sklearnPCA(n_components=n_components)
+    feature_pca = pca.fit_transform(feature_reshaped)
+
+    # Min-max normalization for each component
+    # for show_channel in range(n_components):
+    #     feature_pca[:, show_channel] = (feature_pca[:, show_channel] - feature_pca[:, show_channel].min()) / \
+    #                                     (feature_pca[:, show_channel].max() - feature_pca[:, show_channel].min() + 1e-8)  # Small epsilon to avoid division by zero
+    for show_channel in range(n_components):
+        feature_pca[:, show_channel] = (feature_pca[:, show_channel] - feature_pca[:, show_channel].mean()) / \
+                                        (feature_pca[:, show_channel].std()*10 + 1e-8) # Small epsilon to avoid division by zero
+
+    feature_pca = np.clip(feature_pca+0.5, 0, 1)
+    # Reshape the PCA result back to (height, width, n_components)
+    feature_resized = feature_pca.reshape(batch,height,width,n_components)[...,1:4]
+    return feature_resized
+
+def normalize_mesh_verts(data):
+    # data [N, 3]
+    min_vals, _ = torch.min(data, dim=0)
+    max_vals, _ = torch.max(data, dim=0)
+    bbox_sizes = max_vals - min_vals
+    scale = torch.norm(bbox_sizes)
+    print("Scale:", scale)
+    normalized_verts = verts / scale
+    return normalized_verts
+
+def plot_pointclouds_with_color_mapping(pc1_f, pc2_f,pc1,pc2, query_points, similarity_threshold=None):
+    """
+    Visualizes two 3D point clouds. The second point cloud (pc2) is color-mapped
+    using the 'viridis' colormap based on its similarity (proximity) to the sampled
+    query points in the first point cloud (pc1).
+    
+    Parameters:
+    - pc1: np.ndarray of shape (N, 3), first point cloud #partial
+    - pc2: np.ndarray of shape (M, 3), second point cloud # global
+    - query_points: list of indices in pc1, representing the query points to compare.
+    - similarity_threshold: float, optional, threshold to cap the similarity distance.
+    """
+        
+
+    pc1_f = pc1_f / np.linalg.norm(pc1_f, axis=1)[:, None]  # Normalize the features
+    pc2_f = pc2_f / np.linalg.norm(pc2_f, axis=1)[:, None]  # Normalize the features
+    # Create a figure with subplots
+    fig = plt.figure(figsize=(12, 10))
+    num_query_points = len(query_points)
+    # Set limits and labels
+    size = pc2.max() - pc2.min()
+    # Plot the first point cloud in the first subplot
+    ax1 = fig.add_subplot(1, num_query_points + 1, 1, projection='3d')
+    ax1.scatter(pc2[:, 0], pc2[:, 1], pc2[:, 2], color='grey', label='Point Cloud 1 (Left)', alpha=0.1,s=10)
+
+    # Define a color list for each query point
+    query_colors = cm.tab10(np.linspace(0, 1, num_query_points))  # Use tab10 colormap for distinct colors
+
+    # Highlight query points in pc1 with different colors
+    for i, idx in enumerate(query_points):
+        ax1.scatter(pc1[idx, 0], pc1[idx, 1], pc1[idx, 2], 
+                    color=query_colors[i], s=100, edgecolor='k', label=f'Query Point {idx}')
+
+    ax1.set_title('Point Cloud 1 with Query Points')
+    ax1.set_xlabel('X')
+    ax1.set_ylabel('Y')
+    ax1.set_zlabel('Z')
+    ax1.set_xlim(-size / 1.4, size / 1.4)
+    ax1.set_ylim(-size / 1.4, size / 1.4)
+    ax1.set_zlim(-size / 1.4, size / 1.4)
+    ax1.view_init(elev=45, azim=-45)
+    ax1.grid(True)
+    ax1.legend()
+
+    # Plot the second point cloud in the subsequent subplots
+    for k in range(num_query_points):
+        
+        ax = fig.add_subplot(1, num_query_points + 1, k + 2, projection='3d')
+        
+        # Calculate distances between query points in pc1 and all points in pc2
+        similarity =(pc1_f[query_points[k]][None]@ pc2_f.T).reshape(-1) # (1, 3) x (M, 3) = (1, M)
+        # For each point in pc2, take the minimum distance to any query point
+        min_similarity = np.min(similarity, axis=0)
+        # Optionally cap the similarity distances to a threshold (to avoid extreme values)
+        similarity_threshold= 0.3
+        if similarity_threshold is not None:
+            similarity = np.clip(similarity, similarity_threshold,1)
+        # Normalize the distances to a range of 0 to 1 for colormap mapping
+        similarity = (similarity - np.min(similarity)) / (np.max(similarity) - np.min(similarity))
+        colors = cm.plasma(similarity)
+
+        # Plot the second point cloud with color mapping based on similarity
+        ax.scatter(pc2[:, 0], pc2[:, 1], pc2[:, 2], color=colors, s=15, alpha=1.0, label='Point Cloud 2 (Right)', edgecolor='k')
+        
+        ax.set_xlim(-size / 1.4, size / 1.4)
+        ax.set_ylim(-size / 1.4, size / 1.4)
+        ax.set_zlim(-size / 1.4, size / 1.4)
+        ax.set_title(f'QP_{query_points[k]}')
+        ax.set_xlabel('X')
+        ax.set_ylabel('Y')
+        ax.set_zlabel('Z')
+        ax.view_init(elev=45, azim=-45)
+        ax.grid(True)
+        ax.legend()
+
+    # Show the plot
+    plt.tight_layout()
+    plt.show()
+
+
+def plot_pointclouds_3d_with_copca_old(global_sem_pcd, partial_sem_pcd, global_pcd, partial_pcd):
+    """
+    Visualizes two point clouds in 3D, coloring them based on their PCA components.
+
+    Parameters:
+    - global_pointcloud: numpy array of shape (N, D) for global point cloud.
+    - partial_pointcloud: numpy array of shape (M, D) for partial point cloud.
+    """
+
+
+    n_components = 3
+    # Step 1: Perform PCA on both global and partial point clouds
+    sem_pca = PCA(n_components=n_components)
+    sem_pca = sem_pca.fit(global_sem_pcd)  # shape (N+M, 3)
+
+    transformed_sem_pcd_list = [sem_pca.transform(pcd) for pcd in [global_sem_pcd,partial_sem_pcd]]
+    sem_pcd_pca = np.concatenate(transformed_sem_pcd_list,axis=0)
+    for show_channel in range(n_components):
+        sem_pcd_pca[:, show_channel] = (sem_pcd_pca[:, show_channel] - sem_pcd_pca[:, show_channel].mean()) / \
+                                        (sem_pcd_pca[:, show_channel].std()*5 + 1e-8) # Small epsilon to avoid division by zero
+
+    # sem_pcd_pca_min = sem_pcd_pca.min()
+    # sem_pcd_pca_max = sem_pcd_pca.max()
+    # sem_pcd_pca = (sem_pcd_pca- sem_pcd_pca_min) / (sem_pcd_pca_max - sem_pcd_pca_min)  # Normalize to [0, 1]
+
+    sem_pcd_pca = np.clip(sem_pcd_pca[:,:]+0.5, 0, 1)
+    global_pca = sem_pcd_pca[:global_sem_pcd.shape[0]]  # shape (N, 3)
+    partial_pca = sem_pcd_pca[-partial_sem_pcd.shape[0]:]  # shape (M, 3)
+
+    # Step 2: Create a 3D scatter plot
+    fig = plt.figure(figsize=(12, 6))
+    ax = fig.add_subplot(121, projection='3d')
+
+
+    # Global point cloud
+    ax.scatter(global_pcd[:, 0], global_pcd[:, 1], global_pcd[:, 2], 
+            c=global_pca,  marker='o', s=100, alpha=1.0, label='Global Point Cloud')
+    
+    # Set labels for each axis
+    # ax.set_xlabel('X axis')
+    # ax.set_ylabel('Y axis')
+    # ax.set_zlabel('Z axis')
+    ax.set_xlim(-0.5, 0.5)
+    ax.set_ylim(-0.5, 0.5)
+    ax.set_zlim(-0.5, 0.5)
+    
+    ax1 = fig.add_subplot(122, projection='3d')
+
+    # Partial point cloud
+    ax1.scatter(partial_pcd[:, 0], partial_pcd[:, 1], partial_pcd[:, 2], 
+            c=partial_pca,  marker='o', s=100, alpha=1.0, label='Partial Point Cloud')
+    
+    # ax1.scatter(global_pcd[:, 0], global_pcd[:, 1], global_pcd[:, 2], 
+    #         marker='o', s=10, alpha=0.1)
+    # Set labels for each axis
+    # ax1.set_xlabel('X axis')
+    # ax1.set_ylabel('Y axis')
+    # ax1.set_zlabel('Z axis')
+
+    
+    ax1.set_xlim(-0.5, 0.5)
+    ax1.set_ylim(-0.5, 0.5)
+    ax1.set_zlim(-0.5, 0.5)
+    plt.tight_layout()
+
+    ax.view_init(120,-95)
+    ax1.view_init(120,-95)
+
+ 
+    ax.set_axis_off()
+    ax.set_facecolor((0, 0, 0, 0))
+    ax1.set_axis_off()
+    ax1.set_facecolor((0, 0, 0, 0))
+
+    plt.show()
+
+
+def plot_pointclouds_3d_with_pca(global_sem_pcd, global_pcd):
+    """
+    Visualizes two point clouds in 3D, coloring them based on their PCA components.
+
+    Parameters:
+    - global_pointcloud: numpy array of shape (N, D) for global point cloud.
+    - partial_pointcloud: numpy array of shape (M, D) for partial point cloud.
+    """
+    #sem_pcd = np.concatenate((global_sem_pcd,partial_sem_pcd), axis=0) # shape (N+M, D)
+
+    # Step 1: Perform PCA on both global and partial point clouds
+    sem_pca = PCA(n_components=3)
+    sem_pcd_pca = sem_pca.fit_transform(global_sem_pcd)  # shape (N+M, 3)
+
+    for i in range(3):  # Iterate over each component (3 in total for RGB)
+        sem_pcd_pca_mean = sem_pcd_pca[:, i].mean()
+        sem_pcd_pca_std = sem_pcd_pca[:, i].std()
+        sem_pcd_pca[:, i] = (sem_pcd_pca[:, i] - sem_pcd_pca_mean) / (sem_pcd_pca_std*5+1e-8)  # Normalize to [0, 1]
+
+
+    global_pca = np.clip(sem_pcd_pca+0.5,0,1)
+    # scatter plot
+    fig = plt.figure(figsize=(6, 6))
+    ax = fig.add_subplot(111, projection='3d')
+
+    # Global point cloud
+    ax.scatter(global_pcd[:, 0], global_pcd[:, 1], global_pcd[:, 2], 
+            c=global_pca,  marker='o', s=50, alpha=1.0, label='Global Point Cloud')
+    
+    # Remove axes and background
+    ax.set_axis_off()
+
+    # Set background color to none
+    ax.set_facecolor((0, 0, 0, 0))
+    # # Set labels for each axis
+    # ax.set_xlabel('X axis')
+    # ax.set_ylabel('Y axis')
+    # ax.set_zlabel('Z axis')
+    ax.set_xlim(-0.5, 0.5)
+    ax.set_ylim(-0.5, 0.5)
+    ax.set_zlim(-0.5, 0.5)
+
+    ax.view_init(-73,102)
+
+    return fig
+    
+
+def plot_pointclouds_3d_with_copca(global_sem_pcd_list, global_pcd_list,co_pca=True):
+    """
+    Visualizes multiple point clouds in 3D, each in a separate subplot, after applying CoPCA.
+    Coloring them based on their PCA components.
+
+    Parameters:
+    - global_sem_pcd_list: list of numpy arrays for semantic point clouds (one per object).
+    - global_pcd_list: list of numpy arrays for global point clouds (one per object).
+    """
+    num_pcds = len(global_sem_pcd_list)  # Number of point clouds
+    print("Number of point clouds to visualize:", num_pcds)
+    # Step 1: Perform CoPCA (Common PCA) on the semantic point clouds
+        # Concatenate all point clouds to perform common PCA
+    if co_pca:
+        concatenated_pcds = np.concatenate(global_sem_pcd_list, axis=0)  # shape (N_total, D)
+        copca = PCA(n_components=3, random_state=0)
+        copca.fit(concatenated_pcds[:1024])  # Fit PCA on all point clouds together
+        transformed_sem_pcd_list = [copca.transform(pcd) for pcd in global_sem_pcd_list]
+
+
+        signs = np.sign(np.sum(transformed_sem_pcd_list[0], axis=0))
+        # Post-process to ensure consistent orientation of PCA components
+        for i, transformed_pcd in enumerate(transformed_sem_pcd_list):
+            # For each component (column), align sign based on the sum of values in the column
+            transformed_sem_pcd_list[i] = transformed_pcd * signs
+    else:
+        copca = PCA(n_components=3)
+        transformed_sem_pcd_list = [copca.fit_transform(pcd) for pcd in global_sem_pcd_list]
+        # Post-process to ensure consistent orientation of PCA components
+        for i, transformed_pcd in enumerate(transformed_sem_pcd_list):
+            signs = np.sign(np.sum(transformed_pcd, axis=0))
+            # For each component (column), align sign based on the sum of values in the column
+            transformed_sem_pcd_list[i] = transformed_pcd * signs
+
+
+
+    # Create a figure with subplots arranged in a grid (based on number of point clouds)
+    fig = plt.figure(figsize=(6 * num_pcds, 6))  # Adjust figure size based on the number of subplots
+    
+    # Loop over the point clouds
+    for idx, (sem_pcd_pca, global_pcd) in enumerate(zip(transformed_sem_pcd_list, global_pcd_list)):
+        ax = fig.add_subplot(1, num_pcds, idx + 1, projection='3d')
+
+        # Step 2: Normalize the PCA-transformed data to use as colors
+        for i in range(3):  # Iterate over each component (3 in total for RGB)
+            pca_mean = sem_pcd_pca[:, i].mean()
+            pca_std = sem_pcd_pca[:, i].std()
+            sem_pcd_pca[:, i] = (sem_pcd_pca[:, i] - pca_mean) / (pca_std * 5 + 1e-8)  # Normalize
+
+        global_pca_colors = np.clip(sem_pcd_pca + 0.5, 0, 1)  # Map to [0, 1] for RGB
+
+        # Scatter plot for this point cloud in the current subplot
+        ax.scatter(global_pcd[:, 0], global_pcd[:, 1], global_pcd[:, 2], 
+                   c=global_pca_colors, marker='o', s=50, alpha=1.0)
+
+        # Remove axes and background
+        ax.set_axis_off()
+        ax.set_facecolor((0, 0, 0, 0))
+
+        # Set axis limits for each subplot
+        ax.set_xlim(-0.5, 0.5)
+        ax.set_ylim(-0.5, 0.5)
+        ax.set_zlim(-0.5, 0.5)
+
+        # Set view angle
+        ax.view_init(-55, 102)
+
+    # Adjust spacing between subplots
+    plt.tight_layout()
+
+    return fig
+    
+
+    
+def unnormalize(x):
+    # x.shape : [H,W,3]
+    mean = np.array([0.485, 0.456, 0.406])
+    std = np.array([0.229, 0.224, 0.225])
+    return x * std + mean
+
+
+from custom_utils.housecat6d_dataset import HouseCat6DTrainingDataset
+trainset = HouseCat6DTrainingDataset(image_size=420, sample_num=1024,data_dir='/media/xyz/data1/HouseCat6D')
+
+vis = True
+device = "cuda"
+import matplotlib
+import open3d as o3d
+from pytorch3d.io import load_objs_as_meshes
+import trimesh
+matplotlib.use('TkAgg')
+
+#cat_list = ['bottle','box','can','cup','cutlery','remote','shoe','tube','teapot']
+cat_list = ['cup']
+
+
+sem_global_list = []  
+sem_global_pcd_list = []  
+
+# # load semantc feature and show
+# ########################################
+save_dir = 'Yung/yung_large_files/semantic_feature/test_notebook/8v'
+# #save_dir = './80views_textured_token'
+# if  True:
+#     for cat in cat_list:
+#     # # orriginal    
+#     #     with open(f'/mnt/4T/Yung/yung_large_files/semantic_feature/test_notebook/housecat_{cat}/raw/housecat1_train.txt', 'r') as f:
+#     #         instances = [line.strip() for line in f.readlines()]
+
+#     #     print(instances)
+#     # revised
+#     # instance try cup-grey_handle
+#         instances = ['cup-grey_handle']
+#         sem_global_list = []  
+#         sem_global_pcd_list = []  
+
+#         # Load the mean shape point cloud
+#         meanshape_path = f'Yung/yung_large_files/semantic_feature/test_notebook/saved_pcd/{cat}/mean_shape/mean_shape_pcd_1.txt'
+#         meanshape_pcd_np = np.loadtxt(meanshape_path)
+        
+#         meanshape_pcd_tensor = torch.from_numpy(meanshape_pcd_np)
+#         M = meanshape_pcd_tensor.shape[0]
+#         meanshape_points = meanshape_pcd_tensor.view(1, M, 3).float()
+#     #make sure map to cuda0    
+#         average_aggregated_features = torch.load(f'/mnt/4T/Yung/yung_large_files/semantic_feature/test_notebook/8v_key/sem_cat_pcd_untex/{cat}_dino_feature.pt', map_location={"cuda:1": "cuda:0"})
+#         sem_global_pcd_list.append(meanshape_points[0])
+#         sem_global_list.append(average_aggregated_features[0].detach().cpu())
+#         #fig =plot_pointclouds_3d_with_pca(average_aggregated_features[0].detach().cpu(),meanshape_points[0])
+#         #fig.savefig('test.png')
+#         for j,instance in enumerate(instances):
+#             #break
+#             print("Processing", instance)
+#             #obj_path = f'/media/xyz/data/HouseCat6D/obj_models_small_size_final/{cat}/{instance}.obj'
+#             #instance_pcd_tensor = torch.load(f'{save_dir}/saved_pcd_untex/{cat}/{instance}_pcd.pt')[0]
+#             #obj_path = f'/media/xyz/data1/HouseCat6D/obj_models_small_size_final/{cat}/{instance}.obj'
+#             # instance_pcd_path = f'Yung/yung_large_files/semantic_feature/test_notebook/saved_pcd/{cat}/test/{instance}.txt'
+#             # instance_pcd_np = np.loadtxt(instance_pcd_path)
+#             instance_pcd_path = f'Yung/yung_large_files/pose_can_results/housecat6d_sonata_feature/scene01/000000/cup-grey_handle/input_pca.ply'
+#             pcd = o3d.io.read_point_cloud(instance_pcd_path)
+#             instance_pcd_np = np.asarray(pcd.points)
+            
+#             # Rotate 180 degrees around y axis
+#             rotation_matrix = np.array([
+#                 [-1, 0, 0],
+#                 [0, 1, 0],
+#                 [0, 0, -1]
+#             ])
+#             instance_pcd_np = instance_pcd_np @ rotation_matrix.T
+
+
+#             # Load the instance point cloud
+#             instance_pcd_tensor = torch.from_numpy(instance_pcd_np)
+#             N = instance_pcd_tensor.shape[0]
+#             instance_points = instance_pcd_tensor.view(1, N, 3).float()
+#             try:
+#                 # aggregated_features = torch.load(f'{save_dir}/saved_dino_pcd_untex/{cat}/{instance}_dino_feature.pt')
+#                 aggregated_features = average_aggregated_features
+#             except:
+#                 print(f"Warning: {instance} not found.")
+#                 continue
+#             # plot_pointclouds_3d_with_pca(aggregated_features[0].detach().cpu(),
+#             #                              instance_points[0])
+#             sem_global_pcd_list.append(instance_points[0].detach().cpu())
+#             sem_global_list.append(aggregated_features[0].detach().cpu())
+#             if len(sem_global_list)>4:
+#                 break
+        
+#         fig = plot_pointclouds_3d_with_copca(sem_global_list,sem_global_pcd_list,co_pca=True)
+#         fig.savefig(f'./{save_dir}/{cat}_sam3d.png')
+# ###############################
+
+
+model_dict={'small':'dinov2_vits14',
+            'base':'dinov2_vitb14',
+            'large':'dinov2_vitl14',
+            'giant':'dinov2_vitg14'}
+extractor = ViTExtractor(model_dict['small'],14)
+# use GPPU0
+extractor.model = extractor.model.cuda(0)  # the stride of first conv control outputs resolution
+
+# extractor = torch.hub.load('facebookresearch/dinov2', model_dict['small'], pretrained=True).cuda()
+
+
+# cat_list = ['bottle','box','can','cup','cutlery','glass','remote','shoe','tube','teapot']
+cat_list = ['cup']
+
+#cat_list = ['teapot']
+#TODO: if condition for tex rendering
+for cat in cat_list:
+    # # orriginal    
+    # with open(f'/mnt/4T/Yung/yung_large_files/semantic_feature/test_notebook/housecat_{cat}/raw/housecat1_train.txt', 'r') as f:
+    #     instances = [line.strip() for line in f.readlines()]
+
+        # print(instances)
+    #revised
+    # # instance try cup-grey_handle
+    # instances = ['cup-grey_handle']
+
+    # instance try cup-grey_handle
+    instances = ['cup-grey_handle']
+
+
+    aggregated_features_list = []  # N * [1, 1024, 384]
+    # Load the mean shape point cloud
+    meanshape_path = f'Yung/yung_large_files/semantic_feature/test_notebook/saved_pcd/{cat}/mean_shape/mean_shape_pcd_1.txt'
+    meanshape_pcd_np = np.loadtxt(meanshape_path)
+    meanshape_pcd_tensor = torch.from_numpy(meanshape_pcd_np)
+    M = meanshape_pcd_tensor.shape[0]
+# modify for cuda0
+    meanshape_points = meanshape_pcd_tensor.view(1, M, 3).float().cuda(0)
+
+
+    for j,instance in enumerate(instances):
+# #original
+#         # if instance != 'bottle-85_alcool':
+#         #     continue
+#         print("Processing", instance)
+#         obj_path = f'pose_dataset/HouseCat6D/obj_models_small_size_final/{cat}/{instance}.obj'
+#         instance_pcd_path = f'Yung/yung_large_files/semantic_feature/test_notebook/saved_pcd/{cat}/test/{instance}.txt'
+
+#         # Load the instance point cloud
+#         instance_pcd_np = np.loadtxt(instance_pcd_path)
+#         try:
+#             verts, faces, aux = load_obj(obj_path)
+#         except ValueError as e:
+#             print(f"Warning: {e}, attempting to load without material.")
+
+#             try:
+#                 verts, faces, aux = load_obj(obj_path, load_textures=True)
+#             except ValueError as e2:
+#                 print(f"Failed to load {obj_path} without material: {e2}")
+#                 continue
+#         meshes = Meshes(verts=[verts], faces=[faces.verts_idx], textures=None)
+
+#modify for sam3d
+        print("Processing", instance)
+        obj_path = f'/mnt/4T/Yung/pose_repo_temp/sam-3d-objects/notebook/gaussians/single/housecat6d_relight/000000_relight_msr_000000_cup-grey_handle.ply'
+        instance_pcd_path = obj_path
+        pcd = o3d.io.read_point_cloud(instance_pcd_path)
+        instance_pcd_np = np.asarray(pcd.points)
+        instance_pcd_tensor = torch.from_numpy(instance_pcd_np)
+        N = instance_pcd_tensor.shape[0]
+# modify for cuda0
+        instance_points = instance_pcd_tensor.view(1, N, 3).float().cuda(0)
+
+        try:
+            pcd = o3d.io.read_point_cloud(obj_path)
+            pcd.estimate_normals(
+            search_param=o3d.geometry.KDTreeSearchParamHybrid(
+                radius=0.02,
+                max_nn=30
+            )
+            )
+
+            # Poisson
+            mesh, densities = o3d.geometry.TriangleMesh.create_from_point_cloud_poisson(
+            pcd, depth=8
+            )
+
+            # Density trimming
+            densities = np.asarray(densities)
+            mesh = mesh.select_by_index(
+            np.where(densities > np.quantile(densities, 0.05))[0]
+            )
+
+            # Keep largest component
+            clusters, counts, _ = mesh.cluster_connected_triangles()
+            clusters = np.asarray(clusters)
+            counts = np.asarray(counts)
+            mesh.remove_triangles_by_mask(clusters != counts.argmax())
+            mesh.remove_unreferenced_vertices()
+
+            verts = np.asarray(mesh.vertices)
+            faces = np.asarray(mesh.triangles)
+            print(f"Loaded PLY with {verts.shape[0]} vertices and {faces.shape[0]} faces.")
+
+            # Extract texture colors from point cloud
+            tex = None
+            if pcd.has_colors():
+                print("Point cloud has colors, extracting texture.")
+                colors = np.asarray(pcd.colors)
+            # Map point cloud colors to mesh vertices using nearest neighbor
+            pcd_tree = o3d.geometry.KDTreeFlann(pcd)
+            vertex_colors = np.zeros((verts.shape[0], 3))
+            for i, vert in enumerate(verts):
+                _, idx, _ = pcd_tree.search_knn_vector_3d(vert, 1)
+                vertex_colors[i] = colors[idx[0]]
+            tex = torch.from_numpy(vertex_colors).float().to(device=device)
+            
+        except Exception as e:
+            print(f"Warning: Failed to load PLY: {e}")
+            continue
+
+        # Initialise the mesh with textures
+        verts = torch.from_numpy(verts).float()
+        verts = normalize_mesh_verts(verts)
+
+        if isinstance(faces, np.ndarray):
+            faces = torch.from_numpy(faces)
+
+        faces = faces.to(device=device, dtype=torch.int64)
+        verts = verts.to(device=device, dtype=torch.float32)
+        # Ensure shape is (1, V, 3)
+        if tex.dim() == 2:
+            tex = tex.unsqueeze(0)
+
+        tex = TexturesVertex(verts_features=tex)
+
+        meshes = Meshes(verts=[verts], faces=[faces], textures=None)
+
+
+        if meshes.textures is None:
+            meshes.textures = TexturesVertex(
+                verts_features=torch.ones_like(meshes.verts_padded(), device=device)
+            ) 
+        
+        # Also save as OBJ format to preserve texture information
+        o3d.io.write_triangle_mesh(f'{save_dir}/mesh_{instance}.obj', mesh)
+
+        # render the mesh with 8 views, scale means the distance from the object to the camera
+        image_size=(420,420)
+        #images,fragments,cameras = render_batch(meshes,image_size=image_size,scale=1.0)
+        images,fragments,cameras = render(meshes,image_size=image_size,scale=2.0)
+
+        os.makedirs(f'{save_dir}/{cat}_rgb_dino_untex-try', exist_ok=True)
+        rgb = images.cpu().numpy()[:, :, :, :3]
+        image_grid(rgb, rows=1, cols=8, rgb=True)
+        plt.savefig(f'{save_dir}/{cat}_rgb_dino_untex-try/{instance}_rendering-sam3d.png')
+        plt.close()
+
+        # get the feature point cloud
+        feature_point_cloud, dino_feat_masked, feature_point_cloud_list = fuse_feature_rgbd(extractor,images,fragments,cameras)
+
+        # get the downsampled aggregated feature point cloud
+        num_pts= 1024
+        nn_num= 100 # larger nn_num will make the feature more smooth
+        sampled_points,aggregated_features = downsample_with_knn_feature_aggregation(feature_point_cloud,num_pts,nn_num)
+
+        # #Needed
+        # index = np.random.choice(partial_feature_point_cloud.shape[0], 1024, replace=False)
+        # plot_pointclouds_3d_with_copca(average_aggregated_features.squeeze(0).detach().cpu().numpy(), 
+        #                                partial_feature_point_cloud[index,3:], 
+        #                                sampled_points.squeeze(0).detach().cpu().numpy(), 
+        #                                partial_feature_point_cloud[index,:3])
+        
+
+        q=0
+
+        if False:
+            q+=1
+            inputs = trainset[q]
+            rgb = inputs['rgb'][None].cuda()
+            pts = inputs['pts'][None]
+            choose = inputs['choose'][None]
+            model = inputs['model'][None].cuda()
+            rgb = inputs['rgb'][None].cuda()
+
+            _desc_q = extractor.forward_features(rgb)["x_prenorm"][:, :]
+            #_desc_q = extractor.extract_descriptors(rgb,layer=11,facet='token',include_cls=True).squeeze(1) # B,L,C
+            # _norm_q = torch.linalg.norm(_desc_q, dim=-1)[:, :, None]
+            # _desc_q = _desc_q / (_norm_q)
+
+            dino_feature = _desc_q[:,1:,:]
+
+
+            #dino_feature = self.rgb_extractor.forward_features(rgb)["x_prenorm"][:, 1:]
+            #rgb=self.rgb_extractor.preprocess_pil(rgb)
+            #dino_feature = self.rgb_extractor.extract_descriptors(rgb,layer=11,facet='key') # (1,900,384)
+            f_dim = dino_feature.shape[-1]
+            num_patches =int(dino_feature.shape[1]**0.5) # 1
+            b=1
+            dino_feature = dino_feature.reshape(b, num_patches, num_patches, f_dim).permute(0,3,1,2)
+            
+            dino_feature = F.interpolate(dino_feature, size=(num_patches * 14, num_patches * 14), mode='nearest') 
+            dino_feature_2d_vis = dino_feature.detach().cpu()[0] #384, 224,224
+
+            b, d = dino_feature.shape[0:2]
+            dino_feature = dino_feature.reshape(b,d,-1)
+            choose_2 = choose.unsqueeze(1).repeat(1, d, 1).cuda()
+            dino_feature = torch.gather(dino_feature,2,choose_2).contiguous() # b,d,n
+            
+            #dino_feature = dino_feature / torch.std(dino_feature, dim=1, keepdim=True)
+            #dino_feature = torch.norm(dino_feature, dim=1, keepdim=True)
+            #choose_dino = choose.unsqueeze(1).repeat(1, d, 1Z
+            #sem_model = sem_model / torch.std(sem_model, dim=-1, keepdim=True)
+            #visual_global_sem_high = sem_model.detach().cpu().numpy()[0] #1024,384
+            visual_partial_sem_high = dino_feature.permute(0,2,1).detach().cpu().numpy()[0] #1024,128
+
+            #visual_global_sem_low = self.feature_mlp(sem_model.permute(0,2,1)).permute(0,2,1).detach().cpu().numpy()[0]
+            #visual_partial_sem_low = rgb_local.permute(0,2,1).detach().cpu().numpy()[0]
+            # transform the pts with GT 9D Pose into object coordinate
+            translation_gt = inputs['translation_label'][None]
+            rotation_gt = inputs['rotation_label'][None]
+            size_gt = inputs['size_label'][None]
+            pts_obj_frame = (inputs['pts'] - translation_gt.unsqueeze(1)) / (torch.norm(size_gt, dim=1).view(b, 1, 1) + 1e-8) @ rotation_gt
+            #kpt_obj_frame = (kpt_3d - translation_gt.unsqueeze(1)) / (torch.norm(size_gt, dim=1).view(b, 1, 1) + 1e-8) @ rotation_gt
+            
+            # dino_feature_2d_vis_pca = vis_pca_pixelwise(dino_feature_2d_vis[None])[0]
+            # plt.imshow(dino_feature_2d_vis_pca[:,:,:3])
+            # plt.show()
+            # fig =plt.figure()
+            # rgb_unnorm = unnormalize(rgb[0].permute(1,2,0).detach().cpu())
+            # plt.imshow(rgb_unnorm)
+            # plt.show()
+            # image_mask = ((rgb_unnorm.clone().sum(axis=2) >0.1)*1.0)[None,None] # 224,224
+                
+            # rgb_mask = np.array(image_mask[0,0,:,:,None]).repeat(384, axis=2).transpose(2,0,1)
+
+            # dino_feature_2d_vis[rgb_mask==0] = 0
+            # masked_dino_feature_2d_vis_pca = vis_pca_pixelwise(dino_feature_2d_vis[None])[0]
+            # plt.imshow(masked_dino_feature_2d_vis_pca[:,:,:])
+            # plt.show()
+
+
+            # print('self.pca.cateagg-partial')
+            # index = np.random.choice(partial_feature_point_cloud.shape[0], 1024, replace=False)
+            # #average_aggregated_features = torch.load(f'sem_cat_pcd/{cat}_dino_feature.pt')
+            
+            average_aggregated_features = torch.load(f'/home/xyz/anything6d_project/Sem-GCE-AG-Pose/sem_cat_pcd/{cat}_dino_feature.pt')
+            # #plot_pointclouds_3d_with_copca(aggregated_features.squeeze(0).detach().cpu().numpy(), partial_feature_point_cloud[index,3:], sampled_points.squeeze(0).detach().cpu().numpy(), pts_obj_frame)
+           
+            plot_pointclouds_3d_with_copca_old(average_aggregated_features.squeeze(0).detach().cpu().numpy(),
+                                               visual_partial_sem_high,
+                                               sampled_points.squeeze(0).detach().cpu().numpy(),
+                                              pts_obj_frame[0].detach().cpu().numpy())
+            plt.show()
+
+
+            # plot_pointclouds_3d_with_copca(average_aggregated_features.squeeze(0).detach().cpu().numpy(),
+            #                                 visual_partial_sem_high,
+            #                                sampled_points.squeeze(0).detach().cpu().numpy(),
+            #                                 pts_obj_frame[0].detach().cpu().numpy())
+            
+            
+            # #query_points =np.random.choice(1024, 3)
+            # query_points, sampled_indices = sample_farthest_points(pts_obj_frame, K=4)  # Shape: (1, 1024, 3), (1, 1024)
+            # plot_pointclouds_with_color_mapping(visual_partial_sem_high, 
+            #                                     aggregated_features.squeeze(0).detach().cpu().numpy(),
+            #                                     pts_obj_frame[0].detach().cpu().numpy(),
+            #                                     model[0].detach().cpu().numpy(),
+            #                                     sampled_indices[0], similarity_threshold=None)
+
+
+            # # plot_pointclouds_3d_with_copca(average_aggregated_features.squeeze(0).detach().cpu().numpy(), partial_feature_point_cloud[index,3:], sampled_points.squeeze(0).detach().cpu().numpy(), partial_feature_point_cloud[index,:3])
+            # # plot_pointclouds_3d_with_pca(average_aggregated_features.squeeze(0).detach().cpu().numpy(), partial_feature_point_cloud[index,3:], sampled_points.squeeze(0).detach().cpu().numpy(), partial_feature_point_cloud[index,:3])
+            # partial_feature_point_cloud = feature_point_cloud_list[5]
+            # plot_pointclouds_3d_with_copca(visual_partial_sem_high, 
+            #                             partial_feature_point_cloud[index,3:], 
+            #                             pts_obj_frame[0].detach().cpu().numpy(), 
+            #                             partial_feature_point_cloud[index,:3])
+        
+        # plot_pointclouds_3d_with_copca(average_aggregated_features.squeeze(0).detach().cpu().numpy(), aggregated_features.squeeze(0).detach().cpu().numpy(), sampled_points.squeeze(0).detach().cpu().numpy(), sampled_points.squeeze(0).detach().cpu().numpy())
+
+
+
+        os.makedirs(f'{save_dir}/saved_dino_pcd_untex-try/{cat}', exist_ok=True)
+        torch.save(aggregated_features, f'{save_dir}/saved_dino_pcd_untex-try/{cat}/{instance}_dino_feature-notexture_sam3d.pt')
+
+        os.makedirs(f'{save_dir}/saved_pcd_untex-try/{cat}', exist_ok=True)
+        torch.save(sampled_points, f'{save_dir}/saved_pcd_untex-try/{cat}/{instance}_pcd-notexture_sam3d.pt')
+        
+        aggregated_features_list.append(aggregated_features)
+        # #break
+        vis_dino = vis_pca_pixelwise(np.array(dino_feat_masked))
+        vis_img = np.clip(vis_dino[:,:,:,:],a_min=0,a_max=1)
+        image_grid(vis_img, rows=1, cols=8, rgb=True)
+
+        os.makedirs(f'{save_dir}/{cat}_rgb_dino_untex-try', exist_ok=True)
+        plt.savefig(f'{save_dir}/{cat}_rgb_dino_untex-try/{instance}_dino-notexture_sam3d.png')
+        plt.close()
+        if False:
+
+            rgb = images.cpu().numpy()[:, :, :, :3]
+            mask = images[:, ..., 3].cpu().numpy()!=0
+            depth_image = fragments[:, ..., 0].cpu().numpy()*mask
+            image_grid(rgb, rows=1, cols=8, rgb=True)
+            # os.makedirs(f'/home/tulrfpf/code/PointFlowRenderer/{cat}_rgb_dino', exist_ok=True)
+            # plt.savefig(f'/home/tulrfpf/code/PointFlowRenderer/{cat}_rgb_dino/{instance}_rgb.png')
+            # image_grid(depth_image[...,None], rows=2, cols=4, rgb=True)
+            # image_grid(mask[...,None], rows=2, cols=4, rgb=True)
+
+
+
+            fig = plt.figure(figsize=(10, 10))
+            ax = fig.add_subplot(111, projection="3d")
+            #ax.scatter(sampled_points[:, 2], sampled_points[:,0], sampled_points[:, 1], c="b")
+            pca_color =vis_pca(feature_point_cloud[:, 3:])
+            ax.scatter(feature_point_cloud[:, 2], feature_point_cloud[:, 0], feature_point_cloud[:, 1], c=pca_color,s=0.1)
+            #create_camera_geometry_batch(ax=ax,R_batch=R,T_batch=T,order=(2,0,1))
+            ax.set_xlabel("z")
+            ax.set_ylabel("x")
+            ax.set_zlabel("y")
+            ax.set_xlim(-2, 2)
+            ax.set_ylim(-2, 2)
+            ax.set_zlim(-2, 2)
+            plt.title("Sampled Dense Points from Mesh")
+            plt.show()
+
+            fig = plt.figure(figsize=(10, 10))
+            ax = fig.add_subplot(111, projection="3d")
+            pca_color =vis_pca(aggregated_features.squeeze(0))
+            sampled_points= sampled_points.squeeze(0).cpu().detach().numpy()
+            ax.scatter(sampled_points[:, 2], sampled_points[:, 0], sampled_points[:, 1], c=pca_color,s=50)
+            #create_camera_geometry_batch(ax=ax,R_batch=R,T_batch=T,order=(2,0,1))
+            ax.set_xlabel("z")
+            ax.set_ylabel("x")
+            ax.set_zlabel("y")
+            ax.set_xlim(-2, 2)
+            ax.set_ylim(-2, 2)
+            ax.set_zlim(-2, 2)
+            plt.title("Sampled Sparse Points from Mesh")
+            plt.show()
+            #break
+    # Assign the aggregated features to the mean shape point cloud
+    aggregated_features_tensor = torch.cat(aggregated_features_list, dim=0)  #[N, 1024, 384]
+    average_aggregated_features = aggregated_features_tensor.mean(dim=0, keepdim=True)
+    print("Average Aggregated Features Shape:", average_aggregated_features.shape)  # Should be (1, 1024, 384)
+
+    os.makedirs(f'{save_dir}/sem_cat_pcd_untex-try', exist_ok=True)
+    torch.save(average_aggregated_features, f'{save_dir}/sem_cat_pcd_untex-try/{cat}_dino_feature.pt')
+
+# fig = plt.figure(figsize=(10, 10))
+# ax = fig.add_subplot(111, projection="3d")
+# pca_color =vis_pca(average_aggregated_features.squeeze(0))
+# # sampled_points= sampled_points.squeeze(0).cpu().detach().numpy()
+# meanshape_points = meanshape_points.squeeze(0).cpu().detach().numpy()
+# ax.scatter(meanshape_points[:, 2], meanshape_points[:, 0], meanshape_points[:, 1], c=pca_color,s=10.0, marker='o')
+# ax.set_xlabel("z")
+# ax.set_ylabel("x")
+# ax.set_zlabel("y")
+# ax.set_xlim(-2, 2)
+# ax.set_ylim(-2, 2)
+# ax.set_zlim(-2, 2)
+# plt.title("Shape Prior Dino")
+# plt.show()
+    

feature_alignment.py

@@ -0,0 +1,187 @@
+import numpy as np
+import open3d as o3d
+import os
+import copy
+import trimesh
+import torch
+from sklearn.decomposition import PCA
+
+def align_point_clouds(pcd1_path, pcd2_path, geometric_features1_path, geometric_features2_path, 
+                       semantic_features1_path, semantic_features2_path, distance_threshold=0.05, output_path="aligned_combined.ply"):
+    # # Load point clouds
+    # pcd1 = o3d.io.read_point_cloud(pcd1_path)
+    # pcd2 = o3d.io.read_point_cloud(pcd2_path)
+
+    # Load point clouds
+    pcd1 = torch.load(pcd1_path, map_location="cpu")
+    
+    # Rotate pcd1 90 degrees along x axis
+    rotation_x = torch.tensor([
+        [1, 0, 0],
+        [0, 0, -1],
+        [0, 1, 0]
+    ], dtype=pcd1.dtype)
+    
+    rotation_z = torch.tensor([
+        [0, -1, 0],
+        [1, 0, 0],
+        [0, 0, 1]
+    ], dtype=pcd1.dtype)
+    
+    
+    pcd1 = torch.matmul(pcd1, rotation_x.T)
+    pcd1 = torch.matmul(pcd1, rotation_z.T)
+    pcd2 = torch.load(pcd2_path, map_location="cpu")
+    
+    # Convert to Open3D point clouds
+    # pcd is a torch.Tensor
+    pcd_np1 = pcd1.detach().cpu().numpy().astype(np.float64)
+    pcd1 = o3d.geometry.PointCloud()
+    pcd1.points = o3d.utility.Vector3dVector(pcd_np1.reshape(-1, 3))
+    pcd_np2 = pcd2.detach().cpu().numpy().astype(np.float64)
+    pcd2 = o3d.geometry.PointCloud()
+    pcd2.points = o3d.utility.Vector3dVector(pcd_np2.reshape(-1, 3))
+
+    # Load geometric features
+    geometric_features1 = np.load(geometric_features1_path)
+    geometric_features2 = np.load(geometric_features2_path)
+    
+    # Load semantic features
+    semantic_features1 = torch.load(semantic_features1_path, map_location="cpu").numpy().reshape(1024, 384)
+    semantic_features2 = torch.load(semantic_features2_path, map_location="cpu").numpy().reshape(1024, 384)
+    
+    # Concatenate geometric and semantic features
+    print(f"geometric_features1 shape: {geometric_features1.shape}")
+    print(f"semantic_features1 shape: {semantic_features1.shape}")
+    
+    # combined_features1 = np.concatenate([geometric_features1, semantic_features1], axis=1)
+    # combined_features2 = np.concatenate([geometric_features2, semantic_features2], axis=1)
+    combined_features1 = semantic_features1
+    combined_features2 = semantic_features2
+
+    # save original combined
+    original_pcd = pcd1 + pcd2
+    os.makedirs(output_path, exist_ok=True)
+    o3d.io.write_point_cloud(f"{output_path}/original.ply", original_pcd)
+
+    # save a separated view so pcd1 and pcd2 are in the same file but easily distinguishable
+    bbox1 = np.asarray(pcd1.get_max_bound()) - np.asarray(pcd1.get_min_bound())
+    bbox2 = np.asarray(pcd2.get_max_bound()) - np.asarray(pcd2.get_min_bound())
+    max_extent = max(np.max(bbox1), np.max(bbox2), 1e-6)
+    offset = max_extent * 1.5
+    p1 = copy.deepcopy(pcd1)
+    p2 = copy.deepcopy(pcd2)
+    p1.translate([-offset / 2, 0, 0])
+    p2.translate([ offset / 2, 0, 0])
+    separated_pcd = p1 + p2
+    o3d.io.write_point_cloud(f"{output_path}/original_separate.ply", separated_pcd)
+
+    print(f"pcd1 points shape: {np.asarray(pcd1.points).shape}")
+    print(f"pcd2 points shape: {np.asarray(pcd2.points).shape}")
+    print(f"combined_features1 shape: {combined_features1.shape}")
+    print(f"combined_features2 shape: {combined_features2.shape}")
+    
+    # Convert combined features to Open3D format
+    f1 = o3d.pipelines.registration.Feature()
+    f1.data = combined_features1.T
+    f2 = o3d.pipelines.registration.Feature()
+    f2.data = combined_features2.T
+
+    # RANSAC-based initial alignment
+    result_ransac = o3d.pipelines.registration.registration_ransac_based_on_feature_matching(
+        pcd1, pcd2, f1, f2, True, distance_threshold,
+        o3d.pipelines.registration.TransformationEstimationPointToPoint(False), 4,
+        [o3d.pipelines.registration.CorrespondenceCheckerBasedOnEdgeLength(0.9),
+         o3d.pipelines.registration.CorrespondenceCheckerBasedOnDistance(distance_threshold)],
+        o3d.pipelines.registration.RANSACConvergenceCriteria(4000000, 500)
+    )
+
+    # ICP refinement
+    result_icp = o3d.pipelines.registration.registration_icp(
+        pcd1, pcd2, distance_threshold, result_ransac.transformation,
+        o3d.pipelines.registration.TransformationEstimationPointToPoint()
+    )
+    # Transform and visualize
+    pcd1.transform(result_icp.transformation)
+
+    # Save aligned point clouds separated for easy comparison
+    bbox1 = np.asarray(pcd1.get_max_bound()) - np.asarray(pcd1.get_min_bound())
+    bbox2 = np.asarray(pcd2.get_max_bound()) - np.asarray(pcd2.get_min_bound())
+    max_extent = max(np.max(bbox1), np.max(bbox2), 1e-6)
+    offset = max_extent * 1.5
+    p1 = copy.deepcopy(pcd1)
+    p2 = copy.deepcopy(pcd2)
+    p1.translate([-offset / 2, 0, 0])
+    p2.translate([ offset / 2, 0, 0])
+    
+    # Apply PCA to combined features separately for RGB coloring
+    pca1 = PCA(n_components=3)
+    pca_features1 = pca1.fit_transform(combined_features1)
+    
+    pca2 = PCA(n_components=3)
+    pca_features2 = pca2.fit_transform(combined_features2)
+    
+    # Normalize to [0, 1] range for RGB
+    pca_features1_normalized = (pca_features1 - pca_features1.min(axis=0)) / (pca_features1.max(axis=0) - pca_features1.min(axis=0) + 1e-6)
+    pca_features2_normalized = (pca_features2 - pca_features2.min(axis=0)) / (pca_features2.max(axis=0) - pca_features2.min(axis=0) + 1e-6)
+    
+    p1.colors = o3d.utility.Vector3dVector(pca_features1_normalized)
+    p2.colors = o3d.utility.Vector3dVector(pca_features2_normalized)
+    
+    transformed_separate = p1 + p2
+    o3d.io.write_point_cloud(f"{output_path}/transformed_separate.ply", transformed_separate)
+
+    return result_icp.transformation
+
+# Example usage:
+# align_point_clouds("path_to_pcd1.ply", "path_to_pcd2.ply", "path_to_features1.npy", "path_to_features2.npy", output_path="aligned_combined.ply")
+transformation = align_point_clouds(
+    f"/mnt/4T/Yung/yung_large_files/semantic_feature/test_notebook/8v/saved_pcd_untex-try/cup/cup-grey_handle_pcd-texture_amodal.pt",
+    f"/mnt/4T/Yung/yung_large_files/semantic_feature/test_notebook/8v/saved_pcd_untex-try/cup/cup-grey_handle_pcd-texture.pt",
+    f"yung_large_files/pose_can_results/housecat6d_sonata_feature/scene01/000000/cup-grey_handle/input_features.npy",
+    f"yung_large_files/pose_can_results/housecat6d_sonata_feature/scene01/000000/cup-grey_handle/normalized_groundtruth_features.npy",
+    f"/mnt/4T/Yung/yung_large_files/semantic_feature/test_notebook/8v/saved_dino_pcd_untex-try/cup/cup-grey_handle_dino_feature-texture_amodal.pt",
+    f"/mnt/4T/Yung/yung_large_files/semantic_feature/test_notebook/8v/saved_dino_pcd_untex-try/cup/cup-grey_handle_dino_feature-texture.pt",
+    output_path=f"yung_large_files/pose_can_results/housecat6d_sonata_feature/scene01/000000/cup-grey_handle/semantic_feature-texture"
+)
+# meshfile_name = f"yung_large_files/pose_can_results/output_orientation_Matters/Amodal3r_HouseCat6D_test/scene01/000000/cup-grey_handle/mesh.glb"
+# mesh = trimesh.load(meshfile_name, force='mesh')
+# mesh.apply_transform(transformation)
+# # Save the transformed mesh as GLB
+# transformed_mesh_path = os.path.join(os.path.dirname(meshfile_name), "mesh_transformed_w_semanticand_geometric_feature.glb")
+# # trimesh.export will include vertex colors if present
+# mesh.export(transformed_mesh_path)
+
+# # Visualization of features using PCA for color mapping
+# import matplotlib.pyplot as plt
+
+# # Load the feature file and point cloud
+# features = torch.load("/mnt/4T/Yung/yung_large_files/semantic_feature/test_notebook/8v/saved_dino_pcd_untex-try/cup/cup-grey_handle_dinov3_feature-texture.pt", map_location="cpu")
+# # pcd = o3d.io.read_point_cloud("/mnt/4T/Yung/yung_large_files/pose_can_results/output_orientation_Matters/Amodal3r_HouseCat6D_test/scene01/000000/cup-grey_handle/mesh_downsampled.ply")
+# pcd = torch.load("/mnt/4T/Yung/yung_large_files/semantic_feature/test_notebook/8v/saved_pcd_untex-try/cup/cup-grey_handle_pcd-texture.pt", map_location="cpu")
+
+# # pcd is a torch.Tensor
+# pcd_np = pcd.detach().cpu().numpy().astype(np.float64)
+# # pcd_np = np.asarray(pcd.points).astype(np.float64)
+
+# # Ensure shape is (N,3)
+# pcd_np = pcd_np.reshape(-1, 3)
+
+# print(features.shape)
+# # Convert features to numpy and reshape to 2D
+# features_np = features.detach().cpu().numpy().squeeze(0)
+# print(features_np.shape)
+
+# # Apply PCA to reduce features to 3 components for RGB coloring
+# pca = PCA(n_components=3)
+# pca_features = pca.fit_transform(features_np)
+
+# # Normalize to [0, 1] range for RGB
+# pca_features_normalized = (pca_features - pca_features.min(axis=0)) / (pca_features.max(axis=0) - pca_features.min(axis=0) + 1e-6)
+
+# # Create point cloud and apply PCA colors
+# pcd_o3d = o3d.geometry.PointCloud()
+# pcd_o3d.points = o3d.utility.Vector3dVector(pcd_np)
+# pcd_o3d.colors = o3d.utility.Vector3dVector(pca_features_normalized)
+# o3d.io.write_point_cloud("pcd_colored_new.ply", pcd_o3d)
+