Loads the schedulers state. Arguments: state_dict (dict): scheduler state. Should be an object returned from a ca

Input: pc1: (B,N,C) torch tensor pc2: (B,M,C) torch tensor l1smooth: bool, whether to use l1smooth loss delta: sc

Smooth L1 loss. x = error = pred - gt or dist(pred,gt) 0.5 * |x|^2 if |x|<=d |x| - 0.5 * d if |x|>d

Returns the state of the scheduler as a :class:`dict`. It contains an entry for every variable in self.__dict__ which is not the opti

Input: points: input points data, [B, N, C] idx: sample index data, [B, S, [K]] Return: new_points:, indexed points d

Parse predictions to OBB parameters and suppress overlapping boxes Args: end_points: dict {point_clouds, center, heading

Compute P and R for predicted bounding boxes. Ignores classes! Args: labels: (N x bbox) ground-truth bounding boxes (6 dims) pred

Accumulate one batch of prediction and groundtruth. Args: batch_pred_map_cls: a list of lists [[(pred_cls, pred_box_para

Computes IoU of two axis aligned bboxes. Args: box_a, box_b: 6D of center and lengths Returns: iou

Flip X-right,Y-forward,Z-up to X-right,Y-down,Z-forward Input and output are both (N,3) array

box_size is array(l,w,h), heading_angle is radius clockwise from pos x axis, center is xyz of box center output (8,3) array for 3D box cornde

Ref: http://stackoverflow.com/questions/24467972/calculate-area-of-polygon-given-x-y-coordinates

Calculate Euclid distance between each two points. src^T * dst = xn * xm + yn * ym + zn * zm； sum(src^2, dim=-1) = xn*xn + yn*yn + zn*zn;

Inverse function to angle2class. As ScanNet only has axis-alined boxes so angles are always 0.

Inverse function to size2class

find point radius < SAME_THRES

Use accumulated predictions and groundtruths to compute Average Precision.

Compute area of two convex hull's intersection area. p1,p2 are a list of (x,y) tuples of hull vertices. return a list of (x,y) for th

Parse groundtruth labels to OBB parameters. Args: end_points: dict {center_label, heading_class_label, heading_residual_

Rotate a point cloud back. Args: xyz (torch.Tensor or np.ndarray): Point clouds augment_flip_YZ_XZ (_type_): _descrip

Return an activation function given a string

compute distance between box corners to replace iou Args: crnr1, crnr2: Nx3 points of box corners in camera axis (y points down)

corners: (8,3) no assumption on axis direction

Compute 3D bounding box and semantic classification loss.

Generic functions to compute precision/recall for object detection for a single class. Input: pred: map of {img_id: [(bbo

Generic functions to compute precision/recall for object detection for multiple classes. Input: pred_all: map of {img_id:

points are XYZ RGB (RGB in 0-255), semantic label as nyu40 ids, instance label as 1-#instance, box as (cx,cy,cz,dx,dy,dz,semantic_label)

Input: xyz: pointcloud data, [B, N, 3] npoint: number of samples Return: centroids: sampled pointcloud index, [B, npo

Loss functions Args: end_points: dict { center, heading_scores, heading_residuals_normali

r""" Args: query, key, value: map a query and a set of key-value pairs to an output. See "Attention Is All You Need" for more

Parse predictions to OBB parameters and suppress overlapping boxes Args: end_points: dict {point_clouds, center, heading

Extract the axis aligned box from a pcl or batch of pcls Args: points: Nx3 points or BxNx3 output is 6 dim: xyz pos of center and

Clip a polygon with another polygon. Ref: https://rosettacode.org/wiki/Sutherland-Hodgman_polygon_clipping#Python Args: subjectPolygon:

Input: radius: local region radius nsample: max sample number in local region xyz: all points, [B, N, 3] new_xyz:

Input is NxC, output is num_samplexC

input: p1,p2,p3,p4 return: normal vector, size, quad center, direction

Initialize the detectron2 logger and set its verbosity level to "INFO". Args: output (str): a file name or a directory to save log.

Numpy function for softmax

Export oriented (around Z axis) scene bbox to meshes Args: scene_bbox: (N x 7 numpy array): xyz pos of center and 3 lengths (dx,dy,dz)

Returns a dict with following keys: point_clouds: (N,3+C) center_label: (MAX_NUM_OBJ,3) for GT box center XYZ

Compute 3D bounding box IoU. Input: corners1: numpy array (8,3), assume up direction is negative Y corners2: numpy array (8,3),

Compute 3D bounding box and semantic classification loss.