1237 lines
50 KiB
Python
1237 lines
50 KiB
Python
# Copyright (c) Meta Platforms, Inc. and affiliates.
|
|
# All rights reserved.
|
|
#
|
|
# This source code is licensed under the BSD-style license found in the
|
|
# LICENSE file in the root directory of this source tree.
|
|
|
|
import itertools
|
|
import random
|
|
import unittest
|
|
|
|
import numpy as np
|
|
import torch
|
|
from pytorch3d.structures import utils as struct_utils
|
|
from pytorch3d.structures.pointclouds import (
|
|
join_pointclouds_as_batch,
|
|
join_pointclouds_as_scene,
|
|
Pointclouds,
|
|
)
|
|
|
|
from .common_testing import TestCaseMixin
|
|
|
|
|
|
class TestPointclouds(TestCaseMixin, unittest.TestCase):
|
|
def setUp(self) -> None:
|
|
np.random.seed(42)
|
|
torch.manual_seed(42)
|
|
|
|
@staticmethod
|
|
def init_cloud(
|
|
num_clouds: int = 3,
|
|
max_points: int = 100,
|
|
channels: int = 4,
|
|
lists_to_tensors: bool = False,
|
|
with_normals: bool = True,
|
|
with_features: bool = True,
|
|
min_points: int = 0,
|
|
requires_grad: bool = False,
|
|
):
|
|
"""
|
|
Function to generate a Pointclouds object of N meshes with
|
|
random number of points.
|
|
|
|
Args:
|
|
num_clouds: Number of clouds to generate.
|
|
channels: Number of features.
|
|
max_points: Max number of points per cloud.
|
|
lists_to_tensors: Determines whether the generated clouds should be
|
|
constructed from lists (=False) or
|
|
tensors (=True) of points/normals/features.
|
|
with_normals: bool whether to include normals
|
|
with_features: bool whether to include features
|
|
min_points: Min number of points per cloud
|
|
|
|
Returns:
|
|
Pointclouds object.
|
|
"""
|
|
device = torch.device("cuda:0")
|
|
p = torch.randint(low=min_points, high=max_points, size=(num_clouds,))
|
|
if lists_to_tensors:
|
|
p.fill_(p[0])
|
|
|
|
points_list = [
|
|
torch.rand(
|
|
(i, 3), device=device, dtype=torch.float32, requires_grad=requires_grad
|
|
)
|
|
for i in p
|
|
]
|
|
normals_list, features_list = None, None
|
|
if with_normals:
|
|
normals_list = [
|
|
torch.rand(
|
|
(i, 3),
|
|
device=device,
|
|
dtype=torch.float32,
|
|
requires_grad=requires_grad,
|
|
)
|
|
for i in p
|
|
]
|
|
if with_features:
|
|
features_list = [
|
|
torch.rand(
|
|
(i, channels),
|
|
device=device,
|
|
dtype=torch.float32,
|
|
requires_grad=requires_grad,
|
|
)
|
|
for i in p
|
|
]
|
|
|
|
if lists_to_tensors:
|
|
points_list = torch.stack(points_list)
|
|
if with_normals:
|
|
normals_list = torch.stack(normals_list)
|
|
if with_features:
|
|
features_list = torch.stack(features_list)
|
|
|
|
return Pointclouds(points_list, normals=normals_list, features=features_list)
|
|
|
|
def test_simple(self):
|
|
device = torch.device("cuda:0")
|
|
points = [
|
|
torch.tensor(
|
|
[[0.1, 0.3, 0.5], [0.5, 0.2, 0.1], [0.6, 0.8, 0.7]],
|
|
dtype=torch.float32,
|
|
device=device,
|
|
),
|
|
torch.tensor(
|
|
[[0.1, 0.3, 0.3], [0.6, 0.7, 0.8], [0.2, 0.3, 0.4], [0.1, 0.5, 0.3]],
|
|
dtype=torch.float32,
|
|
device=device,
|
|
),
|
|
torch.tensor(
|
|
[
|
|
[0.7, 0.3, 0.6],
|
|
[0.2, 0.4, 0.8],
|
|
[0.9, 0.5, 0.2],
|
|
[0.2, 0.3, 0.4],
|
|
[0.9, 0.3, 0.8],
|
|
],
|
|
dtype=torch.float32,
|
|
device=device,
|
|
),
|
|
]
|
|
clouds = Pointclouds(points)
|
|
|
|
self.assertClose(
|
|
(clouds.packed_to_cloud_idx()).cpu(),
|
|
torch.tensor([0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 2]),
|
|
)
|
|
self.assertClose(
|
|
clouds.cloud_to_packed_first_idx().cpu(), torch.tensor([0, 3, 7])
|
|
)
|
|
self.assertClose(clouds.num_points_per_cloud().cpu(), torch.tensor([3, 4, 5]))
|
|
self.assertClose(
|
|
clouds.padded_to_packed_idx().cpu(),
|
|
torch.tensor([0, 1, 2, 5, 6, 7, 8, 10, 11, 12, 13, 14]),
|
|
)
|
|
|
|
def test_init_error(self):
|
|
# Check if correct errors are raised when verts/faces are on
|
|
# different devices
|
|
|
|
clouds = self.init_cloud(10, 100, 5)
|
|
points_list = clouds.points_list() # all tensors on cuda:0
|
|
points_list = [
|
|
p.to("cpu") if random.uniform(0, 1) > 0.5 else p for p in points_list
|
|
]
|
|
features_list = clouds.features_list()
|
|
normals_list = clouds.normals_list()
|
|
|
|
with self.assertRaisesRegex(ValueError, "same device"):
|
|
Pointclouds(
|
|
points=points_list, features=features_list, normals=normals_list
|
|
)
|
|
|
|
points_list = clouds.points_list()
|
|
features_list = [
|
|
f.to("cpu") if random.uniform(0, 1) > 0.2 else f for f in features_list
|
|
]
|
|
with self.assertRaisesRegex(ValueError, "same device"):
|
|
Pointclouds(
|
|
points=points_list, features=features_list, normals=normals_list
|
|
)
|
|
|
|
points_padded = clouds.points_padded() # on cuda:0
|
|
features_padded = clouds.features_padded().to("cpu")
|
|
normals_padded = clouds.normals_padded()
|
|
|
|
with self.assertRaisesRegex(ValueError, "same device"):
|
|
Pointclouds(
|
|
points=points_padded, features=features_padded, normals=normals_padded
|
|
)
|
|
|
|
def test_all_constructions(self):
|
|
public_getters = [
|
|
"points_list",
|
|
"points_packed",
|
|
"packed_to_cloud_idx",
|
|
"cloud_to_packed_first_idx",
|
|
"num_points_per_cloud",
|
|
"points_padded",
|
|
"padded_to_packed_idx",
|
|
]
|
|
public_normals_getters = ["normals_list", "normals_packed", "normals_padded"]
|
|
public_features_getters = [
|
|
"features_list",
|
|
"features_packed",
|
|
"features_padded",
|
|
]
|
|
|
|
lengths = [3, 4, 2]
|
|
max_len = max(lengths)
|
|
C = 4
|
|
|
|
points_data = [torch.zeros((max_len, 3)).uniform_() for i in lengths]
|
|
normals_data = [torch.zeros((max_len, 3)).uniform_() for i in lengths]
|
|
features_data = [torch.zeros((max_len, C)).uniform_() for i in lengths]
|
|
for length, p, n, f in zip(lengths, points_data, normals_data, features_data):
|
|
p[length:] = 0.0
|
|
n[length:] = 0.0
|
|
f[length:] = 0.0
|
|
points_list = [d[:length] for length, d in zip(lengths, points_data)]
|
|
normals_list = [d[:length] for length, d in zip(lengths, normals_data)]
|
|
features_list = [d[:length] for length, d in zip(lengths, features_data)]
|
|
points_packed = torch.cat(points_data)
|
|
normals_packed = torch.cat(normals_data)
|
|
features_packed = torch.cat(features_data)
|
|
test_cases_inputs = [
|
|
("list_0_0", points_list, None, None),
|
|
("list_1_0", points_list, normals_list, None),
|
|
("list_0_1", points_list, None, features_list),
|
|
("list_1_1", points_list, normals_list, features_list),
|
|
("padded_0_0", points_data, None, None),
|
|
("padded_1_0", points_data, normals_data, None),
|
|
("padded_0_1", points_data, None, features_data),
|
|
("padded_1_1", points_data, normals_data, features_data),
|
|
("emptylist_emptylist_emptylist", [], [], []),
|
|
]
|
|
false_cases_inputs = [
|
|
("list_packed", points_list, normals_packed, features_packed, ValueError),
|
|
("packed_0", points_packed, None, None, ValueError),
|
|
]
|
|
|
|
for name, points, normals, features in test_cases_inputs:
|
|
with self.subTest(name=name):
|
|
p = Pointclouds(points, normals, features)
|
|
for method in public_getters:
|
|
self.assertIsNotNone(getattr(p, method)())
|
|
for method in public_normals_getters:
|
|
if normals is None or p.isempty():
|
|
self.assertIsNone(getattr(p, method)())
|
|
for method in public_features_getters:
|
|
if features is None or p.isempty():
|
|
self.assertIsNone(getattr(p, method)())
|
|
|
|
for name, points, normals, features, error in false_cases_inputs:
|
|
with self.subTest(name=name):
|
|
with self.assertRaises(error):
|
|
Pointclouds(points, normals, features)
|
|
|
|
def test_simple_random_clouds(self):
|
|
# Define the test object either from lists or tensors.
|
|
for with_normals in (False, True):
|
|
for with_features in (False, True):
|
|
for lists_to_tensors in (False, True):
|
|
N = 10
|
|
cloud = self.init_cloud(
|
|
N,
|
|
lists_to_tensors=lists_to_tensors,
|
|
with_normals=with_normals,
|
|
with_features=with_features,
|
|
)
|
|
points_list = cloud.points_list()
|
|
normals_list = cloud.normals_list()
|
|
features_list = cloud.features_list()
|
|
|
|
# Check batch calculations.
|
|
points_padded = cloud.points_padded()
|
|
normals_padded = cloud.normals_padded()
|
|
features_padded = cloud.features_padded()
|
|
points_per_cloud = cloud.num_points_per_cloud()
|
|
|
|
if not with_normals:
|
|
self.assertIsNone(normals_list)
|
|
self.assertIsNone(normals_padded)
|
|
if not with_features:
|
|
self.assertIsNone(features_list)
|
|
self.assertIsNone(features_padded)
|
|
for n in range(N):
|
|
p = points_list[n].shape[0]
|
|
self.assertClose(points_padded[n, :p, :], points_list[n])
|
|
if with_normals:
|
|
norms = normals_list[n].shape[0]
|
|
self.assertEqual(p, norms)
|
|
self.assertClose(normals_padded[n, :p, :], normals_list[n])
|
|
if with_features:
|
|
f = features_list[n].shape[0]
|
|
self.assertEqual(p, f)
|
|
self.assertClose(
|
|
features_padded[n, :p, :], features_list[n]
|
|
)
|
|
if points_padded.shape[1] > p:
|
|
self.assertTrue(points_padded[n, p:, :].eq(0).all())
|
|
if with_features:
|
|
self.assertTrue(features_padded[n, p:, :].eq(0).all())
|
|
self.assertEqual(points_per_cloud[n], p)
|
|
|
|
# Check compute packed.
|
|
points_packed = cloud.points_packed()
|
|
packed_to_cloud = cloud.packed_to_cloud_idx()
|
|
cloud_to_packed = cloud.cloud_to_packed_first_idx()
|
|
normals_packed = cloud.normals_packed()
|
|
features_packed = cloud.features_packed()
|
|
if not with_normals:
|
|
self.assertIsNone(normals_packed)
|
|
if not with_features:
|
|
self.assertIsNone(features_packed)
|
|
|
|
cur = 0
|
|
for n in range(N):
|
|
p = points_list[n].shape[0]
|
|
self.assertClose(
|
|
points_packed[cur : cur + p, :], points_list[n]
|
|
)
|
|
if with_normals:
|
|
self.assertClose(
|
|
normals_packed[cur : cur + p, :], normals_list[n]
|
|
)
|
|
if with_features:
|
|
self.assertClose(
|
|
features_packed[cur : cur + p, :], features_list[n]
|
|
)
|
|
self.assertTrue(packed_to_cloud[cur : cur + p].eq(n).all())
|
|
self.assertTrue(cloud_to_packed[n] == cur)
|
|
cur += p
|
|
|
|
def test_allempty(self):
|
|
clouds = Pointclouds([], [])
|
|
self.assertEqual(len(clouds), 0)
|
|
self.assertIsNone(clouds.normals_list())
|
|
self.assertIsNone(clouds.features_list())
|
|
self.assertEqual(clouds.points_padded().shape[0], 0)
|
|
self.assertIsNone(clouds.normals_padded())
|
|
self.assertIsNone(clouds.features_padded())
|
|
self.assertEqual(clouds.points_packed().shape[0], 0)
|
|
self.assertIsNone(clouds.normals_packed())
|
|
self.assertIsNone(clouds.features_packed())
|
|
|
|
def test_empty(self):
|
|
N, P, C = 10, 100, 2
|
|
device = torch.device("cuda:0")
|
|
points_list = []
|
|
normals_list = []
|
|
features_list = []
|
|
valid = torch.randint(2, size=(N,), dtype=torch.uint8, device=device)
|
|
for n in range(N):
|
|
if valid[n]:
|
|
p = torch.randint(
|
|
3, high=P, size=(1,), dtype=torch.int32, device=device
|
|
)[0]
|
|
points = torch.rand((p, 3), dtype=torch.float32, device=device)
|
|
normals = torch.rand((p, 3), dtype=torch.float32, device=device)
|
|
features = torch.rand((p, C), dtype=torch.float32, device=device)
|
|
else:
|
|
points = torch.tensor([], dtype=torch.float32, device=device)
|
|
normals = torch.tensor([], dtype=torch.float32, device=device)
|
|
features = torch.tensor([], dtype=torch.int64, device=device)
|
|
points_list.append(points)
|
|
normals_list.append(normals)
|
|
features_list.append(features)
|
|
|
|
for with_normals in (False, True):
|
|
for with_features in (False, True):
|
|
this_features, this_normals = None, None
|
|
if with_normals:
|
|
this_normals = normals_list
|
|
if with_features:
|
|
this_features = features_list
|
|
clouds = Pointclouds(
|
|
points=points_list, normals=this_normals, features=this_features
|
|
)
|
|
points_padded = clouds.points_padded()
|
|
normals_padded = clouds.normals_padded()
|
|
features_padded = clouds.features_padded()
|
|
if not with_normals:
|
|
self.assertIsNone(normals_padded)
|
|
if not with_features:
|
|
self.assertIsNone(features_padded)
|
|
points_per_cloud = clouds.num_points_per_cloud()
|
|
for n in range(N):
|
|
p = len(points_list[n])
|
|
if p > 0:
|
|
self.assertClose(points_padded[n, :p, :], points_list[n])
|
|
if with_normals:
|
|
self.assertClose(normals_padded[n, :p, :], normals_list[n])
|
|
if with_features:
|
|
self.assertClose(
|
|
features_padded[n, :p, :], features_list[n]
|
|
)
|
|
if points_padded.shape[1] > p:
|
|
self.assertTrue(points_padded[n, p:, :].eq(0).all())
|
|
if with_normals:
|
|
self.assertTrue(normals_padded[n, p:, :].eq(0).all())
|
|
if with_features:
|
|
self.assertTrue(features_padded[n, p:, :].eq(0).all())
|
|
self.assertTrue(points_per_cloud[n] == p)
|
|
|
|
def test_list_someempty(self):
|
|
# We want
|
|
# point_cloud = Pointclouds(
|
|
# [pcl.points_packed() for pcl in point_clouds],
|
|
# features=[pcl.features_packed() for pcl in point_clouds],
|
|
# )
|
|
# to work if point_clouds is a list of pointclouds with some empty and some not.
|
|
points_list = [torch.rand(30, 3), torch.zeros(0, 3)]
|
|
features_list = [torch.rand(30, 3), None]
|
|
pcls = Pointclouds(points=points_list, features=features_list)
|
|
self.assertEqual(len(pcls), 2)
|
|
self.assertClose(
|
|
pcls.points_padded(),
|
|
torch.stack([points_list[0], torch.zeros_like(points_list[0])]),
|
|
)
|
|
self.assertClose(pcls.points_packed(), points_list[0])
|
|
self.assertClose(
|
|
pcls.features_padded(),
|
|
torch.stack([features_list[0], torch.zeros_like(points_list[0])]),
|
|
)
|
|
self.assertClose(pcls.features_packed(), features_list[0])
|
|
|
|
points_list = [torch.zeros(0, 3), torch.rand(30, 3)]
|
|
features_list = [None, torch.rand(30, 3)]
|
|
pcls = Pointclouds(points=points_list, features=features_list)
|
|
self.assertEqual(len(pcls), 2)
|
|
self.assertClose(
|
|
pcls.points_padded(),
|
|
torch.stack([torch.zeros_like(points_list[1]), points_list[1]]),
|
|
)
|
|
self.assertClose(pcls.points_packed(), points_list[1])
|
|
self.assertClose(
|
|
pcls.features_padded(),
|
|
torch.stack([torch.zeros_like(points_list[1]), features_list[1]]),
|
|
)
|
|
self.assertClose(pcls.features_packed(), features_list[1])
|
|
|
|
def test_clone_list(self):
|
|
N = 5
|
|
clouds = self.init_cloud(N, 100, 5)
|
|
for force in (False, True):
|
|
if force:
|
|
clouds.points_packed()
|
|
|
|
new_clouds = clouds.clone()
|
|
|
|
# Check cloned and original objects do not share tensors.
|
|
self.assertSeparate(new_clouds.points_list()[0], clouds.points_list()[0])
|
|
self.assertSeparate(new_clouds.normals_list()[0], clouds.normals_list()[0])
|
|
self.assertSeparate(
|
|
new_clouds.features_list()[0], clouds.features_list()[0]
|
|
)
|
|
for attrib in [
|
|
"points_packed",
|
|
"normals_packed",
|
|
"features_packed",
|
|
"points_padded",
|
|
"normals_padded",
|
|
"features_padded",
|
|
]:
|
|
self.assertSeparate(
|
|
getattr(new_clouds, attrib)(), getattr(clouds, attrib)()
|
|
)
|
|
|
|
self.assertCloudsEqual(clouds, new_clouds)
|
|
|
|
def test_clone_tensor(self):
|
|
N = 5
|
|
clouds = self.init_cloud(N, 100, 5, lists_to_tensors=True)
|
|
for force in (False, True):
|
|
if force:
|
|
clouds.points_packed()
|
|
|
|
new_clouds = clouds.clone()
|
|
|
|
# Check cloned and original objects do not share tensors.
|
|
self.assertSeparate(new_clouds.points_list()[0], clouds.points_list()[0])
|
|
self.assertSeparate(new_clouds.normals_list()[0], clouds.normals_list()[0])
|
|
self.assertSeparate(
|
|
new_clouds.features_list()[0], clouds.features_list()[0]
|
|
)
|
|
for attrib in [
|
|
"points_packed",
|
|
"normals_packed",
|
|
"features_packed",
|
|
"points_padded",
|
|
"normals_padded",
|
|
"features_padded",
|
|
]:
|
|
self.assertSeparate(
|
|
getattr(new_clouds, attrib)(), getattr(clouds, attrib)()
|
|
)
|
|
|
|
self.assertCloudsEqual(clouds, new_clouds)
|
|
|
|
def test_detach(self):
|
|
N = 5
|
|
for lists_to_tensors in (True, False):
|
|
clouds = self.init_cloud(
|
|
N, 100, 5, lists_to_tensors=lists_to_tensors, requires_grad=True
|
|
)
|
|
for force in (False, True):
|
|
if force:
|
|
clouds.points_packed()
|
|
|
|
new_clouds = clouds.detach()
|
|
|
|
for cloud in new_clouds.points_list():
|
|
self.assertFalse(cloud.requires_grad)
|
|
for normal in new_clouds.normals_list():
|
|
self.assertFalse(normal.requires_grad)
|
|
for feats in new_clouds.features_list():
|
|
self.assertFalse(feats.requires_grad)
|
|
|
|
for attrib in [
|
|
"points_packed",
|
|
"normals_packed",
|
|
"features_packed",
|
|
"points_padded",
|
|
"normals_padded",
|
|
"features_padded",
|
|
]:
|
|
self.assertFalse(getattr(new_clouds, attrib)().requires_grad)
|
|
|
|
self.assertCloudsEqual(clouds, new_clouds)
|
|
|
|
def assertCloudsEqual(self, cloud1, cloud2):
|
|
N = len(cloud1)
|
|
self.assertEqual(N, len(cloud2))
|
|
|
|
for i in range(N):
|
|
self.assertClose(cloud1.points_list()[i], cloud2.points_list()[i])
|
|
self.assertClose(cloud1.normals_list()[i], cloud2.normals_list()[i])
|
|
self.assertClose(cloud1.features_list()[i], cloud2.features_list()[i])
|
|
has_normals = cloud1.normals_list() is not None
|
|
self.assertTrue(has_normals == (cloud2.normals_list() is not None))
|
|
has_features = cloud1.features_list() is not None
|
|
self.assertTrue(has_features == (cloud2.features_list() is not None))
|
|
|
|
# check padded & packed
|
|
self.assertClose(cloud1.points_padded(), cloud2.points_padded())
|
|
self.assertClose(cloud1.points_packed(), cloud2.points_packed())
|
|
if has_normals:
|
|
self.assertClose(cloud1.normals_padded(), cloud2.normals_padded())
|
|
self.assertClose(cloud1.normals_packed(), cloud2.normals_packed())
|
|
if has_features:
|
|
self.assertClose(cloud1.features_padded(), cloud2.features_padded())
|
|
self.assertClose(cloud1.features_packed(), cloud2.features_packed())
|
|
self.assertClose(cloud1.packed_to_cloud_idx(), cloud2.packed_to_cloud_idx())
|
|
self.assertClose(
|
|
cloud1.cloud_to_packed_first_idx(), cloud2.cloud_to_packed_first_idx()
|
|
)
|
|
self.assertClose(cloud1.num_points_per_cloud(), cloud2.num_points_per_cloud())
|
|
self.assertClose(cloud1.packed_to_cloud_idx(), cloud2.packed_to_cloud_idx())
|
|
self.assertClose(cloud1.padded_to_packed_idx(), cloud2.padded_to_packed_idx())
|
|
self.assertTrue(all(cloud1.valid == cloud2.valid))
|
|
self.assertTrue(cloud1.equisized == cloud2.equisized)
|
|
|
|
def test_offset(self):
|
|
def naive_offset(clouds, offsets_packed):
|
|
new_points_packed = clouds.points_packed() + offsets_packed
|
|
new_points_list = list(
|
|
new_points_packed.split(clouds.num_points_per_cloud().tolist(), 0)
|
|
)
|
|
return Pointclouds(
|
|
points=new_points_list,
|
|
normals=clouds.normals_list(),
|
|
features=clouds.features_list(),
|
|
)
|
|
|
|
N = 5
|
|
clouds = self.init_cloud(N, 100, 10)
|
|
all_p = clouds.points_packed().size(0)
|
|
points_per_cloud = clouds.num_points_per_cloud()
|
|
for force, deform_shape in itertools.product((0, 1), [(all_p, 3), 3]):
|
|
if force:
|
|
clouds._compute_packed(refresh=True)
|
|
clouds._compute_padded()
|
|
clouds.padded_to_packed_idx()
|
|
|
|
deform = torch.rand(deform_shape, dtype=torch.float32, device=clouds.device)
|
|
new_clouds_naive = naive_offset(clouds, deform)
|
|
|
|
new_clouds = clouds.offset(deform)
|
|
|
|
points_cumsum = torch.cumsum(points_per_cloud, 0).tolist()
|
|
points_cumsum.insert(0, 0)
|
|
for i in range(N):
|
|
item_offset = (
|
|
deform
|
|
if deform.ndim == 1
|
|
else deform[points_cumsum[i] : points_cumsum[i + 1]]
|
|
)
|
|
self.assertClose(
|
|
new_clouds.points_list()[i],
|
|
clouds.points_list()[i] + item_offset,
|
|
)
|
|
self.assertClose(
|
|
clouds.normals_list()[i], new_clouds_naive.normals_list()[i]
|
|
)
|
|
self.assertClose(
|
|
clouds.features_list()[i], new_clouds_naive.features_list()[i]
|
|
)
|
|
self.assertCloudsEqual(new_clouds, new_clouds_naive)
|
|
|
|
def test_scale(self):
|
|
def naive_scale(cloud, scale):
|
|
if not torch.is_tensor(scale):
|
|
scale = torch.full((len(cloud),), scale, device=cloud.device)
|
|
new_points_list = [
|
|
scale[i] * points.clone()
|
|
for (i, points) in enumerate(cloud.points_list())
|
|
]
|
|
return Pointclouds(
|
|
new_points_list, cloud.normals_list(), cloud.features_list()
|
|
)
|
|
|
|
N = 5
|
|
for test in ["tensor", "scalar"]:
|
|
for force in (False, True):
|
|
clouds = self.init_cloud(N, 100, 10)
|
|
if force:
|
|
clouds._compute_packed(refresh=True)
|
|
clouds._compute_padded()
|
|
clouds.padded_to_packed_idx()
|
|
if test == "tensor":
|
|
scales = torch.rand(N)
|
|
elif test == "scalar":
|
|
scales = torch.rand(1)[0].item()
|
|
new_clouds_naive = naive_scale(clouds, scales)
|
|
new_clouds = clouds.scale(scales)
|
|
for i in range(N):
|
|
if test == "tensor":
|
|
self.assertClose(
|
|
scales[i] * clouds.points_list()[i],
|
|
new_clouds.points_list()[i],
|
|
)
|
|
else:
|
|
self.assertClose(
|
|
scales * clouds.points_list()[i],
|
|
new_clouds.points_list()[i],
|
|
)
|
|
self.assertClose(
|
|
clouds.normals_list()[i], new_clouds_naive.normals_list()[i]
|
|
)
|
|
self.assertClose(
|
|
clouds.features_list()[i], new_clouds_naive.features_list()[i]
|
|
)
|
|
self.assertCloudsEqual(new_clouds, new_clouds_naive)
|
|
|
|
def test_extend_list(self):
|
|
N = 10
|
|
clouds = self.init_cloud(N, 100, 10)
|
|
for force in (False, True):
|
|
if force:
|
|
# force some computes to happen
|
|
clouds._compute_packed(refresh=True)
|
|
clouds._compute_padded()
|
|
clouds.padded_to_packed_idx()
|
|
new_clouds = clouds.extend(N)
|
|
self.assertEqual(len(clouds) * 10, len(new_clouds))
|
|
for i in range(len(clouds)):
|
|
for n in range(N):
|
|
self.assertClose(
|
|
clouds.points_list()[i], new_clouds.points_list()[i * N + n]
|
|
)
|
|
self.assertClose(
|
|
clouds.normals_list()[i], new_clouds.normals_list()[i * N + n]
|
|
)
|
|
self.assertClose(
|
|
clouds.features_list()[i], new_clouds.features_list()[i * N + n]
|
|
)
|
|
self.assertTrue(clouds.valid[i] == new_clouds.valid[i * N + n])
|
|
self.assertAllSeparate(
|
|
clouds.points_list()
|
|
+ new_clouds.points_list()
|
|
+ clouds.normals_list()
|
|
+ new_clouds.normals_list()
|
|
+ clouds.features_list()
|
|
+ new_clouds.features_list()
|
|
)
|
|
self.assertIsNone(new_clouds._points_packed)
|
|
self.assertIsNone(new_clouds._normals_packed)
|
|
self.assertIsNone(new_clouds._features_packed)
|
|
self.assertIsNone(new_clouds._points_padded)
|
|
self.assertIsNone(new_clouds._normals_padded)
|
|
self.assertIsNone(new_clouds._features_padded)
|
|
|
|
with self.assertRaises(ValueError):
|
|
clouds.extend(N=-1)
|
|
|
|
def test_to(self):
|
|
cloud = self.init_cloud(5, 100, 10) # Using device "cuda:0"
|
|
|
|
cuda_device = torch.device("cuda:0")
|
|
|
|
converted_cloud = cloud.to("cuda:0")
|
|
self.assertEqual(cuda_device, converted_cloud.device)
|
|
self.assertEqual(cuda_device, cloud.device)
|
|
self.assertIs(cloud, converted_cloud)
|
|
|
|
converted_cloud = cloud.to(cuda_device)
|
|
self.assertEqual(cuda_device, converted_cloud.device)
|
|
self.assertEqual(cuda_device, cloud.device)
|
|
self.assertIs(cloud, converted_cloud)
|
|
|
|
cpu_device = torch.device("cpu")
|
|
|
|
converted_cloud = cloud.to("cpu")
|
|
self.assertEqual(cpu_device, converted_cloud.device)
|
|
self.assertEqual(cuda_device, cloud.device)
|
|
self.assertIsNot(cloud, converted_cloud)
|
|
|
|
converted_cloud = cloud.to(cpu_device)
|
|
self.assertEqual(cpu_device, converted_cloud.device)
|
|
self.assertEqual(cuda_device, cloud.device)
|
|
self.assertIsNot(cloud, converted_cloud)
|
|
|
|
def test_to_list(self):
|
|
cloud = self.init_cloud(5, 100, 10)
|
|
device = torch.device("cuda:1")
|
|
|
|
new_cloud = cloud.to(device)
|
|
self.assertTrue(new_cloud.device == device)
|
|
self.assertTrue(cloud.device == torch.device("cuda:0"))
|
|
for attrib in [
|
|
"points_padded",
|
|
"points_packed",
|
|
"normals_padded",
|
|
"normals_packed",
|
|
"features_padded",
|
|
"features_packed",
|
|
"num_points_per_cloud",
|
|
"cloud_to_packed_first_idx",
|
|
"padded_to_packed_idx",
|
|
]:
|
|
self.assertClose(
|
|
getattr(new_cloud, attrib)().cpu(), getattr(cloud, attrib)().cpu()
|
|
)
|
|
for i in range(len(cloud)):
|
|
self.assertClose(
|
|
cloud.points_list()[i].cpu(), new_cloud.points_list()[i].cpu()
|
|
)
|
|
self.assertClose(
|
|
cloud.normals_list()[i].cpu(), new_cloud.normals_list()[i].cpu()
|
|
)
|
|
self.assertClose(
|
|
cloud.features_list()[i].cpu(), new_cloud.features_list()[i].cpu()
|
|
)
|
|
self.assertTrue(all(cloud.valid.cpu() == new_cloud.valid.cpu()))
|
|
self.assertTrue(cloud.equisized == new_cloud.equisized)
|
|
self.assertTrue(cloud._N == new_cloud._N)
|
|
self.assertTrue(cloud._P == new_cloud._P)
|
|
self.assertTrue(cloud._C == new_cloud._C)
|
|
|
|
def test_to_tensor(self):
|
|
cloud = self.init_cloud(5, 100, 10, lists_to_tensors=True)
|
|
device = torch.device("cuda:1")
|
|
|
|
new_cloud = cloud.to(device)
|
|
self.assertTrue(new_cloud.device == device)
|
|
self.assertTrue(cloud.device == torch.device("cuda:0"))
|
|
for attrib in [
|
|
"points_padded",
|
|
"points_packed",
|
|
"normals_padded",
|
|
"normals_packed",
|
|
"features_padded",
|
|
"features_packed",
|
|
"num_points_per_cloud",
|
|
"cloud_to_packed_first_idx",
|
|
"padded_to_packed_idx",
|
|
]:
|
|
self.assertClose(
|
|
getattr(new_cloud, attrib)().cpu(), getattr(cloud, attrib)().cpu()
|
|
)
|
|
for i in range(len(cloud)):
|
|
self.assertClose(
|
|
cloud.points_list()[i].cpu(), new_cloud.points_list()[i].cpu()
|
|
)
|
|
self.assertClose(
|
|
cloud.normals_list()[i].cpu(), new_cloud.normals_list()[i].cpu()
|
|
)
|
|
self.assertClose(
|
|
cloud.features_list()[i].cpu(), new_cloud.features_list()[i].cpu()
|
|
)
|
|
self.assertTrue(all(cloud.valid.cpu() == new_cloud.valid.cpu()))
|
|
self.assertTrue(cloud.equisized == new_cloud.equisized)
|
|
self.assertTrue(cloud._N == new_cloud._N)
|
|
self.assertTrue(cloud._P == new_cloud._P)
|
|
self.assertTrue(cloud._C == new_cloud._C)
|
|
|
|
def test_split(self):
|
|
clouds = self.init_cloud(5, 100, 10)
|
|
split_sizes = [2, 3]
|
|
split_clouds = clouds.split(split_sizes)
|
|
self.assertEqual(len(split_clouds[0]), 2)
|
|
self.assertTrue(
|
|
split_clouds[0].points_list()
|
|
== [clouds.get_cloud(0)[0], clouds.get_cloud(1)[0]]
|
|
)
|
|
self.assertEqual(len(split_clouds[1]), 3)
|
|
self.assertTrue(
|
|
split_clouds[1].points_list()
|
|
== [clouds.get_cloud(2)[0], clouds.get_cloud(3)[0], clouds.get_cloud(4)[0]]
|
|
)
|
|
|
|
split_sizes = [2, 0.3]
|
|
with self.assertRaises(ValueError):
|
|
clouds.split(split_sizes)
|
|
|
|
def test_get_cloud(self):
|
|
clouds = self.init_cloud(2, 100, 10)
|
|
for i in range(len(clouds)):
|
|
points, normals, features = clouds.get_cloud(i)
|
|
self.assertClose(points, clouds.points_list()[i])
|
|
self.assertClose(normals, clouds.normals_list()[i])
|
|
self.assertClose(features, clouds.features_list()[i])
|
|
|
|
with self.assertRaises(ValueError):
|
|
clouds.get_cloud(5)
|
|
with self.assertRaises(ValueError):
|
|
clouds.get_cloud(0.2)
|
|
|
|
def test_get_bounding_boxes(self):
|
|
device = torch.device("cuda:0")
|
|
points_list = []
|
|
for size in [10]:
|
|
points = torch.rand((size, 3), dtype=torch.float32, device=device)
|
|
points_list.append(points)
|
|
|
|
mins = torch.min(points, dim=0)[0]
|
|
maxs = torch.max(points, dim=0)[0]
|
|
bboxes_gt = torch.stack([mins, maxs], dim=1).unsqueeze(0)
|
|
clouds = Pointclouds(points_list)
|
|
bboxes = clouds.get_bounding_boxes()
|
|
self.assertClose(bboxes_gt, bboxes)
|
|
|
|
def test_padded_to_packed_idx(self):
|
|
device = torch.device("cuda:0")
|
|
points_list = []
|
|
npoints = [10, 20, 30]
|
|
for p in npoints:
|
|
points = torch.rand((p, 3), dtype=torch.float32, device=device)
|
|
points_list.append(points)
|
|
|
|
clouds = Pointclouds(points_list)
|
|
|
|
padded_to_packed_idx = clouds.padded_to_packed_idx()
|
|
points_packed = clouds.points_packed()
|
|
points_padded = clouds.points_padded()
|
|
points_padded_flat = points_padded.view(-1, 3)
|
|
|
|
self.assertClose(points_padded_flat[padded_to_packed_idx], points_packed)
|
|
|
|
idx = padded_to_packed_idx.view(-1, 1).expand(-1, 3)
|
|
self.assertClose(points_padded_flat.gather(0, idx), points_packed)
|
|
|
|
def test_getitem(self):
|
|
device = torch.device("cuda:0")
|
|
clouds = self.init_cloud(3, 10, 100)
|
|
|
|
def check_equal(selected, indices):
|
|
for selectedIdx, index in indices:
|
|
self.assertClose(
|
|
selected.points_list()[selectedIdx], clouds.points_list()[index]
|
|
)
|
|
self.assertClose(
|
|
selected.normals_list()[selectedIdx], clouds.normals_list()[index]
|
|
)
|
|
self.assertClose(
|
|
selected.features_list()[selectedIdx], clouds.features_list()[index]
|
|
)
|
|
|
|
# int index
|
|
index = 1
|
|
clouds_selected = clouds[index]
|
|
self.assertEqual(len(clouds_selected), 1)
|
|
check_equal(clouds_selected, [(0, 1)])
|
|
|
|
# list index
|
|
index = [1, 2]
|
|
clouds_selected = clouds[index]
|
|
self.assertEqual(len(clouds_selected), len(index))
|
|
check_equal(clouds_selected, enumerate(index))
|
|
|
|
# slice index
|
|
index = slice(0, 2, 1)
|
|
clouds_selected = clouds[index]
|
|
self.assertEqual(len(clouds_selected), 2)
|
|
check_equal(clouds_selected, [(0, 0), (1, 1)])
|
|
|
|
# bool tensor
|
|
index = torch.tensor([1, 0, 1], dtype=torch.bool, device=device)
|
|
clouds_selected = clouds[index]
|
|
self.assertEqual(len(clouds_selected), index.sum())
|
|
check_equal(clouds_selected, [(0, 0), (1, 2)])
|
|
|
|
# int tensor
|
|
index = torch.tensor([1, 2], dtype=torch.int64, device=device)
|
|
clouds_selected = clouds[index]
|
|
self.assertEqual(len(clouds_selected), index.numel())
|
|
check_equal(clouds_selected, enumerate(index.tolist()))
|
|
|
|
# invalid index
|
|
index = torch.tensor([1, 0, 1], dtype=torch.float32, device=device)
|
|
with self.assertRaises(IndexError):
|
|
clouds_selected = clouds[index]
|
|
index = 1.2
|
|
with self.assertRaises(IndexError):
|
|
clouds_selected = clouds[index]
|
|
|
|
def test_update_padded(self):
|
|
N, P, C = 5, 100, 4
|
|
for with_normfeat in (True, False):
|
|
for with_new_normfeat in (True, False):
|
|
clouds = self.init_cloud(
|
|
N, P, C, with_normals=with_normfeat, with_features=with_normfeat
|
|
)
|
|
|
|
num_points_per_cloud = clouds.num_points_per_cloud()
|
|
|
|
# initialize new points, normals, features
|
|
new_points = torch.rand(
|
|
clouds.points_padded().shape, device=clouds.device
|
|
)
|
|
new_points_list = [
|
|
new_points[i, : num_points_per_cloud[i]] for i in range(N)
|
|
]
|
|
new_normals, new_normals_list = None, None
|
|
new_features, new_features_list = None, None
|
|
if with_new_normfeat:
|
|
new_normals = torch.rand(
|
|
clouds.points_padded().shape, device=clouds.device
|
|
)
|
|
new_normals_list = [
|
|
new_normals[i, : num_points_per_cloud[i]] for i in range(N)
|
|
]
|
|
feat_shape = [
|
|
clouds.points_padded().shape[0],
|
|
clouds.points_padded().shape[1],
|
|
C,
|
|
]
|
|
new_features = torch.rand(feat_shape, device=clouds.device)
|
|
new_features_list = [
|
|
new_features[i, : num_points_per_cloud[i]] for i in range(N)
|
|
]
|
|
|
|
# update
|
|
new_clouds = clouds.update_padded(new_points, new_normals, new_features)
|
|
self.assertIsNone(new_clouds._points_list)
|
|
self.assertIsNone(new_clouds._points_packed)
|
|
|
|
self.assertEqual(new_clouds.equisized, clouds.equisized)
|
|
self.assertTrue(all(new_clouds.valid == clouds.valid))
|
|
|
|
self.assertClose(new_clouds.points_padded(), new_points)
|
|
self.assertClose(new_clouds.points_packed(), torch.cat(new_points_list))
|
|
for i in range(N):
|
|
self.assertClose(new_clouds.points_list()[i], new_points_list[i])
|
|
|
|
if with_new_normfeat:
|
|
for i in range(N):
|
|
self.assertClose(
|
|
new_clouds.normals_list()[i], new_normals_list[i]
|
|
)
|
|
self.assertClose(
|
|
new_clouds.features_list()[i], new_features_list[i]
|
|
)
|
|
self.assertClose(new_clouds.normals_padded(), new_normals)
|
|
self.assertClose(
|
|
new_clouds.normals_packed(), torch.cat(new_normals_list)
|
|
)
|
|
self.assertClose(new_clouds.features_padded(), new_features)
|
|
self.assertClose(
|
|
new_clouds.features_packed(), torch.cat(new_features_list)
|
|
)
|
|
else:
|
|
if with_normfeat:
|
|
for i in range(N):
|
|
self.assertClose(
|
|
new_clouds.normals_list()[i], clouds.normals_list()[i]
|
|
)
|
|
self.assertClose(
|
|
new_clouds.features_list()[i], clouds.features_list()[i]
|
|
)
|
|
self.assertNotSeparate(
|
|
new_clouds.normals_list()[i], clouds.normals_list()[i]
|
|
)
|
|
self.assertNotSeparate(
|
|
new_clouds.features_list()[i], clouds.features_list()[i]
|
|
)
|
|
|
|
self.assertClose(
|
|
new_clouds.normals_padded(), clouds.normals_padded()
|
|
)
|
|
self.assertClose(
|
|
new_clouds.normals_packed(), clouds.normals_packed()
|
|
)
|
|
self.assertClose(
|
|
new_clouds.features_padded(), clouds.features_padded()
|
|
)
|
|
self.assertClose(
|
|
new_clouds.features_packed(), clouds.features_packed()
|
|
)
|
|
self.assertNotSeparate(
|
|
new_clouds.normals_padded(), clouds.normals_padded()
|
|
)
|
|
self.assertNotSeparate(
|
|
new_clouds.features_padded(), clouds.features_padded()
|
|
)
|
|
else:
|
|
self.assertIsNone(new_clouds.normals_list())
|
|
self.assertIsNone(new_clouds.features_list())
|
|
self.assertIsNone(new_clouds.normals_padded())
|
|
self.assertIsNone(new_clouds.features_padded())
|
|
self.assertIsNone(new_clouds.normals_packed())
|
|
self.assertIsNone(new_clouds.features_packed())
|
|
|
|
for attrib in [
|
|
"num_points_per_cloud",
|
|
"cloud_to_packed_first_idx",
|
|
"padded_to_packed_idx",
|
|
]:
|
|
self.assertClose(
|
|
getattr(new_clouds, attrib)(), getattr(clouds, attrib)()
|
|
)
|
|
|
|
def test_inside_box(self):
|
|
def inside_box_naive(cloud, box_min, box_max):
|
|
return ((cloud >= box_min.view(1, 3)) * (cloud <= box_max.view(1, 3))).all(
|
|
dim=-1
|
|
)
|
|
|
|
N, P, C = 5, 100, 4
|
|
|
|
clouds = self.init_cloud(N, P, C, with_normals=False, with_features=False)
|
|
device = clouds.device
|
|
|
|
# box of shape Nx2x3
|
|
box_min = torch.rand((N, 1, 3), device=device)
|
|
box_max = box_min + torch.rand((N, 1, 3), device=device)
|
|
box = torch.cat([box_min, box_max], dim=1)
|
|
|
|
within_box = clouds.inside_box(box)
|
|
|
|
within_box_naive = []
|
|
for i, cloud in enumerate(clouds.points_list()):
|
|
within_box_naive.append(inside_box_naive(cloud, box[i, 0], box[i, 1]))
|
|
within_box_naive = torch.cat(within_box_naive, 0)
|
|
self.assertTrue(torch.equal(within_box, within_box_naive))
|
|
|
|
# box of shape 2x3
|
|
box2 = box[0, :]
|
|
|
|
within_box2 = clouds.inside_box(box2)
|
|
|
|
within_box_naive2 = []
|
|
for cloud in clouds.points_list():
|
|
within_box_naive2.append(inside_box_naive(cloud, box2[0], box2[1]))
|
|
within_box_naive2 = torch.cat(within_box_naive2, 0)
|
|
self.assertTrue(torch.equal(within_box2, within_box_naive2))
|
|
# box of shape 1x2x3
|
|
box3 = box2.expand(1, 2, 3)
|
|
|
|
within_box3 = clouds.inside_box(box3)
|
|
self.assertTrue(torch.equal(within_box2, within_box3))
|
|
|
|
# invalid box
|
|
invalid_box = torch.cat(
|
|
[box_min, box_min - torch.rand((N, 1, 3), device=device)], dim=1
|
|
)
|
|
with self.assertRaisesRegex(ValueError, "Input box is invalid"):
|
|
clouds.inside_box(invalid_box)
|
|
|
|
# invalid box shapes
|
|
invalid_box = box[0].expand(2, 2, 3)
|
|
with self.assertRaisesRegex(ValueError, "Input box dimension is"):
|
|
clouds.inside_box(invalid_box)
|
|
invalid_box = torch.rand((5, 8, 9, 3), device=device)
|
|
with self.assertRaisesRegex(ValueError, "Input box must be of shape"):
|
|
clouds.inside_box(invalid_box)
|
|
|
|
def test_estimate_normals(self):
|
|
for with_normals in (True, False):
|
|
for run_padded in (True, False):
|
|
for run_packed in (True, False):
|
|
clouds = TestPointclouds.init_cloud(
|
|
3,
|
|
100,
|
|
with_normals=with_normals,
|
|
with_features=False,
|
|
min_points=60,
|
|
)
|
|
nums = clouds.num_points_per_cloud()
|
|
if run_padded:
|
|
clouds.points_padded()
|
|
if run_packed:
|
|
clouds.points_packed()
|
|
|
|
normals_est_padded = clouds.estimate_normals(assign_to_self=True)
|
|
normals_est_list = struct_utils.padded_to_list(
|
|
normals_est_padded, nums.tolist()
|
|
)
|
|
self.assertClose(clouds.normals_padded(), normals_est_padded)
|
|
for i in range(len(clouds)):
|
|
self.assertClose(clouds.normals_list()[i], normals_est_list[i])
|
|
self.assertClose(
|
|
clouds.normals_packed(), torch.cat(normals_est_list, dim=0)
|
|
)
|
|
|
|
def test_subsample(self):
|
|
lengths = [4, 5, 13, 3]
|
|
points = [torch.rand(length, 3) for length in lengths]
|
|
features = [torch.rand(length, 5) for length in lengths]
|
|
normals = [torch.rand(length, 3) for length in lengths]
|
|
|
|
pcl1 = Pointclouds(points=points).cuda()
|
|
self.assertIs(pcl1, pcl1.subsample(13))
|
|
self.assertIs(pcl1, pcl1.subsample([6, 13, 13, 13]))
|
|
|
|
lengths_max_4 = torch.tensor([4, 4, 4, 3]).cuda()
|
|
for with_normals, with_features in itertools.product([True, False], repeat=2):
|
|
with self.subTest(f"{with_normals} {with_features}"):
|
|
pcl = Pointclouds(
|
|
points=points,
|
|
normals=normals if with_normals else None,
|
|
features=features if with_features else None,
|
|
)
|
|
pcl_copy = pcl.subsample(max_points=4)
|
|
for length, points_ in zip(lengths_max_4, pcl_copy.points_list()):
|
|
self.assertEqual(points_.shape, (length, 3))
|
|
if with_normals:
|
|
for length, normals_ in zip(lengths_max_4, pcl_copy.normals_list()):
|
|
self.assertEqual(normals_.shape, (length, 3))
|
|
else:
|
|
self.assertIsNone(pcl_copy.normals_list())
|
|
if with_features:
|
|
for length, features_ in zip(
|
|
lengths_max_4, pcl_copy.features_list()
|
|
):
|
|
self.assertEqual(features_.shape, (length, 5))
|
|
else:
|
|
self.assertIsNone(pcl_copy.features_list())
|
|
|
|
pcl2 = Pointclouds(points=points)
|
|
pcl_copy2 = pcl2.subsample(lengths_max_4)
|
|
for length, points_ in zip(lengths_max_4, pcl_copy2.points_list()):
|
|
self.assertEqual(points_.shape, (length, 3))
|
|
|
|
def test_join_pointclouds_as_batch(self):
|
|
"""
|
|
Test join_pointclouds_as_batch
|
|
"""
|
|
|
|
def check_item(x, y):
|
|
self.assertEqual(x is None, y is None)
|
|
if x is not None:
|
|
self.assertClose(torch.cat([x, x, x]), y)
|
|
|
|
def check_triple(points, points3):
|
|
"""
|
|
Verify that points3 is three copies of points.
|
|
"""
|
|
check_item(points.points_padded(), points3.points_padded())
|
|
check_item(points.normals_padded(), points3.normals_padded())
|
|
check_item(points.features_padded(), points3.features_padded())
|
|
|
|
lengths = [4, 5, 13, 3]
|
|
points = [torch.rand(length, 3) for length in lengths]
|
|
features = [torch.rand(length, 5) for length in lengths]
|
|
normals = [torch.rand(length, 3) for length in lengths]
|
|
|
|
# Test with normals and features present
|
|
pcl1 = Pointclouds(points=points, features=features, normals=normals)
|
|
pcl3 = join_pointclouds_as_batch([pcl1] * 3)
|
|
check_triple(pcl1, pcl3)
|
|
|
|
# Test with normals and features present for tensor backed pointclouds
|
|
N, P, D = 5, 30, 4
|
|
pcl = Pointclouds(
|
|
points=torch.rand(N, P, 3),
|
|
features=torch.rand(N, P, D),
|
|
normals=torch.rand(N, P, 3),
|
|
)
|
|
pcl3 = join_pointclouds_as_batch([pcl] * 3)
|
|
check_triple(pcl, pcl3)
|
|
|
|
# Test with inconsistent #features
|
|
with self.assertRaisesRegex(ValueError, "same number of features"):
|
|
join_pointclouds_as_batch([pcl1, pcl])
|
|
|
|
# Test without normals
|
|
pcl_nonormals = Pointclouds(points=points, features=features)
|
|
pcl3 = join_pointclouds_as_batch([pcl_nonormals] * 3)
|
|
check_triple(pcl_nonormals, pcl3)
|
|
pcl_scene = join_pointclouds_as_scene([pcl_nonormals] * 3)
|
|
self.assertEqual(len(pcl_scene), 1)
|
|
self.assertClose(pcl_scene.features_packed(), pcl3.features_packed())
|
|
|
|
# Test without features
|
|
pcl_nofeats = Pointclouds(points=points, normals=normals)
|
|
pcl3 = join_pointclouds_as_batch([pcl_nofeats] * 3)
|
|
check_triple(pcl_nofeats, pcl3)
|
|
pcl_scene = join_pointclouds_as_scene([pcl_nofeats] * 3)
|
|
self.assertEqual(len(pcl_scene), 1)
|
|
self.assertClose(pcl_scene.normals_packed(), pcl3.normals_packed())
|
|
|
|
# Check error raised if all pointclouds in the batch
|
|
# are not consistent in including normals/features
|
|
with self.assertRaisesRegex(ValueError, "some set to None"):
|
|
join_pointclouds_as_batch([pcl, pcl_nonormals, pcl_nonormals])
|
|
with self.assertRaisesRegex(ValueError, "some set to None"):
|
|
join_pointclouds_as_batch([pcl, pcl_nofeats, pcl_nofeats])
|
|
|
|
# Check error if first input is a single pointclouds object
|
|
# instead of a list
|
|
with self.assertRaisesRegex(ValueError, "Wrong first argument"):
|
|
join_pointclouds_as_batch(pcl)
|
|
|
|
# Check error if all pointclouds are not on the same device
|
|
with self.assertRaisesRegex(ValueError, "same device"):
|
|
join_pointclouds_as_batch([pcl, pcl.to("cuda:0")])
|
|
|
|
@staticmethod
|
|
def compute_packed_with_init(
|
|
num_clouds: int = 10, max_p: int = 100, features: int = 300
|
|
):
|
|
clouds = TestPointclouds.init_cloud(num_clouds, max_p, features)
|
|
torch.cuda.synchronize()
|
|
|
|
def compute_packed():
|
|
clouds._compute_packed(refresh=True)
|
|
torch.cuda.synchronize()
|
|
|
|
return compute_packed
|
|
|
|
@staticmethod
|
|
def compute_padded_with_init(
|
|
num_clouds: int = 10, max_p: int = 100, features: int = 300
|
|
):
|
|
clouds = TestPointclouds.init_cloud(num_clouds, max_p, features)
|
|
torch.cuda.synchronize()
|
|
|
|
def compute_padded():
|
|
clouds._compute_padded(refresh=True)
|
|
torch.cuda.synchronize()
|
|
|
|
return compute_padded
|