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