def test_application(self):
im = Image.new('RGB', (10, 10))
lut_numpy = amplify_lut(identity_table(5), 2.0)
self.assertEqual(lut_numpy.table.__class__.__name__, 'ndarray')
im.filter(lut_numpy)
with disable_numpy(operations):
lut_native = amplify_lut(identity_table(5), 2.0)
self.assertEqual(lut_native.table.__class__.__name__, 'list')
im.filter(lut_native)
with disable_numpy(generators):
args = identity_table(5)
self.assertEqual(args.table.__class__.__name__, 'list')
lut_numpy = amplify_lut(args, 2.0)
self.assertEqual(lut_numpy.table.__class__.__name__, 'ndarray')
im.filter(lut_numpy)
args = identity_table(5)
self.assertEqual(args.table.__class__.__name__, 'ndarray')
with disable_numpy(operations):
lut_native = amplify_lut(args, 2.0)
self.assertEqual(lut_native.table.__class__.__name__, 'list')
im.filter(lut_native)
def test_different_dimensions(self):
lut_ref = ImageFilter.Color3DLUT.generate((4, 5, 6),
lambda a, b, c: (a, b, c))
lut_numpy = identity_table((4, 5, 6))
self.assertAlmostEqualLuts(lut_numpy, lut_ref)
with disable_numpy(generators):
lut_native = identity_table((4, 5, 6))
self.assertEqualLuts(lut_native, lut_ref)
def test_application(self):
im = Image.new('RGB', (10, 10))
lut_numpy = identity_table(5)
self.assertEqual(lut_numpy.table.__class__.__name__, 'ndarray')
im.filter(lut_numpy)
with disable_numpy(generators):
lut_native = identity_table(5)
self.assertEqual(lut_native.table.__class__.__name__, 'list')
im.filter(lut_native)
def test_wrong_args(self):
with self.assertRaisesRegexp(ValueError, "only 3-channel cubes"):
result = transform_lut(self.lut5_4c, identity_table(3))
with self.assertRaisesRegexp(ValueError, "only 3-channel cubes"):
result = transform_lut(self.lut5_4c,
identity_table(3),
target_size=5)
with self.assertRaisesRegexp(ValueError, "interpolations"):
result = transform_lut(identity_table(4),
identity_table(4),
interp=Image.NEAREST)
def test_correct_args(self):
result = transform_lut(identity_table((3, 4, 5), target_mode='RGB'),
identity_table((6, 7, 8), target_mode='HSV'))
self.assertEqual(tuple(result.size), (3, 4, 5))
self.assertEqual(result.mode, 'HSV')
self.assertEqual(result.channels, 3)
result = transform_lut(identity_table(3), self.lut5_4c)
self.assertEqual(tuple(result.size), (3, 3, 3))
self.assertEqual(result.mode, None)
self.assertEqual(result.channels, 4)
with disable_numpy(operations):
result = transform_lut(identity_table(3), self.lut5_4c)
self.assertEqual(tuple(result.size), (3, 3, 3))
self.assertEqual(result.mode, None)
self.assertEqual(result.channels, 4)
result = transform_lut(identity_table(4, target_mode='RGB'),
identity_table(5),
target_size=(6, 7, 8))
self.assertEqual(tuple(result.size), (6, 7, 8))
self.assertEqual(result.mode, 'RGB')
self.assertEqual(result.channels, 3)
with disable_numpy(operations):
result = transform_lut(identity_table(4, target_mode='RGB'),
identity_table(5),
target_size=(6, 7, 8))
self.assertEqual(tuple(result.size), (6, 7, 8))
self.assertEqual(result.mode, 'RGB')
self.assertEqual(result.channels, 3)
def test_correctness(self):
lut = ImageFilter.Color3DLUT.generate(5,
callback=lambda r, g, b:
(r + 0.1, g * 1.1, b - 0.1))
lut_05x = ImageFilter.Color3DLUT.generate(
5, callback=lambda r, g, b: (r + 0.05, g * 1.05, b - 0.05))
lut_2x = ImageFilter.Color3DLUT.generate(5,
callback=lambda r, g, b:
(r + 0.2, g * 1.2, b - 0.2))
identity = identity_table(5)
res_numpy = amplify_lut(lut, 1.0)
with disable_numpy(operations):
res_native = amplify_lut(lut, 1.0)
self.assertAlmostEqualLuts(res_numpy, lut)
self.assertAlmostEqualLuts(res_native, res_numpy)
res_numpy = amplify_lut(lut, 0)
with disable_numpy(operations):
res_native = amplify_lut(lut, 0)
self.assertEqualLuts(res_numpy, identity)
self.assertEqualLuts(res_native, res_numpy)
res_numpy = amplify_lut(lut, 0.5)
with disable_numpy(operations):
res_native = amplify_lut(lut, 0.5)
self.assertAlmostEqualLuts(res_numpy, lut_05x)
self.assertAlmostEqualLuts(res_native, res_numpy)
res_numpy = amplify_lut(lut, 2)
with disable_numpy(operations):
res_native = amplify_lut(lut, 2)
self.assertAlmostEqualLuts(res_numpy, lut_2x)
self.assertAlmostEqualLuts(res_native, res_numpy)
def test_correct_args(self):
result = amplify_lut(identity_table((3, 4, 5)), -1)
self.assertEqual(tuple(result.size), (3, 4, 5))
self.assertEqual(result.channels, 3)
result = amplify_lut(self.lut5_4c, 5)
self.assertEqual(tuple(result.size), (5, 5, 5))
self.assertEqual(result.channels, 4)
def test_identity_sizes(self):
identity = identity_table((5, 6, 7))
data = [-1.1, -0.3, 0, 0.1, 0.5, 1, 1.1]
for b in data:
for g in data:
for r in data:
point = sample_lut_cubic(identity, (r, g, b))
for left, right in zip(point, (r, g, b)):
self.assertAlmostEqual(left, right)
def test_identity_17(self):
identity = identity_table(17)
data = [-1.1, -0.3, 0, 0.1, 0.5, 1, 1.1]
for b in data:
for g in data:
for r in data:
point = sample_lut_linear(identity, (r, g, b))
for left, right in zip(point, (r, g, b)):
self.assertAlmostEqual(left, right)
def test_correctness(self):
identity = identity_table(16)
image = Image.open(resource('files', 'hald.4.png'))
lut_numpy = load_hald_image(image)
self.assertEqualLuts(lut_numpy, identity)
with disable_numpy(loaders):
lut_pillow = load_hald_image(image)
self.assertEqualLuts(lut_pillow, identity)
def test_different_dimensions(self):
lut_ref = identity_table((4, 5, 6))
lut_numpy = rgb_color_enhance((4, 5, 6))
self.assertEqualLuts(lut_numpy, lut_ref)
with disable_numpy(generators):
lut_native = rgb_color_enhance((4, 5, 6))
self.assertAlmostEqualLuts(lut_native, lut_ref)
self.assertNotEqualLutTables(lut_native, lut_ref)
def test_fallback_to_linear(self):
lut3 = ImageFilter.Color3DLUT.generate((5, 5, 3), lambda r, g, b:
(r**1.5, g**1.5, b**1.5))
lut4 = ImageFilter.Color3DLUT.generate((5, 5, 4), lambda r, g, b:
(r**1.5, g**1.5, b**1.5))
with warnings.catch_warnings(record=True) as w:
cubic = transform_lut(identity_table((5, 5, 3)),
lut4,
interp=Image.CUBIC)
self.assertEqual(len(w), 0)
linear = transform_lut(identity_table((5, 5, 3)), lut4)
self.assertNotEqualLutTables(cubic, linear)
with warnings.catch_warnings(record=True) as w:
cubic = transform_lut(identity_table((5, 5, 4)),
lut3,
interp=Image.CUBIC)
self.assertEqual(len(w), 1)
self.assertIn('Cubic interpolation', "{}".format(w[0].message))
linear = transform_lut(identity_table((5, 5, 4)), lut3)
self.assertEqualLuts(cubic, linear)
with warnings.catch_warnings(record=True) as w:
cubic = transform_lut(identity_table((5, 5, 3)),
lut4,
target_size=(5, 5, 4),
interp=Image.CUBIC)
self.assertEqual(len(w), 1)
self.assertIn('Cubic interpolation', "{}".format(w[0].message))
linear = transform_lut(identity_table((5, 5, 3)),
lut4,
target_size=(5, 5, 4))
self.assertEqualLuts(cubic, linear)
def test_correct_args(self):
result = resize_lut(identity_table((3, 4, 5), target_mode='RGB'),
(6, 7, 8))
self.assertEqual(tuple(result.size), (6, 7, 8))
self.assertEqual(result.mode, 'RGB')
self.assertEqual(result.channels, 3)
result = resize_lut(self.lut5_4c, 3)
self.assertEqual(tuple(result.size), (3, 3, 3))
self.assertEqual(result.mode, None)
self.assertEqual(result.channels, 4)
with disable_numpy(operations):
result = resize_lut(self.lut5_4c, 3)
self.assertEqual(tuple(result.size), (3, 3, 3))
self.assertEqual(result.mode, None)
self.assertEqual(result.channels, 4)
def test_wrong_args(self):
with self.assertRaisesRegexp(ValueError, "interpolations"):
result = resize_lut(identity_table(4), 5, interp=Image.NEAREST)
class TestRgbColorEnhance(PillowTestCase):
identity = identity_table(5)
def test_wrong_args(self):
lut_4c = ImageFilter.Color3DLUT.generate(
3, channels=4, callback=lambda a, b, c: (a, b, c, 1))
with self.assertRaisesRegexp(ValueError, "3-channels table"):
rgb_color_enhance(lut_4c)
with self.assertRaisesRegexp(ValueError, "Size should be in"):
rgb_color_enhance(0)
with self.assertRaisesRegexp(ValueError, "Size should be in"):
rgb_color_enhance(66)
with self.assertRaisesRegexp(ValueError, "Brightness should be"):
rgb_color_enhance(3, brightness=-1.1)
with self.assertRaisesRegexp(ValueError, "Brightness should be"):
rgb_color_enhance(3, brightness=1.1)
with self.assertRaisesRegexp(ValueError, "Brightness should be"):
rgb_color_enhance(3, brightness=(0.5, 0.5, 1.1))
with self.assertRaisesRegexp(ValueError, "Exposure should be"):
rgb_color_enhance(3, exposure=-5.1)
with self.assertRaisesRegexp(ValueError, "Exposure should be"):
rgb_color_enhance(3, exposure=5.1)
with self.assertRaisesRegexp(ValueError, "Exposure should be"):
rgb_color_enhance(3, exposure=(0.5, 0.5, 5.1))
with self.assertRaisesRegexp(ValueError, "Contrast should be"):
rgb_color_enhance(3, contrast=-1.1)
with self.assertRaisesRegexp(ValueError, "Contrast should be"):
rgb_color_enhance(3, contrast=5.1)
with self.assertRaisesRegexp(ValueError, "Contrast should be"):
rgb_color_enhance(3, contrast=(0.5, 0.5, 5.1))
with self.assertRaisesRegexp(ValueError, "Warmth should be"):
rgb_color_enhance(3, warmth=-1.1)
with self.assertRaisesRegexp(ValueError, "Warmth should be"):
rgb_color_enhance(3, warmth=1.1)
with self.assertRaisesRegexp(ValueError, "Saturation should be"):
rgb_color_enhance(3, saturation=-1.1)
with self.assertRaisesRegexp(ValueError, "Saturation should be"):
rgb_color_enhance(3, saturation=5.1)
with self.assertRaisesRegexp(ValueError, "Saturation should be"):
rgb_color_enhance(3, saturation=(0.5, 0.5, 5.1))
with self.assertRaisesRegexp(ValueError, "Vibrance should be"):
rgb_color_enhance(3, vibrance=-1.1)
with self.assertRaisesRegexp(ValueError, "Vibrance should be"):
rgb_color_enhance(3, vibrance=5.1)
with self.assertRaisesRegexp(ValueError, "Vibrance should be"):
rgb_color_enhance(3, vibrance=(0.5, 0.5, 5.1))
with self.assertRaisesRegexp(ValueError, "Hue should be"):
rgb_color_enhance(3, hue=-0.1)
with self.assertRaisesRegexp(ValueError, "Hue should be"):
rgb_color_enhance(3, hue=1.1)
with self.assertRaisesRegexp(ValueError, "Gamma should be"):
rgb_color_enhance(3, gamma=-0.1)
with self.assertRaisesRegexp(ValueError, "Gamma should be"):
rgb_color_enhance(3, gamma=10.1)
with self.assertRaisesRegexp(ValueError, "Gamma should be"):
rgb_color_enhance(3, gamma=(0.5, 0.5, 10.1))
def test_correct_args(self):
lut = rgb_color_enhance(5)
self.assertTrue(isinstance(lut, ImageFilter.Color3DLUT))
self.assertEqualLuts(lut, self.identity)
lut = rgb_color_enhance(5, brightness=0.1)
self.assertNotEqualLutTables(lut, self.identity)
lut = rgb_color_enhance(5, brightness=(-1, 0, 0))
self.assertNotEqualLutTables(lut, self.identity)
lut = rgb_color_enhance(5, brightness=(0, 0.1, 0))
self.assertNotEqualLutTables(lut, self.identity)
lut = rgb_color_enhance(5, brightness=(0, 0, 1))
self.assertNotEqualLutTables(lut, self.identity)
lut = rgb_color_enhance(5, exposure=0.5)
self.assertNotEqualLutTables(lut, self.identity)
lut = rgb_color_enhance(5, exposure=(-5, 0, 0))
self.assertNotEqualLutTables(lut, self.identity)
lut = rgb_color_enhance(5, exposure=(0, 0.1, 0))
self.assertNotEqualLutTables(lut, self.identity)
lut = rgb_color_enhance(5, exposure=(0, 0, 5))
self.assertNotEqualLutTables(lut, self.identity)
lut = rgb_color_enhance(5, contrast=0.1)
self.assertNotEqualLutTables(lut, self.identity)
lut = rgb_color_enhance(5, contrast=(-1, 0, 0))
self.assertNotEqualLutTables(lut, self.identity)
lut = rgb_color_enhance(5, contrast=(0, 0.1, 0))
self.assertNotEqualLutTables(lut, self.identity)
lut = rgb_color_enhance(5, contrast=(0, 0, 5))
self.assertNotEqualLutTables(lut, self.identity)
lut = rgb_color_enhance(5, warmth=0.1)
self.assertNotEqualLutTables(lut, self.identity)
lut = rgb_color_enhance(5, warmth=-1)
self.assertNotEqualLutTables(lut, self.identity)
lut = rgb_color_enhance(5, warmth=1)
self.assertNotEqualLutTables(lut, self.identity)
lut = rgb_color_enhance(5, saturation=0.1)
self.assertNotEqualLutTables(lut, self.identity)
lut = rgb_color_enhance(5, saturation=(-1, 0, 0))
self.assertNotEqualLutTables(lut, self.identity)
lut = rgb_color_enhance(5, saturation=(0, 0.1, 0))
self.assertNotEqualLutTables(lut, self.identity)
lut = rgb_color_enhance(5, saturation=(0, 0, 5))
self.assertNotEqualLutTables(lut, self.identity)
lut = rgb_color_enhance(5, vibrance=0.1)
self.assertNotEqualLutTables(lut, self.identity)
lut = rgb_color_enhance(5, vibrance=(-1, 0, 0))
self.assertNotEqualLutTables(lut, self.identity)
lut = rgb_color_enhance(5, vibrance=(0, 0.1, 0))
self.assertNotEqualLutTables(lut, self.identity)
lut = rgb_color_enhance(5, vibrance=(0, 0, 5))
self.assertNotEqualLutTables(lut, self.identity)
lut = rgb_color_enhance(5, hue=0.1)
self.assertNotEqualLutTables(lut, self.identity)
lut = rgb_color_enhance(5, hue=1)
self.assertNotEqualLutTables(lut, self.identity)
lut = rgb_color_enhance(5, gamma=1.1)
self.assertNotEqualLutTables(lut, self.identity)
lut = rgb_color_enhance(5, gamma=(0, 1, 1))
self.assertNotEqualLutTables(lut, self.identity)
lut = rgb_color_enhance(5, gamma=(1, 1.1, 1))
self.assertNotEqualLutTables(lut, self.identity)
lut = rgb_color_enhance(5, gamma=(1, 1, 10))
self.assertNotEqualLutTables(lut, self.identity)
def test_different_dimensions(self):
lut_ref = identity_table((4, 5, 6))
lut_numpy = rgb_color_enhance((4, 5, 6))
self.assertEqualLuts(lut_numpy, lut_ref)
with disable_numpy(generators):
lut_native = rgb_color_enhance((4, 5, 6))
self.assertAlmostEqualLuts(lut_native, lut_ref)
self.assertNotEqualLutTables(lut_native, lut_ref)
def test_source_lut(self):
source = rgb_color_enhance(5, saturation=0.5)
lut_ref = rgb_color_enhance(5, saturation=0.5, exposure=0.3, warmth=1)
lut_numpy = rgb_color_enhance(source, exposure=0.3, warmth=1)
self.assertEqualLuts(lut_numpy, lut_ref)
with disable_numpy(generators):
lut_native = rgb_color_enhance(source, exposure=0.3, warmth=1)
self.assertAlmostEqualLuts(lut_native, lut_ref, 14)
self.assertNotEqualLutTables(lut_native, lut_ref)
def test_linear_space(self):
identity = rgb_color_enhance(13)
lut = rgb_color_enhance(13, linear=True)
self.assertTrue(isinstance(lut, ImageFilter.Color3DLUT))
self.assertAlmostEqualLuts(lut, identity)
self.assertNotEqualLutTables(lut, identity)
def test_all_args(self):
lut = rgb_color_enhance(
5, brightness=0.1, exposure=-0.2, contrast=0.1, warmth=0.3,
saturation=0.1, vibrance=0.1, hue=0.1, gamma=1.1, linear=True,
)
self.assertTrue(isinstance(lut, ImageFilter.Color3DLUT))
self.assertNotEqualLutTables(lut, self.identity)
def test_numpy_correctness(self):
lut_numpy = rgb_color_enhance(
13, brightness=0.1, exposure=-0.2, contrast=0.1, warmth=0.5,
saturation=0.1, vibrance=0.1, gamma=1.1, linear=True
)
with disable_numpy(generators):
lut_native = rgb_color_enhance(
13, brightness=0.1, exposure=-0.2, contrast=0.1, warmth=0.5,
saturation=0.1, vibrance=0.1, gamma=1.1, linear=True
)
self.assertAlmostEqualLuts(lut_numpy, lut_native, 10)
self.assertNotEqualLutTables(lut_numpy, lut_native)
def test_application(self):
im = Image.new('RGB', (10, 10))
lut_numpy = rgb_color_enhance(5, saturation=0.5)
self.assertEqual(lut_numpy.table.__class__.__name__, 'ndarray')
im.filter(lut_numpy)
with disable_numpy(generators):
lut_native = rgb_color_enhance(5, saturation=0.5)
self.assertEqual(lut_native.table.__class__.__name__, 'list')
im.filter(lut_native)
lut_numpy = rgb_color_enhance(lut_native, saturation=0.5)
self.assertEqual(lut_numpy.table.__class__.__name__, 'ndarray')
im.filter(lut_numpy)
with disable_numpy(generators):
lut_native = rgb_color_enhance(lut_numpy, saturation=0.5)
self.assertEqual(lut_native.table.__class__.__name__, 'list')
im.filter(lut_native)
class TestTransformLut(PillowTestCase):
identity7 = identity_table(7)
identity9 = identity_table(9)
lut7_in = ImageFilter.Color3DLUT.generate(
7, lambda r, g, b: (r**1.2, g**1.2, b**1.2))
lut7_out = ImageFilter.Color3DLUT.generate(
7, lambda r, g, b: (r**(1 / 1.2), g**(1 / 1.2), b**(1 / 1.2)))
lut9_in = ImageFilter.Color3DLUT.generate(
9, lambda r, g, b: (r**1.2, g**1.2, b**1.2))
lut5_4c = ImageFilter.Color3DLUT.generate(5,
channels=4,
callback=lambda r, g, b:
(r * r, g * g, b * b, 1.0))
def test_wrong_args(self):
with self.assertRaisesRegexp(ValueError, "only 3-channel cubes"):
result = transform_lut(self.lut5_4c, identity_table(3))
with self.assertRaisesRegexp(ValueError, "only 3-channel cubes"):
result = transform_lut(self.lut5_4c,
identity_table(3),
target_size=5)
with self.assertRaisesRegexp(ValueError, "interpolations"):
result = transform_lut(identity_table(4),
identity_table(4),
interp=Image.NEAREST)
def test_correct_args(self):
result = transform_lut(identity_table((3, 4, 5), target_mode='RGB'),
identity_table((6, 7, 8), target_mode='HSV'))
self.assertEqual(tuple(result.size), (3, 4, 5))
self.assertEqual(result.mode, 'HSV')
self.assertEqual(result.channels, 3)
result = transform_lut(identity_table(3), self.lut5_4c)
self.assertEqual(tuple(result.size), (3, 3, 3))
self.assertEqual(result.mode, None)
self.assertEqual(result.channels, 4)
with disable_numpy(operations):
result = transform_lut(identity_table(3), self.lut5_4c)
self.assertEqual(tuple(result.size), (3, 3, 3))
self.assertEqual(result.mode, None)
self.assertEqual(result.channels, 4)
result = transform_lut(identity_table(4, target_mode='RGB'),
identity_table(5),
target_size=(6, 7, 8))
self.assertEqual(tuple(result.size), (6, 7, 8))
self.assertEqual(result.mode, 'RGB')
self.assertEqual(result.channels, 3)
with disable_numpy(operations):
result = transform_lut(identity_table(4, target_mode='RGB'),
identity_table(5),
target_size=(6, 7, 8))
self.assertEqual(tuple(result.size), (6, 7, 8))
self.assertEqual(result.mode, 'RGB')
self.assertEqual(result.channels, 3)
def test_identity_linear(self):
res_numpy = transform_lut(self.lut7_in, self.identity9)
self.assertAlmostEqualLuts(res_numpy, self.lut7_in)
with disable_numpy(operations):
res_native = transform_lut(self.lut7_in, self.identity9)
self.assertAlmostEqualLuts(res_native, res_numpy)
res_numpy = transform_lut(self.identity9, self.lut7_in)
self.assertAlmostEqualLuts(res_numpy, self.lut9_in, 4)
with disable_numpy(operations):
res_native = transform_lut(self.identity9, self.lut7_in)
self.assertAlmostEqualLuts(res_native, res_numpy)
def test_identity_cubic(self):
result = transform_lut(self.lut7_in,
self.identity9,
interp=Image.CUBIC)
self.assertAlmostEqualLuts(result, self.lut7_in)
result = transform_lut(self.identity7,
self.lut9_in,
interp=Image.CUBIC)
self.assertAlmostEqualLuts(result, self.lut7_in, 7)
def test_correctness_linear(self):
res_numpy = transform_lut(self.lut7_in, self.lut7_out)
self.assertAlmostEqualLuts(res_numpy, self.identity7, 4)
with disable_numpy(operations):
res_native = transform_lut(self.lut7_in, self.lut7_out)
self.assertAlmostEqualLuts(res_native, res_numpy)
res_numpy = transform_lut(self.lut7_out, self.lut7_in)
self.assertAlmostEqualLuts(res_numpy, self.identity7, 6)
with disable_numpy(operations):
res_native = transform_lut(self.lut7_out, self.lut7_in)
self.assertAlmostEqualLuts(res_native, res_numpy)
def test_correctness_cubic(self):
result = transform_lut(self.lut7_in, self.lut7_out, interp=Image.CUBIC)
self.assertAlmostEqualLuts(result, self.identity7, 4)
result = transform_lut(self.lut7_out, self.lut7_in, interp=Image.CUBIC)
self.assertAlmostEqualLuts(result, self.identity7, 7)
def test_target_size_correctness_linear(self):
res_numpy = transform_lut(self.lut7_out, self.lut7_in, target_size=9)
self.assertAlmostEqualLuts(res_numpy, self.identity9, 4)
with disable_numpy(operations):
res_native = transform_lut(self.lut7_out,
self.lut7_in,
target_size=9)
self.assertAlmostEqualLuts(res_native, res_numpy)
def test_target_size_correctness_cubic(self):
result = transform_lut(self.lut7_out,
self.lut7_in,
target_size=9,
interp=Image.CUBIC)
self.assertAlmostEqualLuts(result, self.identity9, 4)
def test_fallback_to_linear(self):
lut3 = ImageFilter.Color3DLUT.generate((5, 5, 3), lambda r, g, b:
(r**1.5, g**1.5, b**1.5))
lut4 = ImageFilter.Color3DLUT.generate((5, 5, 4), lambda r, g, b:
(r**1.5, g**1.5, b**1.5))
with warnings.catch_warnings(record=True) as w:
cubic = transform_lut(identity_table((5, 5, 3)),
lut4,
interp=Image.CUBIC)
self.assertEqual(len(w), 0)
linear = transform_lut(identity_table((5, 5, 3)), lut4)
self.assertNotEqualLutTables(cubic, linear)
with warnings.catch_warnings(record=True) as w:
cubic = transform_lut(identity_table((5, 5, 4)),
lut3,
interp=Image.CUBIC)
self.assertEqual(len(w), 1)
self.assertIn('Cubic interpolation', "{}".format(w[0].message))
linear = transform_lut(identity_table((5, 5, 4)), lut3)
self.assertEqualLuts(cubic, linear)
with warnings.catch_warnings(record=True) as w:
cubic = transform_lut(identity_table((5, 5, 3)),
lut4,
target_size=(5, 5, 4),
interp=Image.CUBIC)
self.assertEqual(len(w), 1)
self.assertIn('Cubic interpolation', "{}".format(w[0].message))
linear = transform_lut(identity_table((5, 5, 3)),
lut4,
target_size=(5, 5, 4))
self.assertEqualLuts(cubic, linear)
def test_application(self):
im = Image.new('RGB', (10, 10))
lut_numpy = transform_lut(identity_table(5), identity_table(5))
self.assertEqual(lut_numpy.table.__class__.__name__, 'ndarray')
im.filter(lut_numpy)
with disable_numpy(operations):
lut_native = transform_lut(identity_table(5), identity_table(5))
self.assertEqual(lut_native.table.__class__.__name__, 'list')
im.filter(lut_native)
with disable_numpy(generators):
args = identity_table(5), identity_table(5)
self.assertEqual(args[0].table.__class__.__name__, 'list')
lut_numpy = transform_lut(*args)
self.assertEqual(lut_numpy.table.__class__.__name__, 'ndarray')
im.filter(lut_numpy)
args = identity_table(5), identity_table(5)
self.assertEqual(args[0].table.__class__.__name__, 'ndarray')
with disable_numpy(operations):
lut_native = transform_lut(*args)
self.assertEqual(lut_native.table.__class__.__name__, 'list')
im.filter(lut_native)
def test_identity_2(self):
identity = identity_table(2)
with self.assertRaisesRegexp(ValueError, "requires a table of size 4"):
sample_lut_cubic(identity, (0, 0, 0))
