def j2d_processing(self, kp, center, scale, r, f, is_train): """Process gt 2D keypoints and apply all augmentation transforms.""" nparts = kp.shape[0] for i in range(nparts): kp[i,0:2] = transform(kp[i,0:2]+1, center, scale, [constants.IMG_RES, constants.IMG_RES], rot=r) # convert to normalized coordinates kp[:,:-1] = 2.*kp[:,:-1]/constants.IMG_RES - 1. # flip the x coordinates if is_train and f: kp = flip_kp(kp) kp = kp.astype('float32') return kp
def j2d_processing(self, kp, center, scale, r, f): """Process gt 2D keypoints and apply all augmentation transforms.""" nparts = kp.shape[0] for i in range(nparts): kp[i,0:2] = transform(kp[i,0:2]+1, center, scale, [self.options.img_res, self.options.img_res], rot=r) # convert to normalized coordinates kp[:,:-1] = 2.*kp[:,:-1]/self.options.img_res - 1. # flip the x coordinates if f: kp = flip_kp(kp) kp = kp.astype('float32') return kp
def j2d_heatmap_processing(self, kp, center, scale, r, f): # first process the keypoints nparts = kp.shape[0] for i in range(nparts): kp[i, 0:2] = transform(kp[i, 0:2] + 1, center, scale, [constants.IMG_RES, constants.IMG_RES], rot=r) # flip the x coordinates if f: kp = flip_kp(kp) # generate guaissan heatmap target_weight = np.ones((self.num_joints, 1), dtype=np.float32) target_weight[:, 0] = kp[:, -1] target = np.zeros((self.num_joints, self.heatmap_size[1], self.heatmap_size[0]), dtype=np.float32) tmp_size = self.sigma * 3 for joint_id in range(self.num_joints): feat_stride = self.options.img_res / self.heatmap_size mu_x = int(kp[joint_id][0] / feat_stride[0] + 0.5) mu_y = int(kp[joint_id][1] / feat_stride[1] + 0.5) # Check that any part of the gaussian is in-bounds ul = [int(mu_x - tmp_size), int(mu_y - tmp_size)] br = [int(mu_x + tmp_size + 1), int(mu_y + tmp_size + 1)] if ul[0] >= self.heatmap_size[0] or ul[1] >= self.heatmap_size[1] \ or br[0] < 0 or br[1] < 0: # If not, just return the image as is target_weight[joint_id] = 0 continue # # Generate gaussian size = 2 * tmp_size + 1 x = np.arange(0, size, 1, np.float32) y = x[:, np.newaxis] x0 = y0 = size // 2 # The gaussian is not normalized, we want the center value to equal 1 g = np.exp(- ((x - x0) ** 2 + (y - y0) ** 2) / (2 * self.sigma ** 2)) # Usable gaussian range g_x = max(0, -ul[0]), min(br[0], self.heatmap_size[0]) - ul[0] g_y = max(0, -ul[1]), min(br[1], self.heatmap_size[1]) - ul[1] # Image range img_x = max(0, ul[0]), min(br[0], self.heatmap_size[0]) img_y = max(0, ul[1]), min(br[1], self.heatmap_size[1]) v = target_weight[joint_id] if v > 0.5: target[joint_id][img_y[0]:img_y[1], img_x[0]:img_x[1]] = \ g[g_y[0]:g_y[1], g_x[0]:g_x[1]] return target, target_weight
def j2d_heatmap_location_processing(self, kp, center, scale, r, f): # first process the keypoints nparts = kp.shape[0] for i in range(nparts): kp[i, 0:2] = transform(kp[i, 0:2] + 1, center, scale, [constants.IMG_RES, constants.IMG_RES], rot=r) # flip the x coordinates if f: kp = flip_kp(kp) kp_heatmaps = kp.copy().astype(np.uint8) feat_stride = constants.IMG_RES / self.heatmap_size kp_heatmaps[:, :-1] = kp_heatmaps[:, :-1] / feat_stride kp_heatmaps = kp_heatmaps.astype('float32') return kp_heatmaps
def dp_annot_process(ann, heatmap_size, crop_res, center, scale, IsFlipped): bb_xywh = np.array(ann['bbox']) bbox_gt = [bb_xywh[0], bb_xywh[1], bb_xywh[0] + bb_xywh[2], bb_xywh[1] + bb_xywh[3]] # Cropped Upper left point crop_ul = np.array(transform([1, 1], center, scale, [crop_res] * 2, invert=1)) - 1 # Cropped Bottom right point crop_br = np.array( transform([crop_res + 1] * 2, center, scale, [crop_res] * 2, invert=1)) - 1 bbox_crop = np.concatenate([crop_ul, crop_br]) dp_dict = {} M = heatmap_size # Create blobs for densepose supervision. ################################################## The mask All_labels = blob_utils.zeros(M ** 2, int32=True) All_Weights = blob_utils.zeros(M ** 2, int32=True) ################################################# The points X_points = blob_utils.zeros(196, int32=False) Y_points = blob_utils.zeros(196, int32=False) Ind_points = blob_utils.zeros(196, int32=True) I_points = blob_utils.zeros(196, int32=True) U_points = blob_utils.zeros(196, int32=False) V_points = blob_utils.zeros(196, int32=False) Uv_point_weights = blob_utils.zeros(196, int32=False) ################################################# Ilabel = segm_utils.GetDensePoseMask(ann['dp_masks']) # GT_I = np.array(ann['dp_I']) GT_U = np.array(ann['dp_U']) GT_V = np.array(ann['dp_V']) GT_x = np.array(ann['dp_x']) GT_y = np.array(ann['dp_y']) GT_weights = np.ones(GT_I.shape).astype(np.float32) # ## Do the flipping of the densepose annotation ! if IsFlipped: GT_I, GT_U, GT_V, GT_x, GT_y, Ilabel = DP.get_symmetric_densepose(GT_I, GT_U, GT_V, GT_x, GT_y, Ilabel) # roi_fg = bbox_crop roi_gt = bbox_gt # x1 = roi_fg[0]; x2 = roi_fg[2] y1 = roi_fg[1]; y2 = roi_fg[3] # x1_source = roi_gt[0]; x2_source = roi_gt[2] y1_source = roi_gt[1]; y2_source = roi_gt[3] # x_targets = (np.arange(x1, x2, (x2 - x1) / float(M)) - x1_source) * (255. / (x2_source - x1_source)) y_targets = (np.arange(y1, y2, (y2 - y1) / float(M)) - y1_source) * (255. / (y2_source - y1_source)) # x_targets = x_targets[0:M] ## Strangely sometimes it can be M+1, so make sure size is OK! y_targets = y_targets[0:M] # [X_targets, Y_targets] = np.meshgrid(x_targets, y_targets) New_Index = cv2.remap(Ilabel, X_targets.astype(np.float32), Y_targets.astype(np.float32), interpolation=cv2.INTER_NEAREST, borderMode=cv2.BORDER_CONSTANT, borderValue=(0)) # # All_L = np.zeros(New_Index.shape) All_W = np.ones(New_Index.shape) # All_L = New_Index # gt_length_x = x2_source - x1_source gt_length_y = y2_source - y1_source # GT_y = ((GT_y / 255. * gt_length_y) + y1_source - y1) * (float(M) / (y2 - y1)) GT_x = ((GT_x / 255. * gt_length_x) + x1_source - x1) * (float(M) / (x2 - x1)) # GT_I[GT_y < 0] = 0 GT_I[GT_y > (M - 1)] = 0 GT_I[GT_x < 0] = 0 GT_I[GT_x > (M - 1)] = 0 # points_inside = GT_I > 0 GT_U = GT_U[points_inside] GT_V = GT_V[points_inside] GT_x = GT_x[points_inside] GT_y = GT_y[points_inside] GT_weights = GT_weights[points_inside] GT_I = GT_I[points_inside] # X_points[0:len(GT_x)] = GT_x Y_points[0:len(GT_y)] = GT_y # Ind_points[i, 0:len(GT_I)] = i I_points[0:len(GT_I)] = GT_I U_points[0:len(GT_U)] = GT_U V_points[0:len(GT_V)] = GT_V Uv_point_weights[0:len(GT_weights)] = GT_weights All_labels[:] = np.reshape(All_L.astype(np.int32), M ** 2) All_Weights[:] = np.reshape(All_W.astype(np.int32), M ** 2) # K = cfg.BODY_UV_RCNN.NUM_PATCHES K = 24 # print(K) # U_points = np.tile(U_points, [K + 1]) V_points = np.tile(V_points, [K + 1]) Uv_Weight_Points = np.zeros(U_points.shape) # for jjj in range(1, K + 1): Uv_Weight_Points[jjj * I_points.shape[0]: (jjj + 1) * I_points.shape[0]] = (I_points == jjj).astype( np.float32) # Uv_Weight_Points[:, jjj * I_points.shape[1]: (jjj + 1) * I_points.shape[1]] = (I_points == jjj).astype( # np.float32) ## dp_dict['body_uv_ann_labels'] = np.array(All_labels).astype(np.int32) dp_dict['body_uv_ann_weights'] = np.array(All_Weights).astype(np.float32) # ########################## dp_dict['body_uv_X_points'] = X_points.astype(np.float32) dp_dict['body_uv_Y_points'] = Y_points.astype(np.float32) dp_dict['body_uv_Ind_points'] = Ind_points.astype(np.float32) dp_dict['body_uv_I_points'] = I_points.astype(np.float32) dp_dict['body_uv_U_points'] = U_points.astype( np.float32) #### VERY IMPORTANT : These are switched here : dp_dict['body_uv_V_points'] = V_points.astype(np.float32) dp_dict['body_uv_point_weights'] = Uv_Weight_Points.astype(np.float32) return dp_dict