|
|
|
|
|
import copy
|
|
|
import copy as cp
|
|
|
import os.path as osp
|
|
|
from collections import defaultdict
|
|
|
|
|
|
import numpy as np
|
|
|
import pytest
|
|
|
from mmengine.testing import assert_dict_has_keys
|
|
|
from numpy.testing import assert_array_almost_equal, assert_array_equal
|
|
|
|
|
|
from mmaction.datasets.transforms import (DecompressPose, GeneratePoseTarget,
|
|
|
GenSkeFeat, JointToBone,
|
|
|
MergeSkeFeat, MMCompact, MMDecode,
|
|
|
MMUniformSampleFrames, PadTo,
|
|
|
PoseCompact, PoseDecode,
|
|
|
PreNormalize2D, PreNormalize3D,
|
|
|
ToMotion, UniformSampleFrames)
|
|
|
|
|
|
|
|
|
class TestPoseTransforms:
|
|
|
|
|
|
@staticmethod
|
|
|
def test_decompress_pose():
|
|
|
|
|
|
def get_mode(arr):
|
|
|
cnt = defaultdict(lambda: 0)
|
|
|
for num in arr:
|
|
|
cnt[num] += 1
|
|
|
max_val = max(cnt.values())
|
|
|
return [k for k in cnt if cnt[k] == max_val], max_val
|
|
|
|
|
|
total_frames = 100
|
|
|
img_shape = (224, 224)
|
|
|
frame_inds = np.random.choice(range(100), size=120)
|
|
|
frame_inds.sort()
|
|
|
anno_flag = np.random.random(120) > 0.1
|
|
|
anno_inds = np.array([i for i, f in enumerate(anno_flag) if f])
|
|
|
kp = np.random.random([120, 17, 3])
|
|
|
results = dict(
|
|
|
frame_inds=frame_inds,
|
|
|
keypoint=kp,
|
|
|
total_frames=total_frames,
|
|
|
img_shape=img_shape)
|
|
|
|
|
|
inp = cp.deepcopy(results)
|
|
|
|
|
|
decompress_pose = DecompressPose(squeeze=True, max_person=100)
|
|
|
|
|
|
assert str(decompress_pose) == (
|
|
|
'DecompressPose(squeeze=True, max_person=100)')
|
|
|
return_results = decompress_pose(inp)
|
|
|
assert return_results['keypoint'].shape[:-1] == \
|
|
|
return_results['keypoint_score'].shape
|
|
|
|
|
|
num_person = return_results['keypoint'].shape[0]
|
|
|
num_frame = return_results['keypoint'].shape[1]
|
|
|
assert num_person == get_mode(frame_inds)[1]
|
|
|
assert num_frame == len(set(frame_inds))
|
|
|
|
|
|
inp = cp.deepcopy(results)
|
|
|
decompress_pose = DecompressPose(squeeze=False, max_person=100)
|
|
|
return_results = decompress_pose(inp)
|
|
|
assert return_results['keypoint'].shape[:-1] == \
|
|
|
return_results['keypoint_score'].shape
|
|
|
|
|
|
num_person = return_results['keypoint'].shape[0]
|
|
|
num_frame = return_results['keypoint'].shape[1]
|
|
|
assert num_person == get_mode(frame_inds)[1]
|
|
|
assert num_frame == total_frames
|
|
|
|
|
|
inp = cp.deepcopy(results)
|
|
|
inp['anno_inds'] = anno_inds
|
|
|
decompress_pose = DecompressPose(squeeze=True, max_person=100)
|
|
|
return_results = decompress_pose(inp)
|
|
|
assert return_results['keypoint'].shape[:-1] == \
|
|
|
return_results['keypoint_score'].shape
|
|
|
|
|
|
num_person = return_results['keypoint'].shape[0]
|
|
|
num_frame = return_results['keypoint'].shape[1]
|
|
|
assert num_person == get_mode(frame_inds[anno_inds])[1]
|
|
|
assert num_frame == len(set(frame_inds[anno_inds]))
|
|
|
|
|
|
inp = cp.deepcopy(results)
|
|
|
inp['anno_inds'] = anno_inds
|
|
|
decompress_pose = DecompressPose(squeeze=True, max_person=2)
|
|
|
return_results = decompress_pose(inp)
|
|
|
assert return_results['keypoint'].shape[:-1] == \
|
|
|
return_results['keypoint_score'].shape
|
|
|
|
|
|
num_person = return_results['keypoint'].shape[0]
|
|
|
num_frame = return_results['keypoint'].shape[1]
|
|
|
assert num_person <= 2
|
|
|
assert num_frame == len(set(frame_inds[anno_inds]))
|
|
|
|
|
|
@staticmethod
|
|
|
def test_generate_pose_target():
|
|
|
img_shape = (64, 64)
|
|
|
kp = np.array([[[[24, 24], [40, 40], [24, 40]]]])
|
|
|
kpscore = np.array([[[1., 1., 1.]]])
|
|
|
kp = np.concatenate([kp] * 8, axis=1)
|
|
|
kpscore = np.concatenate([kpscore] * 8, axis=1)
|
|
|
results = dict(
|
|
|
img_shape=img_shape,
|
|
|
keypoint=kp,
|
|
|
keypoint_score=kpscore,
|
|
|
modality='Pose')
|
|
|
|
|
|
generate_pose_target = GeneratePoseTarget(
|
|
|
sigma=1,
|
|
|
with_kp=True,
|
|
|
left_kp=(1, ),
|
|
|
right_kp=(2, ),
|
|
|
left_limb=(0, ),
|
|
|
right_limb=(1, ),
|
|
|
skeletons=())
|
|
|
assert str(generate_pose_target) == ('GeneratePoseTarget(sigma=1, '
|
|
|
'use_score=True, with_kp=True, '
|
|
|
'with_limb=False, skeletons=(), '
|
|
|
'double=False, left_kp=(1,), '
|
|
|
'right_kp=(2,), left_limb=(0,), '
|
|
|
'right_limb=(1,), scaling=1.0)')
|
|
|
return_results = generate_pose_target(copy.deepcopy(results))
|
|
|
assert return_results['imgs'].shape == (8, 3, 64, 64)
|
|
|
assert_array_almost_equal(return_results['imgs'][0],
|
|
|
return_results['imgs'][1])
|
|
|
|
|
|
results = dict(img_shape=img_shape, keypoint=kp, modality='Pose')
|
|
|
|
|
|
generate_pose_target = GeneratePoseTarget(sigma=1, with_kp=True)
|
|
|
return_results = generate_pose_target(copy.deepcopy(results))
|
|
|
assert return_results['imgs'].shape == (8, 3, 64, 64)
|
|
|
assert_array_almost_equal(return_results['imgs'][0],
|
|
|
return_results['imgs'][1])
|
|
|
|
|
|
generate_pose_target = GeneratePoseTarget(
|
|
|
sigma=1,
|
|
|
with_kp=False,
|
|
|
with_limb=True,
|
|
|
skeletons=((0, 1), (1, 2), (0, 2)))
|
|
|
return_results = generate_pose_target(copy.deepcopy(results))
|
|
|
assert return_results['imgs'].shape == (8, 3, 64, 64)
|
|
|
assert_array_almost_equal(return_results['imgs'][0],
|
|
|
return_results['imgs'][1])
|
|
|
|
|
|
generate_pose_target = GeneratePoseTarget(
|
|
|
sigma=1,
|
|
|
with_kp=False,
|
|
|
with_limb=True,
|
|
|
double=True,
|
|
|
left_limb=(0, ),
|
|
|
right_limb=(1, ),
|
|
|
skeletons=((0, 1), (1, 2), (0, 2)))
|
|
|
return_results = generate_pose_target(copy.deepcopy(results))
|
|
|
imgs = return_results['imgs']
|
|
|
assert imgs.shape == (16, 3, 64, 64)
|
|
|
assert_array_almost_equal(imgs[0], imgs[1])
|
|
|
assert_array_almost_equal(imgs[:8, 2], imgs[8:, 2, :, ::-1])
|
|
|
assert_array_almost_equal(imgs[:8, 0], imgs[8:, 1, :, ::-1])
|
|
|
assert_array_almost_equal(imgs[:8, 1], imgs[8:, 0, :, ::-1])
|
|
|
|
|
|
img_shape = (64, 64)
|
|
|
kp = np.array([[[[24, 24], [40, 40], [24, 40]]]])
|
|
|
kpscore = np.array([[[0., 0., 0.]]])
|
|
|
kp = np.concatenate([kp] * 8, axis=1)
|
|
|
kpscore = np.concatenate([kpscore] * 8, axis=1)
|
|
|
results = dict(
|
|
|
img_shape=img_shape,
|
|
|
keypoint=kp,
|
|
|
keypoint_score=kpscore,
|
|
|
modality='Pose')
|
|
|
generate_pose_target = GeneratePoseTarget(
|
|
|
sigma=1, with_kp=True, skeletons=())
|
|
|
return_results = generate_pose_target(copy.deepcopy(results))
|
|
|
assert_array_almost_equal(return_results['imgs'], 0)
|
|
|
|
|
|
img_shape = (64, 64)
|
|
|
kp = np.array([[[[24, 24], [40, 40], [24, 40]]]])
|
|
|
kpscore = np.array([[[0., 0., 0.]]])
|
|
|
kp = np.concatenate([kp] * 8, axis=1)
|
|
|
kpscore = np.concatenate([kpscore] * 8, axis=1)
|
|
|
results = dict(
|
|
|
img_shape=img_shape,
|
|
|
keypoint=kp,
|
|
|
keypoint_score=kpscore,
|
|
|
modality='Pose')
|
|
|
generate_pose_target = GeneratePoseTarget(
|
|
|
sigma=1,
|
|
|
with_kp=False,
|
|
|
with_limb=True,
|
|
|
skeletons=((0, 1), (1, 2), (0, 2)))
|
|
|
return_results = generate_pose_target(copy.deepcopy(results))
|
|
|
assert_array_almost_equal(return_results['imgs'], 0)
|
|
|
|
|
|
img_shape = (64, 64)
|
|
|
kp = np.array([[[[124, 124], [140, 140], [124, 140]]]])
|
|
|
kpscore = np.array([[[0., 0., 0.]]])
|
|
|
kp = np.concatenate([kp] * 8, axis=1)
|
|
|
kpscore = np.concatenate([kpscore] * 8, axis=1)
|
|
|
results = dict(
|
|
|
img_shape=img_shape,
|
|
|
keypoint=kp,
|
|
|
keypoint_score=kpscore,
|
|
|
modality='Pose')
|
|
|
generate_pose_target = GeneratePoseTarget(sigma=1, with_kp=True)
|
|
|
return_results = generate_pose_target(copy.deepcopy(results))
|
|
|
assert_array_almost_equal(return_results['imgs'], 0)
|
|
|
|
|
|
img_shape = (64, 64)
|
|
|
kp = np.array([[[[124., 124.], [140., 140.], [124., 140.]]]])
|
|
|
kpscore = np.array([[[0., 0., 0.]]])
|
|
|
kp = np.concatenate([kp] * 8, axis=1)
|
|
|
kpscore = np.concatenate([kpscore] * 8, axis=1)
|
|
|
results = dict(
|
|
|
img_shape=img_shape,
|
|
|
keypoint=kp,
|
|
|
keypoint_score=kpscore,
|
|
|
modality='Pose')
|
|
|
generate_pose_target = GeneratePoseTarget(
|
|
|
sigma=1,
|
|
|
with_kp=False,
|
|
|
with_limb=True,
|
|
|
skeletons=((0, 1), (1, 2), (0, 2)))
|
|
|
return_results = generate_pose_target(results)
|
|
|
assert_array_almost_equal(return_results['imgs'], 0)
|
|
|
|
|
|
@staticmethod
|
|
|
def test_pose_compact():
|
|
|
results = {}
|
|
|
results['img_shape'] = (100, 100)
|
|
|
fake_kp = np.zeros([1, 4, 2, 2])
|
|
|
fake_kp[:, :, 0] = [10, 10]
|
|
|
fake_kp[:, :, 1] = [90, 90]
|
|
|
results['keypoint'] = fake_kp
|
|
|
|
|
|
pose_compact = PoseCompact(
|
|
|
padding=0, threshold=0, hw_ratio=None, allow_imgpad=False)
|
|
|
inp = copy.deepcopy(results)
|
|
|
ret = pose_compact(inp)
|
|
|
assert ret['img_shape'] == (80, 80)
|
|
|
assert str(pose_compact) == (
|
|
|
'PoseCompact(padding=0, threshold=0, hw_ratio=None, '
|
|
|
'allow_imgpad=False)')
|
|
|
|
|
|
pose_compact = PoseCompact(
|
|
|
padding=0.3, threshold=0, hw_ratio=None, allow_imgpad=False)
|
|
|
inp = copy.deepcopy(results)
|
|
|
ret = pose_compact(inp)
|
|
|
assert ret['img_shape'] == (100, 100)
|
|
|
|
|
|
pose_compact = PoseCompact(
|
|
|
padding=0.3, threshold=0, hw_ratio=None, allow_imgpad=True)
|
|
|
inp = copy.deepcopy(results)
|
|
|
ret = pose_compact(inp)
|
|
|
assert ret['img_shape'] == (104, 104)
|
|
|
|
|
|
pose_compact = PoseCompact(
|
|
|
padding=0, threshold=100, hw_ratio=None, allow_imgpad=False)
|
|
|
inp = copy.deepcopy(results)
|
|
|
ret = pose_compact(inp)
|
|
|
assert ret['img_shape'] == (100, 100)
|
|
|
|
|
|
pose_compact = PoseCompact(
|
|
|
padding=0, threshold=0, hw_ratio=0.75, allow_imgpad=True)
|
|
|
inp = copy.deepcopy(results)
|
|
|
ret = pose_compact(inp)
|
|
|
assert ret['img_shape'] == (80, 106)
|
|
|
|
|
|
@staticmethod
|
|
|
def test_pre_normalize3d():
|
|
|
target_keys = ['keypoint', 'total_frames', 'body_center']
|
|
|
|
|
|
results = dict(keypoint=np.random.randn(2, 40, 25, 3), total_frames=40)
|
|
|
|
|
|
pre_normalize3d = PreNormalize3D(
|
|
|
align_center=True, align_spine=True, align_shoulder=False)
|
|
|
|
|
|
inp = copy.deepcopy(results)
|
|
|
ret1 = pre_normalize3d(inp)
|
|
|
|
|
|
inp = copy.deepcopy(ret1)
|
|
|
ret2 = pre_normalize3d(inp)
|
|
|
|
|
|
assert_array_equal(ret2['body_center'], np.zeros(3))
|
|
|
assert_array_equal(ret1['keypoint'], ret2['keypoint'])
|
|
|
|
|
|
pre_normalize3d = PreNormalize3D(
|
|
|
align_center=True, align_spine=False, align_shoulder=True)
|
|
|
|
|
|
inp = copy.deepcopy(results)
|
|
|
ret3 = pre_normalize3d(inp)
|
|
|
|
|
|
inp = copy.deepcopy(ret3)
|
|
|
ret4 = pre_normalize3d(inp)
|
|
|
|
|
|
assert_array_equal(ret4['body_center'], np.zeros(3))
|
|
|
assert_array_equal(ret3['keypoint'], ret4['keypoint'])
|
|
|
|
|
|
assert assert_dict_has_keys(ret1, target_keys)
|
|
|
assert repr(pre_normalize3d) == 'PreNormalize3D(zaxis=[0, 1], ' \
|
|
|
'xaxis=[8, 4], align_center=True, ' \
|
|
|
'align_spine=False, ' \
|
|
|
'align_shoulder=True)'
|
|
|
|
|
|
@staticmethod
|
|
|
def test_pre_normalize2d():
|
|
|
|
|
|
def check_pose_normalize(origin_kps, target_kps, h, w):
|
|
|
target_kps[..., 0] = target_kps[..., 0] * w / 2 + w / 2
|
|
|
target_kps[..., 1] = target_kps[..., 1] * h / 2 + h / 2
|
|
|
assert_array_almost_equal(origin_kps, target_kps, decimal=4)
|
|
|
|
|
|
results = dict(
|
|
|
keypoint=np.random.randn(1, 40, 17, 2), img_shape=(480, 854))
|
|
|
pre_normalize_2d = PreNormalize2D(img_shape=(1080, 1920))
|
|
|
inp = copy.deepcopy(results)
|
|
|
ret1 = pre_normalize_2d(inp)
|
|
|
check_pose_normalize(
|
|
|
results['keypoint'], ret1['keypoint'], h=480, w=854)
|
|
|
|
|
|
results = dict(keypoint=np.random.randn(1, 40, 17, 2))
|
|
|
pre_normalize_2d = PreNormalize2D(img_shape=(1080, 1920))
|
|
|
inp = copy.deepcopy(results)
|
|
|
ret2 = pre_normalize_2d(inp)
|
|
|
check_pose_normalize(
|
|
|
results['keypoint'], ret2['keypoint'], h=1080, w=1920)
|
|
|
|
|
|
assert repr(pre_normalize_2d) == \
|
|
|
'PreNormalize2D(img_shape=(1080, 1920))'
|
|
|
|
|
|
@staticmethod
|
|
|
def test_joint_to_bone():
|
|
|
with pytest.raises(ValueError):
|
|
|
JointToBone(dataset='invalid')
|
|
|
|
|
|
with pytest.raises(AssertionError):
|
|
|
JointToBone()(dict(keypoint=np.random.randn(2, 15, 25, 4)))
|
|
|
|
|
|
results = dict(keypoint=np.random.randn(2, 15, 25, 3))
|
|
|
joint_to_bone = JointToBone(dataset='nturgb+d')
|
|
|
center_index = 20
|
|
|
results = joint_to_bone(results)
|
|
|
assert_array_equal(results['keypoint'][..., center_index, :],
|
|
|
np.zeros((2, 15, 3)))
|
|
|
|
|
|
results = dict(keypoint=np.random.randn(2, 15, 18, 3))
|
|
|
joint_to_bone = JointToBone(dataset='openpose')
|
|
|
center_index = 0
|
|
|
center_score = results['keypoint'][..., center_index, 2]
|
|
|
results = joint_to_bone(results)
|
|
|
assert_array_equal(results['keypoint'][..., center_index, :2],
|
|
|
np.zeros((2, 15, 2)))
|
|
|
assert_array_almost_equal(results['keypoint'][..., center_index, 2],
|
|
|
center_score)
|
|
|
|
|
|
results = dict(keypoint=np.random.randn(2, 15, 17, 3))
|
|
|
joint_to_bone = JointToBone(dataset='coco')
|
|
|
center_index = 0
|
|
|
center_score = results['keypoint'][..., center_index, 2]
|
|
|
results = joint_to_bone(results)
|
|
|
assert_array_equal(results['keypoint'][..., center_index, :2],
|
|
|
np.zeros((2, 15, 2)))
|
|
|
assert_array_almost_equal(results['keypoint'][..., center_index, 2],
|
|
|
center_score)
|
|
|
|
|
|
results = dict(keypoint=np.random.randn(2, 15, 17, 3))
|
|
|
joint_to_bone = JointToBone(dataset='coco', target='bone')
|
|
|
results = joint_to_bone(results)
|
|
|
assert assert_dict_has_keys(results, ['keypoint', 'bone'])
|
|
|
assert repr(joint_to_bone) == 'JointToBone(dataset=coco, target=bone)'
|
|
|
|
|
|
@staticmethod
|
|
|
def test_to_motion():
|
|
|
with pytest.raises(AssertionError):
|
|
|
ToMotion()(dict(keypoint=np.random.randn(2, 15, 25, 4)))
|
|
|
|
|
|
with pytest.raises(KeyError):
|
|
|
ToMotion(source='j')(dict(keypoint=np.random.randn(2, 15, 25, 4)))
|
|
|
|
|
|
results = dict(keypoint=np.random.randn(2, 15, 25, 3))
|
|
|
to_motion = ToMotion()
|
|
|
results = to_motion(results)
|
|
|
assert_array_equal(results['motion'][:, -1, :, :], np.zeros(
|
|
|
(2, 25, 3)))
|
|
|
assert assert_dict_has_keys(results, ['keypoint', 'motion'])
|
|
|
assert repr(to_motion) == 'ToMotion(dataset=nturgb+d, ' \
|
|
|
'source=keypoint, target=motion)'
|
|
|
|
|
|
@staticmethod
|
|
|
def test_merge_ske_feat():
|
|
|
with pytest.raises(KeyError):
|
|
|
MergeSkeFeat()(dict(b=np.random.randn(2, 15, 25, 3)))
|
|
|
|
|
|
results = dict(
|
|
|
j=np.random.randn(2, 10, 25, 3), b=np.random.randn(2, 10, 25, 3))
|
|
|
merge_ske_feat = MergeSkeFeat(feat_list=['j', 'b'])
|
|
|
results = merge_ske_feat(results)
|
|
|
|
|
|
assert assert_dict_has_keys(results, ['keypoint'])
|
|
|
assert results['keypoint'].shape == (2, 10, 25, 6)
|
|
|
assert repr(merge_ske_feat) == "MergeSkeFeat(feat_list=['j', 'b'], " \
|
|
|
'target=keypoint, axis=-1)'
|
|
|
|
|
|
@staticmethod
|
|
|
def test_gen_ske_feat():
|
|
|
results = dict(keypoint=np.random.randn(1, 10, 25, 3))
|
|
|
|
|
|
gen_ske_feat = GenSkeFeat(dataset='nturgb+d', feats=['j'])
|
|
|
inp = copy.deepcopy(results)
|
|
|
ret1 = gen_ske_feat(inp)
|
|
|
assert_array_equal(ret1['keypoint'], results['keypoint'])
|
|
|
|
|
|
gen_ske_feat = GenSkeFeat(
|
|
|
dataset='nturgb+d', feats=['j', 'b', 'jm', 'bm'])
|
|
|
inp = copy.deepcopy(results)
|
|
|
ret2 = gen_ske_feat(inp)
|
|
|
assert ret2['keypoint'].shape == (1, 10, 25, 12)
|
|
|
|
|
|
results = dict(
|
|
|
keypoint=np.random.randn(1, 10, 17, 2),
|
|
|
keypoint_score=np.random.randn(1, 10, 17))
|
|
|
gen_ske_feat = GenSkeFeat(dataset='coco', feats=['j', 'b', 'jm', 'bm'])
|
|
|
results = gen_ske_feat(results)
|
|
|
assert results['keypoint'].shape == (1, 10, 17, 12)
|
|
|
assert assert_dict_has_keys(results, ['keypoint'])
|
|
|
assert not assert_dict_has_keys(results, ['j', 'b', 'jm', 'bm'])
|
|
|
assert repr(gen_ske_feat) == 'GenSkeFeat(dataset=coco, ' \
|
|
|
"feats=['j', 'b', 'jm', 'bm'], axis=-1)"
|
|
|
|
|
|
@staticmethod
|
|
|
def test_uniform_sample_frames():
|
|
|
results = dict(total_frames=64, start_index=0)
|
|
|
sampling = UniformSampleFrames(
|
|
|
clip_len=8, num_clips=1, test_mode=True, seed=0)
|
|
|
|
|
|
assert repr(sampling) == ('UniformSampleFrames(clip_len=8, '
|
|
|
'num_clips=1, test_mode=True, seed=0)')
|
|
|
sampling_results = sampling(results)
|
|
|
assert sampling_results['clip_len'] == 8
|
|
|
assert sampling_results['frame_interval'] is None
|
|
|
assert sampling_results['num_clips'] == 1
|
|
|
assert_array_equal(sampling_results['frame_inds'],
|
|
|
np.array([4, 15, 21, 24, 35, 43, 51, 63]))
|
|
|
|
|
|
results = dict(total_frames=15, start_index=0)
|
|
|
sampling = UniformSampleFrames(
|
|
|
clip_len=8, num_clips=1, test_mode=True, seed=0)
|
|
|
sampling_results = sampling(results)
|
|
|
assert sampling_results['clip_len'] == 8
|
|
|
assert sampling_results['frame_interval'] is None
|
|
|
assert sampling_results['num_clips'] == 1
|
|
|
assert_array_equal(sampling_results['frame_inds'],
|
|
|
np.array([0, 2, 4, 6, 8, 9, 11, 13]))
|
|
|
|
|
|
results = dict(total_frames=7, start_index=0)
|
|
|
sampling = UniformSampleFrames(
|
|
|
clip_len=8, num_clips=1, test_mode=True, seed=0)
|
|
|
sampling_results = sampling(results)
|
|
|
assert sampling_results['clip_len'] == 8
|
|
|
assert sampling_results['frame_interval'] is None
|
|
|
assert sampling_results['num_clips'] == 1
|
|
|
assert_array_equal(sampling_results['frame_inds'],
|
|
|
np.array([0, 1, 2, 3, 4, 5, 6, 0]))
|
|
|
|
|
|
results = dict(total_frames=7, start_index=0)
|
|
|
sampling = UniformSampleFrames(
|
|
|
clip_len=8, num_clips=8, test_mode=True, seed=0)
|
|
|
sampling_results = sampling(results)
|
|
|
assert sampling_results['clip_len'] == 8
|
|
|
assert sampling_results['frame_interval'] is None
|
|
|
assert sampling_results['num_clips'] == 8
|
|
|
assert len(sampling_results['frame_inds']) == 64
|
|
|
|
|
|
results = dict(total_frames=64, start_index=0)
|
|
|
sampling = UniformSampleFrames(
|
|
|
clip_len=8, num_clips=4, test_mode=True, seed=0)
|
|
|
sampling_results = sampling(results)
|
|
|
assert sampling_results['clip_len'] == 8
|
|
|
assert sampling_results['frame_interval'] is None
|
|
|
assert sampling_results['num_clips'] == 4
|
|
|
assert_array_equal(
|
|
|
sampling_results['frame_inds'],
|
|
|
np.array([
|
|
|
4, 15, 21, 24, 35, 43, 51, 63, 1, 11, 21, 26, 36, 47, 54, 56,
|
|
|
0, 12, 18, 25, 38, 47, 55, 62, 0, 9, 21, 25, 37, 40, 49, 60
|
|
|
]))
|
|
|
|
|
|
results = dict(total_frames=64, start_index=0)
|
|
|
sampling = UniformSampleFrames(
|
|
|
clip_len=8, num_clips=1, test_mode=False, seed=0)
|
|
|
sampling_results = sampling(results)
|
|
|
assert sampling_results['clip_len'] == 8
|
|
|
assert sampling_results['frame_interval'] is None
|
|
|
assert sampling_results['num_clips'] == 1
|
|
|
assert len(sampling_results['frame_inds']) == 8
|
|
|
|
|
|
results = dict(total_frames=7, start_index=0)
|
|
|
sampling = UniformSampleFrames(
|
|
|
clip_len=8, num_clips=1, test_mode=False, seed=0)
|
|
|
sampling_results = sampling(results)
|
|
|
assert sampling_results['clip_len'] == 8
|
|
|
assert sampling_results['frame_interval'] is None
|
|
|
assert sampling_results['num_clips'] == 1
|
|
|
assert len(sampling_results['frame_inds']) == 8
|
|
|
|
|
|
results = dict(total_frames=15, start_index=0)
|
|
|
sampling = UniformSampleFrames(
|
|
|
clip_len=8, num_clips=1, test_mode=False, seed=0)
|
|
|
sampling_results = sampling(results)
|
|
|
assert sampling_results['clip_len'] == 8
|
|
|
assert sampling_results['frame_interval'] is None
|
|
|
assert sampling_results['num_clips'] == 1
|
|
|
assert len(sampling_results['frame_inds']) == 8
|
|
|
|
|
|
@staticmethod
|
|
|
def test_pad_to():
|
|
|
with pytest.raises(AssertionError):
|
|
|
PadTo(length=4, mode='invalid')
|
|
|
|
|
|
results = dict(
|
|
|
keypoint=np.random.randn(2, 3, 17, 3),
|
|
|
total_frames=3,
|
|
|
start_index=0)
|
|
|
|
|
|
inp = copy.deepcopy(results)
|
|
|
pad_to = PadTo(length=6, mode='loop')
|
|
|
ret1 = pad_to(inp)
|
|
|
kp = ret1['keypoint']
|
|
|
assert_array_equal(kp[:, :3], kp[:, 3:])
|
|
|
|
|
|
inp = copy.deepcopy(results)
|
|
|
pad_to = PadTo(length=6, mode='zero')
|
|
|
ret2 = pad_to(inp)
|
|
|
kp = ret2['keypoint']
|
|
|
assert ret2['total_frames'] == 6
|
|
|
assert_array_equal(kp[:, 3:], np.zeros((2, 3, 17, 3)))
|
|
|
|
|
|
@staticmethod
|
|
|
def test_pose_decode():
|
|
|
kp = np.random.random([1, 16, 17, 2])
|
|
|
kpscore = np.random.random([1, 16, 17])
|
|
|
frame_inds = np.array([2, 4, 6, 8, 10])
|
|
|
results = dict(
|
|
|
keypoint=kp, keypoint_score=kpscore, frame_inds=frame_inds)
|
|
|
pose_decode = PoseDecode()
|
|
|
assert repr(pose_decode) == 'PoseDecode()'
|
|
|
decode_results = pose_decode(results)
|
|
|
assert_array_almost_equal(decode_results['keypoint'], kp[:,
|
|
|
frame_inds])
|
|
|
assert_array_almost_equal(decode_results['keypoint_score'],
|
|
|
kpscore[:, frame_inds])
|
|
|
|
|
|
results = dict(keypoint=kp, keypoint_score=kpscore, total_frames=16)
|
|
|
pose_decode = PoseDecode()
|
|
|
decode_results = pose_decode(results)
|
|
|
assert_array_almost_equal(decode_results['keypoint'], kp)
|
|
|
assert_array_almost_equal(decode_results['keypoint_score'], kpscore)
|
|
|
|
|
|
@staticmethod
|
|
|
def test_mm_uniform_sample_frames():
|
|
|
results = dict(total_frames=64, modality='Pose')
|
|
|
sampling = MMUniformSampleFrames(
|
|
|
clip_len=dict(RGB=8, Pose=32), num_clips=1, test_mode=True, seed=0)
|
|
|
assert repr(sampling) == ('MMUniformSampleFrames('
|
|
|
"clip_len={'RGB': 8, 'Pose': 32}, "
|
|
|
'num_clips=1, test_mode=True, seed=0)')
|
|
|
|
|
|
sampling_results = sampling(results)
|
|
|
assert sampling_results['clip_len'] == dict(RGB=8, Pose=32)
|
|
|
assert sampling_results['frame_interval'] is None
|
|
|
assert sampling_results['num_clips'] == 1
|
|
|
assert sampling_results['modality'] == ['RGB', 'Pose']
|
|
|
assert_array_equal(sampling_results['RGB_inds'],
|
|
|
np.array([4, 15, 21, 24, 35, 43, 51, 63]))
|
|
|
assert_array_equal(
|
|
|
sampling_results['Pose_inds'],
|
|
|
np.array([
|
|
|
0, 3, 5, 6, 9, 11, 13, 15, 17, 19, 21, 22, 24, 27, 28, 30, 32,
|
|
|
34, 36, 39, 40, 43, 45, 46, 48, 51, 53, 55, 57, 58, 61, 62
|
|
|
]))
|
|
|
|
|
|
results = dict(total_frames=64, modality='Pose')
|
|
|
sampling = MMUniformSampleFrames(
|
|
|
clip_len=dict(RGB=8, Pose=32),
|
|
|
num_clips=10,
|
|
|
test_mode=True,
|
|
|
seed=0)
|
|
|
sampling_results = sampling(results)
|
|
|
assert sampling_results['clip_len'] == dict(RGB=8, Pose=32)
|
|
|
assert sampling_results['frame_interval'] is None
|
|
|
assert sampling_results['num_clips'] == 10
|
|
|
assert sampling_results['modality'] == ['RGB', 'Pose']
|
|
|
assert len(sampling_results['RGB_inds']) == 80
|
|
|
assert len(sampling_results['Pose_inds']) == 320
|
|
|
|
|
|
results = dict(total_frames=64, modality='Pose')
|
|
|
sampling = MMUniformSampleFrames(
|
|
|
clip_len=dict(RGB=8, Pose=32), num_clips=1, test_mode=False)
|
|
|
sampling_results = sampling(results)
|
|
|
assert sampling_results['clip_len'] == dict(RGB=8, Pose=32)
|
|
|
assert sampling_results['frame_interval'] is None
|
|
|
assert sampling_results['num_clips'] == 1
|
|
|
assert len(sampling_results['RGB_inds']) == 8
|
|
|
assert len(sampling_results['Pose_inds']) == 32
|
|
|
|
|
|
@staticmethod
|
|
|
def test_mm_decode():
|
|
|
mm_decode = MMDecode()
|
|
|
|
|
|
|
|
|
pose_raw_results = dict(
|
|
|
modality=['Pose'],
|
|
|
Pose_inds=np.array([2, 4, 6, 8, 10]),
|
|
|
keypoint=np.random.random([1, 16, 17, 2]),
|
|
|
img_shape=(1080, 1920))
|
|
|
rgb_raw_results = dict(
|
|
|
modality=['RGB'],
|
|
|
RGB_inds=np.array([2, 4, 6, 8, 10]),
|
|
|
frame_dir=osp.join(osp.dirname(__file__), '../../data/test'))
|
|
|
|
|
|
|
|
|
mm_decode(copy.deepcopy(pose_raw_results))
|
|
|
|
|
|
|
|
|
pose_raw_results['keypoint_score'] = np.random.random([1, 16, 17])
|
|
|
pose_results = mm_decode(copy.deepcopy(pose_raw_results))
|
|
|
|
|
|
|
|
|
rgb_results = mm_decode(copy.deepcopy(rgb_raw_results))
|
|
|
|
|
|
|
|
|
pose_rgb_raw_results = {
|
|
|
**rgb_raw_results,
|
|
|
**pose_raw_results, 'modality': ['RGB', 'Pose']
|
|
|
}
|
|
|
pose_rgb_results = mm_decode(copy.deepcopy(pose_rgb_raw_results))
|
|
|
|
|
|
assert_array_equal(pose_rgb_results['keypoint_score'],
|
|
|
pose_results['keypoint_score'])
|
|
|
scaled_keypoint = copy.deepcopy(pose_results['keypoint'])
|
|
|
oh, ow = pose_results['img_shape']
|
|
|
nh, nw = pose_rgb_results['img_shape']
|
|
|
scaled_keypoint[..., 0] *= (nw / ow)
|
|
|
scaled_keypoint[..., 1] *= (nh / oh)
|
|
|
assert_array_equal(pose_rgb_results['keypoint'], scaled_keypoint)
|
|
|
assert_array_equal(pose_rgb_results['imgs'], rgb_results['imgs'])
|
|
|
assert assert_dict_has_keys(
|
|
|
pose_rgb_results, ['filename', 'img_shape', 'original_shape'])
|
|
|
assert repr(mm_decode) == 'MMDecode(io_backend=disk)'
|
|
|
|
|
|
@staticmethod
|
|
|
def test_mm_compact():
|
|
|
results = {}
|
|
|
results['img_shape'] = (100, 100)
|
|
|
fake_kp = np.zeros([1, 4, 2, 2])
|
|
|
fake_kp[:, :, 0] = [10, 10]
|
|
|
fake_kp[:, :, 1] = [90, 90]
|
|
|
results['keypoint'] = fake_kp
|
|
|
results['imgs'] = list(np.zeros([3, 100, 100, 3]))
|
|
|
|
|
|
pose_compact = MMCompact(
|
|
|
padding=0, threshold=0, hw_ratio=1, allow_imgpad=False)
|
|
|
inp = copy.deepcopy(results)
|
|
|
ret = pose_compact(inp)
|
|
|
assert ret['img_shape'] == (80, 80)
|
|
|
assert ret['imgs'][0].shape[:-1] == (80, 80)
|
|
|
assert str(pose_compact) == (
|
|
|
'MMCompact(padding=0, threshold=0, hw_ratio=(1, 1), '
|
|
|
'allow_imgpad=False)')
|
|
|
|
|
|
pose_compact = MMCompact(
|
|
|
padding=0.3, threshold=0, hw_ratio=1, allow_imgpad=False)
|
|
|
inp = copy.deepcopy(results)
|
|
|
ret = pose_compact(inp)
|
|
|
assert ret['img_shape'] == (100, 100)
|
|
|
assert ret['imgs'][0].shape[:-1] == (100, 100)
|
|
|
|
|
|
pose_compact = MMCompact(
|
|
|
padding=0.3, threshold=0, hw_ratio=1, allow_imgpad=True)
|
|
|
inp = copy.deepcopy(results)
|
|
|
ret = pose_compact(inp)
|
|
|
assert ret['img_shape'] == (104, 104)
|
|
|
assert ret['imgs'][0].shape[:-1] == (104, 104)
|
|
|
|
|
|
pose_compact = MMCompact(
|
|
|
padding=0, threshold=100, hw_ratio=1, allow_imgpad=False)
|
|
|
inp = copy.deepcopy(results)
|
|
|
ret = pose_compact(inp)
|
|
|
assert ret['img_shape'] == (100, 100)
|
|
|
assert ret['imgs'][0].shape[:-1] == (100, 100)
|
|
|
|
|
|
pose_compact = MMCompact(
|
|
|
padding=0, threshold=0, hw_ratio=0.75, allow_imgpad=True)
|
|
|
inp = copy.deepcopy(results)
|
|
|
ret = pose_compact(inp)
|
|
|
assert ret['img_shape'] == (80, 106)
|
|
|
assert ret['imgs'][0].shape[:-1] == (80, 106)
|
|
|
|
