def test_image_gradient_sanity():
# Only a sanity check - does it run and generate sensible output?
image = Image(np.zeros([120, 120, 3]))
new_image = image.gradient()
assert(type(new_image) == Image)
assert(new_image.shape == image.shape)
assert(new_image.n_channels == image.n_channels * 2)
def test_image_clip_pixels_cutom_max_uint():
pixels = (np.random.rand(3, 10, 20) * 255).astype(np.uint8)
# add the noise of increased values
pixels[0, 0, 0] = 255
image = Image(pixels, copy=False)
image2 = image.clip_pixels(maximum=200)
assert(image2.pixels.max() <= 200)
def test_texturedtrimesh_copy():
points = np.ones([10, 3])
tcoords = np.ones([10, 3])
trilist = np.ones([10, 3])
landmarks = PointCloud(np.ones([3, 3]), copy=False)
landmarks_im = PointCloud(np.ones([3, 2]), copy=False)
pixels = np.ones([10, 10, 1])
texture = Image(pixels, copy=False)
texture.landmarks['test_im'] = landmarks_im
ttmesh = TexturedTriMesh(points, tcoords, texture, trilist=trilist,
copy=False)
ttmesh.landmarks['test'] = landmarks
ttmesh_copy = ttmesh.copy()
assert (not is_same_array(ttmesh_copy.points, ttmesh.points))
assert (not is_same_array(ttmesh_copy.trilist, ttmesh.trilist))
assert (not is_same_array(ttmesh_copy.tcoords.points,
ttmesh.tcoords.points))
assert (not is_same_array(ttmesh_copy.texture.pixels,
ttmesh.texture.pixels))
assert (not is_same_array(
ttmesh_copy.texture.landmarks['test_im'].lms.points,
ttmesh.texture.landmarks['test_im'].lms.points))
assert (not is_same_array(ttmesh_copy.landmarks['test'].lms.points,
ttmesh.landmarks['test'].lms.points))
def test_rotate_image_90_180():
image = Image(np.array([[1., 2., 3., 4.],
[5., 6., 7., 8.],
[9., 10., 11., 12.]]))
image.landmarks['temp'] = PointCloud(np.array([[1., 1.], [1., 2.],
[2., 1.], [2., 2.]]))
# rotate 90 degrees
rotated_img = image.rotate_ccw_about_centre(theta=90, order=0)
rotated_img.landmarks['temp'] = rotated_img.landmarks['temp'].constrain_to_bounds(
rotated_img.bounds())
assert_allclose(rotated_img.pixels, np.array([[[4., 8., 12.],
[3., 7., 11.],
[2., 6., 10.],
[1., 5., 9.]]]))
assert_almost_equal(rotated_img.landmarks['temp'].points,
np.array([[2., 1.], [1., 1.], [2., 2.], [1., 2.]]))
# rotate 180 degrees
rotated_img = image.rotate_ccw_about_centre(theta=180, order=0)
rotated_img.landmarks['temp'] = rotated_img.landmarks['temp'].constrain_to_bounds(
rotated_img.bounds())
assert_allclose(rotated_img.pixels, np.array([[[12., 11., 10., 9.],
[8., 7., 6., 5.],
[4., 3., 2., 1.]]]))
assert_almost_equal(rotated_img.landmarks['temp'].points,
np.array([[1., 2.], [1., 1.], [0., 2.], [0., 1.]]))
def test_as_greyscale_average():
ones = np.ones([3, 120, 120])
image = Image(ones, copy=True)
image.pixels[0].fill(0.5)
new_image = image.as_greyscale(mode='average')
assert (new_image.shape == image.shape)
assert (new_image.n_channels == 1)
assert_allclose(new_image.pixels[0], ones[0] * 0.83333333)
def test_image_from_vector_inplace_no_copy_warning():
pixels = np.random.rand(10, 20, 2)
pixels2 = np.random.rand(10, 20, 2)
image = Image(pixels)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
image.from_vector_inplace(pixels2.ravel()[::-1], copy=False)
assert len(w) == 1
def test_normalize_norm_image():
pixels = np.ones((120, 120, 3))
pixels[..., 0] = 0.5
pixels[..., 1] = 0.2345
image = Image(pixels)
image.normalize_norm_inplace()
assert_allclose(np.mean(image.pixels), 0, atol=1e-10)
assert_allclose(np.linalg.norm(image.pixels), 1)
def test_copy_landmarks_and_path_with_no_lms_path():
img = Image.init_blank((5, 5))
new_img = Image.init_blank((5, 5))
copy_landmarks_and_path(img, new_img)
assert not hasattr(img, "path")
assert not hasattr(new_img, "path")
assert not img.has_landmarks
assert not new_img.has_landmarks
def test_as_greyscale_luminosity():
ones = np.ones([3, 120, 120])
image = Image(ones, copy=True)
image.pixels[0].fill(0.5)
new_image = image.as_greyscale(mode="luminosity")
assert new_image.shape == image.shape
assert new_image.n_channels == 1
assert_allclose(new_image.pixels[0], ones[0] * 0.850532)
def test_normalize_norm_image():
pixels = np.ones((3, 120, 120))
pixels[0] = 0.5
pixels[1] = 0.2345
image = Image(pixels)
new_image = image.normalize_norm()
assert_allclose(np.mean(new_image.pixels), 0, atol=1e-10)
assert_allclose(np.linalg.norm(new_image.pixels), 1)
def test_normalize_std_image():
pixels = np.ones((3, 120, 120))
pixels[0] = 0.5
pixels[1] = 0.2345
image = Image(pixels)
image.normalize_std_inplace()
assert_allclose(np.mean(image.pixels), 0, atol=1e-10)
assert_allclose(np.std(image.pixels), 1)
def test_image_copy():
pixels = np.ones([1, 10, 10])
landmarks = PointCloud(np.ones([3, 2]), copy=False)
im = Image(pixels, copy=False)
im.landmarks['test'] = landmarks
im_copy = im.copy()
assert (not is_same_array(im.pixels, im_copy.pixels))
assert (not is_same_array(im_copy.landmarks['test'].points,
im.landmarks['test'].points))
def test_normalize_norm_image():
pixels = np.ones((3, 120, 120))
pixels[0] = 0.5
pixels[1] = 0.2345
image = Image(pixels)
with warnings.catch_warnings():
warnings.simplefilter("ignore")
new_image = image.normalize_norm()
assert_allclose(np.mean(new_image.pixels), 0, atol=1e-10)
assert_allclose(np.linalg.norm(new_image.pixels), 1)
def test_normalize_std_image_per_channel():
pixels = np.random.randn(3, 120, 120)
pixels[1] *= 9
pixels[0] += -3
pixels[2] /= 140
image = Image(pixels)
image.normalize_std_inplace(mode='per_channel')
assert_allclose(
np.mean(image.as_vector(keep_channels=True), axis=1), 0, atol=1e-10)
assert_allclose(
np.std(image.as_vector(keep_channels=True), axis=1), 1)
def test_warp_to_mask_image():
img = Image.init_blank((10, 10), n_channels=2)
img.pixels[:, :, :5] = 0.5
template_mask = BooleanImage.init_blank((10, 10))
template_mask.pixels[:, 5:, :] = False
t = Affine.init_identity(2)
warped_img = img.warp_to_mask(template_mask, t)
assert(type(warped_img) == MaskedImage)
result = Image.init_blank((10, 10), n_channels=2).pixels
result[:, :5, :5] = 0.5
assert(np.all(result == warped_img.pixels))
def test_image_clip_pixels_cutom_max():
pixels = np.random.rand(3, 10, 20)
# add the noise of increased values
pixels *= 2.0
pixels[0, 0, 0] = 3.0
pixels[0, 0, 1] = - 0.1
image = Image(pixels, copy=False)
assert(image.pixels.max() > 1.0)
image2 = image.clip_pixels(maximum=0.9)
assert(image2.pixels.max() <= 0.9)
assert(image2.pixels.min() >= 0.0)
def test_normalize_norm_image_per_channel():
pixels = np.random.randn(3, 120, 120)
pixels[1] *= 17
pixels[0] += -114
pixels[2] /= 30
image = Image(pixels)
with warnings.catch_warnings():
warnings.simplefilter("ignore")
new_image = image.normalize_norm(mode="per_channel")
assert_allclose(np.mean(new_image.as_vector(keep_channels=True), axis=1), 0, atol=1e-10)
assert_allclose(np.linalg.norm(new_image.as_vector(keep_channels=True), axis=1), 1)
def test_normalize_norm_image_per_channel():
pixels = np.random.randn(120, 120, 3)
pixels[..., 1] *= 17
pixels[..., 0] += -114
pixels[..., 2] /= 30
image = Image(pixels)
image.normalize_norm_inplace(mode='per_channel')
assert_allclose(
np.mean(image.as_vector(keep_channels=True), axis=0), 0, atol=1e-10)
assert_allclose(
np.linalg.norm(image.as_vector(keep_channels=True), axis=0), 1)
def test_normalize_norm_image_per_channel():
pixels = np.random.randn(3, 120, 120)
pixels[1] *= 17
pixels[0] += -114
pixels[2] /= 30
image = Image(pixels)
new_image = image.normalize_norm(mode='per_channel')
assert_allclose(
np.mean(new_image.as_vector(keep_channels=True), axis=1), 0,
atol=1e-10)
assert_allclose(
np.linalg.norm(new_image.as_vector(keep_channels=True), axis=1), 1)
def test_mirror_vertical_image():
image = Image(np.array([[1., 2., 3., 4.],
[5., 6., 7., 8.],
[9., 10., 11., 12.]]))
image.landmarks['temp'] = PointCloud(np.array([[1., 0.], [1., 1.],
[2., 1.], [2., 2.]]))
mirrored_img = image.mirror()
assert_allclose(mirrored_img.pixels,
np.array([[[4., 3., 2., 1.],
[8., 7., 6., 5.],
[12., 11., 10., 9.]]]))
assert_allclose(mirrored_img.landmarks['temp'].points,
np.array([[1., 3.], [1., 2.], [2., 2.], [2., 1.]]))
def test_mirror_horizontal_image():
image = Image(np.array([[1., 2., 3., 4.],
[5., 6., 7., 8.],
[9., 10., 11., 12.]]))
image.landmarks['temp'] = PointCloud(np.array([[1., 1.], [1., 2.],
[2., 1.], [2., 2.]]))
mirrored_img = image.mirror(axis=0)
assert_allclose(mirrored_img.pixels,
np.array([[[9., 10., 11., 12.],
[5., 6., 7., 8.],
[1., 2., 3., 4.]]]))
assert_allclose(mirrored_img.landmarks['temp'].points,
np.array([[1., 1.], [1., 2.], [0., 1.], [0., 2.]]))
def test_transform_about_centre():
pixels_16 = np.arange(16, dtype=np.float)
image = Image(pixels_16.reshape(4, 4))
transform = Rotation.init_from_2d_ccw_angle(180).compose_before(
UniformScale(2, n_dims=2))
# rotate 90 + scale degrees
transformed_img = image.transform_about_centre(transform, order=0)
expected_pixels = np.rot90(np.repeat(np.repeat(pixels_16, 2).reshape(4, -1),
2, axis=0)[1:, 1:],
k=2)
assert transformed_img.shape == (7, 7)
assert_allclose(transformed_img.pixels[0], expected_pixels)
def test_normalize_std_image_per_channel():
pixels = np.random.randn(3, 120, 120)
pixels[1] *= 9
pixels[0] += -3
pixels[2] /= 140
image = Image(pixels)
with warnings.catch_warnings():
warnings.simplefilter("ignore")
new_image = image.normalize_std(mode='per_channel')
assert_allclose(
np.mean(new_image.as_vector(keep_channels=True), axis=1), 0,
atol=1e-10)
assert_allclose(
np.std(new_image.as_vector(keep_channels=True), axis=1), 1)
def build_parts_image(image, centres, parts_shape, offsets=np.array([[0, 0]]),
normalize_parts=False):
# extract patches
parts = image.extract_patches(PointCloud(np.round(centres.points)), np.array(parts_shape), offsets)
# build parts image
# img.pixels: n_centres x n_offsets x n_channels x height x width
img = Image(parts)
if normalize_parts:
# normalize parts if required
img.normalize_norm_inplace(mode='per_channel')
return img
def my_2d_rasterizer(im, fn=None, group=None, f=None, crop=False, message=None):
"""
Visualisation related function. It accepts a menpo image and renders
a **single** pair of landmarks in a new image.
The fn offers the chance to apply a custom function to the image.
ASSUMPTION: There is no check for the case of no landmarks in the image.
:param im: menpo image.
:param fn: (optional) If None, then the default .view_landmarks() is
used for visualisation, otherwise the provided function.
:param group: (optional) Used in case fn is None.
:param f: (optional) Matplotlib figure to use. Leave None, unless
you know how to modify.
:param crop: (optional) Crop the resulting visualisation to avoid the
the excessive white boundary. By default False.
:param message: (optional) If None, nothing is added in the image. If a
string is passed, then this is annotated (as text) with matplotlib
utilities, i.e. the exact same text is written in the image.
:return: menpo rasterised image.
"""
if fn is None:
f = plt.figure(frameon=False)
if group is None:
# in this case, assume that the first group of landmarks should suffice.
group = im.landmarks.group_labels[0]
r = im.view_landmarks(group=group)
else:
fn(im)
if message is not None:
assert isinstance(message, str)
st1 = 25 + 90 * crop
t = plt.annotate(message, xy=(st1, im.shape[0] - 10),
size=26, fontweight='bold', color='b')
# set background transparency
t.set_bbox(dict(color='w', alpha=0.5, edgecolor='w'))
# get the image from plt
f.tight_layout(pad=0)
# Get the pixels directly from the canvas buffer which is fast
c_buffer, shape = f.canvas.print_to_buffer()
# Turn buffer into numpy array and reshape to image
pixels_buffer = np.fromstring(c_buffer,
dtype=np.uint8).reshape(shape[::-1] + (-1,))
# Prevent matplotlib from rendering
plt.close(f)
# Ignore the Alpha channel
im_plt = Image.init_from_channels_at_back(pixels_buffer[..., :3])
# ensure that they have the same dtype as the original pixels.
dtype = im.pixels.dtype
if dtype != np.uint8:
if dtype == np.float32 or dtype == np.float64:
im_plt.pixels = im_plt.pixels.astype(dtype)
im_plt.pixels /= 255.0
else:
m1 = 'Not recognised type of original dtype ({}).'
print(m1.format(dtype))
if crop:
# # position to crop the rasterised image (hardcoded for now).
cri = (50, 60)
sh1 = im_plt.shape
im_plt = im_plt.crop((cri[0], cri[1]), (sh1[0] + cri[0], sh1[1] + cri[1]))
return im_plt
def _rasterize_matplotlib(image, pclouds, render_lines=True, line_style='-',
line_colour='b', line_width=1, render_markers=True,
marker_style='o', marker_size=1,
marker_face_colour='b', marker_edge_colour='b',
marker_edge_width=1):
import matplotlib.pyplot as plt
# Convert image shape into 100 DPI inches
# This makes sure we maintain the original image size
image_shape = np.array(image.shape)[::-1] / 100.0
f = plt.figure(figsize=image_shape, frameon=False, dpi=100)
image.view(figure_id=f.number, figure_size=image_shape)
for k, p in enumerate(pclouds):
p.view(figure_id=f.number, render_axes=False, figure_size=image_shape,
render_lines=render_lines[k], line_style=line_style[k],
line_colour=line_colour[k], line_width=line_width[k],
render_markers=render_markers[k], marker_style=marker_style[k],
marker_size=marker_size[k],
marker_face_colour=marker_face_colour[k],
marker_edge_colour=marker_edge_colour[k],
marker_edge_width=marker_edge_width[k])
# Make sure the layout is tight so that the image is of the original size
f.tight_layout(pad=0)
# Get the pixels directly from the canvas buffer which is fast
c_buffer, shape = f.canvas.print_to_buffer()
# Turn buffer into numpy array and reshape to image
pixels_buffer = np.fromstring(c_buffer,
dtype=np.uint8).reshape(shape[::-1] + (-1,))
# Prevent matplotlib from rendering
plt.close(f)
# Ignore the Alpha channel
return Image.init_from_channels_at_back(pixels_buffer[..., :3])
def test_crop_to_landmarks():
img = Image.init_blank((100, 100), n_channels=1)
img.landmarks['test'] = bounding_box([0, 0], [10, 10])
img_cropped = img.crop_to_landmarks()
assert_allclose(img_cropped.shape, (10, 10))
assert 1
def iter_image(self):
r"""
Returns a copy of the fitted image with a as many landmark groups as
iteration run by fitting procedure:
- ``iter_0``, containing the initial shape.
- ``iter_1``, containing the the fitted shape at the first
iteration.
- ``...``
- ``iter_n``, containing the final fitted shape.
:type: :map:`Image`
"""
image = Image(self.image.pixels)
for j, s in enumerate(self.shapes()):
image.landmarks['iter_'+str(j)] = s
return image
def test_rescale_to_pointcloud():
img = Image.init_blank((100, 100), n_channels=1)
img.landmarks['test'] = bounding_box([0, 0], [10, 10])
pcloud = bounding_box([0, 0], [25, 25])
img_rescaled = img.rescale_to_pointcloud(pcloud)
assert_allclose(img_rescaled.shape, (250, 250))
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'].points,
np.array([[2.121, 1.414], [1.414, 2.121],
[2.828, 2.121], [2.121, 2.828]]), decimal=3)
from collections import OrderedDict
from mock import patch, MagicMock
import numpy as np
from nose.tools import raises
from scipy.sparse import csr_matrix
from menpo.image import Image
from menpo.shape import (TriMesh, TexturedTriMesh, ColouredTriMesh, PointCloud,
LabelledPointUndirectedGraph)
from menpo.visualize import Menpo3dMissingError
from menpo.testing import surrogate
fake_triangle = np.array([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]])
fake_trilist = np.array([[0, 1, 2]], dtype=np.uint32)
fake_texture = Image.init_blank([10, 10])
fake_tcoords = np.array([[0, 0], [0.5, 0.5], [1.0, 1.0]])
menpo3d_visualize_mock = MagicMock()
menpo3d_visualize_mock.side_effect = ImportError
@surrogate('menpo3d.visualize.TriMeshViewer3d')
@patch('menpo3d.visualize.TriMeshViewer3d', menpo3d_visualize_mock)
@raises(Menpo3dMissingError)
def trimesh_viewer_test():
TriMesh(fake_triangle, trilist=fake_trilist, copy=False).view()
@surrogate('menpo3d.visualize.TexturedTriMeshViewer3d')
@patch('menpo3d.visualize.TexturedTriMeshViewer3d', menpo3d_visualize_mock)
@raises(Menpo3dMissingError)
def textured_trimesh_viewer_test():
def pillow_importer(filepath, asset=None, normalize=True, **kwargs):
r"""
Imports an image using PIL/pillow.
Different image modes cause different importing strategies.
RGB, L, I:
Imported as either `float` or `uint8` depending on normalisation flag.
RGBA:
Imported as :map:`MaskedImage` if normalize is ``True`` else imported
as a 4 channel `uint8` image.
1:
Imported as a :map:`BooleanImage`. Normalisation is ignored.
F:
Imported as a floating point image. Normalisation is ignored.
Parameters
----------
filepath : `Path`
Absolute filepath of image
asset : `object`, optional
An optional asset that may help with loading. This is unused for this
implementation.
normalize : `bool`, optional
If ``True``, normalize between 0.0 and 1.0 and convert to float. If
``False`` just pass whatever PIL imports back (according
to types rules outlined in constructor).
\**kwargs : `dict`, optional
Any other keyword arguments.
Returns
-------
image : :map:`Image` or subclass
The imported image.
"""
import PIL.Image as PILImage
pil_image = PILImage.open(str(filepath))
mode = pil_image.mode
if mode == 'RGBA':
# If normalize is False, then we return the alpha as an extra
# channel, which can be useful if the alpha channel has semantic
# meanings!
if normalize:
alpha = np.array(pil_image)[..., 3].astype(np.bool)
image_pixels = _pil_to_numpy(pil_image, True, convert='RGB')
image = MaskedImage(image_pixels, mask=alpha, copy=False)
else:
# With no normalisation we just return the pixels
image = Image(_pil_to_numpy(pil_image, False), copy=False)
elif mode in ['L', 'I', 'RGB']:
# Greyscale, Integer and RGB images
image = Image(_pil_to_numpy(pil_image, normalize), copy=False)
elif mode == '1':
# Can't normalize a binary image
image = BooleanImage(_pil_to_numpy(pil_image, False), copy=False)
elif mode == 'P':
# Convert pallete images to RGB
image = Image(_pil_to_numpy(pil_image, normalize, convert='RGB'))
elif mode == 'F': # Floating point images
# Don't normalize as we don't know the scale
image = Image(_pil_to_numpy(pil_image, False), copy=False)
else:
raise ValueError('Unexpected mode for PIL: {}'.format(mode))
return image
def test_diagonal_greyscale():
image = Image.init_blank((100, 250), n_channels=1)
assert image.diagonal() == (100 ** 2 + 250 ** 2) ** 0.5
def test_diagonal_kchannel_ndim():
image = Image.init_blank((100, 250, 50), n_channels=5)
assert image.diagonal() == (100 ** 2 + 250 ** 2 + 50 ** 2) ** 0.5
def test_image_from_vector():
pixels = np.random.rand(2, 10, 20)
pixels2 = np.random.rand(2, 10, 20)
image = Image(pixels)
image2 = image.from_vector(pixels2.ravel())
assert(np.all(image2.pixels == pixels2))
def test_image_from_vector_no_copy():
pixels = np.random.rand(2, 10, 20)
pixels2 = np.random.rand(2, 10, 20)
image = Image(pixels)
image2 = image.from_vector(pixels2.ravel(), copy=False)
assert(is_same_array(image2.pixels, pixels2))
def test_create_1d_error():
with raises(ValueError):
Image(np.ones(1))
def test_image_from_vector_inplace_no_copy():
pixels = np.random.rand(2, 10, 20)
pixels2 = np.random.rand(2, 10, 20)
image = Image(pixels)
image._from_vector_inplace(pixels2.ravel(), copy=False)
assert is_same_array(image.pixels, pixels2)
def test_normalize_scale_all():
pixels = np.arange(27, dtype=float).reshape([3, 3, 3])
dummy_scale = lambda *a, **kwargs: np.array(2.0)
image = Image(pixels, copy=False)
new_image = normalize(image, scale_func=dummy_scale, mode="all")
assert_allclose(new_image.pixels, (pixels - 13.0) / 2.0)
def test_normalize_unknown_mode_raises():
image = Image.init_blank((2, 2))
with raises(ValueError):
normalize(image, mode="fake")
import numpy as np
from numpy.testing import assert_allclose
from pytest import raises
import menpo.io as mio
from menpo.image import Image
from menpo.io.output.pickle import pickle_paths_as_pure
from menpo.io.utils import _norm_path
builtins_str = "__builtin__" if sys.version_info[0] == 2 else "builtins"
test_lg = mio.import_landmark_file(mio.data_path_to("lenna.ljson"),
group="LJSON")
nan_lg = test_lg.copy()
nan_lg.points[0, :] = np.nan
test_img = Image(np.random.random([100, 100]))
colour_test_img = Image(np.random.random([3, 100, 100]))
fake_path = "/tmp/test.fake"
@patch("menpo.io.output.base.landmark_types")
@patch("menpo.io.output.base.Path.exists")
@patch("menpo.io.output.base.Path.open")
def test_export_filepath_overwrite_exists(mock_open, exists, landmark_types):
exists.return_value = True
landmark_types.__contains__.return_value = True
mio.export_landmark_file(test_lg, fake_path, overwrite=True)
mock_open.assert_called_with("wb")
landmark_types.__getitem__.assert_called_with(".fake")
export_function = landmark_types.__getitem__.return_value
assert export_function.call_count == 1
import os
from pathlib import PosixPath, WindowsPath, Path
from mock import patch, PropertyMock, MagicMock
from nose.tools import raises
import menpo.io as mio
from menpo.io.utils import _norm_path
from menpo.image import Image
from menpo.io.output.pickle import pickle_paths_as_pure
builtins_str = '__builtin__' if sys.version_info[0] == 2 else 'builtins'
test_lg = mio.import_landmark_file(mio.data_path_to('breakingbad.pts'))
nan_lg = test_lg.copy()
nan_lg.lms.points[0, :] = np.nan
test_img = Image(np.random.random([100, 100]))
fake_path = '/tmp/test.fake'
@patch('menpo.io.output.base.landmark_types')
@patch('menpo.io.output.base.Path.exists')
@patch('menpo.io.output.base.Path.open')
def test_export_filepath_overwrite_exists(mock_open, exists, landmark_types):
exists.return_value = True
mio.export_landmark_file(test_lg, fake_path, overwrite=True)
mock_open.assert_called_with('wb')
landmark_types.__getitem__.assert_called_with('.fake')
export_function = landmark_types.__getitem__.return_value
assert export_function.call_count == 1
def test_normalize_0_variance_raises():
image = Image.init_blank((2, 2))
dummy_scale = lambda *a, **kwargs: np.array(0.0)
with raises(ValueError):
normalize(image, scale_func=dummy_scale)
def test_mirror_image_axis_error():
Image(np.array([[1., 2., 3., 4.], [5., 6., 7., 8.]])).mirror(axis=2)
def _rasterize_pillow(
image,
pclouds,
render_lines=True,
line_style="-",
line_colour="b",
line_width=1,
render_markers=True,
marker_style="o",
marker_size=1,
marker_face_colour="b",
marker_edge_colour="b",
marker_edge_width=1,
):
from PIL import ImageDraw
if image.n_channels not in {1, 3}:
raise ValueError("The Pillow rasterizer only supports grayscale or "
"colour images")
if any(x != "-" for x in line_style):
raise ValueError("The Pillow rasterizer only supports the '-' "
"line style.")
if any(x not in {"o", "s"} for x in marker_style):
raise ValueError("The Pillow rasterizer only supports the 'o' and 's' "
"marker styles.")
if any(x > 1 for x in marker_edge_width):
raise ValueError("The Pillow rasterizer only supports "
"marker_edge_width of 1 or 0.")
if image.n_channels == 1:
# Make the image RGB
image = image.extract_channels([0, 0, 0])
pil_im = image.as_PILImage()
draw = ImageDraw.Draw(pil_im)
line_colour = [_parse_colour(x) for x in line_colour]
marker_edge_colour = [_parse_colour(x) for x in marker_edge_colour]
marker_face_colour = [_parse_colour(x) for x in marker_face_colour]
for k in range(len(pclouds)):
p = pclouds[k]
if isinstance(p, TriMesh):
pclouds[k] = p.as_pointgraph()
points = p.points
if (render_lines[k] and line_width[k] > 0 and hasattr(p, "edges")
and p.edges.size > 0):
edges = p.edges
lines = zip(points[edges[:, 0], :], points[edges[:, 1], :])
for l1, l2 in lines:
draw.line(
[tuple(l1[::-1]), tuple(l2[::-1])],
fill=line_colour[k],
width=line_width[k],
)
if render_markers[k] and marker_size[k] > 0:
draw_func = draw.ellipse if marker_style[
k] == "o" else draw.rectangle
outline = marker_edge_colour[k] if marker_edge_width[
k] == 1 else None
for p in points:
y, x = p
draw_func(
(
x - marker_size[k],
y - marker_size[k],
x + marker_size[k],
y + marker_size[k],
),
fill=marker_face_colour[k],
outline=outline,
)
del draw
pixels = np.asarray(pil_im)
if image.n_channels == 3:
return Image.init_from_channels_at_back(pixels)
else:
return Image(pixels)
def test_normalize_var_all():
pixels = np.arange(27, dtype=float).reshape([3, 3, 3])
image = Image(pixels, copy=False)
new_image = normalize_var(image, mode="all")
assert_allclose(np.var(new_image.pixels), 0.01648, atol=1e-3)
def test_image_from_vector_custom_channels():
pixels = np.random.rand(2, 10, 20)
pixels2 = np.random.rand(3, 10, 20)
image = Image(pixels)
image2 = image.from_vector(pixels2.ravel(), n_channels=3)
assert(np.all(image2.pixels == pixels2))
def test_normalize_std_all():
pixels = np.arange(27, dtype=float).reshape([3, 3, 3])
image = Image(pixels, copy=False)
new_image = normalize_std(image, mode="all")
assert_allclose(np.std(new_image.pixels), 1.0)
def test_rescale_to_diagonal():
image = Image.init_blank((8, 6), n_channels=2)
assert image.diagonal() == 10
rescaled = image.rescale_to_diagonal(5)
assert rescaled.shape == (4, 3)
assert rescaled.n_channels == 2
def test_normalize_no_scale_all():
pixels = np.arange(27, dtype=float).reshape([3, 3, 3])
image = Image(pixels, copy=False)
new_image = normalize(image, scale_func=None, mode="all")
assert_allclose(new_image.pixels, pixels - 13.0)
def test_diagonal_color():
image = Image.init_blank((100, 250), n_channels=3)
assert image.diagonal() == (100 ** 2 + 250 ** 2) ** 0.5
def test_image_extract_channels():
image = Image(np.random.rand(3, 120, 120), copy=False)
extracted = image.extract_channels(0)
assert_equal(extracted.pixels, image.pixels[[0], ...])
def test_image_extract_channels_multiple_reversed():
image = Image(np.random.rand(3, 120, 120), copy=False)
extracted = image.extract_channels([2, 0])
assert_equal(extracted.pixels[0], image.pixels[2])
assert_equal(extracted.pixels[1], image.pixels[0])
def _set_up(self):
# work out feature length per patch
patch_img = Image.blank(self.patch_shape, fill=0)
self._feature_patch_length = self.regression_features(
patch_img).n_parameters
def test_as_pil_image_3channels():
im = Image.init_blank((120, 120), n_channels=3)
new_im = im.as_PILImage()
assert_allclose(np.asarray(new_im.getdata()).reshape(im.pixels.shape),
(im.pixels * 255).astype(np.uint8))
def test_no_op():
image = Image([[1.0, 2.0], [2.0, 1.0]])
new_image = no_op(image)
assert_allclose(image.pixels, new_image.pixels)
assert not is_same_array(image.pixels, new_image.pixels)
def test_as_pil_image_uint8():
im = Image(np.ones((1, 120, 120), dtype=np.uint8), copy=False)
new_im = im.as_PILImage()
assert_allclose(np.asarray(new_im.getdata()).reshape(im.pixels.shape),
im.pixels)
def test_es_values():
image = Image([[1.0, 2.0], [2.0, 1.0]])
es_img = es(image)
k = 1.0 / (2 * (2 ** 0.5))
res = np.array([[[k, -k], [k, -k]], [[k, k], [-k, -k]]])
assert_allclose(es_img.pixels, res)
def _rasterize_pillow(image,
pclouds,
render_lines=True,
line_style='-',
line_colour='b',
line_width=1,
render_markers=True,
marker_style='o',
marker_size=1,
marker_face_colour='b',
marker_edge_colour='b',
marker_edge_width=1):
from PIL import ImageDraw
if any(x != '-' for x in line_style):
raise ValueError("The Pillow rasterizer only supports the '-' "
"line style.")
if any(x not in {'o', 's'} for x in marker_style):
raise ValueError("The Pillow rasterizer only supports the 'o' and 's' "
"marker styles.")
if any(x > 1 for x in marker_edge_width):
raise ValueError('The Pillow rasterizer only supports '
'marker_edge_width of 1 or 0.')
pil_im = image.as_PILImage()
draw = ImageDraw.Draw(pil_im)
line_colour = [_parse_colour(x) for x in line_colour]
marker_edge_colour = [_parse_colour(x) for x in marker_edge_colour]
marker_face_colour = [_parse_colour(x) for x in marker_face_colour]
for k in range(len(pclouds)):
p = pclouds[k]
if isinstance(p, TriMesh):
pclouds[k] = p.as_pointgraph()
points = p.points
if (render_lines[k] and line_width[k] > 0 and hasattr(p, 'edges')
and p.edges.size > 0):
edges = p.edges
lines = zip(points[edges[:, 0], :], points[edges[:, 1], :])
for l1, l2 in lines:
draw.line([tuple(l1[::-1]), tuple(l2[::-1])],
fill=line_colour[k],
width=line_width[k])
if render_markers[k] and marker_size[k] > 0:
draw_func = (draw.ellipse
if marker_style[k] == 'o' else draw.rectangle)
outline = (marker_edge_colour[k]
if marker_edge_width[k] == 1 else None)
for p in points:
y, x = p
draw_func((x - marker_size[k], y - marker_size[k],
x + marker_size[k], y + marker_size[k]),
fill=marker_face_colour[k],
outline=outline)
del draw
pixels = np.asarray(pil_im)
if image.n_channels == 3:
return Image.init_from_channels_at_back(pixels)
else:
return Image(pixels)
def test_sample_image():
im = Image.init_blank((100, 100), fill=2)
p = PointCloud(np.array([[0, 0], [1, 0]]))
arr = im.sample(p)
assert_allclose(arr, [[2., 2.]])
