Resize Photoshop File

[EmilDohne]

Hey @kkgg0521 sorry for the late reply, I've decided to move this here.

In photoshop the canvas and layers are separated when it comes to size. A canvas can be any size and a single layer may be any other size. To achieve what you want to you need to actually resize the layers themselves. Unfortunately there isnt a nice way to swap out image channels at the moment using the photoshopapi but this is planned as it turned out to be quite cumbersome to do this with the current syntax but it is possible.

The main part of the code is the resize_and_swap_layers() function as the rest is simply in order to circumvent this limitation of not being able to swap image data

import psapi
import numpy as np
import cv2


def construct_matching_image_layer(layer, image_data, scale_factor: float) -> psapi.ImageLayer_8bit | psapi.ImageLayer_16bit | psapi.ImageLayer_32bit:
    # Separate out the mask channel and feed it separately than our image data
    mask = None
    for key, channel in image_data.items():
        if key == -2:
            mask = channel
    if mask is not None:
        del image_data[-2]
   
    if isinstance(layer, psapi.ImageLayer_8bit):
        return psapi.ImageLayer_8bit(
            image_data=image_data, 
            layer_name=layer.name, 
            layer_mask=mask, 
            width=int(layer.width * scale_factor), 
            height=int(layer.height * scale_factor), 
            blend_mode=layer.blend_mode, 
            pos_x=int(layer.center_x), 
            pos_y=int(layer.center_y),
            opacity=layer.opacity)
    if isinstance(layer, psapi.ImageLayer_16bit):
        return psapi.ImageLayer_16bit(
            image_data=image_data, 
            layer_name=layer.name, 
            layer_mask=mask, 
            width=int(layer.width * scale_factor), 
            height=int(layer.height * scale_factor), 
            blend_mode=layer.blend_mode, 
            pos_x=int(layer.center_x), 
            pos_y=int(layer.center_y),
            opacity=layer.opacity)
    if isinstance(layer, psapi.ImageLayer_32bit):
        return psapi.ImageLayer_32bit(
            image_data=image_data, 
            layer_name=layer.name, 
            layer_mask=mask, 
            width=int(layer.width * scale_factor), 
            height=int(layer.height * scale_factor), 
            blend_mode=layer.blend_mode, 
            pos_x=int(layer.center_x), 
            pos_y=int(layer.center_y),
            opacity=layer.opacity)


def construct_matching_group_layer(layer, mask: np.ndarray | None, scale_factor: float) -> psapi.GroupLayer_8bit | psapi.GroupLayer_16bit | psapi.GroupLayer_32bit:
    if mask is not None and len(mask.shape) == 2:
        width = mask.shape[1]
        height = mask.shape[0]
    else:
        mask = None
        width = 0
        height = 0
    
    if isinstance(layer, psapi.GroupLayer_8bit):
        lr = psapi.GroupLayer_8bit(
            layer_name=layer.name, 
            layer_mask=mask, 
            width=width,
            height=height,
            blend_mode=layer.blend_mode, 
            pos_x=0, 
            pos_y=0, 
            opacity=layer.opacity,
        )
        lr.layers = layer.layers
        return lr
    if isinstance(layer, psapi.GroupLayer_16bit):
        lr = psapi.GroupLayer_16bit(
            layer_name=layer.name, 
            layer_mask=mask, 
            width=width,
            height=height,
            blend_mode=layer.blend_mode, 
            pos_x=0, 
            pos_y=0, 
            opacity=layer.opacity,
            is_collapsed=layer.is_collapsed
        )
        lr.layers = layer.layers
        return lr
    if isinstance(layer, psapi.GroupLayer_32bit):
        lr = psapi.GroupLayer_32bit(
            layer_name=layer.name, 
            layer_mask=mask, 
            width=width,
            height=height,
            blend_mode=layer.blend_mode, 
            pos_x=0, 
            pos_y=0, 
            opacity=layer.opacity,
            is_collapsed=layer.is_collapsed
        )
        lr.layers = layer.layers
        return lr


def resize_and_swap_layers(root, parent, layer, size_factor: float = .5):
    '''
    Extract a layers image data and resize it, swapping out the layer after.
    Calls on itself recursively until all layers are resized
    '''
    data = None
    mask_data = None
    if (isinstance(layer, psapi.ImageLayer_8bit | psapi.ImageLayer_16bit | psapi.ImageLayer_32bit)):
        data = layer.get_image_data()

   # Resize the image data (if present), since get_image_data 
    if data is not None:
        for channel_id, channel in data.items():
            data[channel_id] = cv2.resize(channel, dsize=(int(layer.width * size_factor), int(layer.height * size_factor)))
    # Resize the mask data (if present)
    else:
        mask_data = layer.get_mask_data()
        print(mask_data.shape)
        if mask_data.size > 0:
            mask_data = cv2.resize(mask_data, dsize=(int(mask_data.shape[1] * size_factor), int(mask_data.shape[0] * size_factor)))

    if (isinstance(layer, psapi.ImageLayer_8bit | psapi.ImageLayer_16bit | psapi.ImageLayer_32bit)):
        new_layer = construct_matching_image_layer(layer, data, scale_factor)
        parent.remove_layer(layer)
        if parent == root:
            parent.add_layer(new_layer)
        else:
            parent.add_layer(root, new_layer)
    elif isinstance(layer, psapi.GroupLayer_8bit | psapi.GroupLayer_16bit | psapi.GroupLayer_32bit):
        new_layer = construct_matching_group_layer(layer, mask_data, scale_factor)
        parent.remove_layer(layer)
        if parent == root:
            parent.add_layer(new_layer)
        else:
            parent.add_layer(root, new_layer)
        # Recursively call on itself to replace the layers
        for layer in new_layer.layers:
            resize_and_swap_layers(root, new_layer, layer, size_factor)
      

if __name__ == "__main__":

   document = psapi.LayeredFile.read("./In.psd")
   scale_factor = .5

   for layer in document.layers:
      resize_and_swap_layers(document, document, layer, scale_factor)

   document.width = int(document.width * scale_factor)
   document.height = int(document.height * scale_factor)

   document.write("./Out.psd")

[kkgg0521]

thank you very much

[EmilDohne]

This is now much simpler than previously. The code for doing this now is:

# Example of replacing image data on a layer
import os
from typing import Union

import numpy as np
import cv2
import psapi


def is_image_layer(layer: Union[psapi.Layer_8bit, psapi.Layer_16bit, psapi.Layer_32bit]) -> bool:
    return isinstance(layer, (psapi.ImageLayer_8bit, psapi.ImageLayer_16bit, psapi.ImageLayer_32bit))


def scale_dimensions(layer: Union[psapi.Layer_8bit, psapi.Layer_16bit, psapi.Layer_32bit], scaling_factor: float) -> None:
    """
    Apply the scaling factor to width, height, center_x and center_y of the layer
    """
    layer.width    *= scaling_factor 
    layer.height   *= scaling_factor 
    layer.center_x *= scaling_factor 
    layer.center_y *= scaling_factor


def main() -> None:
    layered_file = psapi.LayeredFile.read(os.path.join(os.path.dirname(__file__), "BaseFile.psb"))

    # Scale up our canvas, this will not change any of the image data but only prepare it for later
    scaling_factor = 2
    layered_file.width *= scaling_factor
    layered_file.height *= scaling_factor

    # Loop over all the layers in the file and rescale them
    # Note that we have to do it in the following order:
    #
    # - Extract the image data we want to process
    # - Modify the layers' width and height properties
    # - Set the Image data back on the channel
    #
    # The reason for this is that we internally use the layers' width and height to deduce and 
    # verify the numpy array's shape. 

    for layer in layered_file.flat_layers:
        new_shape = (layer.width * scaling_factor, layer.height * scaling_factor)
        if is_image_layer(layer):
            image_data = layer.image_data
            scale_dimensions(layer, scaling_factor)
            for index, channel in image_data.items():
                rescaled_channel = cv2.resize(channel, new_shape, interpolation=cv2.INTER_LINEAR)
                layer[index] = rescaled_channel
        elif layer.has_mask():
            mask = layer.mask
            scale_dimensions(layer, scaling_factor)
            layer.mask = cv2.resize(mask, new_shape, interpolation=cv2.INTER_LINEAR)
            
    layered_file.write(os.path.join(os.path.dirname(__file__), "RescaledFile.psb"))



if __name__ == "__main__":
    main()