Build neck.

Build renderers.

Sample positive and negative bboxes. This is a simple implementation of bbox sampling given candidates, assigning results and ground

Apply element-wise weight and reduce loss. Args: loss (Tensor): Element-wise loss. weight (Tensor): Element-wise weights.

Initialize your cameras with `build_cameras` following: 1): provide `K`, `R`, `T`, `resolution`/`image_size`, `in_ndc` directly.

Parse the raw outputs (losses) of the network. Args: losses (dict): Raw output of the network, which usually contain

Cauculate mean per joint position error (MPJPE) or its variants PA- MPJPE. Report mean per joint position error (MPJPE) and mean per

Write output/temp images.

Convert bbox coordinates from (cx, cy, w, h) to (x1, y1, x2, y2). Args: bbox (Tensor): Shape (n, 4) for bboxes. Returns: Ten

Computes a similarity transform (sR, t) that takes a set of 3D points source_points (N x 3) closest to a set of 3D points target_points, where R

Computes the absolute rotation of a joint from the kinematic chain.

Flip function. Flip rotmat.

Construct a HumanData instance from an npz file. Args: npz_path (str): Path to a dumped npz file. Return

Input: - memory: bs, \sum{hw}, d_model - memory_padding_mask: bs, \sum{hw} - spatial_shapes: nlevel, 2 - learnedw

Get the affine transform matrix, given the center/scale/rot/output_size. Args: center (np.ndarray[2, ]): Center of the bounding box (x, y

Get extrinsics(cam2world) of a kinect RGB camera by kinect id. Args: kinect_id (int): ID of a kinect, starts from

Get mapping list from src to dst. Args: src (str): source data type from keypoints_factory. dst (str): destination data type from

Join the meshes along the batch dim. Args: meshes (Union[ParametricMeshes, List[ParametricMeshes, Meshes, List[Meshes]]]): Me

_summary_ Args: keypoints (torch.Tensor): ..., 51

aa2rotmat.

Create random AssignResult for tests or debugging. Args: num_preds: number of predicted boxes num_gts: number of true

Show cameras as well as axis arrow by vedo.show() Args: with_axis (bool, optional): Whether to show the axis arro

Computes per vertex error (PVE). Args: verts_gt (N x verts_num x 3). verts_pred (N x verts_num x 3). alignment (str, opti

This function computes the weak perspective projection of a set of points. Input: points (bs, N, 3): 3D points scale (bs,1):

For each key in this HumanData, get the dimension for slicing. 0 for default, if no other value specified. Returns: dict:

Slice the cameras by batch dim. Args: index (Union[slice, int, torch.Tensor, List, Tuple]): index for slicing.

Initlialize without blend_params.

Parse results.

Draw line on fig with matplotlib.

Cauculate the Area Under the Curve (AUC) computed for a range of 3DPCK thresholds. Args: keypoint_results (list): Keypoint

Cauculate Percentage of Correct Keypoints (3DPCK) w. or w/o Procrustes alignment. Args: keypoint_results (list): Keypoint

Cauculate per vertex error.

Rotate the 3D joints in the local coordinates. Notes: Joints number: K Args: joints_3d (np.ndarray([K, 3])): Coordinates of k

Get the average value of current window.

Build PyTorch DataLoader. In distributed training, each GPU/process has a dataloader. In non-distributed training, there is only one dataload

Build dataset by the given config.

Check whether the keypoints are compressed. Returns: bool: Whether the keypoints are compressed.

If a key contains 'keypoints', and f'{key}_mask' is in self.keys(), invalid zeros will be removed and f'{key}_mask' will be locked. R

Convert between view_to_world and world_to_view defined extrinsic matrix. Args: R (Union[torch.Tensor, np.ndarray]): extrinsic rotati

Compute the faces, barycentric coordinates for the dynamic landmarks. To do so, we first compute the rotation of the neck around the y-axis a

Get indices of left, right keypoint pairs from specified convention. Args: convention (str): data type from keypoints_factory. ke

Get the number of frames recorded by one iPhone RGB camera. Returns: int: Number of frames.

Get value of attribute key_strict. Returns: bool: Whether to raise error when setting unsupported keys.

Get the number of frames recorded by one Kinect RGB camera. Returns: int: Number of frames.

Convert a folder of images to a video. Args: input_folder (str): input image folder output_path (str): output video file path

Construct a HumanData instance from a dict. Args: source_dict (dict, optional): A dict with items in HumanData fa

nn.Module: normalization layer after the third convolution layer

Convert color channels.

Convert rotation 6d representations to rotation matrixs. Args: rotation_6d (Union[torch.Tensor, numpy.ndarray]): input shape

Convert rotation matrixs to rotation 6d representations. Args: matrix (Union[torch.Tensor, numpy.ndarray]): input shape s

Set requies_grad for all the networks. Args: nets (nn.Module | list[nn.Module]): A list of networks or a single network.

Loss used in RetinaNet for dense detection: https://arxiv.org/abs/1708.02002. Args: inputs: A float tensor of arbitrary shape.

Dump camera name and parameters to dict. Returns: dict: Put self.name and self.parameters_dict in

Convert objects of various python types to :obj:`torch.Tensor`. Supported types are: :class:`numpy.ndarray`, :class:`torch.Tensor`, :class:`S

Convert objects of various python types to :obj:`torch.Tensor`. Supported types are: :class:`numpy.ndarray`, :class:`torch.Tensor`, :class:`S

Check whether the key and its value matches definition in CameraParameter.SUPPORTED_KEYS. Args: key (Any):

Calculates landmarks by barycentric interpolation. Parameters ---------- vertices: torch.tensor BxVx3, dtype = torch.float32 The

Convert a video to a folder of images. Args: input_path (str): video file path output_folder (str): output folder to store the im

Transform the bbox format from xywh to x1y1x2y2. Args: bbox_xywh (np.ndarray): Bounding boxes (with scores), shaped (n, 4) or (n,

Slice input_data along slice_dim with slice_range. Args: input_data (Union[np.ndarray, list, tuple]): Data to be

For older versions of HumanData, call this method to apply missing values (also attributes).