SD-PPP

https://github.com/zombieyang/sd-ppp
Admin
SD-PPP is an unofficial AI plugin for Adobe Photoshop that supports various AI models and APIs,...
Tokens:4,060
Snippets:13
Trust Score:9.4
License:BSD-3-Clause
Update:1 year ago
Show doc for...
Tokens:
Raw
### Get Document from Photoshop

Source: https://github.com/zombieyang/sd-ppp/wiki/All-ComfyUI-Nodes-Manual

Retrieves a Photoshop document by its name. Outputs the document data and its canvas boundary, which can be linked to other SD-PPP nodes for further operations.

```Python
class GetDocument:
    def __init__(self):
        self.document_name = None

    def execute(self):
        # Placeholder for actual Photoshop interaction logic
        print(f"Getting document: {self.document_name}")
        document = "..."
        canvas_bound = "..."
        return document, canvas_bound
```

--------------------------------

### Define Custom SDPPP Nodes in JavaScript

Source: https://github.com/zombieyang/sd-ppp/wiki/SDPPP-rules-to-make-nodes-become-APP-like-UI.

This snippet demonstrates how to define custom nodes and rules for SDPPP within the `javascript/sdppp_custom.js` file. It allows users to integrate non-built-in nodes and manage widget visibility by following the provided comments and examples.

```javascript
// Example structure for defining custom nodes and rules in javascript/sdppp_custom.js

// To make a node built-in supported, define its properties here.
// For example:
// {
//   "name": "MyCustomNode",
//   "category": "custom",
//   "description": "A custom node for specific tasks.",
//   "properties": {
//     "input_value": {"type": "number", "default": 0}
//   }
// }

// To control widget visibility, define rules here.
// For example:
// {
//   "node_name": "MyCustomNode",
//   "show_widgets": true
// }
```

--------------------------------

### Get Linked Layers in Photoshop

Source: https://github.com/zombieyang/sd-ppp/wiki/All-ComfyUI-Nodes-Manual

Fetches layers that are linked within a Photoshop document. Similar to 'Get Layers In Group', it supports filtering by 'first', 'text', 'image', or 'all' layers. Outputs layer data, boundary, and info.

```Python
class GetLinkedLayers:
    def __init__(self):
        self.layer_or_group = None
        self.select = 'all' # Options: 'first', 'text', 'image', 'all'

    def execute(self):
        # Placeholder for actual Photoshop interaction logic
        print(f"Getting linked layers from: {self.layer_or_group} with selection: {self.select}")
        layer_or_group = "..."
        layer_bound = "..."
        layer_info = "..."
        return layer_or_group, layer_bound, layer_info
```

--------------------------------

### Get Layer by ID in Photoshop

Source: https://github.com/zombieyang/sd-ppp/wiki/All-ComfyUI-Nodes-Manual

Fetches a specific Photoshop layer using its identifier within a given document. Outputs the layer data, its boundary, and associated layer information, enabling detailed layer manipulation.

```Python
class GetLayerByID:
    def __init__(self):
        self.document = None

    def execute(self):
        # Placeholder for actual Photoshop interaction logic
        print(f"Getting layer by ID from document: {self.document}")
        layer_or_group = "..."
        layer_bound = "..."
        layer_info = "..."
        return layer_or_group, layer_bound, layer_info
```

--------------------------------

### Get Text from Photoshop

Source: https://github.com/zombieyang/sd-ppp/wiki/All-ComfyUI-Nodes-Manual

Extracts text content from a specified text layer in a Photoshop document. Requires the document and layer to be identified. Outputs the text string, which can be used for various text-based AI tasks or data extraction.

```Python
class GetTextFromPhotoshop:
    def __init__(self):
        self.document = None
        self.layer_or_group = None

    def execute(self):
        # Placeholder for actual Photoshop interaction logic
        print(f"Getting text from layer: {self.layer_or_group} in document: {self.document}")
        text = "..."
        return text
```

--------------------------------

### Get Image from Photoshop

Source: https://github.com/zombieyang/sd-ppp/wiki/All-ComfyUI-Nodes-Manual

Retrieves an image from a specified layer or group within a Photoshop document. Supports defining the canvas boundary for the image extraction. Outputs RGB data and an alpha channel, useful for further processing like VAE encoding or alpha channel manipulation.

```Python
class GetImageFromPhotoshop:
    def __init__(self):
        self.layer_or_group = None
        self.document = None
        self.bound = None

    def execute(self):
        # Placeholder for actual Photoshop interaction logic
        print(f"Getting image from layer: {self.layer_or_group} in document: {self.document} with bounds: {self.bound}")
        rgb_out = "..."
        alpha_out = "..."
        return rgb_out, alpha_out
```

--------------------------------

### Get Selection from Photoshop

Source: https://github.com/zombieyang/sd-ppp/wiki/All-ComfyUI-Nodes-Manual

Captures the current selection within a Photoshop document as a mask. If no selection is active, it defaults to the entire canvas area. The output is a ComfyUI MASK, suitable for use in subsequent image processing or masking operations.

```Python
class GetSelection:
    def __init__(self):
        self.document = None
        self.bound = None

    def execute(self):
        # Placeholder for actual Photoshop interaction logic
        print(f"Getting selection from document: {self.document} with bounds: {self.bound}")
        mask = "..."
        return mask
```

--------------------------------

### Get Layers in Group in Photoshop

Source: https://github.com/zombieyang/sd-ppp/wiki/All-ComfyUI-Nodes-Manual

Retrieves layers contained within a specified group in a Photoshop document. Allows filtering to return only the first matched layer, text layers, image layers, or all layers. Outputs layer data, boundary, and info.

```Python
class GetLayersInGroup:
    def __init__(self):
        self.layer_or_group = None
        self.select = 'all' # Options: 'first', 'text', 'image', 'all'

    def execute(self):
        # Placeholder for actual Photoshop interaction logic
        print(f"Getting layers in group: {self.layer_or_group} with selection: {self.select}")
        layer_or_group = "..."
        layer_bound = "..."
        layer_info = "..."
        return layer_or_group, layer_bound, layer_info
```

--------------------------------

### SD-PPP Parse Layer Info

Source: https://github.com/zombieyang/sd-ppp/wiki/All-ComfyUI-Nodes-Manual

Parses layer information to extract boundary data (left, top, right, bottom) and opacity. Requires LAYER_INFO data as input.

```Python
# input:
# layer_info: the LAYER_INFO data that link by other SD-PPP node
# output:
# bound_left: primitive.
# bound_top: primitive.
# bound_right: tprimitive.
# bound_bottom: primitive.
# opacity: primitive.
```

--------------------------------

### SD-PPP Layer Output

Source: https://github.com/zombieyang/sd-ppp/wiki/All-ComfyUI-Nodes-Manual

Provides the LAYER data and BOUNDARY data that can be linked to other SD-PPP nodes. It also includes LAYER_INFO data for parsing layer information.

```Python
# layer_or_group: the LAYER data that you can link to other SD-PPP node
# layer_bound: the BOUNDARY data that you can link to other SD-PPP node
# layer_info: the LAYER_INFO data that you can link to ParseLayerInfo
```

--------------------------------

### Extract Text from Photoshop Layer in ComfyUI

Source: https://github.com/zombieyang/sd-ppp/wiki/[Deprecated]-Tutorial:-regional-prompting-in-Photoshop-by-SD‐PPP

This snippet demonstrates how to retrieve text content from a Photoshop text layer within a ComfyUI workflow. It's a crucial step for using text-based prompts from Photoshop in your Stable Diffusion generation.

```Python
class GetTextFromPsLayer:
    def __init__(self):
        self.types = {"input": "STRING", "output": "STRING"}

    def execute(self, ps_layer):
        return ps_layer
```

--------------------------------

### Send Image to Photoshop

Source: https://github.com/zombieyang/sd-ppp/wiki/All-ComfyUI-Nodes-Manual

Sends an image (or a batch of images) into a specified layer or group within a Photoshop document. Allows defining the image boundary for placement. This node is crucial for visualizing generated content within Photoshop.

```Python
class SendImageToPhotoshop:
    def __init__(self):
        self.image = None
        self.document = None
        self.layer_or_group = None
        self.bound = None

    def execute(self):
        # Placeholder for actual Photoshop interaction logic
        print(f"Sending image to layer: {self.layer_or_group} in document: {self.document} with bounds: {self.bound}")
        pass
```

--------------------------------

### Extract Mask from Photoshop Linked Layer in ComfyUI

Source: https://github.com/zombieyang/sd-ppp/wiki/[Deprecated]-Tutorial:-regional-prompting-in-Photoshop-by-SD‐PPP

This snippet shows how to extract a mask from a linked layer in Photoshop and use its alpha channel as a mask within ComfyUI. This allows for precise regional control in image generation.

```Python
class GetMaskFromPsLinkedLayer:
    def __init__(self):
        self.types = {"input": "MASK", "output": "MASK"}

    def execute(self, ps_linked_layer):
        return ps_linked_layer
```
Tokens:
Raw