gianscarpe / event-based-monocular-hpe / 101

pending completion

Build # 101

Build Type

Pull #10

travis-ci-com

Committed by

web-flow

Commit Message

<a href="https://github.com/gianscarpe/event-based-monocular-hpe/commit/<a class=hub.com/gianscarpe/event-based-monocular-hpe/commit/bf0cdbd2311f9b8612867b80d1864c7740a9cf2d">bf0cdbd23<a href="https://github.com/gianscarpe/event-based-monocular-hpe/commit/bf0cdbd2311f9b8612867b80d1864c7740a9cf2d">">Merge </a><a class="double-link" href="https://github.com/gianscarpe/event-based-monocular-hpe/commit/<a class="double-link" href="https://github.com/gianscarpe/event-based-monocular-hpe/commit/b662799d2f5add120e8e8652aa718d61563198b8">b662799d2</a>">b662799d2</a><a href="https://github.com/gianscarpe/event-based-monocular-hpe/commit/bf0cdbd2311f9b8612867b80d1864c7740a9cf2d"> into a727c57f3">a727c57f3</a>

Pull Request Pull Request #10: Fix plot

Run Details

9 of 9 new or added lines in 4 files covered. (100.0%)

715 of 1595 relevant lines covered (44.83%)

0.45 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

66.36

/experimenting/dataset/core/dhp19core.py

"""
Core dataset implementation. BaseCore may be inherhit to create a new
DatasetCore. DHP19 and NTU cores are provided
"""

import os
from abc import ABC, abstractmethod

import cv2
import numpy as np
import torch
from scipy import io

from experimenting.utils import Skeleton

from ..utils import get_file_paths
from .base import BaseCore


class DHP19Core(BaseCore):
    """
    DHP19 dataset core class. It provides implementation to load frames,
    heatmaps, 2D joints, 3D joints
    """

    MOVEMENTS_PER_SESSION = {1: 8, 2: 6, 3: 6, 4: 6, 5: 7}
    MAX_WIDTH = 346
    MAX_HEIGHT = 260
    N_JOINTS = 13
    DEFAULT_TEST_SUBJECTS = [1, 2, 3, 4, 5]
    DEFAULT_TEST_VIEW = [1, 2]
    TORSO_LENGTH = 453.5242317

    def __init__(
        self,
        name,
        data_dir,
        hm_dir,
        labels_dir,
        cams,
        movements,
        joints_dir,
        preload_dir,
        n_classes,
        n_joints,
        partition,
        n_channels,
        test_subjects=None,
        test_cams=None,
        avg_torso_length=TORSO_LENGTH,
        *args,
        **kwargs,
    ):
        super(DHP19Core, self).__init__(name, partition)
        self.file_paths = DHP19Core._get_file_paths_with_cam_and_mov(
            data_dir, cams, movements
        )

        self.in_shape = (DHP19Core.MAX_HEIGHT, DHP19Core.MAX_WIDTH)
        self.n_channels = n_channels
        self.n_joints = n_joints

        self.avg_torso_length = avg_torso_length
        self.labels_dir = labels_dir
        self.classification_labels = [
            DHP19Core.get_label_from_filename(x_path) for x_path in self.file_paths
        ]

        self.joints = self._retrieve_2hm_files(joints_dir, "npz")
        self.heatmaps = self._retrieve_2hm_files(hm_dir, "npy")

        if test_subjects is None:
            self.subjects = DHP19Core.DEFAULT_TEST_SUBJECTS
        else:
            self.subjects = test_subjects

        if test_cams is None:
            self.view = DHP19Core.DEFAULT_TEST_VIEW
        else:
            self.view = test_cams

    @staticmethod
    def get_standard_path(subject, session, movement, frame, cam, postfix=""):
        return "S{}_session_{}_mov_{}_frame_{}_cam_{}{}.npy".format(
            subject, session, movement, frame, cam, postfix
        )

    @staticmethod
    def load_frame(path):
        ext = os.path.splitext(path)[1]
        if ext == ".mat":
            x = DHP19Core._load_matlab_frame(path)
        elif ext == ".npy":
            x = np.load(path, allow_pickle=True) / 255.0
            if len(x.shape) == 2:
                x = np.expand_dims(x, -1)
        return x

    def _load_matlab_frame(path):
        """
        Matlab files contain voxelgrid frames and must be loaded properly.
        Information is contained respectiely in attributes: V1n, V2n, V3n, V4n

        Examples:
          S1_.mat

        """
        info = DHP19Core.get_frame_info(path)
        x = np.swapaxes(io.loadmat(path)[f'V{info["cam"] + 1}n'], 0, 1)
        return x

    def get_frame_from_id(self, idx):
        return DHP19Core.load_frame(self.file_paths[idx])

    def get_label_from_id(self, idx):
        return self.classification_labels[idx]

    def get_joint_from_id(self, idx):
        joints_file = np.load(self.joints[idx])
        xyz = joints_file["xyz"].swapaxes(0, 1)
        intrinsic_matrix = torch.tensor(joints_file["camera"])
        extrinsic_matrix = torch.tensor(joints_file["M"])
        return Skeleton(xyz), intrinsic_matrix, extrinsic_matrix

    def get_heatmap_from_id(self, idx):
        hm_path = self.heatmaps[idx]
        return load_heatmap(hm_path, self.N_JOINTS)

    def _get_file_paths_with_cam_and_mov(data_dir, cams=None, movs=None):
        if cams is None:
            cams = [3]

        file_paths = np.array(get_file_paths(data_dir, extensions=[".npy", ".mat"]))
        cam_mask = np.zeros(len(file_paths))

        for c in cams:
            cam_mask += [f"cam_{c}" in x for x in file_paths]

        file_paths = file_paths[cam_mask > 0]
        if movs is not None:
            mov_mask = [
                DHP19Core.get_label_from_filename(x) in movs for x in file_paths
            ]

            file_paths = file_paths[mov_mask]

        return file_paths

    @staticmethod
    def get_frame_info(filename):
        filename = os.path.splitext(os.path.basename(filename))[0]

        result = {
            "subject": int(
                filename[filename.find("S") + 1 : filename.find("S") + 4].split("_")[0]
            ),
            "session": int(DHP19Core._get_info_from_string(filename, "session")),
            "mov": int(DHP19Core._get_info_from_string(filename, "mov")),
            "cam": int(DHP19Core._get_info_from_string(filename, "cam")),
            "frame": DHP19Core._get_info_from_string(filename, "frame"),
        }

        return result

    def get_test_subjects(self):
        return self.subjects

    def get_test_view(self):
        return self.view

    def _get_info_from_string(filename, info, split_symbol="_"):
        return int(filename[filename.find(info) :].split(split_symbol)[1])

    @staticmethod
    def get_label_from_filename(filepath) -> int:
        """Given the filepath, return the correspondent movement label (range [0, 32])

        Args:
            filepath (str): frame absolute filepath

        Returns:
            Frame label

        Examples:
            >>> DHP19Core.get_label_from_filename("S1_session_2_mov_1_frame_249_cam_2.npy")
            8

        """

        label = 0
        info = DHP19Core.get_frame_info(filepath)

        for i in range(1, info["session"]):
            label += DHP19Core.MOVEMENTS_PER_SESSION[i]

        return label + info["mov"] - 1  # label in range [0, max_label)

    def _retrieve_2hm_files(self, labels_dir, suffix):
        labels_hm = [
            os.path.join(
                labels_dir, os.path.basename(x).split(".")[0] + f"_2dhm.{suffix}"
            )
            for x in self.file_paths
        ]
        return labels_hm


def load_heatmap(path, n_joints):
    joints = np.load(path)
    h, w = joints.shape
    y = np.zeros((h, w, n_joints))

    for joint_id in range(1, n_joints + 1):
        heatmap = (joints == joint_id).astype('float')
        if heatmap.sum() > 0:
            y[:, :, joint_id - 1] = decay_heatmap(heatmap)

    return y


def decay_heatmap(heatmap, sigma2=10):
    """

    Args
        heatmap :
           WxH matrix to decay
        sigma2 :
             (Default value = 1)

    Returns

        Heatmap obtained by gaussian-blurring the input
    """
    heatmap = cv2.GaussianBlur(heatmap, (0, 0), sigma2)
    heatmap /= np.max(heatmap)  # keep the max to 1
    return heatmap

1	"""
2	Core dataset implementation. BaseCore may be inherhit to create a new
3	DatasetCore. DHP19 and NTU cores are provided
4	"""
5
6	import os	1✔
7	from abc import ABC, abstractmethod	1✔
8
9	import cv2	1✔
10	import numpy as np	1✔
11	import torch	1✔
12	from scipy import io	1✔
13
14	from experimenting.utils import Skeleton	1✔
15
16	from ..utils import get_file_paths	1✔
17	from .base import BaseCore	1✔
18
19
20	class DHP19Core(BaseCore):	1✔
21	"""
22	DHP19 dataset core class. It provides implementation to load frames,
23	heatmaps, 2D joints, 3D joints
24	"""
25
26	MOVEMENTS_PER_SESSION = {1: 8, 2: 6, 3: 6, 4: 6, 5: 7}	1✔
27	MAX_WIDTH = 346	1✔
28	MAX_HEIGHT = 260	1✔
29	N_JOINTS = 13	1✔
30	DEFAULT_TEST_SUBJECTS = [1, 2, 3, 4, 5]	1✔
31	DEFAULT_TEST_VIEW = [1, 2]	1✔
32	TORSO_LENGTH = 453.5242317	1✔
33
34	def __init__(	1✔
35	self,
36	name,
37	data_dir,
38	hm_dir,
39	labels_dir,
40	cams,
41	movements,
42	joints_dir,
43	preload_dir,
44	n_classes,
45	n_joints,
46	partition,
47	n_channels,
48	test_subjects=None,
49	test_cams=None,
50	avg_torso_length=TORSO_LENGTH,
51	*args,
52	**kwargs,
53	):
54	super(DHP19Core, self).__init__(name, partition)	1✔
55	self.file_paths = DHP19Core._get_file_paths_with_cam_and_mov(	1✔
56	data_dir, cams, movements
57	)
58
59	self.in_shape = (DHP19Core.MAX_HEIGHT, DHP19Core.MAX_WIDTH)	1✔
60	self.n_channels = n_channels	1✔
61	self.n_joints = n_joints	1✔
62
63	self.avg_torso_length = avg_torso_length	1✔
64	self.labels_dir = labels_dir	1✔
65	self.classification_labels = [	1✔
66	DHP19Core.get_label_from_filename(x_path) for x_path in self.file_paths
67	]
68
69	self.joints = self._retrieve_2hm_files(joints_dir, "npz")	1✔
70	self.heatmaps = self._retrieve_2hm_files(hm_dir, "npy")	1✔
71
72	if test_subjects is None:	1✔
73	self.subjects = DHP19Core.DEFAULT_TEST_SUBJECTS	×
74	else:
75	self.subjects = test_subjects	1✔
76
77	if test_cams is None:	1✔
78	self.view = DHP19Core.DEFAULT_TEST_VIEW	1✔
79	else:
80	self.view = test_cams	×
81
82	@staticmethod	1✔
83	def get_standard_path(subject, session, movement, frame, cam, postfix=""):	1✔
84	return "S{}_session_{}_mov_{}_frame_{}_cam_{}{}.npy".format(	×
85	subject, session, movement, frame, cam, postfix
86	)
87
88	@staticmethod	1✔
89	def load_frame(path):	1✔
90	ext = os.path.splitext(path)[1]	×
91	if ext == ".mat":	×
92	x = DHP19Core._load_matlab_frame(path)	×
93	elif ext == ".npy":	×
94	x = np.load(path, allow_pickle=True) / 255.0	×
95	if len(x.shape) == 2:	×
96	x = np.expand_dims(x, -1)	×
97	return x	×
98
99	def _load_matlab_frame(path):	1✔
100	"""
101	Matlab files contain voxelgrid frames and must be loaded properly.
102	Information is contained respectiely in attributes: V1n, V2n, V3n, V4n
103
104	Examples:
105	S1_.mat
106
107	"""
108	info = DHP19Core.get_frame_info(path)	×
109	x = np.swapaxes(io.loadmat(path)[f'V{info["cam"] + 1}n'], 0, 1)	×
110	return x	×
111
112	def get_frame_from_id(self, idx):	1✔
113	return DHP19Core.load_frame(self.file_paths[idx])	×
114
115	def get_label_from_id(self, idx):	1✔
116	return self.classification_labels[idx]	×
117
118	def get_joint_from_id(self, idx):	1✔
119	joints_file = np.load(self.joints[idx])	×
120	xyz = joints_file["xyz"].swapaxes(0, 1)	×
121	intrinsic_matrix = torch.tensor(joints_file["camera"])	×
122	extrinsic_matrix = torch.tensor(joints_file["M"])	×
123	return Skeleton(xyz), intrinsic_matrix, extrinsic_matrix	×
124
125	def get_heatmap_from_id(self, idx):	1✔
126	hm_path = self.heatmaps[idx]	×
127	return load_heatmap(hm_path, self.N_JOINTS)	×
128
129	def _get_file_paths_with_cam_and_mov(data_dir, cams=None, movs=None):	1✔
130	if cams is None:	1✔
131	cams = [3]	×
132
133	file_paths = np.array(get_file_paths(data_dir, extensions=[".npy", ".mat"]))	1✔
134	cam_mask = np.zeros(len(file_paths))	1✔
135
136	for c in cams:	1✔
137	cam_mask += [f"cam_{c}" in x for x in file_paths]	1✔
138
139	file_paths = file_paths[cam_mask > 0]	1✔
140	if movs is not None:	1✔
141	mov_mask = [	×
142	DHP19Core.get_label_from_filename(x) in movs for x in file_paths
143	]
144
145	file_paths = file_paths[mov_mask]	×
146
147	return file_paths	1✔
148
149	@staticmethod	1✔
150	def get_frame_info(filename):	1✔
151	filename = os.path.splitext(os.path.basename(filename))[0]	1✔
152
153	result = {	1✔
154	"subject": int(
155	filename[filename.find("S") + 1 : filename.find("S") + 4].split("_")[0]
156	),
157	"session": int(DHP19Core._get_info_from_string(filename, "session")),
158	"mov": int(DHP19Core._get_info_from_string(filename, "mov")),
159	"cam": int(DHP19Core._get_info_from_string(filename, "cam")),
160	"frame": DHP19Core._get_info_from_string(filename, "frame"),
161	}
162
163	return result	1✔
164
165	def get_test_subjects(self):	1✔
166	return self.subjects	1✔
167
168	def get_test_view(self):	1✔
169	return self.view	1✔
170
171	def _get_info_from_string(filename, info, split_symbol="_"):	1✔
172	return int(filename[filename.find(info) :].split(split_symbol)[1])	1✔
173
174	@staticmethod	1✔
175	def get_label_from_filename(filepath) -> int:	1✔
176	"""Given the filepath, return the correspondent movement label (range [0, 32])
177
178	Args:
179	filepath (str): frame absolute filepath
180
181	Returns:
182	Frame label
183
184	Examples:
185	>>> DHP19Core.get_label_from_filename("S1_session_2_mov_1_frame_249_cam_2.npy")
186	8
187
188	"""
189
190	label = 0	1✔
191	info = DHP19Core.get_frame_info(filepath)	1✔
192
193	for i in range(1, info["session"]):	1✔
194	label += DHP19Core.MOVEMENTS_PER_SESSION[i]	1✔
195
196	return label + info["mov"] - 1 # label in range [0, max_label)	1✔
197
198	def _retrieve_2hm_files(self, labels_dir, suffix):	1✔
199	labels_hm = [	1✔
200	os.path.join(
201	labels_dir, os.path.basename(x).split(".")[0] + f"_2dhm.{suffix}"
202	)
203	for x in self.file_paths
204	]
205	return labels_hm	1✔
206
207
208	def load_heatmap(path, n_joints):	1✔
209	joints = np.load(path)	×
210	h, w = joints.shape	×
211	y = np.zeros((h, w, n_joints))	×
212
213	for joint_id in range(1, n_joints + 1):	×
214	heatmap = (joints == joint_id).astype('float')	×
215	if heatmap.sum() > 0:	×
216	y[:, :, joint_id - 1] = decay_heatmap(heatmap)	×
217
218	return y	×
219
220
221	def decay_heatmap(heatmap, sigma2=10):	1✔
222	"""
223
224	Args
225	heatmap :
226	WxH matrix to decay
227	sigma2 :
228	(Default value = 1)
229
230	Returns
231
232	Heatmap obtained by gaussian-blurring the input
233	"""
234	heatmap = cv2.GaussianBlur(heatmap, (0, 0), sigma2)	×
235	heatmap /= np.max(heatmap) # keep the max to 1	×
236	return heatmap	×

gianscarpe / event-based-monocular-hpe / 101

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous