Send data to socket :param fig: plotly figure :param socket: socket object :param socket_type: type of socket to use

Load scan given its scan_path using open3d. Scan can be defined as: - .ply file - .ply.gz file :param scan_path: (str) of path

Load landmarks from file and return the landmarks as torch tensor. Landmark file is defined in the following format: - .txt extensio

Find unit vertex normals.

Check if the input_dict has all the required fields with defined values. Required data for fitting is the scans: - name, - vertices

Close sockets and terminate dash app subprocess. :param visualize: boolean indicating if visualization is on :param socket: socket object

Save results in save_path/YYYY_MM_DD_HH_MM_SS folder. If continue_run is folder of type YYYY_MM_DD_HH_MM_SS, then save results in save_pa

Return list of already fitted scans - founds as .npz files in the save_path directory :param cfg: config dictionary with

Get list of scan names that have been skipped because of missing data. :param cfg: config dictionary with save_path: pa

This function processes the cfg["use_landmarks"] which states which landamrks to use during optimization. The function returns a standar

The optimization iteration steps to visualize from visualize_steps are processed into a list of iteration indices to visualize. :param

Run dahs app in a subprocess. :param port: port to run the dash app on. The visualization should be available at localhost:<port> If

Plot the initial plotly figure for the optimization. Plotting the input scan as point cloud and the initial body model template as point

Set up the socket for sending data to the Dash app Currently only zmq is supported. :param socket_type: type of socket to use

Visualize error curves (losses) for the optimization. Vertical lines are added when weights of losses are changed. :param losses: (dic

Plot the final fit figure for the optimization. Plotting the input scan as mesh if faces are given, else plotting as point cloud. Plo

Plot the points of the optimized body model for iteration :param fig: (plotly) figure :param pc: (torch.tensor) (N,3) :param it

Fit a body body model (SMPL/SMPLX) to the input scan using data, landmark and prior losses :param: input_dict (dict): with keys:

Fit a body body model (SMPL/SMPLX) to the input scan using data, landmark and prior losses :param: input_dict (dict): with keys:

Fit template vertices onto scan. Either start from body model in T-pose or from previous fit. :param: input_dict (dict): with keys:

Initialize the loss_weights if 0-th iteration is not provided in loss_weights dictionary :param loss_weights: dictionary of loss weights

Visualize the PVE errors as a color map on the fitted body model. :param verts: np.array (N,3) :param vert_errors: np.array (N,) :par

Check if all the scan dict has all the required fields If all the data is there, return True, else False Required data is: name, vertices

Close a socket. :param socket: socket object

Create the dash app with 3 plot layout: 3d plot, error curves and the final fit. return: the dash app

Create a background thread to continuously update the figure. :param socket: the zmq socket :param app: the dash app

Given vertices and faces, creates a wireframe of plotly segments. Used for visualizing the wireframe. :param verts:

Set up the ZeroMQ socket for receiving data from the optimization script.

Creates (N,3,4) homogeneous transformation matrix Either random or eye matrix for rotation and 0 for translation. Homogeneous

Initialize the loss_weights if 0-th iteration is missing from the loss_weights dictionary :param loss_weights: dictionary of loss weights

Create graph operation for negative log-likelihood calculation

Parse landamrk txt file with formatting x y z landmark_name :param data (List[str]) list of strings, each string represe

Parse landamrk txt file with formatting landmark_index landmark_name :param data (List[str]) list of strings, each string

Process CAESAR dataset landmarks from .lnd file. Reading file from AUX to END flags. :param landmark_path (str): path to landmark .lnd

:param x: (torch.tensor) dim N x 3 :param y: (torch.tensor) dim N x 3

Terminate the dash app subprocess asking nicely first, then forcefully. :param dash_app_process: the dash app subprocess :param dash

Rotates the normals by homogeneous transformation A (given as N x 3 x 4) A missing last row [0,0,0,1] Input: normals: pytorch Tensor of

:return (dict): dictionary with keys: "name": name of scan "vertices": (N,3) np.array "faces": (N,3) np.a

:return (dict): dictionary with keys: "name": name of scan "vertices": (N,3) np.array "faces": (N,3) np.a

:return (dict): dictionary

:param data_dir (str): path to caesar dataset :param load_countries (str or list): countries to load.

:param data_dir (str): path to caesar dataset :param load_gt (bool): whether to load ground truth fitting or not

Loading 4DHumanOutfit dataset Expecint the following structure: smpl params save as: parameters_path/subj_name/subj_name-

Evaluate the chamfer distance of the fitted body model to the scan. :param fitting_results_path: (str) Path to folder with fitting resu

Evaluate the PVE of the fitted body model to the ground truth (GT) body. When evaluating a dataset - the GT is presumed to be given by

Directional Chamfer Distance from bm template to vertices Sum the distances from every point of the template to the closest point

Directional Chamfer Distance from template to vertices Sum the distances from every point of the template to the closest point

Difference between homo transformations between neighboring template points :param A: (torch.tensor) transformation matrix A

summed L2 norm between scan_landmarks and template_landmarks :param scan_landmarks: (torch.tensor) dim (N,3) :param template

For each template vertex i, find the closest nearest neighbors in the scan and compute the angle between their normals and the normal

Returns the mean of the mixture