r""" Run the network T (= seq_len) times and generate T outputs, where T is the sequence length of xs. Args: xs: (seq_len

Run the network T (= seq_len) times and generate T outputs, where T is the sequence length of xs. Args: xs: (seq_len, ba

r""" Args: input: :math:`(*, C_{in})`, input tensor. Returns: :math:`(*, C_{out})`, output te

r""" Args: x: :math:`(*, C_{in})`, input tensor. Returns: :math:`(*, C_{out})`, output tensor

r""" Args: x (\*, in_features): input tensor dx (\*, in_features): same shape as x, or

r""" Args: x (batch, dim_input, seq_len) or (seq_len, batch, dim_input): the input sequence. batch_fi

r""" Args: input (batch, cin, seq_len): input sequence Returns: output (batch, cin, seq_len_o

Args: input: (batch, cin, seq_len) style: (batch, dim_style) Returns: (batch, cout, seq_len_out)

Args: inputs: (seq_len, batch_size, dim_input) input used to compute attention context_vectors: (num_

Args: x: (num_char, batch, dim_input) symbol embedding valid_lens: (batch,) valid seq

r""" Args: input: - For A: `(*, in_features)` - For AT: `(*, out_features)` - For

r""" Args: x `(*, in_features)`: input tensor s `(*, style_features)`: style tensor or

r""" Args: x `(*, in_features)`: input tensor styles `(*, style_features)` or list of tensors `(*, sty

r""" Args: x: `(*, B, C)` Returns: y: `(*, B, C)`

Args: logits (N, C): tensor of logits. targets (N, ): :math:`targets_i \in {0,1}`

Args: x (batch, dim_input, seq_len) or (seq_len, batch, dim_input): input sequence batch_first (bool)

Args: x: (batch, dim_input) h: current/initial hidden state. If None, a all-zero hidd

Args: x: (seq_len, batch_size, dim_input) h0: hidden state of the lstm. See :py:class:`nn.LSTM`.

apply the color correction Args: x: (*, 3) Returns: (*, 3) corrected x

r"""Pass the input through the encoder layer. Args: src: the sequence to the encoder layer (required). src_mask: the

r"""Pass the input through the encoder layers in turn. Args: src: the sequence to the encoder (required). mask: the m

Args: points: (b, m, k, 3) or (bm, k, 3), m: number of rays, n: number of neighbor points, xyz coord of points addit

Gather the points belonging to each grid cell. Args: grid_idxs: (b, n), grid linear index of each point total_cells: (b,) total grid cells valid_mask

Gather the points belonging to each grid cell. Args: grid_idxs: (b, n), grid linear index of each point total_cells: (b,) total grid cells valid_mask

Generate a camera path that looks at the world origin Args: num_poses: number of camera poses sampled on the circle

Sample grid on theta and phi. phi here: angle between z-axis and camera position Args: num_theta: num_phi: including two

Generate a rect camera path that looks at x_center, y_center Args: num_poses: number of camera poses sampled on the rect

Generate a spiral camera path that looks at the world origin Args: num_poses: number of camera poses sampled on the spira

Generate `n` random camera poses, all of them within a cone of angle of `max_angle` (in degree) (i.e., -max_angle, max_angle) pointing toward

Generate a cleaned mesh in the new directory. Args: input_dir: input folder of the mesh (obj) output_dir: output folder of t

Construct a camera pose homogeneous matrix H_c2w from camera frame R_w and position t_w. Args: R_w: (*, 3, 3) camera coo

Construct a camera pose homogeneous matrix H_c2w. Args: pinhole_location_w: (*, 3) pinhole location in the world coordin

Create arrows pointing from one camera position to the next one. Returns: list of list of arrows. (b, q-1)

Get the current learning rate.

This function is called after setup_assets.

r""" Returns a lambda function that internally calls positional_encoding. Args: num_encoding_functions: Number of encodin

Compute the grid index given xyz_w. Args: points: (b, n, 3) grid_size: (b, 3) long. number of grid cells in x y z. center: (b, 3) center of the grid

Return indexes of which the files do not exist.

Given n points (xyz) and m rays, return the neighboring points to each ray. Args: points: (*, n, 3) ray_origins:

Return the cooresponding numpy dtype.

get number of points (excluding point at inf) but including the invalid points.

get number of valid points (excluding point at inf) but including the invalid points.

Create a camera coordinate frame (as a mesh) in the world coordinate.

Returns the max ray chunk size.

Return rgbd_image (with surface normal) to compare with other methods. Camera should be the orignal camera used to cast the camera ra

Uniformly distribute `total_samples` within [0, 1)^{d}. Args: total_samples: total number of samples d:

Returns the shape of idx-th sample.

Given a trajectory of camera poses, create a trajectory that is a spiral near the trajectory. The function only moves the ca

Return the cooresponding numpy dtype.

Return the uid of the i-th line in the index file. If with_uid was set to False, returns None.

Load gif to numpy array. Args: filename: filename of the gif crop_ratio: ratio of part to be cropped crop_dir: dire

Compute the intersection between grid cells and the ray. Args: ray_origins: (b, m, 3) ray_directions: (b, m, 3) ray_radius: (b,) grid_size: (b, 3) lo

Given linear index, return (i,j,k) Args: ind: # (*, n) long, x + y * sx + z * sx * sy (*, n) long, z + y *

Given linear index, return (i,j,k) Args: ind: (*, n) int64_t, z + y * sz + x * sy * sz size: (*, 3) int64_t Returns: (*, n, 3) int64_t

Called during inference.

A helper function to initialize the weights of a linear/convolutional layer. Args: weight: (*), an n-dimensional torch.T

Interpolate rotation and translation so that it follows the shortest path and has constant speed. Ref: https://www.geometrictools.com/Do

Geodestic interpolation between RigidMotion H0 and RigidMotion H1. t=0 -> H0, t=1 -> H1. Args: t: float or (*,), interp

Interpolate the surface normal of the intersection points using surface normal on the vertices. Args: mesh: raycast_results:

launch the inference, using the parameters in the config yaml file. Args: config_filename: yaml filename

Load the csv file containing the camera information about each scene. Args: filename: csv file containing the camera inf

Load a model (:py:class:`BaseModel`) to device and as eval mode. Args: filename: filename of the pt file model_n

load a pretrained pointersect model from bolt. Args: filename: filename of the model checkpoint device:

Load the state dictionary.

Load the state dictionary.

Load the state dictionary.

Convenient function to call lpips library to calculate the LPIPS metric. Not differentiable. Args: rgb: (h, w, 3), in the range

Move optimizer to a specific device. Args: optimizer: the optimzer to move device: the torch device

Pad x in the sequence dimension so that x has sequence length at least min_seq_len Args: x: (seq_len, b, dim) if not

Compute the intersection between plane_i and ray_i. Returns: ts: (*,)

Plot multiple images by concatenate them in space.

Clean the mesh uv and textures, normalize the mesh within [-scale, scale]. Args: mesh: input mesh scale: parameter to scalin

Print a 2D matrix. The function automatically breaks lines when printing a large 2D array. Args: arr: The matrix to prin

Calculate the PSNR metric. Non-differentiable. Args: rgb: (h, w, 3), in the range of [0, 1] gts: (h, w, 3), in the range of

Create a new tensor or nested list of tensors that has the same shape as x. Each of the tensor is filled with iid samples from a standard nor

Randomly crop a sequence from each sequence in xs. Args: xs: (seq_len, batch, *) input sequences valid_lens:

Use open3d's visualizer to render image and depth_map from the camera. Args: meshes: a list of meshes intrinsic_matrix:

Check whether a ray intersect with an axis-aligned bounding box. Args: ray_origin: (3,) a point on the ray (with t = 0)

Given n points associated with each of the m rays (each row in points), rotate and translate the coordinate so that - ray direction becom

Uvmap a mesh file using xatlas. All existing textures are discarded. Args: filename: input mesh file out_filena