Helper to create a Variable stored on CPU memory. Args: name: name of the variable shape: list of ints initializer: initializer for Vari

Input: xyz: (batch_size, ndataset, 3) TF tensor feature: (batch_size, ndataset, channel) TF tensor npoint: int32

Helper to create an initialized Variable with weight decay. Note that the Variable is initialized with a truncated normal distribution. A weight

Input: xyz1: (batch_size, ndataset1

Input: points: (b,m,c) float32 array, known points idx: (b,n,3) int32 array, indices to known points weight: (b,n,3) floa

Input: xyz1: (b,n,3) float32 array, unknown points xyz2: (b,m,3) float32 array, known points Output: dist: (b,n,3) fl

Batch normalization on convolutional maps and beyond... Ref.: http://stackoverflow.com/questions/33949786/how-could-i-use-batch-normalization-in-te

Input: depthwise version of pointconv

input: batch_size * ndataset * 3 float32 batch_size * npoints int32 returns: batch_size * npoints * 3 float32

Batch normalization on 2D convolutional maps. Args: inputs: Tensor, 4D BHWC input maps is_training: boolean tf.Varialbe, true i

Render point cloud to image with alpha channel. Input: points: Nx3 numpy array (+y is up direction) Output: g

Input: points: (batch_size, ndataset, channel) float32 array, points to sample from idx: (batch_size, npoint, nsample) int32 arra

Discover Euler angle vector from 3x3 matrix Uses the conventions above. Parameters ---------- M : array-like, shape (3,3) cy_th

Input: radius: float32, ball search radius nsample: int32, number of points selected in each ball region xyz1: (batch_siz

Batch normalization on 1D convolutional maps. Args: inputs: Tensor, 3D BLC input maps is_training: boolean tf.Varialbe, true in

Batch normalization on 3D convolutional maps. Args: inputs: Tensor, 5D BDHWC input maps is_training: boolean tf.Varialbe, true

Batch normalization on FC data. Args: inputs: Tensor, 2D BxC input is_training: boolean tf.Varialbe, true indicates training ph

Yield successive n-sized chunks from l.

Return matrix for rotations around z, y and x axes Uses the z, then y, then x convention above Parameters ---------- z : scalar

Return quaternion corresponding to these Euler angles Uses the z, then y, then x convention above Parameters ---------- z : scalar

ops: dict mapping from string to tf ops

ops: dict mapping from string to tf ops

input: int32 batch_size * ndataset * 3 float32 returns: batch_size * npoint int32

Semantic segmentation PointNet, input is BxNx3, output Bxnum_class

Semantic segmentation PointNet, input is BxNx3, output Bxnum_class

CONSTANT WEIGHT TODO input: dist (b,n,3) output: weight (b,n,3)

input: points (b,n,c), idx (b,m,nsample) output: out (b,m,nsample,c)

input: grad_out (b,m,nsample,c), idx (b,m,nsample), output: grad_points (b,n,c)

input: points (b,m,c), idx (b,n,3), weight (b,n,3) output: out (b,n,c)

input: grad_out (b,n,c), idx (b,n,3), weight (b,n,3) output: grad_points (b,m,c)

Input: k: int32, number of k in k-nn search xyz1: (batch_size, ndataset, c) float32 array, input points xyz2: (batch_size

input points Nx3 numpy array (+y is up direction). return an numpy array gray image of size 500x1500.

Demo for draw_point_cloud function

input is Nx3 points output is imgsize*imgsize*num_sample*3 assumes points are in range [-radius, radius] samples num_sample p

input is Nx3 points. output is vsize*vsize*vsize assumes points are in range [-radius, radius]

input is Nx3 points output is vsize*vsize*vsize*num_sample*3 assumes points are in range [-radius, radius] samples num_sample

input: batch_size * ncategory float32 batch_size * npoints float32 returns: batch_size * npoints int32

points is a Nx3 numpy array

input: radius (1), nsample (1), xyz1 (b,n,3), xyz2 (b,m,3) output: idx (b,m,nsample)

read XYZ point cloud from filename PLY file

Input: k: int32, number of k SMALLEST elements selected dist: (b,m,n) float32 array, distance matrix, m query points, n dataset p

input: k (1), distance matrix dist (b,m,n) output: idx (b,m,n), val (b,m,n)

input: points (b,m,c), idx (b,n,3), weight (b,n,3) output: out (b,n,c)

input: grad_out (b,n,c), idx (b,n,3), weight (b,n,3) output: grad_points (b,m,c)

Find three nearest neigbors with square distance input: xyz1 (b,n,3), xyz2(b,m,3) output: dist (b,n,3), idx (b,n,3)

Find three nearest neigbors with square distance input: xyz1 (b,n,3), xyz2(b,m,3) output: dist (b,n,3), idx (b,n,3)

ops: dict mapping from string to tf ops

vol is occupancy grid (value = 0 or 1) of size vsize*vsize*vsize return Nx3 numpy array.