def test_conv_jacobian_points(self, num_points, num_samples, num_features, batch_size, radius, num_kernel_points, dimension): cell_sizes = np.float32(np.repeat(radius, dimension)) points, batch_ids = utils._create_random_point_cloud_segmented( batch_size, num_points, dimension=dimension) features = np.random.rand(num_points, num_features[0]) point_samples, batch_ids_samples = \ utils._create_random_point_cloud_segmented( batch_size, num_samples, dimension=dimension) point_cloud_samples = PointCloud(point_samples, batch_ids_samples) point_cloud = PointCloud(points, batch_ids) grid = Grid(point_cloud, cell_sizes) neighborhood = Neighborhood(grid, cell_sizes, point_cloud_samples) neighborhood.compute_pdf() conv_layer = KPConv(num_features[0], num_features[1], num_kernel_points) def conv_points(points_in): point_cloud._points = points_in neighborhood._grid._sorted_points = \ tf.gather(points_in, grid._sorted_indices) conv_result = conv_layer(features, point_cloud, point_cloud_samples, radius, neighborhood) return conv_result self.assert_jacobian_is_correct_fn(conv_points, [np.float32(points)], atol=1e-3, delta=1e-3)
def test_neighbors_on_3D_meshgrid_without_gridDS(self, num_points_cbrt, num_points_samples_cbrt, radius, expected_num_neighbors): num_points = num_points_cbrt**3 num_samples = num_points_samples_cbrt**3 points = utils._create_uniform_distributed_point_cloud_3D( num_points_cbrt, flat=True) batch_ids = np.zeros(num_points) points_samples = utils._create_uniform_distributed_point_cloud_3D( num_points_samples_cbrt, bb_min=1 / (num_points_samples_cbrt + 1), flat=True) batch_ids_samples = np.zeros(num_samples) point_cloud = PointCloud(points, batch_ids) point_cloud_samples = PointCloud(points_samples, batch_ids_samples) # without grid neigh_ranges, _ = find_neighbors_no_grid( point_cloud, point_cloud_samples, radius) num_neighbors = np.zeros(num_samples) num_neighbors[0] = neigh_ranges[0] num_neighbors[1:] = neigh_ranges[1:] - neigh_ranges[:-1] expected_num_neighbors = \ np.ones_like(num_neighbors) * expected_num_neighbors self.assertAllEqual(num_neighbors, expected_num_neighbors)
def test_compute_keys_tf(self, num_points, batch_size, scale, radius, dimension): radius = np.repeat(radius, dimension) points, batch_ids = utils._create_random_point_cloud_segmented( batch_size, num_points * batch_size, dimension=dimension, sizes=np.ones(batch_size, dtype=int) * num_points, clean_aabb=False) point_cloud = PointCloud(points, batch_ids) #Compute the number of cells in the grid. aabb = point_cloud.get_AABB() aabb_sizes = aabb._aabb_max - aabb._aabb_min batch_num_cells = tf.cast(tf.math.ceil(aabb_sizes / radius), tf.int32) total_num_cells = tf.maximum(tf.reduce_max(batch_num_cells, axis=0), 1) keys_tf = compute_keys_tf(point_cloud, total_num_cells, radius) aabb_min = aabb._aabb_min.numpy() aabb_min_per_point = aabb_min[batch_ids, :] cell_ind = np.floor((points - aabb_min_per_point) / radius).astype(int) cell_ind = np.minimum(np.maximum(cell_ind, [0] * dimension), total_num_cells) cell_multiplier = np.flip(np.cumprod(np.flip(total_num_cells))) cell_multiplier = np.concatenate((cell_multiplier, [1]), axis=0) keys = batch_ids * cell_multiplier[0] + \ np.sum(cell_ind * cell_multiplier[1:].reshape([1, -1]), axis=1) # check unsorted keys self.assertAllEqual(keys_tf, keys)
def test_compute_keys_with_sort(self, num_points, batch_size, scale, radius, dimension): radius = np.repeat(radius, dimension) points, batch_ids = utils._create_random_point_cloud_segmented( batch_size, num_points * batch_size, dimension=dimension, sizes=np.ones(batch_size, dtype=int) * num_points, clean_aabb=False) point_cloud = PointCloud(points, batch_ids) aabb = point_cloud.get_AABB() grid = Grid(point_cloud, radius) total_num_cells = grid._num_cells.numpy() aabb_min = aabb._aabb_min.numpy() aabb_min_per_point = aabb_min[batch_ids, :] cell_ind = np.floor((points - aabb_min_per_point) / radius).astype(int) cell_ind = np.minimum(np.maximum(cell_ind, [0] * dimension), total_num_cells) cell_multiplier = np.flip(np.cumprod(np.flip(total_num_cells))) cell_multiplier = np.concatenate((cell_multiplier, [1]), axis=0) keys = batch_ids * cell_multiplier[0] + \ np.sum(cell_ind * cell_multiplier[1:].reshape([1, -1]), axis=1) # check unsorted keys self.assertAllEqual(grid._cur_keys, keys) # sort descending sorted_keys = np.flip(np.sort(keys)) # check if the cell keys per point are equal self.assertAllEqual(grid._sorted_keys, sorted_keys)
def test_neighbors_on_3D_meshgrid(self, num_points_cbrt, num_points_samples_cbrt, radius, expected_num_neighbors): num_points = num_points_cbrt**3 num_samples = num_points_samples_cbrt**3 points = utils._create_uniform_distributed_point_cloud_3D( num_points_cbrt, flat=True) batch_ids = np.zeros(num_points) points_samples = utils._create_uniform_distributed_point_cloud_3D( num_points_samples_cbrt, bb_min=1 / (num_points_samples_cbrt + 1), flat=True) batch_ids_samples = np.zeros(num_samples) point_cloud = PointCloud(points, batch_ids) point_cloud_samples = PointCloud(points_samples, batch_ids_samples) radius = np.float32(np.repeat([radius], 3)) grid = Grid(point_cloud, radius) neighborhood = Neighborhood(grid, radius, point_cloud_samples) neigh_ranges = neighborhood._samples_neigh_ranges num_neighbors = np.zeros(num_samples) num_neighbors[0] = neigh_ranges[0] num_neighbors[1:] = neigh_ranges[1:] - neigh_ranges[:-1] expected_num_neighbors = \ np.ones_like(num_neighbors) * expected_num_neighbors self.assertAllEqual(num_neighbors, expected_num_neighbors)
def test_convolution(self, num_points, num_samples, num_features, batch_size, radius, num_kernel_points, dimension): cell_sizes = np.float32(np.repeat(radius, dimension)) points, batch_ids = utils._create_random_point_cloud_segmented( batch_size, num_points, dimension=dimension) features = np.random.rand(num_points, num_features[0]) point_cloud = PointCloud(points, batch_ids) point_samples, batch_ids_samples = \ utils._create_random_point_cloud_segmented( batch_size, num_samples, dimension=dimension) point_cloud_samples = PointCloud(point_samples, batch_ids_samples) grid = Grid(point_cloud, cell_sizes) neighborhood = Neighborhood(grid, cell_sizes, point_cloud_samples) # tf conv_layer = KPConv(num_features[0], num_features[1], num_kernel_points) conv_result_tf = conv_layer(features, point_cloud, point_cloud_samples, radius, neighborhood) # numpy neighbor_ids = neighborhood._original_neigh_ids.numpy() nb_ranges = neighborhood._samples_neigh_ranges.numpy() nb_ranges = np.concatenate(([0], nb_ranges), axis=0) kernel_points = conv_layer._kernel_points.numpy() sigma = conv_layer._sigma.numpy() # extract variables weights = conv_layer._weights.numpy() features_on_neighbors = features[neighbor_ids[:, 0]] # compute distances to kernel points point_diff = (points[neighbor_ids[:, 0]] -\ point_samples[neighbor_ids[:, 1]])\ / np.expand_dims(cell_sizes, 0) kernel_point_diff = np.expand_dims(point_diff, axis=1) -\ np.expand_dims(kernel_points, axis=0) distances = np.linalg.norm(kernel_point_diff, axis=2) # compute linear interpolation weights for features based on distances kernel_weights = np.maximum(1 - (distances / sigma), 0) weighted_features = np.expand_dims(features_on_neighbors, axis=2) *\ np.expand_dims(kernel_weights, axis=1) # sum over neighbors (integration) weighted_features_per_sample = \ np.zeros([num_samples, num_features[0], num_kernel_points]) for i in range(num_samples): weighted_features_per_sample[i] = \ np.sum(weighted_features[nb_ranges[i]:nb_ranges[i + 1]], axis=0) # convolution with summation over kernel dimension conv_result_np = \ np.matmul( weighted_features_per_sample.reshape( -1, num_features[0] * num_kernel_points), weights) self.assertAllClose(conv_result_tf, conv_result_np, atol=1e-5)
def test_basis_proj_jacobian(self, num_points, num_samples, num_features, batch_size, radius, hidden_size, dimension): cell_sizes = np.float32(np.repeat(radius, dimension)) points, batch_ids = utils._create_random_point_cloud_segmented( batch_size, num_points, dimension=dimension) features = np.random.rand(num_points, num_features[0]) point_cloud = PointCloud(points, batch_ids) point_samples, batch_ids_samples = \ utils._create_random_point_cloud_segmented( batch_size, num_samples, dimension=dimension) point_cloud_samples = PointCloud(point_samples, batch_ids_samples) grid = Grid(point_cloud, cell_sizes) neighborhood = Neighborhood(grid, cell_sizes, point_cloud_samples) nb_ids = neighborhood._original_neigh_ids # tf conv_layer = MCConv(num_features[0], num_features[1], dimension, 1, [hidden_size]) neigh_point_coords = points[nb_ids[:, 0].numpy()] center_point_coords = point_samples[nb_ids[:, 1].numpy()] kernel_input = (neigh_point_coords - center_point_coords) / radius basis_weights_tf = tf.reshape(conv_layer._weights_tf[0], [dimension, hidden_size]) basis_biases_tf = tf.reshape(conv_layer._bias_tf[0], [1, hidden_size]) basis_neighs = \ tf.matmul(kernel_input.astype(np.float32), basis_weights_tf) +\ basis_biases_tf basis_neighs = tf.nn.leaky_relu(basis_neighs) _, _, counts = tf.unique_with_counts(neighborhood._neighbors[:, 1]) max_num_nb = tf.reduce_max(counts).numpy() with self.subTest(name='features'): def basis_proj_features(features_in): return basis_proj_tf(basis_neighs, features_in, neighborhood) / (max_num_nb) self.assert_jacobian_is_correct_fn(basis_proj_features, [np.float32(features)], atol=1e-4, delta=1e-3) with self.subTest(name='neigh_basis'): def basis_proj_basis_neighs(basis_neighs_in): return basis_proj_tf(basis_neighs_in, features, neighborhood) / (max_num_nb) self.assert_jacobian_is_correct_fn(basis_proj_basis_neighs, [np.float32(basis_neighs)], atol=1e-4, delta=1e-3)
def test_exceptions_raised_at_construction(self, num_points, msgs): points = np.random.rand(num_points) batch_ids = np.zeros(num_points) with self.assertRaisesRegex(ValueError, msgs[0]): _ = PointCloud(points, batch_ids) points = np.random.rand(num_points, 3) with self.assertRaisesRegexp(ValueError, msgs[1]): _ = PointCloud(points) with self.assertRaisesRegexp(AssertionError, msgs[2]): _ = PointCloud(points, batch_ids[1:])
def compute_pdf(points_in): point_cloud = PointCloud(points_in, batch_ids, batch_size) grid = Grid(point_cloud, cell_sizes) point_cloud_samples = PointCloud(samples, samples_batch_ids, batch_size) neighborhood = Neighborhood(grid, cell_sizes, point_cloud_samples) neighborhood.compute_pdf(bandwidths, KDEMode.constant, normalize=True) # account for influence of neighborhood size _, _, counts = tf.unique_with_counts(neighborhood._neighbors[:, 1]) max_num_nb = tf.cast(tf.reduce_max(counts), tf.float32) return neighborhood._pdf / max_num_nb
def test_grid_datastructure(self, num_points, batch_size, scale, radius, dimension): radius = np.float32(np.repeat(radius, dimension)) points, batch_ids = utils._create_random_point_cloud_segmented( batch_size, num_points * batch_size, dimension=dimension, sizes=np.ones(batch_size, dtype=int) * num_points, clean_aabb=True) point_cloud = PointCloud(points, batch_ids) #Compute the number of cells in the grid. aabb = point_cloud.get_AABB() aabb_sizes = aabb._aabb_max - aabb._aabb_min batch_num_cells = tf.cast(tf.math.ceil(aabb_sizes / radius), tf.int32) total_num_cells = tf.maximum(tf.reduce_max(batch_num_cells, axis=0), 1) keys = compute_keys(point_cloud, total_num_cells, radius) keys = tf.sort(keys, direction='DESCENDING') ds_tf = build_grid_ds_tf(keys, total_num_cells, batch_size) keys = keys.numpy() ds_numpy = np.full( (batch_size, total_num_cells[0], total_num_cells[1], 2), 0) if dimension == 2: cells_per_2D_cell = 1 elif dimension > 2: cells_per_2D_cell = np.prod(total_num_cells[2:]) for key_iter, key in enumerate(keys): curDSIndex = key // cells_per_2D_cell yIndex = curDSIndex % total_num_cells[1] auxInt = curDSIndex // total_num_cells[1] xIndex = auxInt % total_num_cells[0] curbatch_ids = auxInt // total_num_cells[0] if key_iter == 0: ds_numpy[curbatch_ids, xIndex, yIndex, 0] = key_iter else: prevKey = keys[key_iter - 1] prevDSIndex = prevKey // cells_per_2D_cell if prevDSIndex != curDSIndex: ds_numpy[curbatch_ids, xIndex, yIndex, 0] = key_iter nextIter = key_iter + 1 if nextIter >= len(keys): ds_numpy[curbatch_ids, xIndex, yIndex, 1] = len(keys) else: nextKey = keys[key_iter + 1] nextDSIndex = nextKey // cells_per_2D_cell if nextDSIndex != curDSIndex: ds_numpy[curbatch_ids, xIndex, yIndex, 1] = key_iter + 1 # check if the data structure is equal self.assertAllEqual(ds_tf, ds_numpy)
def test_local_pooling(self, num_points, num_samples, batch_size, radius, dimension): cell_sizes = np.float32(np.repeat(radius, dimension)) points, batch_ids = utils._create_random_point_cloud_segmented( batch_size, num_points, dimension=dimension) features = np.random.rand(num_points, dimension) point_cloud = PointCloud(points, batch_ids) point_samples, batch_ids_samples = \ utils._create_random_point_cloud_segmented( batch_size, num_samples, dimension=dimension) point_cloud_samples = PointCloud(point_samples, batch_ids_samples) grid = Grid(point_cloud, cell_sizes) neighborhood = Neighborhood(grid, cell_sizes, point_cloud_samples) neighbor_ids = neighborhood._original_neigh_ids.numpy() features_on_neighbors = features[neighbor_ids[:, 0]] #max pooling with self.subTest(name='max_pooling_to_sampled'): PoolLayer = MaxPooling() pool_tf = PoolLayer(features, point_cloud, point_cloud_samples, cell_sizes) pool_numpy = np.empty([num_samples, dimension]) for i in range(num_samples): pool_numpy[i] = np.max( features_on_neighbors[neighbor_ids[:, 1] == i], axis=0) self.assertAllClose(pool_tf, pool_numpy) point_cloud.set_batch_shape([batch_size // 2, 2]) padded = PoolLayer(features, point_cloud, point_cloud_samples, cell_sizes, return_padded=True) self.assertTrue(padded.shape.rank > 2) #max pooling with self.subTest(name='average_pooling_to_sampled'): PoolLayer = AveragePooling() pool_tf = PoolLayer(features, point_cloud, point_cloud_samples, cell_sizes) pool_numpy = np.empty([num_samples, dimension]) for i in range(num_samples): pool_numpy[i] = np.mean( features_on_neighbors[neighbor_ids[:, 1] == i], axis=0) self.assertAllClose(pool_tf, pool_numpy)
def sample(neighborhood, sample_mode='poisson', name=None): """ Sampling for a neighborhood. Args: neighborhood: A `Neighborhood` instance. sample_mode: A `string`, either `'poisson'`or `'cell average'`. Returns: A `PointCloud` instance, the sampled points. An `int` `Tensor` of shape `[S]`, the indices of the sampled points, `None` for cell average sampling. """ sample_mode_value = sample_modes[sample_mode.lower()] #Compute the sampling. sampled_points, sampled_batch_ids, sampled_indices = \ sampling(neighborhood, sample_mode_value) #Save the sampled point cloud. if sample_mode_value == 0: sampled_indices = tf.gather( neighborhood._grid._sorted_indices, sampled_indices) else: sampled_indices = None sampled_point_cloud = PointCloud( points=sampled_points, batch_ids=sampled_batch_ids, batch_size=neighborhood._point_cloud_sampled._batch_size_numpy) return sampled_point_cloud, sampled_indices
def test_sampling_poisson_disk_on_random(self, num_points, batch_size, cell_size, dimension): cell_sizes = np.float32(np.repeat(cell_size, dimension)) points, batch_ids = utils._create_random_point_cloud_segmented( batch_size, num_points * batch_size, dimension=dimension, sizes=np.ones(batch_size, dtype=int) * num_points) point_cloud = PointCloud(points, batch_ids) grid = Grid(point_cloud, cell_sizes) neighborhood = Neighborhood(grid, cell_sizes) sampled_point_cloud, _ = sample(neighborhood, 'poisson') sampled_points = sampled_point_cloud._points.numpy() sampled_batch_ids = sampled_point_cloud._batch_ids.numpy() min_dist = 1.0 for i in range(batch_size): indices = np.where(sampled_batch_ids == i) diff = np.expand_dims(sampled_points[indices], 1) - \ np.expand_dims(sampled_points[indices], 0) dists = np.linalg.norm(diff, axis=2) dists = np.sort(dists, axis=1) min_dist = min(min_dist, np.amin(dists[:, 1])) self.assertLess(min_dist, cell_size + 1e-3)
def compute_keys_tf(point_cloud: PointCloud, num_cells, cell_size, name=None): """ Computes the regular grid cell keys of a point cloud. For a point in cell `c` the key is computed as \\(key = batch_id * prod_{d=0}^{D} num_cells_{d} + \\) \\(sum_{d=0}^{D}( c_{d} prod_{d'=d+1}^{D} num_cells_{d'} ) \\). Args: point_cloud: A `PointCloud` instance. num_cells: An `int` `Tensor` of shape `[D]`, the total number of cells per dimension. cell_size: An `int` `Tensor` of shape `[D]`, the cell sizes per dimension. Returns: An `int` `Tensor` of shape `[N]`, the keys per point. """ aabb = point_cloud.get_AABB() abb_min_per_batch = aabb._aabb_min aabb_min_per_point = tf.gather(abb_min_per_batch, point_cloud._batch_ids) cell_ind = tf.math.floor( (point_cloud._points - aabb_min_per_point) / cell_size) cell_ind = tf.cast(cell_ind, tf.int32) cell_ind = tf.minimum(tf.maximum(cell_ind, tf.zeros_like(cell_ind)), num_cells) cell_multiplier = tf.math.cumprod(num_cells, reverse=True) cell_multiplier = tf.concat((cell_multiplier, [1]), axis=0) keys = point_cloud._batch_ids * cell_multiplier[0] + \ tf.math.reduce_sum(cell_ind * tf.reshape(cell_multiplier[1:], [1, -1]), axis=1) return tf.cast(keys, tf.int64)
def test_flatten_unflatten_padded(self, batch_shape, num_points, dimension): batch_size = np.prod(batch_shape) points, sizes = utils._create_random_point_cloud_padded( num_points, batch_shape, dimension=dimension) point_cloud = PointCloud(points, sizes=sizes) retrieved_points = point_cloud.get_points().numpy() self.assertAllEqual(points.shape, retrieved_points.shape) points = points.reshape([batch_size, num_points, dimension]) retrieved_points = retrieved_points.reshape( [batch_size, num_points, dimension]) sizes = sizes.reshape([batch_size]) for i in range(batch_size): self.assertAllClose(points[i, :sizes[i]], retrieved_points[i, :sizes[i]]) self.assertTrue(np.all(retrieved_points[i, sizes[i]:] == 0))
def test_grid_datastructure(self, num_points, batch_size, scale, radius, dimension): radius = np.repeat(radius, dimension) points, batch_ids = utils._create_random_point_cloud_segmented( batch_size, num_points * batch_size, dimension=dimension, sizes=np.ones(batch_size, dtype=int) * num_points, clean_aabb=True) point_cloud = PointCloud(points, batch_ids) aabb = point_cloud.get_AABB() grid = Grid(point_cloud, radius, aabb) total_num_cells = grid._num_cells.numpy() keys = grid._sorted_keys.numpy() ds_numpy = np.full( (batch_size, total_num_cells[0], total_num_cells[1], 2), 0) if dimension == 2: cells_per_2D_cell = 1 elif dimension > 2: cells_per_2D_cell = np.prod(total_num_cells[2:]) for key_iter, key in enumerate(keys): curDSIndex = key // cells_per_2D_cell yIndex = curDSIndex % total_num_cells[1] auxInt = curDSIndex // total_num_cells[1] xIndex = auxInt % total_num_cells[0] curbatch_ids = auxInt // total_num_cells[0] if key_iter == 0: ds_numpy[curbatch_ids, xIndex, yIndex, 0] = key_iter else: prevKey = keys[key_iter - 1] prevDSIndex = prevKey // cells_per_2D_cell if prevDSIndex != curDSIndex: ds_numpy[curbatch_ids, xIndex, yIndex, 0] = key_iter nextIter = key_iter + 1 if nextIter >= len(keys): ds_numpy[curbatch_ids, xIndex, yIndex, 1] = len(keys) else: nextKey = keys[key_iter + 1] nextDSIndex = nextKey // cells_per_2D_cell if nextDSIndex != curDSIndex: ds_numpy[curbatch_ids, xIndex, yIndex, 1] = key_iter + 1 # check if the data structure is equal self.assertAllEqual(grid.get_DS(), ds_numpy)
def __init__(self, point_cloud: PointCloud, cell_sizes, sample_mode='poisson', name=None): #Initialize the attributes. self._aabb = point_cloud.get_AABB() self._point_clouds = [point_cloud] self._cell_sizes = [] self._neighborhoods = [] self._dimension = point_cloud._dimension self._batch_shape = point_cloud._batch_shape #Create the different sampling operations. cur_point_cloud = point_cloud for sample_iter, cur_cell_sizes in enumerate(cell_sizes): cur_cell_sizes = tf.convert_to_tensor(value=cur_cell_sizes, dtype=tf.float32) # Check if the cell size is defined for all the dimensions. # If not, the last cell size value is tiled until all the dimensions # have a value. cur_num_dims = tf.gather(cur_cell_sizes.shape, 0) cur_cell_sizes = tf.cond( cur_num_dims < self._dimension, lambda: tf.concat( (cur_cell_sizes, tf.tile( tf.gather(cur_cell_sizes, [ tf.rank(cur_cell_sizes) - 1 ]), [self._dimension - cur_num_dims])), axis=0), lambda: cur_cell_sizes) tf.assert_greater( self._dimension + 1, cur_num_dims, f'Too many dimensions in cell sizes {cur_num_dims} ' + \ f'instead of max. {self._dimension}') # old version, does not run in graph mode # if cur_num_dims < self._dimension: # cur_cell_sizes = tf.concat((cur_cell_sizes, # tf.tile(tf.gather(cur_cell_sizes, # [tf.rank(cur_cell_sizes) - 1]), # [self._dimension - cur_num_dims])), # axis=0) # if cur_num_dims > self._dimension: # raise ValueError( # f'Too many dimensions in cell sizes {cur_num_dims} ' + \ # f'instead of max. {self._dimension}') self._cell_sizes.append(cur_cell_sizes) #Create the sampling operation. cur_grid = Grid(cur_point_cloud, cur_cell_sizes, self._aabb) cur_neighborhood = Neighborhood(cur_grid, cur_cell_sizes) cur_point_cloud, _ = sample(cur_neighborhood, sample_mode) self._neighborhoods.append(cur_neighborhood) cur_point_cloud.set_batch_shape(self._batch_shape) self._point_clouds.append(cur_point_cloud)
def test_aabb_diameter(self, batch_shape, max_num_points, dimension): points, sizes = utils._create_random_point_cloud_padded( max_num_points, batch_shape, dimension) batch_size = np.prod(batch_shape) diameter_numpy = np.empty(batch_size) points_flat = np.reshape(points, [batch_size, max_num_points, dimension]) sizes_flat = np.reshape(sizes, [batch_size]) for i in range(batch_size): curr_pts = points_flat[i][:sizes_flat[i]] diag = np.amax(curr_pts, axis=0) - np.amin(curr_pts, axis=0) diameter_numpy[i] = np.linalg.norm(diag) diameter_numpy = np.reshape(diameter_numpy, batch_shape) aabb_tf = PointCloud(points, sizes=sizes).get_AABB() diameter_tf = aabb_tf.get_diameter() self.assertAllClose(diameter_numpy, diameter_tf)
def test_conv_rigid_jacobian_params(self, num_points, num_samples, num_features, batch_size, radius, num_kernel_points, dimension): cell_sizes = np.float32(np.repeat(radius, dimension)) points, batch_ids = utils._create_random_point_cloud_segmented( batch_size, num_points, dimension=dimension) point_cloud = PointCloud(points, batch_ids) point_samples, batch_ids_samples = \ utils._create_random_point_cloud_segmented( batch_size, num_samples, dimension=dimension) point_cloud_samples = PointCloud(point_samples, batch_ids_samples) grid = Grid(point_cloud, cell_sizes) neighborhood = Neighborhood(grid, cell_sizes, point_cloud_samples) conv_layer = KPConv(num_features[0], num_features[1], num_kernel_points) features = np.random.rand(num_points, num_features[0]) with self.subTest(name='features'): def conv_features(features_in): conv_result = conv_layer(features_in, point_cloud, point_cloud_samples, radius, neighborhood) return conv_result self.assert_jacobian_is_correct_fn(conv_features, [features], atol=1e-3, delta=1e-3) with self.subTest(name='weights'): def conv_weights(weigths_in): conv_layer._weights = weigths_in conv_result = conv_layer(features, point_cloud, point_cloud_samples, radius, neighborhood) return conv_result weights = conv_layer._weights self.assert_jacobian_is_correct_fn(conv_weights, [weights], atol=1e-3, delta=1e-3)
def test_neighbors_are_from_same_batch(self, batch_size, num_points, num_samples, radius, dimension): points, batch_ids = utils._create_random_point_cloud_segmented( batch_size, num_points, dimension=dimension) samples, batch_ids_samples = utils._create_random_point_cloud_segmented( batch_size, num_samples, dimension=dimension) radius = np.float32(np.repeat([radius], dimension)) point_cloud = PointCloud(points, batch_ids) point_cloud_samples = PointCloud(samples, batch_ids_samples) grid = Grid(point_cloud, radius) neighborhood = Neighborhood(grid, radius, point_cloud_samples) batch_ids_in = tf.gather(point_cloud._batch_ids, neighborhood._original_neigh_ids[:, 0]) batch_ids_out = tf.gather(point_cloud_samples._batch_ids, neighborhood._original_neigh_ids[:, 1]) batch_check = batch_ids_in == batch_ids_out self.assertTrue(np.all(batch_check))
def compute_neighborhoods(grid, radius, point_cloud_centers=None, max_neighbors=0, return_ranges=False, return_sorted_ids=False, name=None): """ Neighborhood of a point cloud. Args: grid: A 'Grid' instance, the regular grid data structure. radius: A `float` `Tensor` of shape `[D]`, the radius used to select the neighbors. Should be smaller than the cell size of the grid. point_cloud_centers: A 'PointCloud' instance. Samples point cloud. If None, the sorted points from the grid will be used. max_neighbors: An `int`, maximum number of neighbors per sample, if `0` all neighbors are selected. (optional) return_ranges: A `bool`, if 'True` returns the neighborhood ranges as a second output, default is `False`. (optional) return_sorted_ids: A 'bool', if 'True' the neighbor ids are with respect to the sorted points in the grid, default is `False`. (optional) Returns: neighbors: An `int` `Tensor` of shape `[M, 2]`, the indices to neighbor pairs, where element `i` is `[neighbor_id, center_id]`. ranges: If `return_ranges` is `True` returns a second 'int` Tensor` of shape `[N2]`, such that the neighbor indices of center point `i` are `neighbors[ranges[i]]:neigbors[ranges[i+1]]` for `i>0`. """ radii = cast_to_num_dims(radius, grid._point_cloud._dimension) #Save the attributes. if point_cloud_centers is None: point_cloud_centers = PointCloud(grid._sorted_points, grid._sorted_batch_ids, grid._batch_size) #Find the neighbors, with indices with respect to sorted points in the grid nb_ranges, neighbors = find_neighbors(grid, point_cloud_centers, radii, max_neighbors) #Original neighIds. if not return_sorted_ids: aux_original_neigh_ids = tf.gather(grid._sorted_indices, neighbors[:, 0]) original_neigh_ids = tf.concat([ tf.reshape(aux_original_neigh_ids, [-1, 1]), tf.reshape(neighbors[:, 1], [-1, 1]) ], axis=-1) neighbors = original_neigh_ids if return_ranges: return neighbors, nb_ranges else: return neighbors
def test_find_neighbors(self, num_points, num_samples, batch_size, radius, dimension): cell_sizes = np.repeat(radius, dimension) points, batch_ids = utils._create_random_point_cloud_segmented( batch_size, num_points * batch_size, dimension=dimension, sizes=np.ones(batch_size, dtype=int) * num_points) point_cloud = PointCloud(points, batch_ids) samples_points, batch_ids_samples = \ utils._create_random_point_cloud_segmented( batch_size, num_samples * batch_size, dimension=dimension, sizes=np.ones(batch_size, dtype=int) * num_samples) point_cloud_sampled = PointCloud(samples_points, batch_ids_samples) grid = Grid(point_cloud, cell_sizes) neighborhood = Neighborhood(grid, cell_sizes, point_cloud_sampled) sorted_points = grid._sorted_points neighbors_tf = neighborhood._neighbors neighbors_numpy = [[] for i in range(num_samples * batch_size)] for k in range(batch_size): for i in range(num_samples): for j in range(num_points): diffArray = (samples_points[i + k * num_samples] - \ sorted_points[(batch_size - k - 1) * num_points + j])\ / cell_sizes if np.linalg.norm(diffArray) < 1.0: neighbors_numpy[k * num_samples + i].append((batch_size - k - 1)\ * num_points + j) allFound = True for neigh in neighbors_tf: found = False for ref_neigh in neighbors_numpy[neigh[1]]: if ref_neigh == neigh[0]: found = True allFound = allFound and found self.assertTrue(allFound)
def test_global_pooling(self, num_points, batch_size, dimension): points, batch_ids = utils._create_random_point_cloud_segmented( batch_size, num_points * batch_size, dimension=dimension, equal_sized_batches=True) features = np.random.rand(batch_size, num_points, dimension) point_cloud = PointCloud(points, batch_ids) # max pooling with self.subTest(name='max_pooling'): PoolLayer = GlobalMaxPooling() pool_tf = PoolLayer(features, point_cloud) pool_numpy = np.empty([batch_size, dimension]) features = features.reshape([-1, dimension]) for i in range(batch_size): pool_numpy[i] = np.max(features[batch_ids == i], axis=0) self.assertAllClose(pool_numpy, pool_tf) point_cloud.set_batch_shape([batch_size // 2, 2]) padded = PoolLayer(features, point_cloud, return_padded=True) self.assertTrue(padded.shape.rank > 2) # average pooling with self.subTest(name='average_pooling'): PoolLayer = GlobalAveragePooling() pool_tf = PoolLayer(features, point_cloud) pool_numpy = np.empty([batch_size, dimension]) for i in range(batch_size): pool_numpy[i] = np.mean(features[batch_ids == i], axis=0) self.assertAllClose(pool_numpy, pool_tf) point_cloud.set_batch_shape([batch_size // 2, 2]) padded = PoolLayer(features, point_cloud, return_padded=True) self.assertTrue(padded.shape.rank > 2)
def test_sampling_poisson_disk_on_uniform(self, num_points_sqrt, scale): points = utils._create_uniform_distributed_point_cloud_2D( num_points_sqrt, scale=scale) cell_sizes = scale * np.array([2, 2], dtype=np.float32) \ / num_points_sqrt batch_ids = np.zeros([len(points)]) point_cloud = PointCloud(points, batch_ids) grid = Grid(point_cloud, cell_sizes) neighborhood = Neighborhood(grid, cell_sizes) sample_point_cloud, _ = sample(neighborhood, 'poisson') sampled_points = sample_point_cloud._points.numpy() expected_num_pts = num_points_sqrt**2 // 2 self.assertTrue(len(sampled_points) == expected_num_pts)
def test_aabb_min_max(self, batch_size, num_points, dimension): points, batch_ids = utils._create_random_point_cloud_segmented( batch_size, num_points, dimension) aabb_max_numpy = np.empty([batch_size, dimension]) aabb_min_numpy = np.empty([batch_size, dimension]) for i in range(batch_size): aabb_max_numpy[i] = np.amax(points[batch_ids == i], axis=0) aabb_min_numpy[i] = np.amin(points[batch_ids == i], axis=0) aabb_tf = PointCloud(points, batch_ids=batch_ids, batch_size=batch_size).get_AABB() self.assertAllClose(aabb_max_numpy, aabb_tf._aabb_max) self.assertAllClose(aabb_min_numpy, aabb_tf._aabb_min)
def poisson_disk_sampling(point_cloud, radius=None, neighborhood=None, return_ids=False, name=None): """ Poisson disk sampling of a point cloud. Note: Either `radius` or `neighborhood` must be provided. Args: point_cloud: A `PointCloud` instance. radius: A `float` or a `float` `Tensor` of shape `[D]`, the radius for the Poisson disk sampling. neighborhood: A `Neighborhood` instance. return_ids: A `bool`, if `True` returns the indices of the sampled points. (optional) Returns: A `PointCloud` instance. An `int` `Tensor` of shape `[S]`, if `return_ids` is `True`. Raises: ValueError: If no radius or neighborhood is given. """ if radius is None and neighborhood is None: raise ValueError( "Missing Argument! Either radius or neighborhood must be given!") if neighborhood is None: # compute neighborhood radii = cast_to_num_dims(radius, point_cloud) grid = Grid(point_cloud, radii) neighborhood = Neighborhood(grid, radii) #Compute the sampling. sampled_points, sampled_batch_ids, sampled_indices = \ sampling(neighborhood, 1) sampled_point_cloud = PointCloud( points=sampled_points, batch_ids=sampled_batch_ids, batch_size=neighborhood._point_cloud_sampled._batch_size) if return_ids: sampled_indices = tf.gather(neighborhood._grid._sorted_indices, sampled_indices) return sampled_point_cloud, sampled_indices else: return sampled_point_cloud
def test_sampling_average_on_random(self, num_points, batch_size, cell_size, dimension): cell_sizes = np.repeat(cell_size, dimension) points, batch_ids = utils._create_random_point_cloud_segmented( batch_size, num_points * batch_size, dimension=dimension, sizes=np.ones(batch_size, dtype=int) * num_points) #print(points.shape, batch_ids.shape) point_cloud = PointCloud(points=points, batch_ids=batch_ids) grid = Grid(point_cloud, cell_sizes) neighborhood = Neighborhood(grid, cell_sizes) sample_point_cloud, _ = sample(neighborhood, 'average') sampled_points_tf = sample_point_cloud._points.numpy() sorted_keys = neighborhood._grid._sorted_keys.numpy() sorted_points = neighborhood._grid._sorted_points.numpy() sampled_points_numpy = [] cur_point = np.repeat(0.0, dimension) cur_key = -1 cur_num_points = 0.0 for pt_id, cur_key_point in enumerate(sorted_keys): if cur_key_point != cur_key: if cur_key != -1: cur_point /= cur_num_points sampled_points_numpy.append(cur_point) cur_key = cur_key_point cur_point = [0.0, 0.0, 0.0] cur_num_points = 0.0 cur_point += sorted_points[pt_id] cur_num_points += 1.0 cur_point /= cur_num_points sampled_points_numpy.append(cur_point) equal = True for point_numpy in sampled_points_numpy: found = False for point_tf in sampled_points_tf: if np.all(np.abs(point_numpy - point_tf) < 0.0001): found = True equal = equal and found self.assertTrue(equal)
def cell_average_sampling(point_cloud, cell_sizes=None, grid=None, name=None): """ Cell average sampling of a point cloud. Note: Either `cell_sizes` or `grid` must be provided. Args: point_cloud: A `PointCloud` instance. cell_sizes: A `float` or a `float` `Tensor` of shape `[D]`, the cell sizes for the sampling. grid: A `Grid` instance. Returns: A `PointCloud` instance. Raises: ValueError: If no radius or grid is given. """ if cell_sizes is None and grid is None: raise ValueError( "Missing Argument! Either cell_sizes or grid must be given!") if grid is None: # compute grid cell_sizes = cast_to_num_dims(cell_sizes, point_cloud) grid = Grid(point_cloud, cell_sizes) neighborhood = Neighborhood(grid, cell_sizes) #Compute the sampling. sampled_points, sampled_batch_ids, sampled_indices = \ sampling(neighborhood, 0) sampled_point_cloud = PointCloud( points=sampled_points, batch_ids=sampled_batch_ids, batch_size=neighborhood._point_cloud_sampled._batch_size) return sampled_point_cloud
def __init__(self, grid: Grid, radius, point_cloud_sample=None, max_neighbors=0, name=None): radii = tf.reshape( tf.cast(tf.convert_to_tensor(value=radius), tf.float32), [-1]) if radii.shape[0] == 1: radii = tf.repeat(radius, grid._point_cloud._dimension) #Save the attributes. if point_cloud_sample is None: self._equal_samples = True self._point_cloud_sampled = PointCloud(grid._sorted_points, grid._sorted_batch_ids, grid._batch_size) else: self._equal_samples = False self._point_cloud_sampled = point_cloud_sample self._grid = grid self._radii = radii self.max_neighbors = max_neighbors #Find the neighbors. self._samples_neigh_ranges, self._neighbors = find_neighbors( self._grid, self._point_cloud_sampled, self._radii, max_neighbors) #Original neighIds. aux_original_neigh_ids = tf.gather(self._grid._sorted_indices, self._neighbors[:, 0]) self._original_neigh_ids = tf.concat([ tf.reshape(aux_original_neigh_ids, [-1, 1]), tf.reshape(self._neighbors[:, 1], [-1, 1]) ], axis=-1) #Initialize the pdf self._pdf = None self._transposed = None
def _flatten_features(features, point_cloud: PointCloud): """ Converts features of shape `[A1, ..., An, C]` to shape `[N, C]`. Args: features: A `Tensor`. point_cloud: A `PointCloud` instance. Returns: A `Tensor` of shape `[N, C]`. """ if features.shape.ndims > 2: sizes = point_cloud.get_sizes() features, _ = flatten_batch_to_2d(features, sizes) sorting = tf.math.invert_permutation(point_cloud._sorted_indices_batch) features = tf.gather(features, sorting) else: tf.assert_equal( tf.shape(features)[0], tf.shape(point_cloud._points)[0]) tf.assert_equal(tf.rank(features), 2) return features