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_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 test_construction_methods(self, max_num_points, batch_size,
batch_shape):
points, sizes = utils._create_random_point_cloud_padded(
max_num_points, batch_shape)
num_points = np.sum(sizes)
sizes_flat = sizes.reshape([batch_size])
points_flat = points.reshape([batch_size, max_num_points, 3])
batch_ids = np.repeat(np.arange(0, batch_size), sizes_flat)
points_seg = np.empty([num_points, 3])
cur_id = 0
for pts, size in zip(points_flat, sizes_flat):
points_seg[cur_id:cur_id + size] = pts[:size]
cur_id += size
pc_from_padded = PointCloud(points, sizes=sizes)
self.assertAllEqual(batch_ids, pc_from_padded._batch_ids)
self.assertAllClose(points_seg, pc_from_padded._points)
pc_from_ids = PointCloud(points_seg, batch_ids)
pc_from_ids.set_batch_shape(batch_shape)
pc_from_sizes = PointCloud(points_seg, sizes=sizes_flat)
pc_from_sizes.set_batch_shape(batch_shape)
self.assertAllEqual(batch_ids, pc_from_sizes._batch_ids)
points_from_padded = pc_from_padded.get_points(
max_num_points=max_num_points)
points_from_ids = pc_from_ids.get_points(max_num_points=max_num_points)
points_from_sizes = pc_from_sizes.get_points(
max_num_points=max_num_points)
self.assertAllEqual(points_from_padded, points_from_ids)
self.assertAllEqual(points_from_ids, points_from_sizes)
self.assertAllEqual(points_from_sizes, points_from_padded)