def test_embedded():
# This file contains both an embedded and linked png
psd = PSDImage.load(os.path.join(DATA_PATH, 'placedLayer.psd'))
link = psd.smart_objects['5a96c404-ab9c-1177-97ef-96ca454b82b7']
assert link.filename == 'linked-layer.png'
with open(os.path.join(DATA_PATH, 'linked-layer.png'), 'rb') as f:
assert link.data == f.read()
def test_layer_visibility():
visible = dict(
(layer.name, layer.visible)
for layer in PSDImage(decode_psd('hidden-layer.psd')).layers)
assert visible['Shape 1']
assert not visible['Shape 2']
assert visible['Background']
def test_render_quality(filename):
psd = PSDImage.load(full_name(filename))
preview = psd.as_PIL()
rendered = psd.as_PIL(render=True)
assert isinstance(preview, Image)
assert isinstance(rendered, Image)
preview_hash = imagehash.average_hash(preview)
rendered_hash = imagehash.average_hash(rendered)
error_count = np.sum(np.bitwise_xor(preview_hash.hash, rendered_hash.hash))
error_rate = error_count / float(preview_hash.hash.size)
assert error_rate <= 0.1
def test_groups_without_opening():
psd = PSDImage(decode_psd('broken-groups.psd'))
group1, group2 = psd.layers
assert group1.name == 'bebek'
assert group2.name == 'anne'
assert len(group1.layers) == 1
assert len(group2.layers) == 1
assert group1.layers[0].name == 'el sol'
assert group2.layers[0].name == 'kas'
def test_mask_data_as_pil(filename):
psd = PSDImage.load(full_name(filename))
for layer in psd.descendants():
if layer.has_mask():
mask = layer.mask
if mask.has_box():
assert mask.as_PIL() is not None
else:
assert mask.width == 0 or mask.height == 0
assert mask.bbox.width == 0 or mask.bbox.height == 0
assert mask.background_color is not None
assert not mask.disabled
def test_groups_simple():
psd = PSDImage(decode_psd('group.psd'))
assert len(psd.layers) == 2
group = psd.layers[0]
assert group.kind == "group"
assert len(group.layers) == 1
assert group.name == 'Group 1'
assert group.closed is False
group_element = group.layers[0]
assert group_element.name == 'Shape 1'
def test_clipping():
psd = PSDImage(decode_psd('clipping-mask2.psd'))
assert psd.layers[0].name == 'Group 1'
layer = psd.layers[0].layers[0]
assert layer.name == 'Rounded Rectangle 4'
assert layer.has_clip_layers()
assert layer.clip_layers[0].name == 'Color Balance 1'
assert psd.layers[1].name == 'Rounded Rectangle 3'
assert psd.layers[1].clip_layers[0].name == 'Brightness/Contrast 1'
assert psd.layers[2].name == 'Polygon 1'
assert psd.layers[2].clip_layers[0].name == 'Ellipse 1'
assert psd.layers[2].clip_layers[1].name == 'Rounded Rectangle 2'
assert psd.layers[2].clip_layers[2].name == 'Rounded Rectangle 1'
assert psd.layers[2].clip_layers[3].name == 'Color Fill 1'
assert psd.layers[3].name == 'Background'
def test_group_visibility():
psd = PSDImage(decode_psd('hidden-groups.psd'))
group2, group1, bg = psd.layers
assert group2.name == 'Group 2'
assert group1.name == 'Group 1'
assert bg.name == 'Background'
assert bg.visible is True
assert group2.visible is True
assert group1.visible is False
assert group2.layers[0].visible is True
# The flag is 'visible=True', but this layer is hidden
# because its group is not visible.
assert group1.layers[0].visible is True
def test_mask_data_api():
psd = PSDImage.load(full_name('layer_mask_data.psd'))
layer = psd.layers[0]
assert layer.has_mask()
mask = layer.mask
assert mask.has_real()
assert mask.top == 146
assert mask.left == 36
assert mask.bottom == 186
assert mask.right == 170
assert mask.background_color == 255
assert mask.relative_to_layer == False
assert mask.disabled == False
assert mask.inverted == False
assert mask.user_mask_from_render == True
assert mask.parameters_applied == True
assert mask.parameters
assert mask.real_flags
def test_adjustment_and_shapes():
psd = PSDImage(decode_psd('adjustment-fillers.psd'))
for layer in psd.layers:
if layer.bbox.width:
assert isinstance(layer.as_PIL(), Image)
if layer.kind == "adjustment":
assert layer.adjustment_type
assert layer.data
if layer.kind == "shape":
assert isinstance(layer.get_anchors(), list)
if layer.has_origination():
assert layer.origination
if layer.has_vector_mask():
vector_mask = layer.vector_mask
assert vector_mask
if layer.has_path():
assert len(vector_mask.anchors) > 0
if layer.has_stroke():
assert layer.stroke
if layer.has_stroke_content():
assert layer.stroke_content
def test_userapi_placed_layers():
img = PSDImage(decode_psd("placedLayer.psd"))
bg = img.layers[3]
assert bg.kind == 'pixel'
assert not hasattr(bg, 'object_bbox')
assert not hasattr(bg, 'placed_bbox')
layer0 = img.layers[0]
assert layer0.kind == 'smartobject'
assert layer0.object_bbox == BBox(0, 0, 64, 64)
assert layer0.placed_bbox == BBox(x1=96.0, y1=96.0, x2=160.0, y2=160.0)
layer1 = img.layers[1]
assert layer1.kind == 'smartobject'
assert layer1.object_bbox == BBox(0, 0, 101, 55)
assert layer1.object_bbox.width == 101
assert layer1.placed_bbox == BBox(x1=27.0, y1=73.0, x2=229.0, y2=183.0)
layer2 = img.layers[2]
assert layer2.kind == 'smartobject'
assert layer2.object_bbox == BBox(0, 0, 64, 64)
assert layer2.placed_bbox == BBox(x1=96.0, y1=96.0, x2=160.0, y2=160.0)
def __init__(self):
self.special_file = open("teste.psd", 'rb')
self.resource_list = []
list_hex = self.special_file.read()
t = self.special_file.readline(100)
#t_u = binascii.hexlify(t)
#t = int(t_u, 16)
''''c = 0
for a in list_hex:
print a.encode("hex")
if c == 50:
break
c += 1
pass'''
self.file_analyse = PSDImage.load("teste.psd")
self.resource_ids_maker()
self.extract_header(list_hex)
lastIndex = self.color_mode(list_hex)
self.image_resource(list_hex, lastIndex)
pass
def test_composite_grayscale(filename, point, color):
psd = PSDImage.load(full_name(filename))
assert color == color_PIL(psd, point)
def test_layer_colors(filename, layer_num, point, color, get_color):
psd = PSDImage.load(full_name(filename))
layer = psd.layers[layer_num]
assert color == get_color(layer, point)
def test_generator():
psd = PSDImage.load(full_name('hidden-groups.psd'))
assert len([True for layer in psd.layers]) == 3
assert len([True for layer in psd.descendants()]) == 5
def test_composite(filename, point, color, get_color):
if (get_color == color_pymaging
and filename == 'background-red-opacity-80.psd'):
pytest.xfail("Pymaging white-bg removal not implemented")
psd = PSDImage.load(full_name(filename))
assert color == get_color(psd, point)
def test_group_with_empty_layer():
psd = PSDImage(decode_psd('empty-layer.psd'))
group1, bg = psd.layers
assert group1.name == 'group'
assert bg.name == 'Background'
def test_composite(filename, point, color, get_color):
psd = PSDImage.load(full_name(filename))
assert color == get_color(psd, point)
def test_groups_32bit():
psd = PSDImage(decode_psd('32bit5x5.psd'))
assert len(psd.layers) == 3
assert psd.layers[0].name == 'Background copy 2'
def test_no_groups():
psd = PSDImage(decode_psd('2layers.psd'))
assert len(psd.layers) == 2
assert not any(layer.kind == "group" for layer in psd.layers)
def psd():
return PSDImage(decode_psd('fill_adjustments.psd'))
def test_render_clip_layers(filename):
psd = PSDImage.load(full_name(filename))
image1 = psd.as_PIL()
image2 = psd.as_PIL(render=True)
assert isinstance(image1, Image)
assert isinstance(image2, Image)
def test_userapi_no_placed_layers():
img = PSDImage(decode_psd("1layer.psd"))
layer = img.layers[0]
assert not hasattr(layer, 'object_bbox')
assert not hasattr(layer, 'placed_bbox')
def test_adjustment_and_shapes():
psd = PSDImage(decode_psd('adjustment-mask.psd'))
for layer in psd.descendants():
layer.as_PIL()
if layer.has_mask():
layer.mask.as_PIL()
def test_layer_merging_pixels(filename, point, color):
psd = PSDImage.load(full_name(filename))
merged_image = psd.as_PIL_merged()
assert color[:3] == merged_image.getpixel(point)[:3]
assert merged_image.getpixel(point)[3] == 255 # alpha channel
def test_layer_colors_grayscale(filename, layer_num, point, color):
psd = PSDImage.load(full_name(filename))
layer = psd.layers[layer_num]
assert color == color_PIL(layer, point)
def test_mask_index():
psd = PSDImage.load(full_name('mask-index.psd'))
layer = psd.layers[0]
assert layer.has_mask()
assert layer._index == 0
def test_layer_merging_size(filename, point, color):
psd = PSDImage.load(full_name(filename))
merged_image = psd.as_PIL_merged()
assert merged_image.size == psd.as_PIL().size
def test_print_tree(filename):
psd = PSDImage(decode_psd(filename))
psd.print_tree()
def test_layer_merging_pixels_transparency(filename, point, color):
psd = PSDImage.load(full_name(filename))
merged_image = psd.as_PIL_merged()
assert color == merged_image.getpixel(point)
def test_generator_with_clip_layers():
psd = PSDImage.load(full_name('clipping-mask.psd'))
assert not psd.layers[0].has_clip_layers()
assert len([True for layer in psd.layers]) == 2
assert len([True for layer in psd.descendants()]) == 7
assert len([True for layer in psd.descendants(include_clip=False)]) == 6
