def _recursive_procrustes(self):
r"""
Recursively calculates a procrustes alignment.
"""
from menpo.shape import PointCloud
if self.n_iterations > self.max_iterations:
return False
av_aligned_source = sum(t.aligned_source.points for t in self.transforms) / self.n_sources
new_target = PointCloud(av_aligned_source)
# rescale the new_target to be the same size as the original about
# it's centre
rescale = UniformScale(self.initial_target_scale / new_target.norm(), self.n_dims)
centre = Translation(-new_target.centre)
rescale_about_centre = centre.compose_before(rescale).compose_before(centre.pseudoinverse)
rescale_about_centre.apply_inplace(new_target)
# check to see if we have converged yet
delta_target = np.linalg.norm(self.target.points - new_target.points)
if delta_target < 1e-6:
return True
else:
self.n_iterations += 1
for t in self.transforms:
t.set_target(new_target)
self.target = new_target
return self._recursive_procrustes()
def test_pointcloud_bounding_box_3d():
points = np.array([[1.0, 2.0, 3.0], [3.0, 2.0, 1.0]])
pc = PointCloud(points)
bb = pc.bounding_box()
bb_bounds = bb.bounds()
assert_allclose(bb_bounds[0], [1.0, 2.0, 1.0])
assert_allclose(bb_bounds[1], [3.0, 2.0, 3.0])
def test_pointcloud_centre():
points = np.array([[0, 0],
[1., 1],
[0, 2]])
pc = PointCloud(points)
c = pc.centre()
assert_allclose(c, [1. / 3., 1.])
def sparse_target(self):
r"""
The current sparse `menpo.shape.PointCloud` that this object produces.
:type: `menpo.shape.PointCloud`
"""
sparse_target = PointCloud(self.target.points[:self.n_landmarks])
return self._sparse_instance.from_vector(sparse_target.as_vector())
def test_pointcloud_centre_of_bounds():
points = np.array([[0, 0],
[1., 1],
[0, 2]])
pc = PointCloud(points)
cb = pc.centre_of_bounds()
assert_allclose(cb, [0.5, 1.])
assert 1
def test_pointcloud_flatten_rebuild():
points = np.array([[1, 2, 3], [1, 1, 1]])
pc = PointCloud(points)
flattened = pc.as_vector()
new_pc = pc.from_vector(flattened)
assert np.all(new_pc.n_dims == pc.n_dims)
assert np.all(new_pc.n_points == pc.n_points)
assert np.all(pc.points == new_pc.points)
def test_pointcloud_bounding_box():
points = np.array([[0, 0],
[1., 1],
[0, 2]])
pc = PointCloud(points)
bb = pc.bounding_box()
bb_bounds = bb.bounds()
assert_allclose(bb_bounds[0], [0., 0.])
assert_allclose(bb_bounds[1], [1., 2.])
def test_pointcloud_copy_method():
points = np.array([[1, 2, 3], [1, 1, 1]])
landmarks = PointCloud(np.ones([3, 3]), copy=False)
p = PointCloud(points, copy=False)
p.landmarks["test"] = landmarks
p_copy = p.copy()
assert not is_same_array(p_copy.points, p.points)
assert not is_same_array(p_copy.landmarks["test"].lms.points, p.landmarks["test"].lms.points)
def _align_mean_shape_with_bbox(self, bbox):
# Convert 3D landmarks to 2D by removing the Z axis
template_shape = PointCloud(self.mm.landmarks.points[:, [1, 0]])
# Rotation that flips over x axis
rot_matrix = np.eye(template_shape.n_dims)
rot_matrix[0, 0] = -1
template_shape = Rotation(rot_matrix,
skip_checks=True).apply(template_shape)
# Align the 2D landmarks' bbox with the provided bbox
return AlignmentSimilarity(template_shape.bounding_box(),
bbox).apply(template_shape)
def _parse_marker_size(marker_size, points):
if marker_size is None:
from menpo.shape import PointCloud
from scipy.spatial.distance import squareform
pc = PointCloud(points, copy=False)
if 1 < pc.n_points < 1000:
d = squareform(pc.distance_to(pc))
d.sort()
min_10pc = d[int(d.shape[0] / 10)]
marker_size = min_10pc / 5
else:
marker_size = 0.1
return marker_size
def test_LandmarkManager_group_order():
points = np.ones((10, 3))
pcloud = PointCloud(points, copy=False)
target = PointCloud(points)
man = LandmarkManager()
man['test_set'] = pcloud.copy()
man['abc'] = pcloud.copy()
man['def'] = pcloud.copy()
assert_equal(list(man._landmark_groups.keys()), ['test_set', 'abc', 'def'])
# check that after deleting and inserting the order will remain the same.
del man['test_set']
man['tt'] = pcloud.copy()
assert_equal(list(man._landmark_groups.keys()), ['abc', 'def', 'tt'])
def test_pointcloud_init_from_depth_image():
fake_z = np.random.uniform(size=(10, 10))
pc = PointCloud.init_from_depth_image(Image(fake_z))
assert pc.n_points == 100
assert pc.n_dims == 3
assert_allclose(pc.range()[:2], [9, 9])
assert pc.points[:, -1].max() <= 1.0
assert pc.points[:, -1].min() >= 0.0
def test_constrain_landmarks_to_bounds():
im = Image.init_blank((10, 10))
im.landmarks['test'] = PointCloud.init_2d_grid((20, 20))
with warnings.catch_warnings():
warnings.simplefilter('ignore')
im.constrain_landmarks_to_bounds()
assert not im.has_landmarks_outside_bounds()
assert_allclose(im.landmarks['test'].lms.bounds(), im.bounds())
def __init__(self, points, tcoords, texture, trilist=None, copy=True):
super(TexturedTriMesh, self).__init__(points, trilist=trilist,
copy=copy)
self.tcoords = PointCloud(tcoords, copy=copy)
if not copy:
self.texture = texture
else:
self.texture = texture.copy()
def _parse_marker_size(marker_size, points):
if marker_size is None:
from menpo.shape import PointCloud
pc = PointCloud(points, copy=False)
# This is the way that mayavi automatically computes the scale factor in
# case the user passes scale_factor = 'auto'. We use it for both the
# marker_size as well as the numbers_size.
xyz_min, xyz_max = pc.bounds()
x_min, y_min, z_min = xyz_min
x_max, y_max, z_max = xyz_max
distance = np.sqrt(((x_max - x_min) ** 2 +
(y_max - y_min) ** 2 +
(z_max - z_min) ** 2) /
(4 * pc.n_points ** 0.33))
if distance == 0:
marker_size = 1
else:
marker_size = 0.1 * distance
return marker_size
def test_pointcloud_init_from_depth_image_masked():
fake_z = np.random.uniform(size=(10, 10))
mask = np.zeros(fake_z.shape, dtype=np.bool)
mask[2:6, 2:6] = True
im = MaskedImage(fake_z, mask=mask)
pc = PointCloud.init_from_depth_image(im)
assert pc.n_points == 16
assert pc.n_dims == 3
assert_allclose(pc.range()[:2], [3, 3])
assert pc.points[:, -1].max() <= 1.0
assert pc.points[:, -1].min() >= 0.0
def tojson(self):
r"""
Convert this `TriMesh` to a dictionary JSON representation.
Returns
-------
dictionary with 'points' and 'trilist' keys. Both are lists suitable
for use in the by the `json` standard library package.
"""
json_dict = PointCloud.tojson(self)
json_dict['trilist'] = self.trilist.tolist()
return json_dict
def test_register_landmark_importer(is_file):
from menpo.shape import PointCloud
lmark = PointCloud.init_2d_grid((1, 1))
def foo_importer(filepath, **kwargs):
return lmark
is_file.return_value = True
with patch.dict(mio.input.extensions.image_landmark_types, {}, clear=True):
mio.register_landmark_importer('.foo', foo_importer)
new_lmark = mio.import_landmark_file('fake.foo')
assert lmark is new_lmark
def test_align_2d_rotation():
rotation_matrix = np.array([[0, 1],
[-1, 0]])
rotation = Rotation(rotation_matrix)
source = PointCloud(np.array([[0, 1],
[1, 1],
[-1, -5],
[3, -5]]))
target = rotation.apply(source)
# estimate the transform from source and target
estimate = AlignmentRotation(source, target)
# check the estimates is correct
assert_allclose(rotation.h_matrix,
estimate.h_matrix, atol=1e-14)
def test_sample_maskedimage_error_values():
m = np.zeros([100, 100], dtype=np.bool)
m[1, 0] = True
im = MaskedImage.init_blank((100, 100), mask=m, fill=2)
p = PointCloud(np.array([[0, 0], [1, 0]]))
try:
im.sample(p)
# Expect exception!
assert 0
except OutOfMaskSampleError as e:
sampled_mask = e.sampled_mask
sampled_values = e.sampled_values
assert_allclose(sampled_values, [[2., 2.]])
assert_allclose(sampled_mask, [[False, True]])
def homog_compose_before_alignment_nonuniformscale_test():
homog = Homogeneous(np.array([[0, 1, 0],
[1, 0, 0],
[0, 0, 1]]))
scale = UniformScale(2.5, 2)
source = PointCloud(np.array([[0, 1],
[1, 1],
[-1, -5],
[3, -5]]))
target = scale.apply(source)
# estimate the transform from source and target
s = AlignmentUniformScale(source, target)
res = homog.compose_before(s)
assert(type(res) == Homogeneous)
def test_register_landmark_importer(is_file):
from menpo.shape import PointCloud
from menpo.landmark import LandmarkGroup
lmark = LandmarkGroup.init_with_all_label(PointCloud.init_2d_grid((1, 1)))
def foo_importer(filepath, **kwargs):
return lmark
is_file.return_value = True
with patch.dict(mio.input.extensions.image_landmark_types, {}, clear=True):
mio.register_landmark_importer('.foo', foo_importer)
new_lmark = mio.import_landmark_file('fake.foo')
assert lmark is new_lmark
def test_register_landmark_importer(is_file):
from menpo.shape import PointCloud
lmark = PointCloud.init_2d_grid((1, 1))
def foo_importer(filepath, **kwargs):
return lmark
is_file.return_value = True
with patch.dict(mio.input.extensions.image_landmark_types, {}, clear=True):
mio.register_landmark_importer(".foo", foo_importer)
new_lmark = mio.import_landmark_file("fake.foo")
assert lmark is new_lmark
def pseudoinverse(self):
r"""
The pseudoinverse of the transform - that is, the transform that
results from swapping `source` and `target`, or more formally, negating
the transforms parameters. If the transform has a true inverse this
is returned instead.
:type: ``type(self)``
"""
from menpo.shape import PointCloud, TriMesh # to avoid circular import
new_source = TriMesh(self.target.points, self.source.trilist)
new_target = PointCloud(self.source.points)
return type(self)(new_source, new_target)
def _pointcloud_subset(face_cloud, subset):
r"""
Selects a semantic subset of points from a face pointcloud
Parameters
----------
face_cloud
subset
Returns
-------
The `lips` or `chin` pointclouds, as a subset of `face_cloud`
"""
if subset == 'lips':
subset_pts = PointCloud(face_cloud.points[48:68])
elif subset == 'chin':
subset_pts = PointCloud(
np.vstack((face_cloud.points[2:15], face_cloud.points[48:68])))
else:
raise Exception(
'unsupported landmark subset, only lips/chin are implemented')
return subset_pts
def test_align_2d_translation_from_vector_inplace():
t_vec = np.array([1, 2])
translation = Translation(t_vec)
source = PointCloud(np.array([[0, 1],
[1, 1],
[-1, -5],
[3, -5]]))
target = translation.apply(source)
# estimate the transform from source to source..
estimate = AlignmentTranslation(source, source)
# and update from_vector
estimate.from_vector_inplace(t_vec)
# check the estimates is correct
assert_allclose(target.points,
estimate.target.points)
def test_align_2d_translation_set_target():
t_vec = np.array([1, 2])
translation = Translation(t_vec)
source = PointCloud(np.array([[0, 1],
[1, 1],
[-1, -5],
[3, -5]]))
target = translation.apply(source)
# estimate the transform from source to source..
estimate = AlignmentTranslation(source, source)
# and change the target.
estimate.set_target(target)
# check the estimates is correct
assert_allclose(translation.h_matrix,
estimate.h_matrix)
def clm_correct(clm_model_path, image, map, lms_init):
""" tune landmarks using clm (constrained local model)"""
filehandler = open(os.path.join(clm_model_path), "rb")
try:
part_model = pickle.load(filehandler)
except UnicodeDecodeError:
part_model = pickle.load(filehandler,
fix_imports=True,
encoding="latin1")
filehandler.close()
# from ECT: https://github.com/HongwenZhang/ECT-FaceAlignment
part_model.opt = dict()
part_model.opt['numIter'] = 5
part_model.opt['kernel_covariance'] = 10
part_model.opt['sigOffset'] = 25
part_model.opt['sigRate'] = 0.25
part_model.opt['pdm_rho'] = 20
part_model.opt['verbose'] = False
part_model.opt['rho2'] = 20
part_model.opt['ablation'] = (True, True)
part_model.opt['ratio1'] = 0.12
part_model.opt['ratio2'] = 0.08
part_model.opt['smooth'] = True
fitter = GradientDescentCLMFitter(part_model, n_shape=30)
image.rspmap_data = np.swapaxes(np.swapaxes(map, 1, 3), 2, 3)
fr = fitter.fit_from_shape(image=image,
initial_shape=PointCloud(lms_init),
gt_shape=PointCloud(lms_init))
w_pdm_clm = fr.final_shape.points
return w_pdm_clm
def mean_pointcloud(pointclouds):
r"""
Compute the mean of a `list` of :map:`PointCloud` or subclass objects.
The list is assumed to be homogeneous i.e all elements of the list are
assumed to belong to the same point cloud subclass just as all elements
are also assumed to have the same number of points and represent
semantically equivalent point clouds.
Parameters
----------
pointclouds: `list` of :map:`PointCloud` or subclass
List of point cloud or subclass objects from which we want to compute
the mean.
Returns
-------
mean_pointcloud : :map:`PointCloud` or subclass
The mean point cloud or subclass.
"""
# make a temporary PointCloud (with copy=False for low overhead)
tmp_pc = PointCloud(sum(pc.points for pc in pointclouds) /
len(pointclouds), copy=False)
# use the type of the first element in the list to rebuild from the vector
return pointclouds[0].from_vector(tmp_pc.as_vector())
def perturb_init_shape(init_shape, num):
ret = [init_shape]
if num <= 1:
return ret
dx = np.random.uniform(low=-0.10, high=0.10, size=(num - 1))
dy = np.random.uniform(low=-0.10, high=0.10, size=(num - 1))
scale = np.random.normal(1, 0.07, size=(num - 1))
normalized_offsets = np.dstack((dy, dx))[0]
for i in range(num - 1):
ret.append(
PointCloud((init_shape.points - init_shape.centre()) * scale[i] +
init_shape.centre() +
init_shape.range() * normalized_offsets[i]))
return ret
def test_procrustes_no_target():
# square
src_1 = PointCloud(
np.array([[1.0, 1.0], [1.0, -1.0], [-1.0, -1.0], [-1.0, 1.0]]))
# rhombus
src_2 = PointCloud(
np.array([[2.0, 0.0], [4.0, 2.0], [6.0, 0.0], [4.0, -2.0]]))
# trapezoid
src_3 = PointCloud(
np.array([[-0.5, -1.5], [2.5, -1.5], [2.8, -2.5], [-0.2, -2.5]]))
gpa = GeneralizedProcrustesAnalysis([src_1, src_2, src_3])
aligned_1 = gpa.transforms[0].apply(gpa.sources[0])
aligned_2 = gpa.transforms[1].apply(gpa.sources[1])
aligned_3 = gpa.transforms[2].apply(gpa.sources[2])
assert (gpa.converged is True)
assert (gpa.n_iterations == 5)
assert (gpa.n_sources == 3)
assert (np.round(gpa.initial_target_scale * 100) == 195.)
assert (np.round(gpa.mean_alignment_error() * 10) == 4.)
assert_allclose(np.around(aligned_1.points, decimals=1),
np.around(aligned_2.points, decimals=1))
res_3 = np.array([[0.7, -0.3], [2.6, -0.4], [2.7, -1.0], [0.9, -0.9]])
assert_allclose(np.around(aligned_3.points, decimals=1), res_3)
assert_allclose(gpa.target.points, gpa.mean_aligned_shape().points)
def test_pca_variance_after_trim():
samples = [PointCloud(np.random.randn(10)) for _ in range(10)]
model = PCAModel(samples)
# set number of active components
model.trim_components(5)
# kept variance must be smaller than total variance
assert (model.variance < model.original_variance)
# kept variance ratio must be smaller than 1.0
assert (model.variance_ratio < 1.0)
# noise variance must be bigger than 0.0
assert (model.noise_variance > 0.0)
# noise variance ratio must also be bigger than 0.0
assert (model.noise_variance_ratio > 0.0)
# inverse noise variance is computable
assert (model.inverse_noise_variance == 1 / model.noise_variance)
def test_procrustes_with_target():
# square
src_1 = PointCloud(
np.array([[1.0, 1.0], [1.0, -1.0], [-1.0, -1.0], [-1.0, 1.0]]))
# trapezoid
src_2 = PointCloud(
np.array([[-0.5, -1.5], [2.5, -1.5], [2.8, -2.5], [-0.2, -2.5]]))
# rhombus as target
src_trg = PointCloud(
np.array([[2.0, 0.0], [4.0, 2.0], [6.0, 0.0], [4.0, -2.0]]))
gpa = GeneralizedProcrustesAnalysis([src_1, src_2], target=src_trg)
aligned_1 = gpa.transforms[0].apply(gpa.sources[0])
aligned_2 = gpa.transforms[1].apply(gpa.sources[1])
assert (gpa.converged is True)
assert (gpa.n_iterations == 2)
assert (gpa.n_sources == 2)
assert (gpa.initial_target_scale == 4.)
assert (np.round(gpa.av_alignment_error * 100) == 93.)
assert_allclose(np.around(aligned_1.points, decimals=1),
np.around(src_trg.points, decimals=1))
res_2 = np.array([[2.0, -0.9], [4.9, 1.6], [6.0, 0.9], [3.1, -1.6]])
assert_allclose(np.around(aligned_2.points, decimals=1), res_2)
mean = np.array([[2.0, -0.5], [4.5, 1.8], [6.0, 0.5], [3.5, -1.8]])
assert_allclose(np.around(gpa.mean_aligned_shape.points, decimals=1), mean)
def _align_source(self, source, eps=1e-3, max_iter=100):
# Initial Alignment using PCA
# p0, r, sm, tm = self._pca_align(source)
# transforms.append([r, sm, tm])
p0 = source.points
a_p, transforms, iters, point_corr = self._align(p0, eps, max_iter)
iters = [source.points, p0] + iters
self._test_iteration.append(iters)
self.transformations.append(transforms)
self.point_correspondence.append(point_corr)
return PointCloud(a_p)
def test_single_ndarray_patch():
patch_shape = (8, 7)
n_channels = 4
im = Image.init_blank((32, 32), n_channels)
patch = np.zeros((2, 2, n_channels) + patch_shape)
patch[0, 0, ...] = np.full((n_channels,) + patch_shape, 1) # Should be unused
patch[0, 1, ...] = np.full((n_channels,) + patch_shape, 2)
patch[1, 0, ...] = np.full((n_channels,) + patch_shape, 3) # Should be unused
patch[1, 1, ...] = np.full((n_channels,) + patch_shape, 4)
patch_center = PointCloud(np.array([[4.0, 4.0], [16.0, 16.0]]))
new_im = im.set_patches(patch, patch_center, offset_index=1)
res = np.zeros((32, 32))
res[:8, 1:8] = 2
res[12:20, 13:20] = 4
assert_array_equal(new_im.pixels[2], res)
def test_align_2d_similarity_set_target():
linear_component = np.array([[2, -6], [6, 2]])
translation_component = np.array([7, -8])
h_matrix = np.eye(3, 3)
h_matrix[:-1, :-1] = linear_component
h_matrix[:-1, -1] = translation_component
similarity = Similarity(h_matrix)
source = PointCloud(np.array([[0, 1], [1, 1], [-1, -5], [3, -5]]))
target = similarity.apply(source)
# estimate the transform from source to source
estimate = AlignmentSimilarity(source, source, allow_mirror=True)
# and set the target
estimate.set_target(target)
# check the estimates is correct
assert_allclose(similarity.h_matrix, estimate.h_matrix)
def test_landmarkgroup_copy_method():
points = np.ones((10, 3))
mask_dict = OrderedDict([('all', np.ones(10, dtype=np.bool))])
pcloud = PointCloud(points, copy=False)
lgroup = LandmarkGroup(pcloud, mask_dict, copy=False)
lgroup_copy = lgroup.copy()
assert (not is_same_array(lgroup_copy.lms.points, lgroup.lms.points))
# Check the mask dictionary is deepcopied properly
assert (lgroup._labels_to_masks is not lgroup_copy._labels_to_masks)
masks = zip(lgroup_copy._labels_to_masks.values(),
lgroup._labels_to_masks.values())
for ms in masks:
assert (ms[0] is not ms[1])
def test_align_2d_affine_set_target():
linear_component = np.array([[1, -6], [-3, 2]])
translation_component = np.array([7, -8])
h_matrix = np.eye(3, 3)
h_matrix[:-1, :-1] = linear_component
h_matrix[:-1, -1] = translation_component
affine = Affine(h_matrix)
source = PointCloud(np.array([[0, 1], [1, 1], [-1, -5], [3, -5]]))
target = affine.apply(source)
# estimate the transform from source and source
estimate = AlignmentAffine(source, source)
# and set the target
estimate.set_target(target)
# check the estimates is correct
assert_allclose(affine.h_matrix, estimate.h_matrix)
def test_align_2d_translation_from_vector():
t_vec = np.array([1, 2])
translation = Translation(t_vec)
source = PointCloud(np.array([[0, 1], [1, 1], [-1, -5], [3, -5]]))
target = translation.apply(source)
# estimate the transform from source to source..
estimate = AlignmentTranslation(source, source)
# and update from_vector
new_est = estimate.from_vector(t_vec)
# check the original is unchanged
assert_allclose(estimate.source.points, source.points)
assert_allclose(estimate.target.points, source.points)
# check the new estimate has the source and target correct
assert_allclose(new_est.source.points, source.points)
assert_allclose(new_est.target.points, target.points)
def __init__(self, sources, target=None):
from menpo.shape import PointCloud
if len(sources) < 2 and target is None:
raise ValueError("Need at least two sources to align")
self.n_sources = len(sources)
self.n_points, self.n_dims = sources[0].n_points, sources[0].n_dims
self.sources = sources
if target is None:
# set the target to the mean source position
self.target = PointCloud(
sum([s.points for s in self.sources]) / self.n_sources)
else:
assert self.n_dims, self.n_points == target.shape
self.target = target
def mean_pointcloud(pointclouds):
r"""
Compute the mean of a list of point cloud objects
Parameters
----------
pointclouds: list of :class:`menpo.shape.PointCloud`
List of point cloud objects from which we want to
compute the mean.
Returns
-------
mean_pointcloud: class:`menpo.shape.PointCloud`
The mean point cloud.
"""
return PointCloud(np.mean([pc.points for pc in pointclouds], axis=0))
def FastNICP(sources, target):
aligned = []
corrs = []
for source in sources:
pts, _ = icp(source.points, target.points)
mesh = TriMesh(pts)
try:
a_s, corr = nicp(mesh, target, us=2001, ls=1, step=100)
except:
print('Failed Fast NICP')
nicp_result = SNICP([PointCloud(pts)], target)
corr = nicp_result.point_correspondence[0]
a_s = nicp_result.aligned_shapes[0]
aligned.append(a_s)
corrs.append(corr)
return aligned, corrs
def test_mirror_vertical_image():
image = Image(
np.array([[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0],
[9.0, 10.0, 11.0, 12.0]]))
image.landmarks["temp"] = PointCloud(
np.array([[1.0, 0.0], [1.0, 1.0], [2.0, 1.0], [2.0, 2.0]]))
mirrored_img = image.mirror()
assert_allclose(
mirrored_img.pixels,
np.array([[[4.0, 3.0, 2.0, 1.0], [8.0, 7.0, 6.0, 5.0],
[12.0, 11.0, 10.0, 9.0]]]),
)
assert_allclose(
mirrored_img.landmarks["temp"].points,
np.array([[1.0, 3.0], [1.0, 2.0], [2.0, 2.0], [2.0, 1.0]]),
)
def fit_shape_to_box(normal_shape, box):
x, y = box.points[0]
w, h = box.range()
# center_x = x + w*2.0/3.0
# center_y = y + h/2.0
center_x = x + w/2.0
center_y = y + h/2.0
shape = normal_shape.points - normal_shape.centre()
shape *= [0.9*h/2.0, 0.9*w/2.0]
# shape *= [h/2.0, w/2.0]
shape += [center_x, center_y]
return PointCloud(shape)
def test_rotate_image_45():
image = Image(
np.array([[1., 2., 3., 4.], [5., 6., 7., 8.], [9., 10., 11., 12.],
[13., 14., 15., 16.]]))
image.landmarks['temp'] = PointCloud(
np.array([[1., 1.], [1., 2.], [2., 1.], [2., 2.]]))
rotated_img = image.rotate_ccw_about_centre(theta=45, order=0)
assert_allclose(
rotated_img.pixels,
np.array([[[0., 0., 4., 0., 0.], [0., 3., 7., 8., 0.],
[1., 6., 7., 11., 16.], [0., 5., 10., 15., 15.],
[0., 0., 13., 14., 0.]]]))
assert_almost_equal(rotated_img.landmarks['temp'].lms.points,
np.array([[2.121, 1.414], [1.414, 2.121],
[2.828, 2.121], [2.121, 2.828]]),
decimal=3)
def test_single_list_patch():
patch_shape = (8, 7)
n_channels = 4
im = Image.init_blank((32, 32), n_channels)
patch = [
Image(np.full((n_channels,) + patch_shape, 1)),
Image(np.full((n_channels,) + patch_shape, 2)), # Should be unused
Image(np.full((n_channels,) + patch_shape, 3)),
Image(np.full((n_channels,) + patch_shape, 4)),
] # Should be unused
patch_center = PointCloud(np.array([[4.0, 4.0], [16.0, 16.0]]))
new_im = im.set_patches(patch, patch_center, offset_index=0)
res = np.zeros((32, 32))
res[:8, 1:8] = 1
res[12:20, 13:20] = 3
assert_array_equal(new_im.pixels[0], res)
def test_colouredtrimesh_copy():
points = np.ones([10, 3])
colours = np.ones([10, 3])
trilist = np.ones([10, 3])
landmarks = PointCloud(np.ones([3, 3]), copy=False)
ctmesh = ColouredTriMesh(points, trilist=trilist, colours=colours,
copy=False)
ctmesh.landmarks['test'] = landmarks
ctmesh_copy = ctmesh.copy()
assert (not is_same_array(ctmesh_copy.points, ctmesh.points))
assert (not is_same_array(ctmesh_copy.trilist, ctmesh.trilist))
assert (not is_same_array(ctmesh_copy.colours, ctmesh.colours))
assert (not is_same_array(ctmesh_copy.landmarks['test'].lms.points,
ctmesh.landmarks['test'].lms.points))
def as_menpo_img(self):
"""
Converts image to menpo image
Returns
-------
menpo.image.Image: current image as menpo image
"""
menpo_img = Image(self.img)
lmk = self.lmk
menpo_lmk = PointCloud(self.lmk)
lmk_manager = LandmarkManager()
lmk_manager["LMK"] = menpo_lmk
menpo_img.landmarks = lmk_manager
return menpo_img
def test_align_2d_affine_compose_target():
source = PointCloud(np.array([[0, 1],
[1, 1],
[-1, -5],
[3, -5]]))
target = UniformScale(2.0, n_dims=2).apply(source)
original_estimate = AlignmentAffine(source, target)
new_estimate = original_estimate.copy()
new_estimate.compose_after_from_vector_inplace(
np.array([0, 0, 0, 0, 1, 1.]))
estimate_target = new_estimate.target
correct_target = original_estimate.compose_after(
Translation([1, 1.])).apply(source)
assert_allclose(estimate_target.points, correct_target.points)
def test_init_from_pointcloud_return_transform():
correct_tr = Translation([5, 5])
pc = correct_tr.apply(PointCloud.init_2d_grid((10, 10)))
im, tr = Image.init_from_pointcloud(pc, return_transform=True)
assert im.shape == (9, 9)
assert_allclose(tr.as_vector(), -correct_tr.as_vector())
def sparse_target(self):
sparse_target = PointCloud(self.target.points[:self.n_landmarks])
return self._sparse_instance.from_vector(sparse_target.as_vector())
def test_pointcloud_no_nan_values():
pcloud = PointCloud(np.random.rand(3, 2), copy=False)
assert not pcloud.has_nan_values()
def test_pointcloud_has_nan_values():
pcloud = PointCloud(np.random.rand(3, 2), copy=False)
pcloud.points[0, 0] = np.nan
assert pcloud.has_nan_values()
def test_pointcloud_init_2d_grid_incorrect_type_spacing_raises():
PointCloud.init_2d_grid([10, 10], spacing={})
def test_pointcloud_init_2d_grid_3d_spacing_raises():
PointCloud.init_2d_grid([10, 10], spacing=[1, 1, 1])
def test_pointcloud_init_2d_grid_3d_raises():
PointCloud.init_2d_grid([10, 10, 10])
def test_pointcloud_init_2d_grid_unequal_spacing():
pc = PointCloud.init_2d_grid([10, 10], spacing=(2., 3))
assert pc.n_points == 100
assert pc.n_dims == 2
assert_allclose(pc.range(), [18, 27])
def test_pointcloud_init_2d_grid_single_spacing():
pc = PointCloud.init_2d_grid([10, 10], spacing=2)
assert pc.n_points == 100
assert pc.n_dims == 2
assert_allclose(pc.range(), [18, 18])
def test_pointcloud_bounding_box_3d_fail():
points = np.array([[0, 0, 0],
[1, 1, 1]])
pc = PointCloud(points)
pc.bounding_box()
def test_pointcloud_init_2d_grid():
pc = PointCloud.init_2d_grid([10, 10])
assert pc.n_points == 100
assert pc.n_dims == 2
assert_allclose(pc.range(), [9, 9])
