Args: boxes_a: (N, 7) [x, y, z, dx, dy, dz, heading] boxes_b: (M, 7) [x, y, z, dx, dy, dz, heading] Returns: ans_iou

Args: boxes_a: (N, 7) [x, y, z, dx, dy, dz, heading] boxes_b: (M, 7) [x, y, z, dx, dy, dz, heading] Returns: ans_iou

Builds frustum to voxel transformation Returns: f2v_module: nn.Module, Frustum to voxel transformation

Builds frustum feature network Returns: ffn_module: nn.Module, Frustum feature network

Converts calibration object to transformation matricies Args: calib: calibration.Calibration, Calibration object Returns

Reset the state of the inner optimizer.

Compute foreground mask for images Args: gt_boxes2d: (B, N, 4), 2D box labels shape: torch.Size or tuple, Foreground mask des

Performs all_gather operation on the provided tensors. *** Warning ***: torch.distributed.all_gather has no gradient.

Helper from pytorch. :return: Pytorch array of points.

:param corners3d: (N, 8, 3) corners in rect coordinate :return: boxes: (None, 4) [x1, y1, x2, y2] in rgb coordinate :return:

Create an `optim.Optimizer` from `opt_func` with `lr`. Set lr on `layer_groups`.

1. get pc inside 4*sample_box 2. label pc inside gt_box 3. move to sample_box 4. crop pc inside sample_box 5. gt_box as la

Args: box_encodings: (B, N, 7 + ?) x, y, z, w, l, h, r, custom values anchors: (B, N, 7 + C) or (N, 7 + C) [x, y, z,

Args: box_encodings: (B, N, 7 + ?) x, y, z, w, l, h, r, custom values anchors: (B, N, 7 + C) or (N, 7 + C) [x, y, z,

Args: box_encodings: (N, 8 + C) [x, y, z, dx, dy, dz, cos, sin, ...] points: [x, y, z] pred_classes: (N)

Encodes the box instance to a JSON-friendly vector representation. :return: [<float>: 16]. List of floats encoding the box.

Args: gt_boxes: (N, 7 + C) [x, y, z, dx, dy, dz, heading, ...] points: (N, 3) [x, y, z] gt_classes: (N) [

Args: boxes3d: [x, y, z, dx, dy, dz, heading], (x, y, z) is the box center extra_width: [extra_x, extra_y, extra_z] Returns:

Uses iterative farthest point sampling to select a set of npoint features that have the largest minimum distance :param ctx:

:param ctx: :param features: (B, C, N) :param idx: (B, npoint) index tensor of the features to gather :return:

Find the three nearest neighbors of unknown in known :param ctx: :param unknown: (B, N, 3) :param known: (B, M, 3)

Performs weight linear interpolation on 3 features :param ctx: :param features: (B, C, M) Features descriptors to be interpol

:param ctx: :param features: (B, C, N) tensor of features to group :param idx: (B, npoint, nsample) tensor containing the ind

:param ctx: :param radius: float, radius of the balls :param nsample: int, maximum number of features in the balls :p

:param xyz: (B, N, 3) xyz coordinates of the features :param new_xyz: (B, npoint, 3) centroids :param features: (B, C, N) des

:param xyz: (B, N, 3) xyz coordinates of the features :param new_xyz: ignored :param features: (B, C, N) descriptors of the f

:param xyz: (B, N, 3) tensor of the xyz coordinates of the features :param features: (B, N, C) tensor of the descriptors of the the f

:param unknown: (B, n, 3) tensor of the xyz positions of the unknown features :param known: (B, m, 3) tensor of the xyz positions of

Args: ctx: max_range: int, max range of voxels to be grouped nsample: int, maximum number of features in

Args: new_coords: (M1 + M2 ..., 3) centers voxel indices of the ball query xyz: (N1 + N2 ..., 3) xyz coordinates of t

:param xyz: (N1 + N2 ..., 3) tensor of the xyz coordinates of the features :param xyz_batch_cnt: (batch_size), [N1, N2, ...]

Args: ctx: radius: float, radius of the balls nsample: int, maximum number of features in the balls

Args: ctx: features: (N1 + N2 ..., C) tensor of features to group features_batch_cnt: (batch_size) [N1 +

Args: xyz: (N1 + N2 ..., 3) xyz coordinates of the features xyz_batch_cnt: (batch_size), [N1, N2, ...] ne

Args: ctx: xyz: (B, N, 3) where N > npoint npoint: int, number of features in the sampled set Re

Args: ctx: xyz: (N1 + N2 + ..., 3) where N > npoint xyz_batch_cnt: [N1, N2, ...] npoint: int,

Args: ctx: unknown: (N1 + N2..., 3) unknown_batch_cnt: (batch_size), [N1, N2, ...] known: (M1

Args: ctx: features: (M1 + M2 ..., C) idx: [N1 + N2 ..., 3] weight: [N1 + N2 ..., 3]

Args: ctx: // support_xyz: (N1 + N2 ..., 3) xyz coordinates of the features // xyz_batch_cnt: (batch_size

Args: ctx: support_xyz: (N1 + N2 ..., 3) xyz coordinates of the features xyz_batch_cnt: (batch_size), [N1

Args: unknown: (N1 + N2 ..., 3) known: (M1 + M2 ..., 3) unknow_feats: (N1 + N2 ..., C1) known

Args: support_xyz: (N1 + N2 ..., 3) xyz coordinates of the features support_features: (N1 + N2 ..., C) point-wise fea

:param xyz: (N1 + N2 ..., 3) tensor of the xyz coordinates of the features :param xyz_batch_cnt: (batch_size), [N1, N2, ...]

Args: ctx: points: (B, N, 3) point_features: (B, N, C) boxes3d: (B, num_boxes, 7), [x, y, z,

Args: ctx: rois: (N, 7) [x, y, z, dx, dy, dz, heading] (x, y, z) is the box center pts: (npoints, 3)

Args: input: (B, #anchors, #classes) float tensor. Predicted logits for each class target: (B, #ancho

Args: input: (B, #anchors, #codes) float tensor. Ecoded predicted locations of objects. target: (B, #

Args: input: (B, #anchors, #codes) float tensor. Ecoded predicted locations of objects. target: (B, #

Args: input: (B, #anchors, #classes) float tensor. Predited logits for each class. target: (B, #ancho

Args: output: (batch x dim x h x w) or (batch x max_objects) mask: (batch x max_objects) ind: (batch x ma

Args: data_dict: points: (N, 3 + C_in) gt_boxes: optional, (N, 7 + C) [x, y, z, dx, dy, dz, headi

Args: data_dict: points: (N, 3 + C_in) ... Returns: data_dict: