def compose_layer(layer, force=False, **kwargs): """Compose a single layer with pixels.""" from PIL import Image, ImageChops assert layer.bbox != (0, 0, 0, 0), 'Layer bbox is (0, 0, 0, 0)' image = layer.topil(**kwargs) if image is None or force: texture = create_fill(layer) if texture is not None: image = texture if image is None: return image # TODO: Group should have the following too. # Apply vector mask. if layer.has_vector_mask() and (force or not layer.has_pixels()): vector_mask = draw_vector_mask(layer) if image.mode.endswith('A'): offset = vector_mask.info['offset'] vector_mask = ImageChops.darker(image.getchannel('A'), vector_mask) vector_mask.info['offset'] = offset image.putalpha(vector_mask) # Apply stroke. if layer.has_stroke() and layer.stroke.enabled: image = draw_stroke(image, layer, vector_mask) # Apply mask. image = apply_mask(layer, image) # Apply layer fill effects. effect_base = image.copy() apply_opacity(image, layer.tagged_blocks.get_data(Tag.BLEND_FILL_OPACITY, 255)) image = apply_effect(layer, image, effect_base) # Clip layers. if layer.has_clip_layers(): clip_box = Group.extract_bbox(layer.clip_layers) offset = image.info.get('offset', layer.offset) bbox = offset + (offset[0] + image.width, offset[1] + image.height) if intersect(bbox, clip_box) != (0, 0, 0, 0): clip_image = compose(layer.clip_layers, bbox=bbox, context=image.copy()) if image.mode.endswith('A'): mask = image.getchannel('A') else: mask = Image.new('L', image.size, 255) if clip_image.mode.endswith('A'): mask = ImageChops.darker(clip_image.getchannel('A'), mask) clip_image.putalpha(mask) image = blend(image, clip_image, (0, 0)) # Apply opacity. apply_opacity(image, layer.opacity) return image
def _apply_layer_ops(layer, image, force=False, bbox=None): """Apply layer masks, effects, and clipping.""" from PIL import Image, ImageChops # Apply vector mask. if layer.has_vector_mask() and (force or not layer.has_pixels()): offset = image.info.get('offset', layer.offset) mask_box = offset + (offset[0] + image.width, offset[1] + image.height) vector_mask = draw_vector_mask(layer, mask_box) if image.mode.endswith('A'): offset = vector_mask.info['offset'] vector_mask = ImageChops.darker(image.getchannel('A'), vector_mask) vector_mask.info['offset'] = offset image.putalpha(vector_mask) # Apply stroke. if layer.has_stroke() and layer.stroke.enabled: image = draw_stroke(image, layer, vector_mask) # Apply mask. image = apply_mask(layer, image, bbox=bbox) # Apply layer fill effects. apply_opacity( image, layer.tagged_blocks.get_data(Tag.BLEND_FILL_OPACITY, 255) ) if layer.effects.enabled: image = apply_effect(layer, image, image.copy()) # Clip layers. if layer.has_clip_layers(): clip_box = Group.extract_bbox(layer.clip_layers) offset = image.info.get('offset', layer.offset) bbox = offset + (offset[0] + image.width, offset[1] + image.height) if intersect(bbox, clip_box) != (0, 0, 0, 0): clip_image = compose( layer.clip_layers, force=force, bbox=bbox, context=image.copy() ) if image.mode.endswith('A'): mask = image.getchannel('A') else: mask = Image.new('L', image.size, 255) if clip_image.mode.endswith('A'): mask = ImageChops.darker(clip_image.getchannel('A'), mask) clip_image.putalpha(mask) image = blend(image, clip_image, (0, 0)) # Apply opacity. apply_opacity(image, layer.opacity) return image
def draw_stroke(backdrop, layer, vector_mask=None): from PIL import Image, ImageChops import aggdraw from psd_tools.composer.blend import blend width = layer._psd.width height = layer._psd.height setting = layer.stroke._data # Draw mask. stroke_width = float(setting.get('strokeStyleLineWidth', 1.)) mask = Image.new('L', (width, height)) draw = aggdraw.Draw(mask) for subpath in layer.vector_mask.paths: path = ' '.join(map(str, _generate_symbol(subpath, width, height))) symbol = aggdraw.Symbol(path) pen = aggdraw.Pen(255, int(2 * stroke_width)) draw.symbol((0, 0), symbol, pen, None) draw.flush() del draw # For now, path operations are not implemented. if vector_mask: vector_mask_ = Image.new('L', (width, height)) vector_mask_.paste(vector_mask, vector_mask.info['offset']) mask = ImageChops.darker(mask, vector_mask_) offset = backdrop.info.get('offset', layer.offset) bbox = offset + (offset[0] + backdrop.width, offset[1] + backdrop.height) mask = mask.crop(bbox) # Paint the mask. painter = setting.get('strokeStyleContent') mode = setting.get('strokeStyleBlendMode').enum if not painter: logger.warning('Empty stroke style content.') return backdrop if painter.classID == b'solidColorLayer': image = draw_solid_color_fill(mask.size, painter) elif painter.classID == b'gradientLayer': image = draw_gradient_fill(mask.size, painter) elif painter.classID == b'patternLayer': image = draw_pattern_fill(mask.size, layer._psd, painter) else: logger.warning('Unknown painter: %s' % painter) return backdrop image.putalpha(mask) return blend(backdrop, image, (0, 0), mode)
def compose(layers, bbox=None, context=None, layer_filter=None, color=None, **kwargs): """ Compose layers to a single :py:class:`PIL.Image`. If the layers do not have visible pixels, the function returns `None`. Example:: image = compose([layer1, layer2]) In order to skip some layers, pass `layer_filter` function which should take `layer` as an argument and return `True` to keep the layer or return `False` to skip:: image = compose( layers, layer_filter=lambda x: x.is_visible() and x.kind == 'type' ) By default, visible layers are composed. .. note:: This function is experimental and does not guarantee Photoshop-quality rendering. Currently the following are ignored: - Adjustments layers - Layer effects - Blending mode (all blending modes become normal) Shape drawing is inaccurate if the PSD file is not saved with maximum compatibility. :param layers: a layer, or an iterable of layers. :param bbox: (left, top, bottom, right) tuple that specifies a region to compose. By default, all the visible area is composed. The origin is at the top-left corner of the PSD document. :param context: `PIL.Image` object for the backdrop rendering context. Must be used with the correct `bbox` size. :param layer_filter: a callable that takes a layer and returns `bool`. :param color: background color in `int` or `tuple`. :return: :py:class:`PIL.Image` or `None`. """ from PIL import Image if not hasattr(layers, '__iter__'): layers = [layers] def _default_filter(layer): return layer.is_visible() layer_filter = layer_filter or _default_filter valid_layers = [x for x in layers if layer_filter(x)] if len(valid_layers) == 0: return context if bbox is None: bbox = Group.extract_bbox(valid_layers) if bbox == (0, 0, 0, 0): return context if context is None: mode = get_pil_mode(valid_layers[0]._psd.color_mode, True) context = Image.new( mode, (bbox[2] - bbox[0], bbox[3] - bbox[1]), color=color if color is not None else 'white', ) context.putalpha(0) # Alpha must be forced to correctly blend. context.info['offset'] = (bbox[0], bbox[1]) for layer in valid_layers: if intersect(layer.bbox, bbox) == (0, 0, 0, 0): continue if layer.is_group(): if layer.blend_mode == BlendMode.PASS_THROUGH: context = layer.compose(context=context, bbox=bbox, **kwargs) continue else: image = layer.compose(**kwargs) else: image = compose_layer(layer, **kwargs) if image is None: continue logger.debug('Composing %s' % layer) offset = image.info.get('offset', layer.offset) offset = (offset[0] - bbox[0], offset[1] - bbox[1]) context = blend(context, image, offset, layer.blend_mode) return context
def apply_effect(layer, backdrop, base_image): """Apply effect to the image. ..note: Correct effect order is the following. All the effects are first applied to the original image then blended together. * dropshadow * outerglow * (original) * patternoverlay * gradientoverlay * coloroverlay * innershadow * innerglow * bevelemboss * satin * stroke """ from PIL import ImageChops for effect in layer.effects: if effect.__class__.__name__ == 'PatternOverlay': image = draw_pattern_fill(base_image.size, layer._psd, effect.value) if base_image.mode.endswith('A'): alpha = base_image.getchannel('A') if image.mode.endswith('A'): alpha = ImageChops.darker(alpha, image.getchannel('A')) image.putalpha(alpha) backdrop = blend(backdrop, image, (0, 0), effect.blend_mode) for effect in layer.effects: if effect.__class__.__name__ == 'GradientOverlay': image = draw_gradient_fill(base_image.size, effect.value) if base_image.mode.endswith('A'): alpha = base_image.getchannel('A') if image.mode.endswith('A'): alpha = ImageChops.darker(alpha, image.getchannel('A')) image.putalpha(alpha) backdrop = blend(backdrop, image, (0, 0), effect.blend_mode) for effect in layer.effects: if effect.__class__.__name__ == 'ColorOverlay': image = draw_solid_color_fill(base_image.size, effect.value) if base_image.mode.endswith('A'): alpha = base_image.getchannel('A') if image.mode.endswith('A'): alpha = ImageChops.darker(alpha, image.getchannel('A')) image.putalpha(alpha) backdrop = blend(backdrop, image, (0, 0), effect.blend_mode) for effect in layer.effects: if effect.__class__.__name__ == 'Stroke': from PIL import ImageOps if layer.has_vector_mask(): alpha = draw_vector_mask(layer) elif base_image.mode.endswith('A'): alpha = base_image.getchannel('A') else: alpha = base_image.convert('L') alpha.info['offset'] = base_image.info['offset'] flat = alpha.getextrema()[0] < 255 # Expand the image size setting = effect.value size = int(setting.get(Key.SizeKey)) offset = backdrop.info['offset'] backdrop = ImageOps.expand(backdrop, size) backdrop.info['offset'] = tuple(x - size for x in offset) offset = alpha.info['offset'] alpha = ImageOps.expand(alpha, size) alpha.info['offset'] = tuple(x - size for x in offset) if not layer.has_vector_mask() and setting.get( Key.Style).enum == Enum.InsetFrame and flat: image = create_stroke_effect(alpha, setting, layer._psd, True) backdrop.paste(image) else: image = create_stroke_effect(alpha, setting, layer._psd) backdrop = blend(backdrop, image, (0, 0), effect.blend_mode) return backdrop