def __getitem__(self, index): img_path = self.img_list[index] img = np.array(cv2.resize(cv2.imread(img_path), (368, 368)), dtype=np.float32) kpt = self.kpt_list[index] center = self.center_list[index] scale = self.scale_list[index] # expand dataset img, kpt, center = self.transformer(img, kpt, center, scale) height, width, _ = img.shape # limbsMap = getLimbs(img, kpt, height, width, self.stride, self.bodyParts, 25, 1) box = getBoundingBox(img, self.kpt_list[index], height, width, self.stride) heatmap = np.zeros((int(height / self.stride), int( width / self.stride), int(len(kpt) + 1)), dtype=np.float32) for i in range(len(kpt)): # resize from 368 to 46 x = int(kpt[i][0]) * 1.0 / self.stride y = int(kpt[i][1]) * 1.0 / self.stride heat_map = guassian_kernel(size_h=int(height / self.stride), size_w=int(width / self.stride), center_x=x, center_y=y, sigma=self.sigma) heat_map[heat_map > 1] = 1 heat_map[heat_map < 0.0099] = 0 heatmap[:, :, i + 1] = heat_map heatmap[:, :, 0] = 1.0 - np.max(heatmap[:, :, 1:], axis=2) # for background centermap = np.zeros((height, width, 1), dtype=np.float32) center_map = guassian_kernel(size_h=height, size_w=width, center_x=center[0], center_y=center[1], sigma=3) center_map[center_map > 1] = 1 center_map[center_map < 0.0099] = 0 centermap[:, :, 0] = center_map img = Mytransforms.normalize(Mytransforms.to_tensor(img), [128.0, 128.0, 128.0], [256.0, 256.0, 256.0]) heatmap = Mytransforms.to_tensor(heatmap) centermap = Mytransforms.to_tensor(centermap) # limbsMap = Mytransforms.to_tensor(limbsMap) box = Mytransforms.to_tensor(box) return img, heatmap, centermap, img_path, 0, box
def getDataloader(dataset, train_dir, val_dir, test_dir, sigma, stride, workers, batch_size): if dataset == 'LSP': train_loader = torch.utils.data.DataLoader(lsp_lspet_data.LSP_Data( 'lspet', train_dir, sigma, stride, Mytransforms.Compose([ Mytransforms.RandomHorizontalFlip(), ])), batch_size=batch_size, shuffle=True, num_workers=workers, pin_memory=True) val_loader = torch.utils.data.DataLoader(lsp_lspet_data.LSP_Data( 'lsp', val_dir, sigma, stride, Mytransforms.Compose([ Mytransforms.TestResized(368), ])), batch_size=1, shuffle=True, num_workers=1, pin_memory=True) test_loader = 0 elif dataset == 'MPII': train_loader = torch.utils.data.DataLoader(mpii_data.mpii( train_dir, sigma, "Train", Mytransforms.Compose([ Mytransforms.TestResized(368), ])), batch_size=batch_size, shuffle=True, num_workers=workers, pin_memory=True) val_loader = torch.utils.data.DataLoader(mpii_data.mpii( val_dir, sigma, "Val", Mytransforms.Compose([ Mytransforms.TestResized(368), ])), batch_size=1, shuffle=True, num_workers=1, pin_memory=True) test_loader = torch.utils.data.DataLoader(mpii_data.mpii( test_dir, sigma, "Val", Mytransforms.Compose([ Mytransforms.TestResized(368), ])), batch_size=1, shuffle=True, num_workers=1, pin_memory=True) # elif dataset == 'COCO': # train_loader = torch.utils.data.DataLoader( # coco_data.COCO_Data(True, train_dir, sigma, stride, # Mytransforms.Compose([Mytransforms.RandomResized(), # Mytransforms.RandomRotate(40), # #Mytransforms.RandomCrop(368), # Mytransforms.SinglePersonCrop(368), # Mytransforms.RandomHorizontalFlip(),])), # batch_size = batch_size, shuffle=True, # num_workers = workers, pin_memory=True) # val_loader = torch.utils.data.DataLoader( # coco_data.COCO_Data(False, val_dir, sigma, stride, # Mytransforms.Compose([Mytransforms.TestResized(368), # Mytransforms.SinglePersonCrop(368),])), # batch_size = 1, shuffle=True, # num_workers = workers, pin_memory=True) elif dataset == 'Penn_Action': train_loader = torch.utils.data.DataLoader(penn_action.Penn_Action( train_dir, sigma, batch_size, True, Mytransforms.Compose([ Mytransforms.TestResized(368), ])), batch_size=1, shuffle=True, num_workers=workers, pin_memory=True) val_loader = torch.utils.data.DataLoader(penn_action.Penn_Action( val_dir, sigma, batch_size, False, Mytransforms.Compose([ Mytransforms.TestResized(368), ])), batch_size=1, shuffle=True, num_workers=1, pin_memory=True) test_loader = None elif dataset == 'NTID': train_loader = torch.utils.data.DataLoader(ntid_data.NTID( train_dir, sigma, "Train", Mytransforms.Compose([ Mytransforms.TestResized(368), Mytransforms.RandomHorizontalFlip_NTID(), ])), batch_size=batch_size, shuffle=True, num_workers=workers, pin_memory=True) val_loader = torch.utils.data.DataLoader(ntid_data.NTID( val_dir, sigma, "Val", Mytransforms.Compose([ Mytransforms.TestResized(368), ])), batch_size=1, shuffle=True, num_workers=1, pin_memory=True) test_loader = torch.utils.data.DataLoader(ntid_data.NTID( test_dir, sigma, "Test", ), batch_size=1, shuffle=True, num_workers=1, pin_memory=True) elif dataset == 'PoseTrack': train_loader = torch.utils.data.DataLoader( posetrack_data.PoseTrack_Data( True, train_dir, sigma, stride, Mytransforms.Compose([ Mytransforms.TestResized(368), ])), batch_size=batch_size, shuffle=True, num_workers=workers, pin_memory=True) val_loader = torch.utils.data.DataLoader(posetrack_data.PoseTrack_Data( False, val_dir, sigma, stride, Mytransforms.Compose([ Mytransforms.TestResized(368), ])), batch_size=1, shuffle=True, num_workers=1, pin_memory=True) elif dataset == "BBC": train_loader = torch.utils.data.DataLoader(bbc_data.BBC( train_dir, sigma, "Train", Mytransforms.Compose([ Mytransforms.TestResized(368), Mytransforms.RandomHorizontalFlip_NTID(), ])), batch_size=batch_size, shuffle=True, num_workers=workers, pin_memory=True) val_loader = torch.utils.data.DataLoader(bbc_data.BBC( val_dir, sigma, "Val", Mytransforms.Compose([ Mytransforms.TestResized(368), ])), batch_size=1, shuffle=True, num_workers=1, pin_memory=True) test_loader = torch.utils.data.DataLoader(bbc_data.BBC( val_dir, sigma, "Test", ), batch_size=1, shuffle=True, num_workers=1, pin_memory=True) return train_loader, val_loader, test_loader
def __getitem__(self, index): frames = self.frames_data[index] data = np.load(os.path.join(self.data_dir, frames)).item() nframes = data['nframes'] # 151 framespath = data['framepath'] dim = data['dimensions'] # [360,480] x = data['x'] # 151 * 13 y = data['y'] # 151 * 13 visibility = data['visibility'] # 151 * 13 img_paths = [] start_index = np.random.randint(0, nframes - 1 - self.seqTrain + 1) images = torch.zeros(self.seqTrain, 3, self.height, self.width) # [3,368,368] centermaps = torch.zeros(self.seqTrain, 1, self.height, self.width) # [3,368,368] # boxes = torch.zeros(self.seqTrain, 5, self.height, self.width) # [3,368,368] label = np.zeros((3, 13, self.seqTrain)) lms = np.zeros((1, 3, 13)) kps = np.zeros((13 + 5, 3)) # build data set-------- label_size = 368 label_map = torch.zeros(self.seqTrain, self.parts_num + 1, label_size, label_size) for i in range(self.seqTrain): # read image img_path = os.path.join('/home/bm3768/Desktop/Pose/'+framespath[34:],\ '%06d' % (start_index + i + 1) + '.jpg') img_paths.append(img_path) img = np.array(Image.open(img_path), dtype=np.float32) # Image img_path = self.images_dir + variable['img_paths'] # BBox was added to the labels by the authors to perform additional training and testing, as referred in the paper. # Intentionally left as comment since it is not part of the dataset. # bbox = np.load(self.labels_dir + "BBOX/" + variable['img_paths'][:-4] + '.npy') # read label label[0, :, i] = x[start_index + i] label[1, :, i] = y[start_index + i] label[2, :, i] = visibility[start_index + i] # 1 * 13 # bbox[i, :] = data['bbox'][start_index + i] # # make the joints not in the figure vis=-1(Do not produce label) for part in range(0, 13): # for each part if self.isNotOnPlane(label[0, part, i], label[1, part, i], dim[1], dim[0]): label[2, part, i] = -1 temp2 = label.transpose([2, 1, 0]) kps[:13] = temp2[0] center_x = int(label_size/2) center_y = int(label_size/2) kps[13] = [int((bbox[i,0]+bbox[i,2])/2),int((bbox[i,1]+bbox[i,3])/2),1] kps[14] = [bbox[i,0],bbox[i,1],1] kps[15] = [bbox[i,0],bbox[i,3],1] kps[16] = [bbox[i,2],bbox[i,1],1] kps[17] = [bbox[i,2],bbox[i,3],1] center = [center_x, center_y] img, kps, center = self.transform(img, kps, center) box = kps[-5:] kpts = kps[:13] label[:,:,i] = kpts.transpose(1,0) img = np.array(cv2.resize(cv2.imread(img_path),(368,368)), dtype=np.float32) # Image images[i, :, :, :] = transforms.ToTensor()(img) centermap = np.zeros((self.height, self.width, 1), dtype=np.float32) center_map = guassian_kernel(size_h=self.height, size_w=self.width, center_x=center[0], center_y=center[1], sigma=3) center_map[center_map > 1] = 1 center_map[center_map < 0.0099] = 0 centermap[:, :, 0] = center_map centermaps[i, :, :, :] = transforms.ToTensor()(centermap) heatmap = np.zeros((368, 368, 14), dtype=np.float32) for k in range(13): # resize from 368 to 46 xk = int(kpts[k][0]) yk = int(kpts[k][1]) heat_map = guassian_kernel(size_h=368, size_w=368, center_x=xk, center_y=yk, sigma=self.sigma) heat_map[heat_map > 1] = 1 heat_map[heat_map < 0.0099] = 0 heatmap[:, :, k+1] = heat_map # box_heatmap = np.zeros((368, 368, 5), dtype=np.float32) # for k in range(5): # # resize from 368 to 46 # xk = int(box[k][0]) # yk = int(box[k][1]) # heat_map = guassian_kernel(size_h=368, size_w=368, center_x=xk, center_y=yk, sigma=self.sigma) # heat_map[heat_map > 1] = 1 # heat_map[heat_map < 0.0099] = 0 # box_heatmap[:, :, k] = heat_map heatmap[:, :, 0] = 1.0 - np.max(heatmap[:, :, 1:], axis=2) # for background label_map[i] = transforms.ToTensor()(heatmap) # boxes[i] = transforms.ToTensor()(box_heatmap) for i in range(self.seqTrain): images[i] = Mytransforms.normalize(images[i], [128.0, 128.0, 128.0],[256.0, 256.0, 256.0]) label_map[i] = transforms.ToTensor()(heatmap) return images, label_map, centermaps, img_paths#, 0, boxes
def __getitem__(self, index): scale_factor = 0.25 variable = self.anno[self.img_List[index]] while not os.path.isfile(self.labels_dir + variable['img_paths'][:-4] + '.png'): index = index - 1 variable = self.anno[self.img_List[index]] img_path = self.images_dir + variable['img_paths'] # BBox was added to the labels by the authors to perform additional training and testing, as referred in the paper. # Intentionally left as comment since it is not part of the dataset. # bbox = np.load(self.labels_dir + "BBOX/" + variable['img_paths'][:-4] + '.npy') points = torch.Tensor(variable['joint_self']) center = torch.Tensor(variable['objpos']) scale = variable['scale_provided'] if center[0] != -1: center[1] = center[1] + 15 * scale scale = scale * 1.25 # Single Person nParts = points.size(0) img = cv2.imread(img_path) # box = np.zeros((2,2)) # for i in range(bbox.shape[0]): # if center[0] > bbox[i,0] and center[0] < bbox[i,2] and\ # center[1] > bbox[i,1] and center[1] < bbox[i,3]: # upperLeft = bbox[i,0:2].astype(int) # bottomRight = bbox[i,-2:].astype(int) # box = bbox[i,:] # img[:,0:upperLeft[0],:] = np.ones(img[:,0:upperLeft[0],:].shape) *255 # img[0:upperLeft[1],:,:] = np.ones(img[0:upperLeft[1],:,:].shape) *255 # img[:,bottomRight[0]:,:] = np.ones(img[:,bottomRight[0]:,:].shape)*255 # img[bottomRight[1]:,:,:] = np.ones(img[bottomRight[1]:,:,:].shape)*255 # break # img, upperLeft, bottomRight, points, center = crop(img, points, center, scale, [self.height, self.width]) kpt = points # img, kpt, center = self.transformer(img, points, center) if img.shape[0] != 368 or img.shape[1] != 368: kpt[:, 0] = kpt[:, 0] * (368 / img.shape[1]) kpt[:, 1] = kpt[:, 1] * (368 / img.shape[0]) img = cv2.resize(img, (368, 368)) height, width, _ = img.shape heatmap = np.zeros((int(height / self.stride), int( width / self.stride), int(len(kpt) + 1)), dtype=np.float32) for i in range(len(kpt)): # resize from 368 to 46 x = int(kpt[i][0]) * 1.0 / self.stride y = int(kpt[i][1]) * 1.0 / self.stride heat_map = guassian_kernel(size_h=int(height / self.stride), size_w=int(width / self.stride), center_x=x, center_y=y, sigma=self.sigma) heat_map[heat_map > 1] = 1 heat_map[heat_map < 0.0099] = 0 heatmap[:, :, i + 1] = heat_map heatmap[:, :, 0] = 1.0 - np.max(heatmap[:, :, 1:], axis=2) # for background centermap = np.zeros( (int(height / self.stride), int(width / self.stride), 1), dtype=np.float32) center_map = guassian_kernel(size_h=int(height / self.stride), size_w=int(width / self.stride), center_x=int(center[0] / self.stride), center_y=int(center[1] / self.stride), sigma=3) center_map[center_map > 1] = 1 center_map[center_map < 0.0099] = 0 centermap[:, :, 0] = center_map orig_img = cv2.imread(img_path) img = Mytransforms.normalize(Mytransforms.to_tensor(img), [128.0, 128.0, 128.0], [256.0, 256.0, 256.0]) heatmap = Mytransforms.to_tensor(heatmap) centermap = Mytransforms.to_tensor(centermap) return img, heatmap, centermap, img_path
def __getitem__(self, index): im = cv2.imread(self.img_List[index]) if im is None: print(self.img_List[index]) im = cv2.imread(self.img_List[index - 1]) img = np.array(im, dtype=np.float32) kps = self.kps[index] shift = [img.shape[1] - 368, img.shape[0] - 368] img = img[-368:, -368:, :] # print(kps) kps[:, 0] = kps[:, 0] - shift[0] kps[:, 1] = kps[:, 1] - shift[1] # print(kps) # print(self.img_List[index]) # print(img.shape) center = {} center[0] = [img.shape[0] / 2, img.shape[1] / 2] # print(kps.shape, img.shape) # expand dataset # if self.is_train == "Train": # img, kps, center = self.transform(img, kps, center) height, width, _ = img.shape kps[kps < 0] = 0 # limbsMap = getLimbs(img, kpt, height, width, 8, self.bodyParts, self.parts_num, 1) box = getBoundingBox(img, kps, height, width, 8) heatmap = np.zeros((46, 46, int(len(kps) + 1)), dtype=np.float32) for i in range(len(kps)): # resize from 368 to 46 x = int(kps[i][0]) * 1.0 / 8 y = int(kps[i][1]) * 1.0 / 8 heat_map = guassian_kernel(size_h=368 / 8, size_w=368 / 8, center_x=x, center_y=y, sigma=self.sigma) heat_map[heat_map > 1] = 1 heat_map[heat_map < 0.0099] = 0 heatmap[:, :, i + 1] = heat_map heatmap[:, :, 0] = 1.0 - np.max(heatmap[:, :, 1:], axis=2) # for background centermap = np.zeros((height, width, 1), dtype=np.float32) center_map = guassian_kernel(size_h=height, size_w=width, center_x=184, center_y=184, sigma=3) center_map[center_map > 1] = 1 center_map[center_map < 0.0099] = 0 centermap[:, :, 0] = center_map img = Mytransforms.normalize(Mytransforms.to_tensor(img), [128.0, 128.0, 128.0], [256.0, 256.0, 256.0]) heatmap = Mytransforms.to_tensor(heatmap) centermap = Mytransforms.to_tensor(centermap) # limbsMap = Mytransforms.to_tensor(limbsMap) box = Mytransforms.to_tensor(box) return img, heatmap, centermap, self.img_List[index], 0, box return img, 0, 0, self.img_List[index], 0, 0
def train_val(model, device, args): data_root = args.data_root train_txt = data_root + args.train_txt val_txt = data_root + args.val_txt cudnn.benchmark = True train_loader = torch.utils.data.DataLoader(CPNFolder( train_txt, args.output_shape, Mytransforms.Compose([ Mytransforms.RandomResized(), Mytransforms.RandomRotate(40), Mytransforms.RandomCrop(320), Mytransforms.RandomHorizontalFlip(), ])), batch_size=args.batch_size, shuffle=True, num_workers=args.workers, pin_memory=True) if args.test_interval != 0 and args.val_txt is not None: val_loader = torch.utils.data.DataLoader(CPNFolder( val_txt, args.output_shape, Mytransforms.Compose([ Mytransforms.TestResized(320), ])), batch_size=args.batch_size, shuffle=False, num_workers=args.workers, pin_memory=True) params, multiple = get_parameters(model, args, False) optimizer = torch.optim.SGD(params, args.base_lr, momentum=args.momentum, weight_decay=args.weight_decay) batch_time = AverageMeter() data_time = AverageMeter() losses = AverageMeter() global_losses = [AverageMeter() for i in range(4)] refine_losses = AverageMeter() end = time.time() iters = args.start_iters learning_rate = args.base_lr model.train() while iters < args.max_iter: for i, (input, label15, label11, label9, label7, valid) in enumerate(train_loader): #learning_rate = adjust_learning_rate(optimizer, iters, args.base_lr, policy=args.lr_policy, policy_parameter=args.policy_parameter, multiple=multiple) data_time.update(time.time() - end) label15 = label15.to(device) label11 = label11.to(device) label9 = label9.to(device) label7 = label7.to(device) valid = valid.to(device) labels = [label15, label11, label9, label7] global_out, refine_out = model(input) global_loss, refine_loss = L2_loss(global_out, refine_out, labels, valid, args.top_k, args.batch_size, args.num_points) loss = 0.0 for i, global_loss1 in (global_loss): loss += global_loss1 global_losses[i].update(global_loss1.data[0], input.size(0)) loss += refine_loss losses.update(loss.data[0], input.size(0)) refine_losses.update(refine_loss.data[0], input.size(0)) optimizer.zero_grad() loss.backward() optimizer.step() batch_time.update(time.time() - end) end = time.time() iters += 1 if iters % args.display == 0: print( 'Train Iteration: {0}\t' 'Time {batch_time.sum:.3f}s / {1}iters, ({batch_time.avg:.3f})\t' 'Data load {data_time.sum:.3f}s / {1}iters, ({data_time.avg:3f})\n' 'Learning rate = {2}\n' 'Loss = {loss.val:.8f} (ave = {loss.avg:.8f})\n'.format( iters, args.display, learning_rate, batch_time=batch_time, data_time=data_time, loss=losses)) for cnt in range(0, 4): print( 'Global Net Loss{0} = {loss1.val:.8f} (ave = {loss1.avg:.8f})' .format(cnt + 1, loss1=global_losses[cnt])) print( 'Refine Net Loss = {loss1.val:.8f} (ave = {loss1.avg:.8f})' .format(loss1=refine_losses)) print( time.strftime( '%Y-%m-%d %H:%M:%S -----------------------------------------------------------------------------------------------------------------\n', time.localtime())) batch_time.reset() data_time.reset() losses.reset() for cnt in range(4): global_losses[cnt].reset() refine_losses.reset() if args.test_interval != 0 and args.val_dir is not None and iters % args.test_interval == 0: model.eval() for j, (input, label15, label11, label9, label7, valid) in enumerate(val_loader): label15 = label15.to(device) label11 = label11.to(device) label9 = label9.to(device) label7 = label7.to(device) valid = valid.to(device) labels = [label15, label11, label9, label7] global_out, refine_out = model(input) global_loss, refine_loss = L2_loss(global_out, refine_out, labels, valid, args.top_k, args.batch_size, args.num_points) loss = 0.0 for i, global_loss1 in enumerate(global_loss): loss += global_loss1 global_losses[i].update(global_loss1.data[0], input.size(0)) loss += refine_loss losses.update(loss.data[0], input.size(0)) refine_losses.update(refine_loss.data[0], input.size(0)) batch_time.update(time.time() - end) end = time.time() # save_checkpoint({ # 'iter': iters, # 'state_dict': model.state_dict(), # }, 'cpn_fashion') print( 'Test Time {batch_time.sum:.3f}s, ({batch_time.avg:.3f})\t' 'Loss {loss.avg:.8f}\n'.format(batch_time=batch_time, loss=losses)) for cnt in range(0, 4): print( 'Global Net Loss{0} = {loss1.val:.8f} (ave = {loss1.avg:.8f})' .format(cnt + 1, loss1=global_losses[cnt])) print( 'Refine Net Loss = {loss1.val:.8f} (ave = {loss1.avg:.8f})' .format(loss1=refine_losses)) print( time.strftime( '%Y-%m-%d %H:%M:%S -----------------------------------------------------------------------------------------------------------------\n', time.localtime())) batch_time.reset() losses.reset() for cnt in range(4): global_losses[cnt].reset() refine_losses.reset() model.train() if iters == args.max_iter: break
def __getitem__(self, index): im = cv2.imread(self.img_List[index]) if im is None: print(self.img_List[index]) im = cv2.imread(self.img_List[index - 1]) img = np.array(im, dtype=np.float32) kps = self.kps[index] center = {} center[0] = [img.shape[0] / 2, img.shape[1] / 2] prefix_length = self.img_List[index].rfind('images') sufix_start = self.img_List[index].rfind('/') frame_number = int(self.img_List[index][sufix_start + 1:-4]) label_file = self.img_List[index][:prefix_length]+"labels"+\ self.img_List[index][prefix_length+6:sufix_start+1]+\ self.img_List[index][prefix_length+11:sufix_start]+".mat" if scipy.io.loadmat(label_file)['arr'][frame_number] is None: print(self.img_List[index]) kps2 = scipy.io.loadmat(label_file)['arr'][frame_number - 1] im = cv2.imread(self.img_List[index - 1]) else: kps2 = scipy.io.loadmat(label_file)['arr'][frame_number] # Remove Knee, ankle and foot detections (not visible in the image) kps2 = np.delete(kps2, [26, 27, 28, 29, 30, 31, 34, 35, 36, 37, 38, 39], axis=0) kpt = np.zeros((self.parts_num, 2)) # kpt2 = np.zeros((self.parts_num,2)) for i in range(0, self.parts_num): kpt[i, 0] = kps2[2 * i] kpt[i, 1] = kps2[2 * i + 1] # kpt2[i, 0] = kps2[2*i] # kpt2[i, 1] = kps2[2*i+1] # expand dataset # if self.is_train == "Train": # img, kpt, center = self.transform(img, kpt, center) height, width, _ = img.shape kpt[kpt < 0] = 0 # limbsMap = getLimbs(img, kpt, height, width, 8, self.bodyParts, self.parts_num, 1) box = getBoundingBox(img, kpt, height, width, 8) heatmap = np.zeros( (int(height / 8), int(width / 8), int(len(kpt) + 1)), dtype=np.float32) for i in range(len(kpt)): # resize from 368 to 46 x = int(kpt[i][0]) * 1.0 / 8 y = int(kpt[i][1]) * 1.0 / 8 heat_map = guassian_kernel(size_h=height / 8, size_w=width / 8, center_x=x, center_y=y, sigma=self.sigma) heat_map[heat_map > 1] = 1 heat_map[heat_map < 0.0099] = 0 heatmap[:, :, i + 1] = heat_map heatmap[:, :, 0] = 1.0 - np.max(heatmap[:, :, 1:], axis=2) # for background centermap = np.zeros((height, width, 1), dtype=np.float32) center_map = guassian_kernel(size_h=height, size_w=width, center_x=184, center_y=184, sigma=3) center_map[center_map > 1] = 1 center_map[center_map < 0.0099] = 0 centermap[:, :, 0] = center_map img = Mytransforms.normalize(Mytransforms.to_tensor(img), [128.0, 128.0, 128.0], [256.0, 256.0, 256.0]) heatmap = Mytransforms.to_tensor(heatmap) centermap = Mytransforms.to_tensor(centermap) # limbsMap = Mytransforms.to_tensor(limbsMap) box = Mytransforms.to_tensor(box) return img, heatmap, centermap, self.img_List[index], 0, box
def __getitem__(self, index): scale_factor = 0.25 variable = self.anno[self.img_List[index]] while not os.path.isfile(self.labels_dir + variable['img_paths'][:-4] + '.png'): index = index - 1 variable = self.anno[self.img_List[index]] img_path = self.images_dir + variable['img_paths'] segmented = cv2.imread(self.labels_dir + "segmented/" + variable['img_paths'][:-4] + '.png') bbox = np.load(self.labels_dir + "BBOX/" + variable['img_paths'][:-4] + '.npy') points = torch.Tensor(variable['joint_self']) center = torch.Tensor(variable['objpos']) scale = variable['scale_provided'] if center[0] != -1: center[1] = center[1] + 15 * scale scale = scale * 1.25 # Single Person nParts = points.size(0) img = cv2.imread(img_path) box = np.zeros((2, 2)) for i in range(bbox.shape[0]): if center[0] > bbox[i,0] and center[0] < bbox[i,2] and\ center[1] > bbox[i,1] and center[1] < bbox[i,3]: upperLeft = bbox[i, 0:2].astype(int) bottomRight = bbox[i, -2:].astype(int) box = bbox[i, :] img[:, 0:upperLeft[0], :] = np.ones( img[:, 0:upperLeft[0], :].shape) * 255 img[0:upperLeft[1], :, :] = np.ones( img[0:upperLeft[1], :, :].shape) * 255 img[:, bottomRight[0]:, :] = np.ones( img[:, bottomRight[0]:, :].shape) * 255 img[bottomRight[1]:, :, :] = np.ones( img[bottomRight[1]:, :, :].shape) * 255 break # img, upperLeft, bottomRight, points, center = crop(img, points, center, scale, [self.height, self.width]) kpt = points # img, kpt, center = self.transformer(img, points, center) if img.shape[0] != 368 or img.shape[1] != 368: kpt[:, 0] = kpt[:, 0] * (368 / img.shape[1]) kpt[:, 1] = kpt[:, 1] * (368 / img.shape[0]) img = cv2.resize(img, (368, 368)) height, width, _ = img.shape # quit() heatmap = np.zeros((int(height / self.stride), int( width / self.stride), int(len(kpt) + 1)), dtype=np.float32) for i in range(len(kpt)): # resize from 368 to 46 x = int(kpt[i][0]) * 1.0 / self.stride y = int(kpt[i][1]) * 1.0 / self.stride heat_map = guassian_kernel(size_h=int(height / self.stride), size_w=int(width / self.stride), center_x=x, center_y=y, sigma=self.sigma) heat_map[heat_map > 1] = 1 heat_map[heat_map < 0.0099] = 0 heatmap[:, :, i + 1] = heat_map heatmap[:, :, 0] = 1.0 - np.max(heatmap[:, :, 1:], axis=2) # for background centermap = np.zeros( (int(height / self.stride), int(width / self.stride), 1), dtype=np.float32) center_map = guassian_kernel(size_h=int(height / self.stride), size_w=int(width / self.stride), center_x=int(center[0] / self.stride), center_y=int(center[1] / self.stride), sigma=3) center_map[center_map > 1] = 1 center_map[center_map < 0.0099] = 0 centermap[:, :, 0] = center_map orig_img = cv2.imread(img_path) img = Mytransforms.normalize(Mytransforms.to_tensor(img), [128.0, 128.0, 128.0], [256.0, 256.0, 256.0]) heatmap = Mytransforms.to_tensor(heatmap) centermap = Mytransforms.to_tensor(centermap) segmented = Mytransforms.to_tensor(segmented) # cv2.imwrite("/home/bm3768/Desktop/Pose/Posezilla/samples/2.png",segmented) return img, heatmap, centermap, img_path, orig_img, segmented, box
def __getitem__(self, index): if self.is_train: items = "/home/bm3768/Desktop/Pose/dataset/PoseTrack/" + self.train_list[ index] else: items = "/home/bm3768/Desktop/Pose/dataset/PoseTrack/" + self.val_list[ index] im = cv2.imread(items) if im is None: print(items) img = np.array(im, dtype=np.float32) kps = np.asarray(self.keypoints[index]) center = {} center[0] = [img.shape[0] / 2, img.shape[1] / 2] # print("kps ", kps.shape) kpt = np.zeros((kps.shape[0], 17, 3)) for i in range(kps.shape[0]): points = np.reshape(kps[i], (17, 3)) kpt[i] = points kpts = np.zeros((kpt.shape[0] * 17, 3)) for i in range(kpt.shape[0]): kpts[17 * i:17 * (i + 1), :] = kpt[i, :, :] # print("Image ", img.shape) # print("Kpt ", kpt.shape) # print("Kpts ", kpts.shape) # print("Center ", center) img, kpts, center = self.transformer(img, kpts, center) for i in range(kpt.shape[0]): kpt[i, :, :] = kpts[17 * i:17 * (i + 1), :] # kpt = torch.Tensor(kpt) # print("Image ", img.shape) # print("Kpt ", kpt.shape) # print("Center ", center) height, width, _ = img.shape # kpt = np.zeros((17,3)) # for i in range(kpts.shape[0]): # kpt = kpt + kpts[i,:,:] # print(kpt[:,2]) # np.clip(kpt[:,2],0,1,kpt[:,2]) # print(kpt[:,2]) box = getBoundingBox(img, kpt, height, width, self.stride) heatmaps = np.zeros( (kpt.shape[0], int(height / self.stride), int( width / self.stride), int(kpt.shape[1] + 1)), dtype=np.float32) for i in range(kpt.shape[0]): for j in range(kpt.shape[1]): # resize from 368 to 46 x = int(kpt[i, j, 0]) * 1.0 / self.stride y = int(kpt[i, j, 1]) * 1.0 / self.stride heat_map = guassian_kernel(size_h=height / self.stride, size_w=width / self.stride, center_x=x, center_y=y, sigma=self.sigma) heat_map[heat_map > 1] = 1 heat_map[heat_map < 0.0099] = 0 heatmaps[i, :, :, j + 1] = heat_map heatmaps[i, :, :, 0] = 1.0 - np.max(heatmaps[i, :, :, 1:], axis=2) # for background # print(heatmaps.shape) # heatmap = np.zeros((int(height/self.stride), int(width/self.stride), int(kpt.shape[1]+1)), dtype=np.float32) heatmap = np.sum(heatmaps, axis=0) # print(heatmap.shape) centermap = np.zeros((height, width, 1), dtype=np.float32) center_map = guassian_kernel(size_h=height, size_w=width, center_x=center[0][0], center_y=center[0][1], sigma=3) center_map[center_map > 1] = 1 center_map[center_map < 0.0099] = 0 centermap[:, :, 0] = center_map img = Mytransforms.normalize(Mytransforms.to_tensor(img), [128.0, 128.0, 128.0], [256.0, 256.0, 256.0]) heatmap = Mytransforms.to_tensor(heatmap) centermap = Mytransforms.to_tensor(centermap) box = Mytransforms.to_tensor(box) return img, heatmap, centermap, items, 0, box