Using Layer Effects in PSD files

Overview

In Aspose.PSD for Python, you can create various effects on layers to enhance the visual appearance of your images. This can be achieved using the BlendingOptions class, which provides methods to add different types of effects such as stroke, inner shadow, drop shadow, gradient overlay, color overlay, pattern overlay, and outer glow.

To demonstrate the creation of effects on layers, let’s consider the following code sample

In this code sample, we first load a PSD image and save the original image as a PNG. Then, we create different effects on different layers using the BlendingOptions class. Here’s a brief explanation of each effect:

Stroke: We add a gradient stroke to layer 1, specifying the stroke size, gradient color points, and transparency points.

Inner Shadow: We add an inner shadow to layer 2, specifying the angle and color of the shadow.

Drop Shadow: We add a drop shadow to layer 3, specifying the angle and color of the shadow.

Gradient Overlay: We add a gradient overlay to layer 4, specifying the gradient color points and transparency points.

Color Overlay: We add a color overlay to layer 5, specifying the color and opacity of the overlay.

Pattern Overlay: We add a pattern overlay to layer 6, specifying the pattern data, width, and height.

Outer Glow: We add an outer glow to layer 7, specifying the size and fill color of the glow.

Finally, we save the modified image as both a PNG and a PSD.

This is just a basic example of how you can create effects on layers using Aspose.PSD for Python. You can customize the effects further by adjusting the parameters and properties of each effect. The library provides various options and settings to create complex and visually appealing effects.

I hope this article helps you understand how to create effects on layers in Aspose.PSD for Python. Feel free to explore the library’s documentation for more details and examples.

Please check full example.

Example

from aspose.psd import Image, Color
from aspose.psd.fileformats.png import PngColorType
from aspose.psd.fileformats.psd import PsdImage
from aspose.psd.fileformats.psd.layers.fillsettings import GradientColorPoint, GradientTransparencyPoint, FillType, \
    GradientFillSettings, PatternFillSettings, ColorFillSettings
from aspose.psd.imageloadoptions import PsdLoadOptions
from aspose.psd.imageoptions import PngOptions
from aspose.pycore import cast


def LayerEffectsFullTest(self):
    source = self.GetFileInBaseFolderByIssue("ShowCases", "nines.psd")
    result_orig = self.GetFileInOutputFolder("nines_orig.png")
    result_psd = self.GetFileInOutputFolder("nines_mod.psd")
    result_mod = self.GetFileInOutputFolder("nines_mod.png")

    # Set the PNG options
    png_opt = PngOptions()
    png_opt.color_type = PngColorType.TRUECOLOR_WITH_ALPHA

    # Set the PSD load options
    psd_opt = PsdLoadOptions()
    psd_opt.load_effects_resource = True

    # Load the PSD image
    with Image.load(source, psd_opt) as img:
        # Cast to PsdImage
        image = cast(PsdImage, img)

        # Save the original image as PNG
        image.save(result_orig, png_opt)

        # Test data for gradient
        gradient_color_points = [
            GradientColorPoint(Color.red, 0, 50),
            GradientColorPoint(Color.green, 1024, 50),
            GradientColorPoint(Color.blue, 2048, 50)
        ]

        tp1 = GradientTransparencyPoint()
        tp1.location = 0
        tp1.median_point_location = 50
        tp1.opacity = 128

        tp2 = GradientTransparencyPoint()
        tp2.location = 2048
        tp2.median_point_location = 50
        tp2.opacity = 176
        gradient_transparency_points = [tp1, tp2]

        # Add stroke to layer 1
        stroke = image.layers[1].blending_options.add_stroke(FillType.GRADIENT)
        stroke.size = 3
        gradient_fill = cast(GradientFillSettings, stroke.fill_settings)
        gradient_fill.color_points = gradient_color_points
        gradient_fill.transparency_points = gradient_transparency_points

        # Add inner shadow to layer 2
        inner_shadow = image.layers[2].blending_options.add_inner_shadow()
        inner_shadow.angle = 60
        inner_shadow.color = Color.yellow

        # Add drop shadow to layer 3
        drop_shadow = image.layers[3].blending_options.add_drop_shadow()
        drop_shadow.angle = 30
        drop_shadow.color = Color.violet

        # Add gradient overlay to layer 4
        gradient_overlay = image.layers[4].blending_options.add_gradient_overlay()
        gradient_overlay.settings.color_points = gradient_color_points
        gradient_overlay.settings.transparency_points = gradient_transparency_points

        # Add color overlay to layer 5
        color_overlay = image.layers[5].blending_options.add_color_overlay()
        color_overlay.color = Color.azure
        color_overlay.opacity = 120

        # Add pattern overlay to layer 6
        pattern_overlay = image.layers[6].blending_options.add_pattern_overlay()

        patSettings = cast(PatternFillSettings, pattern_overlay.settings)

        patSettings.pattern_data = [
            Color.red.to_argb(), Color.transparent.to_argb(),
            Color.transparent.to_argb(), Color.red.to_argb()
        ]

        patSettings.pattern_width = 2
        patSettings.pattern_height = 2

        # Add outer glow to layer 7
        outer_glow = image.layers[7].blending_options.add_outer_glow()
        outer_glow.size = 10
        outer_glow.fill_color = ColorFillSettings()
        outer_glow.fill_color.color = Color.crimson

        # Save the modified image as PNG and PSD
        image.save(result_mod, png_opt)
        image.save(result_psd)