def test_poisson_disk_sampling(self):
import point_cloud_utils as pcu
import numpy as np
# v is a nv by 3 NumPy array of vertices
# f is an nf by 3 NumPy array of face indexes into v
# n is a nv by 3 NumPy array of vertex normals
v, f, n = pcu.read_obj(os.path.join(self.test_path, "cube_twist.obj"))
bbox = np.max(v, axis=0) - np.min(v, axis=0)
bbox_diag = np.linalg.norm(bbox)
# Generate very dense random samples on the mesh (v, f, n)
# Note that this function works with no normals, just pass in an empty array np.array([], dtype=v.dtype)
# v_dense is an array with shape (100*v.shape[0], 3) where each row is a point on the mesh (v, f)
# n_dense is an array with shape (100*v.shape[0], 3) where each row is a the normal of a point in v_dense
v_dense, n_dense = pcu.sample_mesh_random(v, f, n, num_samples=v.shape[0] * 100)
# Downsample v_dense to be from a blue noise distribution:
#
# v_poisson is a downsampled version of v where points are separated by approximately
# `radius` distance, use_geodesic_distance indicates that the distance should be measured on the mesh.
#
# n_poisson are the corresponding normals of v_poisson
v_poisson, n_poisson = pcu.sample_mesh_poisson_disk(
v_dense, f, n_dense, radius=0.01 * bbox_diag, use_geodesic_distance=True)
def sample_pointcloud_mesh(obj_path):
off_v, off_f, off_n = pcu.read_obj(obj_path)
if off_n.shape[0] != off_v.shape[0]:
off_n = np.array([])
v_dense, n_dense = pcu.sample_mesh_random(off_v,
off_f,
off_n,
num_samples=point_num)
return v_dense
def shootCloud(V, F, density: int = 256, occlusion=80, shuffle=False):
cloud, _ = pcu.sample_mesh_random(V,
F,
np.array([], dtype=V.dtype),
num_samples=density + occlusion)
tree = KDTree(cloud)
# find occlusion nearest neighbours and remove
if occlusion > 0:
x = np.random.randint(len(cloud))
_, nearest_ind = tree.query(cloud[x].reshape(-1, 3), k=occlusion)
cloud = np.delete(cloud, nearest_ind, axis=0)
# unorder the data
if shuffle:
np.random.shuffle(cloud)
return cloud
def test_mesh_sampling(self):
import point_cloud_utils as pcu
import numpy as np
# v is a nv by 3 NumPy array of vertices
# f is an nf by 3 NumPy array of face indexes into v
# n is a nv by 3 NumPy array of vertex normals if they are specified, otherwise an empty array
v, f, n = pcu.read_obj(os.path.join(self.test_path, "cube_twist.obj"))
bbox = np.max(v, axis=0) - np.min(v, axis=0)
bbox_diag = np.linalg.norm(bbox)
f_idx1, bc1 = pcu.sample_mesh_random(v, f, num_samples=1000, random_seed=1234567)
f_idx2, bc2 = pcu.sample_mesh_random(v, f, num_samples=1000, random_seed=1234567)
f_idx3, bc3 = pcu.sample_mesh_random(v, f, num_samples=1000, random_seed=7654321)
self.assertTrue(np.all(f_idx1 == f_idx2))
self.assertTrue(np.all(bc1 == bc2))
self.assertFalse(np.all(f_idx1 == f_idx3))
self.assertFalse(np.all(bc1 == bc3))
# Generate very dense random samples on the mesh (v, f)
f_idx, bc = pcu.sample_mesh_random(v, f, num_samples=v.shape[0] * 4)
v_dense = (v[f[f_idx]] * bc[:, np.newaxis]).sum(1)
s_idx = pcu.downsample_point_cloud_poisson_disk(v_dense, 0, 0.1*bbox_diag, random_seed=1234567)
s_idx2 = pcu.downsample_point_cloud_poisson_disk(v_dense, 0, 0.1*bbox_diag, random_seed=1234567)
s_idx3 = pcu.downsample_point_cloud_poisson_disk(v_dense, 0, 0.1 * bbox_diag, random_seed=7654321)
self.assertTrue(np.all(s_idx == s_idx2))
if s_idx3.shape == s_idx.shape:
self.assertFalse(np.all(s_idx == s_idx3))
else:
self.assertFalse(s_idx.shape == s_idx3.shape)
# Ensure we can request more samples than vertices and get something reasonable
s_idx_0 = pcu.downsample_point_cloud_poisson_disk(v_dense, 2*v_dense.shape[0], random_seed=1234567)
s_idx = pcu.downsample_point_cloud_poisson_disk(v_dense, 1000, random_seed=1234567)
s_idx2 = pcu.downsample_point_cloud_poisson_disk(v_dense, 1000, random_seed=1234567)
s_idx3 = pcu.downsample_point_cloud_poisson_disk(v_dense, 1000, random_seed=7654321)
self.assertTrue(np.all(s_idx == s_idx2))
if s_idx3.shape == s_idx.shape:
self.assertFalse(np.all(s_idx == s_idx3))
else:
self.assertFalse(s_idx.shape == s_idx3.shape)
f_idx1, bc1 = pcu.sample_mesh_poisson_disk(v, f, num_samples=1000,
random_seed=1234567, use_geodesic_distance=True,
oversampling_factor=5.0)
f_idx2, bc2 = pcu.sample_mesh_poisson_disk(v, f, num_samples=1000,
random_seed=1234567, use_geodesic_distance=True,
oversampling_factor=5.0)
f_idx3, bc3 = pcu.sample_mesh_poisson_disk(v, f, num_samples=1000,
random_seed=7654321, use_geodesic_distance=True,
oversampling_factor=5.0)
self.assertTrue(np.all(f_idx1 == f_idx2))
self.assertTrue(np.all(bc1 == bc2))
if f_idx1.shape == f_idx3.shape:
self.assertFalse(np.all(f_idx1 == f_idx3))
if bc1.shape == bc3.shape:
self.assertFalse(np.all(bc1 == bc3))
f_idx1, bc1 = pcu.sample_mesh_poisson_disk(v, f, num_samples=-1, radius=0.01*bbox_diag,
random_seed=1234567, oversampling_factor=5.0)
f_idx2, bc2 = pcu.sample_mesh_poisson_disk(v, f, num_samples=-1, radius=0.01*bbox_diag,
random_seed=1234567, oversampling_factor=5.0)
f_idx3, bc3 = pcu.sample_mesh_poisson_disk(v, f, num_samples=-1, radius=0.01*bbox_diag,
random_seed=7654321, oversampling_factor=5.0)
self.assertTrue(np.all(f_idx1 == f_idx2))
self.assertTrue(np.all(bc1 == bc2))
if f_idx1.shape == f_idx3.shape:
self.assertFalse(np.all(f_idx1 == f_idx3))
if bc1.shape == bc3.shape:
self.assertFalse(np.all(bc1 == bc3))