import torch import torch.nn as nn from torch.nn import functional as F import open3d as o3d import trimesh import copy import time import cv2 import logging import numpy as np import pytorch3d from pytorch3d.io import load_objs_as_meshes, load_obj from pytorch3d.structures import Meshes from pytorch3d.vis.plotly_vis import AxisArgs, plot_batch_individually, plot_scene from pytorch3d.vis.texture_vis import texturesuv_image_matplotlib from pytorch3d.renderer import ( PerspectiveCameras, PointLights, RasterizationSettings, MeshRenderer, MeshRasterizer, SoftPhongShader, ) from transformers import AutoTokenizer, AutoImageProcessor, AutoModel from transformers import AutoProcessor, CLIPVisionModelWithProjection from transformers import CLIPProcessor, CLIPModel from sklearn.metrics.pairwise import cosine_similarity import ssl import os os.environ['CURL_CA_BUNDLE'] = '' ssl._create_default_https_context = ssl._create_unverified_context from pointnet2_utils import ( gather_operation, furthest_point_sample, ) class LayerNorm2d(nn.Module): def __init__(self, num_channels: int, eps: float = 1e-6) -> None: super().__init__() self.weight = nn.Parameter(torch.ones(num_channels)) self.bias = nn.Parameter(torch.zeros(num_channels)) self.eps = eps def forward(self, x: torch.Tensor) -> torch.Tensor: u = x.mean(1, keepdim=True) s = (x - u).pow(2).mean(1, keepdim=True) x = (x - u) / torch.sqrt(s + self.eps) x = self.weight[:, None, None] * x + self.bias[:, None, None] return x def interpolate_pos_embed(model, checkpoint_model): if 'pos_embed' in checkpoint_model: pos_embed_checkpoint = checkpoint_model['pos_embed'] embedding_size = pos_embed_checkpoint.shape[-1] num_patches = model.patch_embed.num_patches num_extra_tokens = model.pos_embed.shape[-2] - num_patches # height (== width) for the checkpoint position embedding orig_size = int((pos_embed_checkpoint.shape[-2] - num_extra_tokens) ** 0.5) # height (== width) for the new position embedding new_size = int(num_patches ** 0.5) # class_token and dist_token are kept unchanged if orig_size != new_size: print("Position interpolate from %dx%d to %dx%d" % (orig_size, orig_size, new_size, new_size)) extra_tokens = pos_embed_checkpoint[:, :num_extra_tokens] # only the position tokens are interpolated pos_tokens = pos_embed_checkpoint[:, num_extra_tokens:] pos_tokens = pos_tokens.reshape(-1, orig_size, orig_size, embedding_size).permute(0, 3, 1, 2) pos_tokens = torch.nn.functional.interpolate( pos_tokens, size=(new_size, new_size), mode='bicubic', align_corners=False) pos_tokens = pos_tokens.permute(0, 2, 3, 1).flatten(1, 2) new_pos_embed = torch.cat((extra_tokens, pos_tokens), dim=1) checkpoint_model['pos_embed'] = new_pos_embed def sample_pts_feats(pts, feats, npoint=2048, return_index=False): ''' pts: B*N*3 feats: B*N*C ''' sample_idx = furthest_point_sample(pts, npoint) pts = gather_operation(pts.transpose(1,2).contiguous(), sample_idx) pts = pts.transpose(1,2).contiguous() feats = gather_operation(feats.transpose(1,2).contiguous(), sample_idx) feats = feats.transpose(1,2).contiguous() if return_index: return pts, feats, sample_idx else: return pts, feats def get_chosen_pixel_feats(img, choose): shape = img.size() if len(shape) == 3: pass elif len(shape) == 4: B, C, H, W = shape img = img.reshape(B, C, H*W) else: assert False choose = choose.unsqueeze(1).repeat(1, C, 1) x = torch.gather(img, 2, choose).contiguous() return x.transpose(1,2).contiguous() def pairwise_distance( x: torch.Tensor, y: torch.Tensor, normalized: bool = False, channel_first: bool = False ) -> torch.Tensor: r"""Pairwise distance of two (batched) point clouds. Args: x (Tensor): (*, N, C) or (*, C, N) y (Tensor): (*, M, C) or (*, C, M) normalized (bool=False): if the points are normalized, we have "x2 + y2 = 1", so "d2 = 2 - 2xy". channel_first (bool=False): if True, the points shape is (*, C, N). Returns: dist: torch.Tensor (*, N, M) """ if channel_first: channel_dim = -2 xy = torch.matmul(x.transpose(-1, -2), y) # [(*, C, N) -> (*, N, C)] x (*, C, M) else: channel_dim = -1 xy = torch.matmul(x, y.transpose(-1, -2)) # (*, N, C) x [(*, M, C) -> (*, C, M)] if normalized: sq_distances = 2.0 - 2.0 * xy else: x2 = torch.sum(x ** 2, dim=channel_dim).unsqueeze(-1) # (*, N, C) or (*, C, N) -> (*, N) -> (*, N, 1) y2 = torch.sum(y ** 2, dim=channel_dim).unsqueeze(-2) # (*, M, C) or (*, C, M) -> (*, M) -> (*, 1, M) sq_distances = x2 - 2 * xy + y2 sq_distances = sq_distances.clamp(min=0.0) return sq_distances def compute_feature_similarity(feat1, feat2, type='cosine', temp=1.0, normalize_feat=True): r''' Args: feat1 (Tensor): (B, N, C) feat2 (Tensor): (B, M, C) Returns: atten_mat (Tensor): (B, N, M) ''' if normalize_feat: feat1 = F.normalize(feat1, p=2, dim=2) feat2 = F.normalize(feat2, p=2, dim=2) if type == 'cosine': atten_mat = feat1 @ feat2.transpose(1,2) elif type == 'L2': atten_mat = torch.sqrt(pairwise_distance(feat1, feat2)) else: assert False atten_mat = atten_mat / temp return atten_mat def compute_triangle_normals(pts): pts = pts.squeeze(0) A = pts[:, 1] - pts[:, 0] # (6000, 3) B = pts[:, 2] - pts[:, 0] # (6000, 3) N = torch.cross(A, B, dim=1) normal_magnitude = torch.norm(N, dim=1, keepdim=True) return normal_magnitude.unsqueeze(0) def aug_pose_noise(gt_r, gt_t, std_rots=[15, 10, 5, 1.25, 1], max_rot=45, sel_std_trans=[0.2, 0.2, 0.2], max_trans=0.8): B = gt_r.size(0) device = gt_r.device std_rot = np.random.choice(std_rots) angles = torch.normal(mean=0, std=std_rot, size=(B, 3)).to(device=device) angles = angles.clamp(min=-max_rot, max=max_rot) ones = gt_r.new(B, 1, 1).zero_() + 1 zeros = gt_r.new(B, 1, 1).zero_() a1 = angles[:,0].reshape(B, 1, 1) * np.pi / 180.0 a1 = torch.cat( [torch.cat([torch.cos(a1), -torch.sin(a1), zeros], dim=2), torch.cat([torch.sin(a1), torch.cos(a1), zeros], dim=2), torch.cat([zeros, zeros, ones], dim=2)], dim=1 ) a2 = angles[:,1].reshape(B, 1, 1) * np.pi / 180.0 a2 = torch.cat( [torch.cat([ones, zeros, zeros], dim=2), torch.cat([zeros, torch.cos(a2), -torch.sin(a2)], dim=2), torch.cat([zeros, torch.sin(a2), torch.cos(a2)], dim=2)], dim=1 ) a3 = angles[:,2].reshape(B, 1, 1) * np.pi / 180.0 a3 = torch.cat( [torch.cat([torch.cos(a3), zeros, torch.sin(a3)], dim=2), torch.cat([zeros, ones, zeros], dim=2), torch.cat([-torch.sin(a3), zeros, torch.cos(a3)], dim=2)], dim=1 ) rand_rot = a1 @ a2 @ a3 rand_trans = torch.normal( mean=torch.zeros([B, 3]).to(device), std=torch.tensor(sel_std_trans, device=device).view(1, 3), ) rand_trans = torch.clamp(rand_trans, min=-max_trans, max=max_trans) rand_rot = gt_r @ rand_rot rand_trans = gt_t + rand_trans rand_trans[:,2] = torch.clamp(rand_trans[:,2], min=1e-6) return rand_rot.detach(), rand_trans.detach() def compute_coarse_Rt( end_points, atten, pts1, pts2, depth, radius, mask, bbox, model_pts=None, n_proposal1=6000, n_proposal2=300, ): WSVD = WeightedProcrustes() B, N1, _ = pts1.size() N2 = pts2.size(1) device = pts1.device # compute soft assignment matrix pred_score = torch.softmax(atten, dim=2) * torch.softmax(atten, dim=1) pred_label1 = torch.max(pred_score[:,1:,:], dim=2)[1] pred_label2 = torch.max(pred_score[:,:,1:], dim=1)[1] weights1 = (pred_label1>0).float() weights2 = (pred_label2>0).float() pred_score = pred_score[:, 1:, 1:].contiguous() pred_score = pred_score * weights1.unsqueeze(2) * weights2.unsqueeze(1) pred_score = pred_score.reshape(B, N1*N2) ** 1.5 # sample pose hypothese cumsum_weights = torch.cumsum(pred_score, dim=1) cumsum_weights /= (cumsum_weights[:, -1].unsqueeze(1).contiguous()+1e-8) idx = torch.searchsorted(cumsum_weights, torch.rand(B, n_proposal1*3, device=device)) idx1, idx2 = idx.div(N2, rounding_mode='floor'), idx % N2 idx1 = torch.clamp(idx1, max=N1-1).unsqueeze(2).repeat(1,1,3) idx2 = torch.clamp(idx2, max=N2-1).unsqueeze(2).repeat(1,1,3) p1 = torch.gather(pts1, 1, idx1).reshape(B,n_proposal1,3,3).reshape(B*n_proposal1,3,3) p2 = torch.gather(pts2, 1, idx2).reshape(B,n_proposal1,3,3).reshape(B*n_proposal1,3,3) # # visualize the correspondences # rgb_img = end_points['rgb_ori'].cpu().numpy() # depth_img = end_points['depth'].cpu().numpy() * 1000 # intrinsic = end_points['K'].reshape(3,3) # rgb = o3d.geometry.Image((rgb_img).astype(np.uint8)) # depth = o3d.geometry.Image((depth_img).astype(np.uint16)) # rgbd = o3d.geometry.RGBDImage.create_from_color_and_depth(rgb, depth, depth_scale=1000.0) # width = rgb_img.shape[1] # height = rgb_img.shape[0] # cx = int(intrinsic[0,2]) # cy = int(intrinsic[1,2]) # fx = int(intrinsic[0,0]) # fy = int(intrinsic[1,1]) # intri = o3d.camera.PinholeCameraIntrinsic(width=width, height=height, fx=fx, fy=fy, cx=cx, cy=cy) # o3d_points = o3d.geometry.PointCloud.create_from_rgbd_image(rgbd, intrinsic=intri) # pcd1 = o3d.geometry.PointCloud() # o3d.visualization.draw_geometries([o3d_points]) # template_list = [ # [[1., 0., 0.,], [0., 1., 0.], [0., 0., 1.]], # identity # # [[-1., 0., 0.], [0., 1., 0.], [0., 0., 1.]], # mirror along x # # [[1., 0., 0.], [0., -1., 0.], [0., 0., 1.]], # mirror along y # # [[1., 0., 0.], [0., 1., 0.], [0., 0., -1.]], # mirror along z # [[1., 0., 0.], [0., 0., -1.], [0., 1., 0.]], # 90 around x # # [[1., 0., 0.], [0., 0., 1.], [0., -1., 0.]], # -90 around x # [[0., 0., -1.], [0., 1., 0.], [1., 0., 0.]], # 90 around y # # [[0., 0., 1.], [0., 1., 0.], [-1., 0., 0.]], # -90 around y # [[0., -1., 0.], [1., 0., 0.], [0., 0., 1.]], # 90 around z # # [[0., 1., 0.], [-1., 0., 0.], [0., 0., 1.]] # -90 around z # ] # template_tensor = torch.tensor(template_list, device='cuda') # template_tensor = template_tensor.unsqueeze(0).repeat(n_proposal1,1,1,1).reshape(-1,3,3) pred_rs, pred_ts = WSVD(p2, p1, None) pred_rs = pred_rs.reshape(B, n_proposal1, 3, 3) pred_ts = pred_ts.reshape(B, n_proposal1, 1, 3) p1 = p1.reshape(B, n_proposal1, 3, 3) p2 = p2.reshape(B, n_proposal1, 3, 3) # original dis from sam6d dis = torch.norm((p1 - pred_ts) @ pred_rs - p2, dim=3).mean(2) # add dis from normal vector # mesh = end_points['mesh'] # sample_pts = torch.tensor(trimesh.sample.sample_surface(mesh, 5000)[0], device = 'cuda',dtype=torch.float32) # breakpoint() # transformed_sample_pts = (pred_rs @ sample_pts.reshape(-1,3).T).T.reshape(-1,3) + pred_ts* (radius + 1e-6) # mesh_pts = (p1 - pred_ts) @ pred_rs # mesh_normal = compute_triangle_normals(mesh_pts) # obs_normal = compute_triangle_normals(p2) # eps=1e-6 # cos_sim = torch.sum(mesh_normal * obs_normal, dim=2).clamp(-1.0 + eps, 1.0 - eps) # angle =(cos_sim - cos_sim.min()) / (cos_sim.max() - cos_sim.min() + 1e-8) # shape (1, 6000) # dis_combien = (dis + angle)/2 ## customize dis mesh = end_points['mesh'] K = end_points['K'].reshape(3,3).to(dtype=torch.float64) # only project center of CAD model and make sure its depths is not overlimit center = torch.tensor(mesh.centroid, device = 'cuda') transformed_center = center.reshape(1,1,1,3) + pred_ts* (radius.reshape(-1, 1, 1) + 1e-6) Z = transformed_center[..., 2].clamp(min=1e-6) point_2d = (K @ transformed_center.squeeze().T ) point_2d[0] = (point_2d[0]/point_2d[2]).int() point_2d[1] = (point_2d[1]/point_2d[2] ).int() x = point_2d[0].int() y = point_2d[1].int() depth_center = torch.tensor(0.).repeat(n_proposal1).unsqueeze(0).cuda() for i in range(n_proposal1): try: depth_center[0,i] = depth[y[i].item(), x[i].item()] except IndexError: depth_center[0,i] = -1 depth_gap = Z.flatten() - depth_center.flatten() ## given that prediction center deoth should always be larger than gt depth # idx_depth = torch.where(depth_gap > 0)[0] # if len(idx_depth) == 0: # print('all hypothesis are not correct') # pred_R = torch.eye(3).unsqueeze(0).cuda() # pred_t = torch.zeros(1,3).cuda() # return pred_R,pred_t,None idx_dis = torch.topk(dis, n_proposal2, dim=1, largest=False)[1].sort()[0] # idx = torch.tensor(np.intersect1d(idx_dis.cpu().numpy(), idx_depth.cpu().numpy())).cuda() # if len(idx) == 0: # print('no good selection') # pred_R = torch.eye(3).unsqueeze(0).cuda() # pred_t = torch.zeros(1,3).cuda() # return pred_R,pred_t,None idx = idx_dis idx = idx.squeeze(0) pred_rs = torch.gather(pred_rs, 1, idx.reshape(B,idx.shape[0],1,1).repeat(1,1,3,3)) pred_ts = torch.gather(pred_ts, 1, idx.reshape(B,idx.shape[0],1,1).repeat(1,1,1,3)) p1 = torch.gather(p1, 1, idx.reshape(B,idx.shape[0],1,1).repeat(1,1,3,3)) p2 = torch.gather(p2, 1, idx.reshape(B,idx.shape[0],1,1).repeat(1,1,3,3)) # # # pose selection transformed_pts = (pts1.unsqueeze(1) - pred_ts) @ pred_rs transformed_pts = transformed_pts.reshape(B*idx.shape[0], -1, 3) if model_pts is None: model_pts = pts2 expand_model_pts = model_pts.unsqueeze(1).repeat(1,idx.shape[0],1,1).reshape(B*idx.shape[0], -1, 3) dis = torch.sqrt(pairwise_distance(transformed_pts, expand_model_pts)) dis = dis.min(2)[0].reshape(B, idx.shape[0], -1) scores = weights1.unsqueeze(1).sum(2) / ((dis * weights1.unsqueeze(1)).sum(2) +1e-8) # add pred-depth vs gt depth comparison score # cad_points = pts1.reshape(-1,3) # # pcd = o3d.geometry.PointCloud() # # pcd.points = o3d.utility.Vector3dVector(cad_points) # # o3d.visualization.draw_geometries([pcd]) # scene_pts = pred_ts * (cad_points.reshape(1,1,-1,3)) + pred_ts* (radius + 1e-6) # rgb_img = end_points['rgb_ori'].to(torch.uint8) # depth_img = end_points['depth']* 1000 # rgb = o3d.geometry.Image(rgb_img.cpu().numpy()) # depth = o3d.geometry.Image(depth_img.cpu().numpy()) # rgbd = o3d.geometry.RGBDImage.create_from_color_and_depth(rgb, depth, depth_scale=1000) # width = rgb_img.shape[1] # height = rgb_img.shape[0] # cx = int(K[0,2]) # cy = int(K[1,2]) # fx = int(K[0,0]) # fy = int(K[1,1]) # intri = o3d.camera.PinholeCameraIntrinsic(width=width, height=height, fx=fx, fy=fy, cx=cx, cy=cy) # o3d_points = o3d.geometry.PointCloud.create_from_rgbd_image(rgbd, intrinsic=intri) # scene_points = np.array(o3d_points.points) # cad_points = torch.tensor(trimesh.sample.volume_mesh(mesh, count=500), device='cuda') # cad_points_exp = cad_points.unsqueeze(0).unsqueeze(0) # pred_rs_exp = pred_rs.unsqueeze(2) # cad_points_trans = cad_points_exp.transpose(-1, -2) # cad_points = torch.matmul(pred_rs_exp.float(), cad_points_trans.float()) # cad_points = cad_points.squeeze(2).transpose(-1, -2) # cad_points += pred_ts * radius # cad_points[...,2] = cad_points[...,2] + 1e-6 # avoid divide by 0 # x = cad_points[..., 0] / cad_points[..., 2] # y = cad_points[..., 1] / cad_points[..., 2] # U = K[0, 0] * x + K[0, 2] # V = K[1, 1] * y + K[1, 2] # in_bound = (U >= 0) & (U < width) & (V >= 0) & (V < height) # cad_points_filtered = cad_points.clone() # cad_points_filtered[~in_bound] = np.nan # grid_size = 0.01 # x, y, z = scene_points[:, 0], scene_points[:, 1], scene_points[:, 2] # x_min, y_min = x.min(), y.min() # x_idx = ((x - x_min) / grid_size).astype(int) # y_idx = ((y - y_min) / grid_size).astype(int) # from collections import defaultdict # grid = defaultdict(list) # for xi, yi, zi in zip(x_idx, y_idx, z): # grid[(xi, yi)].append(zi) # averaged_points = [] # for (xi, yi), z_vals in grid.items(): # x_center = x_min + (xi + 0.5) * grid_size # y_center = y_min + (yi + 0.5) * grid_size # z_min = np.min(z_vals) # averaged_points.append([x_center, y_center, z_min]) # averaged_points = np.array(averaged_points) # pcd = o3d.geometry.PointCloud() # pcd.points = o3d.utility.Vector3dVector(averaged_points) # pcd.paint_uniform_color([1, 0., 0.]) # pcd2 = o3d.geometry.PointCloud() # pcd2.points = o3d.utility.Vector3dVector(cad_points_filtered[0,0,:,:].cpu().numpy()) # pcd2.paint_uniform_color([0, 0.1, 1.]) # o3d.visualization.draw_geometries([pcd,pcd2,o3d_points]) # Step 1: Build the pillar lookup dictionary # x_min = averaged_points[:, 0].min() # y_min = averaged_points[:, 1].min() # pillar_dict = {} # for x, y, z in averaged_points: # xi = int((x - x_min) / grid_size) # yi = int((y - y_min) / grid_size) # pillar_dict[(xi, yi)] = z # qp_np = cad_points_filtered.squeeze(0).cpu().numpy() # # qp_np = cad_points.squeeze(0).cpu().numpy() # depth_diffs = np.full((qp_np.shape[0], qp_np.shape[1]), np.nan) # for i in range(qp_np.shape[0]): # for j in range(qp_np.shape[1]): # x, y, z = qp_np[i, j] # if np.isnan(x) or np.isnan(y) or np.isnan(z): # continue # xi = int((x - x_min) / grid_size) # yi = int((y - y_min) / grid_size) # key = (xi, yi) # if key in pillar_dict: # z_pillar = pillar_dict[key] # depth_diffs[i, j] = z - z_pillar # depth_diffs = torch.tensor(depth_diffs) # negative_mask = depth_diffs < 0 # neg_diffs_only = torch.where(negative_mask, depth_diffs, torch.zeros_like(depth_diffs)) # depth_scores = torch.abs(neg_diffs_only.sum(dim=1)) # depth_scores = depth_scores / (depth_scores.sum() + 1e-8) # depth_scores *= 1000 # points = torch.tensor(mesh.sample(1000, return_index=False), device='cuda') # obs_pts = pred_ts * (points.reshape(1,1,-1,3)) + pred_ts* (radius + 1e-6) # obs_depth = obs_pts[..., 2].clamp(min=1e-6) # obs_img_pts = (K.unsqueeze(0).repeat(len(idx), 1, 1) @ obs_pts.squeeze().permute(0, 2, 1) ).permute(0,2,1) # obs_img_pts[:,:,0] = (obs_img_pts[:,:,0]/obs_img_pts[:,:,0]).int() # obs_img_pts[:,:,1] = (obs_img_pts[:,:,1]/obs_img_pts[:,:,2] ).int() # x = point_2d[0].int() # y = point_2d[1].int() sorted_x, indices = torch.sort(scores,descending=True) idx = indices[0,0] # print('-----------------',idx,scores[0,idx]) pred_R = torch.gather(pred_rs, 1, idx.reshape(B,1,1,1).repeat(1,1,3,3)).squeeze(1) pred_t = torch.gather(pred_ts, 1, idx.reshape(B,1,1,1).repeat(1,1,1,3)).squeeze(2).squeeze(1) pose = np.eye(4) pose[:3,:3] = pred_R.cpu().numpy() pose[:3,3] = pred_t.cpu().numpy() * radius[0].cpu().numpy() mesh_o3d = o3d.geometry.TriangleMesh(o3d.utility.Vector3dVector(mesh.vertices), o3d.utility.Vector3iVector(mesh.faces)) pcd_obj = mesh_o3d.sample_points_uniformly(number_of_points=1000) pcd_obj_trans = copy.deepcopy(pcd_obj).transform(pose) pcd_obj_trans.paint_uniform_color([0.1, 0.1, 1]) if 0: scores = scores - depth_scores.cuda() sorted_x, indices = torch.sort(scores,descending=True) idx = indices[0,1] idx = torch.tensor(14) # print('-----------------',idx,scores[0,idx]) pred_R = torch.gather(pred_rs, 1, idx.reshape(B,1,1,1).repeat(1,1,3,3)).squeeze(1) pred_t = torch.gather(pred_ts, 1, idx.reshape(B,1,1,1).repeat(1,1,1,3)).squeeze(2).squeeze(1) pose = np.eye(4) pose[:3,:3] = pred_R.cpu().numpy() pose[:3,3] = pred_t.cpu().numpy() * radius[0].cpu().numpy() mesh_o3d = o3d.geometry.TriangleMesh(o3d.utility.Vector3dVector(mesh.vertices), o3d.utility.Vector3iVector(mesh.faces)) pcd_obj2 = mesh_o3d.sample_points_uniformly(number_of_points=1000) pcd_obj_trans2 = copy.deepcopy(pcd_obj2).transform(pose) pcd_obj_trans2.paint_uniform_color([1, 0.1, 0.1]) o3d.visualization.draw_geometries([pcd_obj_trans,pcd_obj_trans2,o3d_points]) breakpoint() #vis the center # sphere = o3d.geometry.TriangleMesh.create_sphere(radius=0.02) # sphere.translate() # sphere.paint_uniform_color([1, 0, 0]) # pcd2 = o3d.geometry.PointCloud() # pcd2.points = o3d.utility.Vector3dVector(qp_np[10]) # pcd2.paint_uniform_color([0.1, 0.1, 1]) # o3d.visualization.draw_geometries([pcd,pcd2,o3d_points]) # approach 2: try project cad points onto 2D img and compare with pillarized gt_depth if 0: grid_size = 5 depth_img = end_points['depth']* 1000 height, width = depth_img.shape H_trim = height - height % grid_size W_trim = width - width % grid_size depth_trimmed = depth_img[:H_trim, :W_trim] reshaped = depth_trimmed.reshape( H_trim // grid_size, grid_size, W_trim // grid_size, grid_size ) reshaped = reshaped.permute(0, 2, 1, 3) # min_pillars = reshaped.min(dim=3).values.min(dim=2).values n_y, n_x = reshaped.shape[:2] pillar_dict = {} for yi in range(n_y): for xi in range(n_x): block = reshaped[yi, xi] min_val = torch.min(block) pillar_dict[(xi, yi)] = min_val.item() # cad_points = torch.tensor(trimesh.sample.volume_mesh(mesh, count=1000), device='cuda') cad_points = torch.tensor(mesh.sample(1000), device='cuda') cad_points = torch.matmul( pred_rs.squeeze(0).float(), cad_points.T.float()) cad_points = cad_points.transpose(-1, -2) cad_points_trans = cad_points + pred_ts.squeeze(0) * radius cad_points_trans[...,2] = cad_points_trans[...,2] + 1e-6 # avoid divide by 0 x = cad_points_trans[..., 0] / cad_points_trans[..., 2] y = cad_points_trans[..., 1] / cad_points_trans[..., 2] U = K[0, 0] * x + K[0, 2] V = K[1, 1] * y + K[1, 2] depth_diffs = np.full((cad_points_trans.shape[0], cad_points_trans.shape[1]), np.nan) for i in range(U.shape[0]): for j in range(U.shape[1]): x,y = U[i,j], V[i,j] z = cad_points_trans[i,j, 2] xi = int(x/grid_size) yi = int(y/grid_size) key = (xi, yi) if key in pillar_dict: z_pillar = pillar_dict[key] depth_diffs[i, j] = z - z_pillar depth_diffs = torch.tensor(depth_diffs) negative_mask = depth_diffs < 0 neg_diffs_only = torch.where(negative_mask, depth_diffs, torch.zeros_like(depth_diffs)) depth_scores = torch.abs(neg_diffs_only.sum(dim=1)) depth_scores = depth_scores / (depth_scores.sum() + 1e-8) depth_scores *= 1000 scores = weights1.unsqueeze(1).sum(2) / ((dis * weights1.unsqueeze(1)).sum(2) +1e-8) scores = scores - (depth_scores).cuda() sorted_x, indices = torch.sort(scores,descending=True) idx = indices[0,0] # print('-----------------',idx,scores[0,idx]) pred_R = torch.gather(pred_rs, 1, idx.reshape(B,1,1,1).repeat(1,1,3,3)).squeeze(1) pred_t = torch.gather(pred_ts, 1, idx.reshape(B,1,1,1).repeat(1,1,1,3)).squeeze(2).squeeze(1) pose = np.eye(4) pose[:3,:3] = pred_R.cpu().numpy() pose[:3,3] = pred_t.cpu().numpy() * radius[0].cpu().numpy() mesh_o3d = o3d.geometry.TriangleMesh(o3d.utility.Vector3dVector(mesh.vertices), o3d.utility.Vector3iVector(mesh.faces)) pcd_obj2 = mesh_o3d.sample_points_uniformly(number_of_points=1000) pcd_obj_trans2 = copy.deepcopy(pcd_obj2).transform(pose) pcd_obj_trans2.paint_uniform_color([1, 0.1, 0.1]) # o3d.visualization.draw_geometries([pcd_obj_trans,pcd_obj_trans2,o3d_points]) # breakpoint() # pcd3 = o3d.geometry.PointCloud() # pcd3.points = o3d.utility.Vector3dVector(cad_points_trans[0].cpu().numpy()) # pcd3.paint_uniform_color([0.1, 0.1, 1]) # o3d.visualization.draw_geometries([pcd,pcd3,o3d_points]) # breakpoint() # p1 = torch.gather(p1, 1, idx.reshape(B,1,1,1).repeat(1,1,3,3)).squeeze(1) # p2 = torch.gather(p2, 1, idx.reshape(B,1,1,1).repeat(1,1,3,3)).squeeze(1) # p1 = (p1 - pred_t *(radius.reshape(-1, 1, 1) + 1e-6)) @ pred_R # points = p1.cpu().numpy().reshape(-1,3) # points = p2.cpu().numpy().reshape(-1,3) # p1 = p1.repeat(4,1,1).unsqueeze(0) # p2 = p2.repeat(4,1,1).unsqueeze(0) # pred_R_template = (pred_R @ template_tensor) # pcd = torch.tensor(mesh.sample(1000), device='cuda') # points_h = torch.hstack([pcd, torch.ones((pcd.shape[0], 1)).cuda()]) # pose = torch.eye(4).type(torch.float64).cuda() # pose[:3,:3] = pred_R[0] # pose[:3,3] = pred_t[0] # points_transformed_h = (pose @ points_h.cuda().T).T # points_transformed = points_transformed_h[:, :3] # mask = end_points['mask_ori']/255 # rgb_img = end_points['rgb_ori'] # depth_img = end_points['depth'] * 1000 # rgb_img = rgb_img * mask[:,:,None] # depth_img = depth_img * mask # rgb = o3d.geometry.Image(rgb_img.cpu().numpy()) # depth = o3d.geometry.Image(depth_img.cpu().numpy()) # rgbd = o3d.geometry.RGBDImage.create_from_color_and_depth(rgb, depth, depth_scale=1000) # width = rgb_img.shape[1] # height = rgb_img.shape[0] # cx = int(K[0,2]) # cy = int(K[1,2]) # fx = int(K[0,0]) # fy = int(K[1,1]) # intri = o3d.camera.PinholeCameraIntrinsic(width=width, height=height, fx=fx, fy=fy, cx=cx, cy=cy) # o3d_points = o3d.geometry.PointCloud.create_from_rgbd_image(rgbd, intrinsic=intri) # o3d_points.translate(-o3d_points.get_center()) # breakpoint() # o3d.visualization.draw_geometries([o3d_points]) # pred_t = pred_t.repeat(4, 1).reshape(1,-1,1,3) # p1 = (p1 - pred_t) @ pred_R # mesh_normal = compute_triangle_normals(p1) # obs_normal = compute_triangle_normals(p2) # cos_sim = torch.sum(mesh_normal * obs_normal, dim=2).clamp(-1.0 + eps, 1.0 - eps) # angle =(cos_sim - cos_sim.min()) / (cos_sim.max() - cos_sim.min() + 1e-8) # shape (1, 6000) # add rot error # device = 'cpu' # mesh = load_objs_as_meshes(['/workspace/cad_model/box_02/box_02.obj'], device=device) # meshes = mesh.extend(10) # fx, fy = K[0,0].item(), K[1,1].item() # cx, cy = K[0,2].item(), K[1,2].item() # h = 480 # w = 640 # image_size = torch.tensor([[480, 640]]) # RT = torch.eye(4) # RT[3,3] = 1 # RT[:3,:3] = pred_R.reshape(3,3) # RT[:3,3] = pred_t * (radius.reshape(-1, 1, 1) + 1e-6) # # transfom axis to pytorch3d format # Rz = torch.tensor([[-1,0, 0, 0], # [0, -1, 0, 0], # [0, 0, 1, 0], # [0, 0, 0, 1]]).float() # RT = torch.matmul(Rz, RT) # template_pose_rot = [ # torch.tensor([[[1., 0., 0.,], [0., 1., 0.], [0., 0., 1.]]], device = 'cuda'), # identity # torch.tensor([[[-1., 0., 0.], [0., 1., 0.], [0., 0., 1.]]], device = 'cuda'), # mirror along x # torch.tensor([[[1., 0., 0.], [0., -1., 0.], [0., 0., 1.]]], device = 'cuda'), # mirror along y # torch.tensor([[[1., 0., 0.], [0., 1., 0.], [0., 0., -1.]]], device = 'cuda'), # mirror along z # torch.tensor([[[1., 0., 0.], [0., 0., -1.], [0., 1., 0.]]], device = 'cuda'), # 90 around x # torch.tensor([[[1., 0., 0.], [0., 0., 1.], [0., -1., 0.]]], device = 'cuda'), # -90 around x # torch.tensor([[[0., 0., -1.], [0., 1., 0.], [1., 0., 0.]]], device = 'cuda'), # 90 around y # torch.tensor([[[0., 0., 1.], [0., 1., 0.], [-1., 0., 0.]]], device = 'cuda'), # -90 around y # torch.tensor([[[0., -1., 0.], [1., 0., 0.], [0., 0., 1.]]], device = 'cuda'), # 90 around z # torch.tensor([[[0., 1., 0.], [-1., 0., 0.], [0., 0., 1.]]], device = 'cuda') # -90 around z # ] # rot_tensor = torch.cat(template_pose_rot, dim=0) # shape (10,3,3) # base_rot = RT[:3, :3] # new_rot = base_rot.unsqueeze(0) @ rot_tensor.cpu() # RT_batch = RT.unsqueeze(0).repeat(10, 1, 1) # RT_batch[:, :3, :3] = new_rot # R = torch.transpose(RT_batch[:,:3, :3], 1, 2).reshape(-1, 3, 3).detach() # T = RT_batch[:,:3,3].reshape(-1,3).detach() # f = torch.tensor((fx, fy), dtype=torch.float32).unsqueeze(0) # p = torch.tensor((cx, cy), dtype=torch.float32).unsqueeze(0) # cameras = PerspectiveCameras( # R = R, # T = T, # focal_length=f, # principal_point=p, # image_size=image_size, # in_ndc=False, # device="cpu") # raster_settings = RasterizationSettings( # image_size=(h,w), # blur_radius=0.0, # faces_per_pixel=10, # ) # rasterizer = MeshRasterizer( # cameras=cameras, # raster_settings=raster_settings # ) # lights = PointLights(device=device, location=[[0.0, 0.0, -3.0]]) # renderer = MeshRenderer( # rasterizer=rasterizer, # shader=SoftPhongShader( # device=device, # cameras=cameras, # lights=lights # ) # ) # fragments = rasterizer(meshes) # # depths_render = fragments.zbuf.detach().cpu().numpy() # depths_render = fragments.zbuf[..., 0].detach().cpu().numpy() # images = np.array(renderer(meshes)) # images = images[:, ..., :3] # emb_list = [] # depth_emb_list = [] # y1, y2, x1, x2 = end_points['bbox'] # for i in range(images.shape[0]): # img = images[i] # img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR) # img = (img*255).astype(np.int32) # img = img[y1.int().item():y2.int().item(), x1.int().item():x2.int().item()] # depth_render = depths_render[i][y1.int().item():y2.int().item(), x1.int().item():x2.int().item()] # if len(depth_render.shape) != 3: # depth_render = np.expand_dims(depth_render, axis=-1) # depth_render = np.repeat(depth_render*1000, 3, axis=-1).astype(np.uint8) # depth_render_emb = compute_embedding(depth_render) # render_emb = compute_embedding(img) # emb_list.append(render_emb) # depth_emb_list.append(depth_render_emb) # rgb = end_points['rgb_ori'].cpu().numpy()[y1.int().item():y2.int().item(), x1.int().item():x2.int().item()] # depth_crop = depth.unsqueeze(-1).cpu().numpy()[y1.int().item():y2.int().item(), x1.int().item():x2.int().item()] # depth_crop = np.repeat(depth_crop*1000, 3, axis=-1).astype(np.uint8) # depth_emb = compute_embedding(depth_crop) # # get vit embedding of two images (rendering and observation) and compute cosine similarity # # rgb = np.concatenate([rgb, depth_crop], axis=-1) # rgb_emb = compute_embedding(rgb) # score_sim_rgb = [] # score_sim_depth = [] # for idx, emb in enumerate(emb_list): # similarity = cosine_similarity(emb.reshape(1,-1).cpu().numpy(), rgb_emb.reshape(1,-1).cpu().numpy())[0][0] # sim_depth = cosine_similarity(depth_emb_list[idx].reshape(1,-1).cpu().numpy(), depth_emb.reshape(1,-1).cpu().numpy())[0][0] # score_sim_rgb.append(similarity) # score_sim_depth.append(sim_depth) # # cv2.imwrite('a.png', images[0]) # final_score = [(a + b) / 2 for a, b in zip(score_sim_rgb, score_sim_depth)] # max_index = final_score.index(max(final_score)) # print('-------------->',max_index) # pred_R = pred_R @ template_pose_rot[max_index] # pred_R = pred_R[idx].unsqueeze(0) return pred_R, pred_t, _ # return pred_R, pred_t, transformed_center.reshape(6000,3).cpu().numpy() # return pred_R, pred_t, (pred_ts_filter* (radius.reshape(-1, 1, 1) + 1e-6)).cpu().numpy().reshape(-1,3) # return pred_R, pred_t, (pred_ts_out* (radius.reshape(-1, 1, 1) + 1e-6)).cpu().numpy().reshape(-1,3) # return pred_R, pred_t, (pred_ts_filter* (radius.reshape(-1, 1, 1) + 1e-6)).cpu().numpy().reshape(-1,3) # return pred_R.unsqueeze(0), pred_t.unsqueeze(0).unsqueeze(0), (pred_t* (radius.reshape(-1, 1, 1) + 1e-6)).cpu().numpy().reshape(-1,3) def compute_fine_Rt( atten, pts1, pts2, radius, end_points, model_pts=None, dis_thres=0.15 ): if model_pts is None: model_pts = pts2 # compute pose WSVD = WeightedProcrustes(weight_thresh=0.0) assginment_mat = torch.softmax(atten, dim=2) * torch.softmax(atten, dim=1) label1 = torch.max(assginment_mat[:,1:,:], dim=2)[1] label2 = torch.max(assginment_mat[:,:,1:], dim=1)[1] assginment_mat = assginment_mat[:, 1:, 1:] * (label1>0).float().unsqueeze(2) * (label2>0).float().unsqueeze(1) # max_idx = torch.max(assginment_mat, dim=2, keepdim=True)[1] # pred_pts = torch.gather(pts2, 1, max_idx.expand_as(pts1)) normalized_assginment_mat = assginment_mat / (assginment_mat.sum(2, keepdim=True) + 1e-6) pred_pts = normalized_assginment_mat @ pts2 assginment_score = assginment_mat.sum(2) pred_R, pred_t = WSVD(pred_pts, pts1, assginment_score) # breakpoint() # compute score pred_pts = (pts1 - pred_t.unsqueeze(1)) @ pred_R dis = torch.sqrt(pairwise_distance(pred_pts, model_pts)).min(2)[0] mask = (label1>0).float() pose_score = (dis < dis_thres).float() pose_score = (pose_score * mask).sum(1) / (mask.sum(1) + 1e-8) pose_score = pose_score * mask.mean(1) # add depth filter if 0: mesh = end_points['mesh'] K = end_points['K'].reshape(3,3).to(dtype=torch.float32) sample_pts = torch.tensor(trimesh.sample.sample_surface(mesh, 5000)[0], device = 'cuda',dtype=torch.float32) transformed_sample_pts = (pred_R @ sample_pts.reshape(-1,3).T).T.reshape(-1,3) + pred_t* (radius + 1e-6) Z = transformed_sample_pts[..., 2].clamp(min=1e-6) point_2d = (K @ transformed_sample_pts.reshape(-1,3).T ) point_2d[0] = (point_2d[0]/point_2d[2]).int() point_2d[1] = (point_2d[1]/point_2d[2] ).int() x = point_2d[0].int() y = point_2d[1].int() depth = end_points['depth'] depth_observation = torch.tensor(0.).repeat(5000).unsqueeze(0).cuda() for i in range(5000): try: depth_observation[0,i] = depth[y[i].item(), x[i].item()] except IndexError: depth_observation[0,i] = -1 depth_gap = Z- depth_observation count = (depth_gap > 0).sum().item() # # given that prediction center deoth should always be larger than gt depth if count < 2500: print('wrong pose from fine network') pred_R = torch.eye(3).unsqueeze(0).cuda() pred_t = torch.zeros(1,3).cuda() return pred_R, pred_t, pose_score, None # add pose refinement # mesh = end_points['mesh'] # vertices = torch.tensor(trimesh.bounds.corners(mesh.bounds), device = 'cuda', dtype=torch.float32) # K = end_points['K'].reshape(3,3) # transformed_vertices = ((pred_R @ vertices.T).squeeze().T) + (pred_t* (radius.reshape(-1, 1, 1) + 1e-6)) # edges_connection = [(0, 1), (0,3),(0,4), (1,5), (1,2), (2,6), (6,5),(5,1), (4,5), (6,7),(4,7),(3,7)] # Z_depth = transformed_vertices[..., 2].clamp(min=1e-6) # point_2d = (K @ transformed_vertices.squeeze().T ) # point_2d[0] = (point_2d[0]/point_2d[2]).int() # point_2d[1] = (point_2d[1]/point_2d[2] ).int() # x = point_2d[0].int().cpu().numpy() # y = point_2d[1].int().cpu().numpy() # depth = end_points['depth'].cpu().numpy() # rgb = end_points['rgb_ori'].cpu().numpy().squeeze() # # get convex hull of object # points = np.stack([x, y], axis=-1) # n_sample = 50 # edge_points = [] # pose_correct = True # vis = rgb.copy() # for start_idx, end_idx in edges_connection: # pt1 = tuple(points[start_idx]) # pt2 = tuple(points[end_idx]) # cv2.line(vis, pt1, pt2, color=(0, 255, 0), thickness=2) # cv2.imwrite('vis.png', vis) # transformed_vertices = transformed_vertices.detach().cpu().numpy() # for start_idx, end_idx in edges_connection: # edge = np.linspace(points[start_idx], points[end_idx], num=n_sample, dtype=int) # Z_gt = depth[edge[:,1], edge[:,0]] # Z_object = np.linspace(transformed_vertices[0,start_idx,2], transformed_vertices[0,end_idx,2], num=n_sample, dtype=np.float32) # X_object = np.linspace(transformed_vertices[0,start_idx,0], transformed_vertices[0,end_idx,0], num=n_sample, dtype=np.float32) # Y_object = np.linspace(transformed_vertices[0,start_idx,1], transformed_vertices[0,end_idx,1], num=n_sample, dtype=np.float32) # edge_points.append(np.stack([X_object, Y_object, Z_object], axis=-1)) # depth_gap = Z_gt - Z_object # depth_gap = np.round(depth_gap, decimals=3) # # skip if outside the image # if points[start_idx][0] not in range(0, rgb.shape[1]) or points[start_idx][1] not in range(0, rgb.shape[0]): # continue # if points[end_idx][0] not in range(0, rgb.shape[1]) or points[end_idx][1] not in range(0, rgb.shape[0]): # continue # # visualize the edge # vis = rgb.copy() # cv2.line(vis, tuple(points[start_idx]), tuple(points[end_idx]), (0, 0, 255) , 3) # cv2.imwrite('vis.png', vis) # # print(depth_gap) # if len(depth_gap[depth_gap < -0.02])>=int(0.5*n_sample): # # print('edge is occluded') # continue # not_occluded_depth = depth_gap[depth_gap >= -0.05] # # set a threshold for depth gap. if larger than 0.05 (5cm), pose is wrong # # print('num of hover points: ', len(not_occluded_depth[not_occluded_depth> 0.05])) # # if len(not_occluded_depth[not_occluded_depth> 0.05]) >= int(0.2*n_sample): # # print('-------------------> too much hover points!!!<------------------') # # pose_correct = False # # break # edge = edge[np.where(not_occluded_depth < 0.05)[0]] # #now check whether the projected edge is edge or not on the rgbd image. if not, pose is wrong # # gray = cv2.cvtColor(depth, cv2.COLOR_BGR2GRAY).astype(np.uint8) # edges = cv2.Canny((depth*1000).astype(np.uint8), threshold1=50, threshold2=150) # x1,y1 = edge[0] # x2,y2 = edge[-1] # edges_mask = np.zeros_like(depth) # # edges = np.stack((edges,)*3, axis=-1) # length_projected_edge =int( (abs(x2-x1)**2 + abs(y2-y1)**2)**0.5) # # cv2.line(edges_mask, tuple(points[i]), tuple(points[i+1]), (1, 1, 1) , 8) # masked_edges = edges * edges_mask # valid = np.sum( masked_edges/255)/length_projected_edge # print('valid:', valid) # if valid < 1: # print('edge is not edge on the rgbd image!!!') # pose_correct = False # print('pose is correct:',pose_correct) # edge_points = np.array(edge_points).reshape(-1,3) return pred_R, pred_t, pose_score, None def compute_embedding(image): if 1: # using CLIP clip_model = "openai/clip-vit-base-patch32" vision_model = CLIPVisionModelWithProjection.from_pretrained(clip_model) model = CLIPModel.from_pretrained ("openai/clip-vit-base-patch32") processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32") inputs = processor(images=[image], return_tensors="pt", padding=True) inputs = inputs.to('cpu') image_outputs = vision_model(**inputs) img_feats = image_outputs.image_embeds.view(1, -1) img_feats = img_feats / img_feats.norm(p=2, dim=-1, keepdim=True) return img_feats.detach() if 0: # using DINOv2 processor = AutoImageProcessor.from_pretrained('facebook/dinov2-small') model = AutoModel.from_pretrained('facebook/dinov2-small').to('cuda') with torch.no_grad(): inputs = processor(images= image, return_tensors = "pt").to('cuda') outputs = model(**inputs) embedding = outputs.last_hidden_state.mean(dim=1) return embedding def backproject_points(xy_points, depth_image,K): K_inv = np.linalg.inv(K) points_3d = [] for (u, v) in xy_points: u = int(round(u)) v = int(round(v)) z = depth_image[v, u] pixel_homog = np.array([u, v, 1.0]) pt_3d = z * (K_inv @ pixel_homog) points_3d.append(pt_3d) return np.array(points_3d) def weighted_procrustes( src_points, ref_points, weights=None, weight_thresh=0.0, eps=1e-5, return_transform=False, src_centroid = None, ref_centroid = None, ): r"""Compute rigid transformation from `src_points` to `ref_points` using weighted SVD. Modified from [PointDSC](https://github.com/XuyangBai/PointDSC/blob/master/models/common.py). Args: src_points: torch.Tensor (B, N, 3) or (N, 3) ref_points: torch.Tensor (B, N, 3) or (N, 3) weights: torch.Tensor (B, N) or (N,) (default: None) weight_thresh: float (default: 0.) eps: float (default: 1e-5) return_transform: bool (default: False) Returns: R: torch.Tensor (B, 3, 3) or (3, 3) t: torch.Tensor (B, 3) or (3,) transform: torch.Tensor (B, 4, 4) or (4, 4) """ if src_points.ndim == 2: src_points = src_points.unsqueeze(0) ref_points = ref_points.unsqueeze(0) if weights is not None: weights = weights.unsqueeze(0) squeeze_first = True else: squeeze_first = False batch_size = src_points.shape[0] if weights is None: weights = torch.ones_like(src_points[:, :, 0]) weights = torch.where(torch.lt(weights, weight_thresh), torch.zeros_like(weights), weights) weights = weights / (torch.sum(weights, dim=1, keepdim=True) + eps) weights = weights.unsqueeze(2) # (B, N, 1) if src_centroid is None: src_centroid = torch.sum(src_points * weights, dim=1, keepdim=True) # (B, 1, 3) elif len(src_centroid.size()) == 2: src_centroid = src_centroid.unsqueeze(1) src_points_centered = src_points - src_centroid # (B, N, 3) if ref_centroid is None: ref_centroid = torch.sum(ref_points * weights, dim=1, keepdim=True) # (B, 1, 3) elif len(ref_centroid.size()) == 2: ref_centroid = ref_centroid.unsqueeze(1) ref_points_centered = ref_points - ref_centroid # (B, N, 3) H = src_points_centered.permute(0, 2, 1) @ (weights * ref_points_centered) U, _, V = torch.svd(H) Ut, V = U.transpose(1, 2), V eye = torch.eye(3).unsqueeze(0).repeat(batch_size, 1, 1).to(src_points.device) eye[:, -1, -1] = torch.sign(torch.det(V @ Ut)) R = V @ eye @ Ut t = ref_centroid.permute(0, 2, 1) - R @ src_centroid.permute(0, 2, 1) t = t.squeeze(2) if return_transform: transform = torch.eye(4).unsqueeze(0).repeat(batch_size, 1, 1).cuda() transform[:, :3, :3] = R transform[:, :3, 3] = t if squeeze_first: transform = transform.squeeze(0) return transform else: if squeeze_first: R = R.squeeze(0) t = t.squeeze(0) return R, t class WeightedProcrustes(nn.Module): def __init__(self, weight_thresh=0.5, eps=1e-5, return_transform=False): super(WeightedProcrustes, self).__init__() self.weight_thresh = weight_thresh self.eps = eps self.return_transform = return_transform def forward(self, src_points, tgt_points, weights=None,src_centroid = None,ref_centroid = None): return weighted_procrustes( src_points, tgt_points, weights=weights, weight_thresh=self.weight_thresh, eps=self.eps, return_transform=self.return_transform, src_centroid=src_centroid, ref_centroid=ref_centroid )