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 j3d_processing(self, S, r, f):
"""Process gt 3D keypoints and apply all augmentation transforms."""
# in-plane rotation
rot_mat = np.eye(3)
if not r == 0:
rot_rad = -r * np.pi / 180
sn, cs = np.sin(rot_rad), np.cos(rot_rad)
rot_mat[0, :2] = [cs, -sn]
rot_mat[1, :2] = [sn, cs]
S = np.einsum('ij,kj->ki', rot_mat, S)
# flip the x coordinates
if f:
S = flip_kp(S)
S = S.astype('float32')
return S
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
