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))