init

.gitignore

@@ -0,0 +1,37 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+__pycache__/*
+*.py[cod]
+*$py.class
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Jupyter Notebook
+*.ipynb_checkpoints
+*.ipynb:Zone.Identifier
+
+.venv

.python-version

@@ -0,0 +1 @@
+3.10

.vscode/.ruff.toml

@@ -0,0 +1,32 @@
+exclude = [
+    "**/*.ipynb"
+]
+
+[lint]
+select = [
+    "ANN", # 型アノテーション
+    "D",   # docstring
+    # "B", # バグを誘発するコード
+    "I",   # isort
+    "RUF016",
+    "RUF005",
+]
+extend-ignore = [
+    "D100",  # docstringを書いていない外部パッケージがある為無効化
+    "D104",  # パッケージのドキュメント
+    "D107",  # __init__ 関数のDoc string (クラスの説明は クラス自体のdocstringに記述する為省略)
+    "D400",  # 句読点で終わる、日本語で書いているので無効化する
+    "D203",  # クラスのdocstringの前に空白を入れる、D211と競合する為無効化
+    "D213",  # 複数行のdocstringは2行目から書く、D212と競合する為無効化
+    "D413",  # docstringの最終セクションの後の空行
+    "D415",  # 句読点で終わる、日本語で書いているので無効化する
+
+    "F403",
+
+    "ANN202",  # プライベート関数の戻り値アノテーション
+    "ANN204",  # __init__ の戻り値アノテーション (常に None の為省略)
+
+    # ruff 最新バージョンでは削除済み
+    "ANN101",  # メソッドの selfは暗黙的に分かる為、省略
+    "ANN102",  # クラスメソッドの clsは暗黙的に分かる為、省略
+]

.vscode/settings.json

@@ -0,0 +1,20 @@
+{
+  "editor.defaultFormatter": "esbenp.prettier-vscode",
+  "editor.formatOnSave": true,
+  "editor.codeActionsOnSave": {
+    "source.fixAll.eslint": "explicit",
+    "source.organizeImports": "explicit"
+  },
+  "typescript.preferences.importModuleSpecifier": "non-relative",
+  "[python]": {
+    "editor.defaultFormatter": "charliermarsh.ruff",
+    "editor.codeActionsOnSave": {
+      "source.fixAll": "explicit",
+      "source.organizeImports": "explicit"
+    },
+    "editor.tabSize": 4
+  },
+  "ruff.lint.args": ["--config", "${workspaceFolder}/.vscode/.ruff.toml"],
+  "ruff.organizeImports": false,
+  "files.insertFinalNewline": true
+}

LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 sk-uma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

LICENCE-layerdivider

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 mattya_monaca
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,12 +1,102 @@
----
-title: Faster Layerdivider
-emoji: 📉
-colorFrom: blue
-colorTo: pink
-sdk: gradio
-sdk_version: 5.25.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Faster layerdivider
+
+This is an optimized version of a part of the processing from the single-layer decomposition tool [layerdivider](https://github.com/mattyamonaca/layerdivider) by [mattya_monaca](https://github.com/mattyamonaca).
+
+A tool to divide a single illustration into a layered structure.
+![スクリーンショット 2023-03-07 034638](https://user-images.githubusercontent.com/48423148/223202706-5c6e9108-0cf4-40dc-b840-9c3df3d540da.png)
+
+![スクリーンショット_20230307_035053](https://user-images.githubusercontent.com/48423148/223345165-e4e2e7f6-059f-445a-ac3d-2c9c3ecd094a.png)
+
+https://user-images.githubusercontent.com/48423148/223344286-bf2dff31-3fc5-4970-8d68-86274f1f36eb.mp4
+
+# Install
+
+## Local Install
+
+### Windows Installation
+
+#### Required Dependencies
+
+Python 3.10.8 and Git
+
+#### install Step
+
+##### use uv (recommended)
+
+1. clone repository
+
+```
+git clone https://github.com/mattyamonaca/layerdivider
+```
+
+2. run `install.ps1` first time use, waiting for installation to complete.
+3. run `run_gui.ps1` to open local gui.
+4. open website localhost:port to use(The default is localhost:7860).
+
+#### Optional: For Python Launcher Users
+
+If you use Python launcher (py command) for executing Python, you should use install_with_launcher.ps1 instead of install.ps1.
+The reason is install_with_launcher.ps1 uses py command for executing venv module, while install.ps1 uses python command.
+
+# 処理内容
+
+1. 入力された画像をピクセル単位で RGB 情報に従いクラスタリング
+2. 色の類似度（CIEDE2000 基準）が近いクラスタを統合
+3. 入力された画像をブラー処理で平滑化
+4. クラスタごとにブラー処理後の色の平均値を出し、算出した平均値ですべてのピクセルを塗りなおし
+5. 2-4 を指定された回数繰り返し実行
+6. 最終的なクラスタリング結果に基づき、ベースとなるレイヤーを作成
+7. ベースレイヤーの各色を、入力された画像のクラスタ毎の平均色で塗りなおし
+8. ベースレイヤーとオリジナルの色差に基づいて効果レイヤーを算出
+
+# Processing content
+
+1. Cluster the input image based on RGB information at the pixel level.
+2. Merge clusters with similar color similarity (based on CIEDE2000 criteria).
+3. Smooth the input image using a blur process.
+4. For each cluster, calculate the average color value after blurring and repaint all pixels with this calculated value.
+5. Repeat steps 2-4 for a specified number of times.
+6. Create a base layer based on the final clustering result.
+7. Repaint each color in the base layer with the average color of each cluster in the input image.
+8. Calculate an effect layer based on differences between the base layer and original colors.
+
+# パラメータ説明
+
+- loops: 処理 2-4 を繰り返す回数
+- init_cluster: 処理 1 で生成するクラスタの数（大きいほど細かくレイヤー分けされる）
+- ciede_threshold: 処理 2 でどの程度色が類似していたらクラスタを結合するか決める閾値
+- blur_size: 処理 3 でかけるブラー処理の大きさ（大きいほど強くぼかす）
+- output_layer_mode
+  - normal: 通常レイヤーのみで出力される PSD を構成
+  - composite: 通常レイヤー、スクリーンレイヤー、乗算レイヤー、減算レイヤー、加算レイヤーを組み合わせて出力される PSD を構成
+
+# Parameter Description
+
+- loops: Number of times to repeat processing 2-4.
+- init_cluster: Number of clusters generated in process 1 (the larger the number, the more finely layered it is).
+- ciede_threshold: Threshold for determining when to combine clusters in process 2 based on how similar their colors are.
+- blur_size: Size of the blur applied in process 3 (the larger the size, the stronger the blurring effect).
+- output_layer_mode:
+  - normal: Constructs a PSD that only includes normal layers.
+  - composite: Constructs a PSD by combining normal layers with screen, multiply, subtract and add layers.
+
+# ライセンス
+
+`pytoshop/*` 以外と `pytoshop/packbits.py` については MIT ライセンス `pytoshop/*` と ``pytoshop/packbits.py` については BSD ライセンス
+詳細はライセンスファイルをご確認ください。
+
+# 謝辞
+
+以下のコードを参考にしました。
+
+## https://github.com/mattyamonaca/layerdivider
+
+本リポジトリの元となるコード、理論はこのリポジトリを継承しています。
+
+## https://github.com/mdboom/pytoshop
+
+psd ファイルへの書き込み
+
+## https://github.com/psd-tools/packbits
+
+`packbits.py` の元となるコード

app.py

@@ -0,0 +1,165 @@
+import os
+import sys
+
+import cv2
+import gradio as gr
+
+from ldivider.ld_convertor import cv2pil, pil2cv
+from ldivider.ld_processor_fast import get_base, get_composite_layer, get_normal_layer
+from ldivider.ld_utils import save_psd
+from pytoshop.enums import BlendMode
+
+path = os.getcwd()
+output_dir = f"{path}/output"
+input_dir = f"{path}/input"
+model_dir = f"{path}/segment_model"
+
+
+class webui:
+    def __init__(self):
+        self.demo = gr.Blocks()
+
+    def color_base_divide(
+        self, input_image, loops, init_cluster, ciede_threshold, blur_size, layer_mode
+    ):
+        image = pil2cv(input_image)
+        self.input_image = cv2.cvtColor(image, cv2.COLOR_BGR2RGBA)
+
+        base_image, label = get_base(
+            self.input_image, loops, init_cluster, ciede_threshold, blur_size
+        )
+
+        image = cv2pil(image)
+        if layer_mode == "composite":
+            (
+                base_layer_list,
+                shadow_layer_list,
+                bright_layer_list,
+                addition_layer_list,
+                subtract_layer_list,
+            ) = get_composite_layer(self.input_image, base_image, label)
+            filename = save_psd(
+                self.input_image,
+                [
+                    base_layer_list,
+                    bright_layer_list,
+                    shadow_layer_list,
+                    subtract_layer_list,
+                    addition_layer_list,
+                ],
+                ["base", "screen", "multiply", "subtract", "addition"],
+                [
+                    BlendMode.normal,
+                    BlendMode.screen,
+                    BlendMode.multiply,
+                    BlendMode.subtract,
+                    BlendMode.linear_dodge,
+                ],
+                output_dir,
+                layer_mode,
+            )
+            base_layer_list = [cv2pil(layer) for layer in base_layer_list]
+            return (
+                [image, base_image],
+                base_layer_list,
+                bright_layer_list,
+                shadow_layer_list,
+                filename,
+            )
+        elif layer_mode == "normal":
+            base_layer_list, bright_layer_list, shadow_layer_list = get_normal_layer(
+                self.input_image, base_image, label
+            )
+            filename = save_psd(
+                self.input_image,
+                [base_layer_list, bright_layer_list, shadow_layer_list],
+                ["base", "bright", "shadow"],
+                [BlendMode.normal, BlendMode.normal, BlendMode.normal],
+                output_dir,
+                layer_mode,
+            )
+            return (
+                [image, base_image],
+                base_layer_list,
+                bright_layer_list,
+                shadow_layer_list,
+                filename,
+            )
+        else:
+            return None
+
+    def launch(self, share):
+        with self.demo:
+            with gr.Row():
+                with gr.Column():
+                    input_image = gr.Image(type="pil")
+                    with gr.Accordion("ColorBase Settings", open=True):
+                        loops = gr.Slider(
+                            1, 20, value=1, step=1, label="loops", show_label=True
+                        )
+                        init_cluster = gr.Slider(
+                            1,
+                            50,
+                            value=10,
+                            step=1,
+                            label="init_cluster",
+                            show_label=True,
+                        )
+                        ciede_threshold = gr.Slider(
+                            1,
+                            50,
+                            value=5,
+                            step=1,
+                            label="ciede_threshold",
+                            show_label=True,
+                        )
+                        blur_size = gr.Slider(
+                            1, 20, value=5, label="blur_size", show_label=True
+                        )
+                        layer_mode = gr.Dropdown(
+                            ["normal", "composite"],
+                            value="normal",
+                            label="output_layer_mode",
+                            show_label=True,
+                        )
+
+                    submit = gr.Button(value="Create PSD")
+                with gr.Row():
+                    with gr.Column():
+                        with gr.Tab("output"):
+                            output_0 = gr.Gallery()
+                        with gr.Tab("base"):
+                            output_1 = gr.Gallery()
+                        with gr.Tab("bright"):
+                            output_2 = gr.Gallery()
+                        with gr.Tab("shadow"):
+                            output_3 = gr.Gallery()
+
+                        output_file = gr.File()
+
+            submit.click(
+                self.color_base_divide,
+                inputs=[
+                    input_image,
+                    loops,
+                    init_cluster,
+                    ciede_threshold,
+                    blur_size,
+                    layer_mode,
+                ],
+                outputs=[output_0, output_1, output_2, output_3, output_file],
+            )
+
+        self.demo.queue()
+        self.demo.launch(share=share)
+
+
+if __name__ == "__main__":
+    ui = webui()
+    if len(sys.argv) > 1:
+        if sys.argv[1] == "share":
+            ui.launch(share=True)
+        else:
+            ui.launch(share=False)
+    else:
+        ui.launch(share=False)

ldivider/ld_convertor.py

@@ -0,0 +1,27 @@
+import numpy as np
+from PIL import Image
+
+
+def pil2cv(image: Image.Image) -> np.ndarray:
+    """PIL Image to OpenCV image"""
+    new_image = np.array(image, dtype=np.uint8)
+    if new_image.ndim == 2:
+        pass
+    elif new_image.shape[2] == 3:
+        new_image = new_image[:, :, ::-1]
+    elif new_image.shape[2] == 4:
+        new_image = new_image[:, :, [2, 1, 0, 3]]
+    return new_image
+
+
+def cv2pil(image: np.ndarray) -> Image.Image:
+    """OpenCV image to PIL Image"""
+    new_image = image.copy()
+    if new_image.ndim == 2:
+        pass
+    elif new_image.shape[2] == 3:
+        new_image = new_image[:, :, ::-1]
+    elif new_image.shape[2] == 4:
+        new_image = new_image[:, :, [2, 1, 0, 3]]
+    new_image = Image.fromarray(new_image)
+    return new_image

ldivider/ld_processor_fast.py

@@ -0,0 +1,269 @@
+import random
+from typing import List, Tuple
+
+import cv2
+import numpy as np
+from skimage import color
+from sklearn.cluster import MiniBatchKMeans
+from sklearn.utils import shuffle
+
+
+def _fix_seed(seed: int) -> None:
+    random.seed(seed)
+    np.random.seed(seed)
+
+
+SEED = 42
+_fix_seed(SEED)
+
+
+def _get_new_group(rgb_means: np.ndarray, threshold: int):
+    merge_target = []
+    lab_means = color.rgb2lab(rgb_means, channel_axis=1)
+    for i in range(len(rgb_means)):
+        for j in range(i + 1, len(rgb_means)):
+            distance = color.deltaE_ciede2000(lab_means[i], lab_means[j])
+            if distance < threshold:
+                merge_target.append((i, j))
+    merge_dict = {k: v for k, v in enumerate(range(len(lab_means)))}
+    for a, b in merge_target:
+        a = merge_dict[a]
+        merge_dict[b] = a
+    new_group_keys = {k: v for v, k in enumerate(set(merge_dict.values()))}
+    groups = {k: [] for k in new_group_keys.values()}
+    for k in merge_dict.keys():
+        merge_dict[k] = new_group_keys[merge_dict[k]]
+        groups[merge_dict[k]].append(k)
+    return merge_dict, groups
+
+
+def _get_rgb_means(
+    img: np.ndarray,
+    labels: np.ndarray,
+    label_counts: int,
+) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    """画像の平均色を取得する"""
+    cls = np.arange(label_counts)
+
+    masks = np.bitwise_and(img[:, :, 3] > 127, cls.reshape(-1, 1, 1) == labels)
+
+    cls_counts = masks.sum(axis=(1, 2))  # 各クラスのピクセル数
+    cls_sum = (img[:, :, :3] * masks[:, :, :, None]).sum(
+        axis=(1, 2)
+    )  # 各クラスのRGBの合計値
+    rgb_means = cls_sum / (cls_counts[:, None] + 1e-6)  # 各クラスのRGBの平均値
+
+    return rgb_means, cls_counts, masks
+
+
+def get_base(
+    img: np.ndarray,
+    loop: int,
+    cls_num: int,
+    threshold: int,
+    size: int,
+    kmeans_samples: int = -1,
+) -> Tuple[np.ndarray, np.ndarray]:
+    """画像をクラスタリングして平均色を取得し、色の近いクラスタを統合する関数
+
+    Parameters
+    ----------
+    img : np.ndarray
+        入力画像
+    loop : int
+        ループ回数
+    cls_num : int
+        クラスタ数
+    threshold : int
+        統合する閾値
+    size : int
+        ブラーのサイズ
+    kmeans_samples : int, optional
+        kmenas のサンプル数, by default -1
+    """
+    rgb_flatten = cluster_samples = img[..., :3].reshape((-1, 3))
+    im_h, im_w = img.shape[:2]
+
+    alpha_mask = np.where(img[..., 3] > 127)
+    resampling = False
+    if rgb_flatten.shape[0] > len(alpha_mask[0]):
+        # 透過部分がある場合は透過部分のみをサンプリング
+        cluster_samples = img[..., :3][alpha_mask].reshape((-1, 3))
+        resampling = True
+
+    if len(rgb_flatten) > kmeans_samples and kmeans_samples > 0:
+        # kmeans のサンプル数が指定されている場合は一部のみを使用する
+        cluster_samples = shuffle(
+            cluster_samples, random_state=0, n_samples=kmeans_samples
+        )
+        resampling = True
+
+    kmeans = MiniBatchKMeans(n_clusters=cls_num).fit(cluster_samples)
+
+    if resampling:
+        labels = kmeans.predict(rgb_flatten)
+    else:
+        labels = kmeans.labels_
+
+    label_counts = kmeans.n_clusters
+    labels = labels.reshape(im_h, im_w)
+
+    assert loop > 0
+    img_ori = img.copy()
+    for i in range(loop):
+        img = cv2.blur(img, (size, size))
+        rgb_means, cls_counts, _ = _get_rgb_means(img, labels, label_counts)
+        merge_dict, groups = _get_new_group(rgb_means, threshold)
+        label_counts = len(groups)
+        group_means = {}
+        for group_id, label_ids in groups.items():
+            means = rgb_means[label_ids]
+            cnt = cls_counts[label_ids]
+            group_means[group_id] = (means * cnt[:, None]).sum(axis=0) / cnt.sum()
+        for k, v in merge_dict.items():
+            labels[labels == k] = v
+            if i != loop - 1:
+                img[labels == v, :3] = group_means[v]
+
+    img = img_ori
+    rgb_means, cls_counts, masks = _get_rgb_means(img, labels, label_counts)
+    for mask, rgb in zip(masks, rgb_means):
+        img[mask, :3] = rgb
+
+    img = img.clip(0, 255).astype(np.uint8)
+    labels = labels.squeeze().astype(np.uint32)
+    return img, labels
+
+
+def _split_img_batch(
+    images: List[np.ndarray], labels: np.ndarray
+) -> List[List[np.ndarray]]:
+    unique_labels = np.unique(labels)  # ラベルの一意なクラスを取得
+
+    splited_images = [[] for _ in range(len(images))]
+
+    for cls_no in unique_labels:
+        mask = labels == cls_no  # マスクを拡張してimageの次元に合わせる
+        for i, image in enumerate(images):
+            masked_img = image * mask[:, :, None]
+            splited_images[i].append(masked_img)
+
+    return splited_images
+
+
+def get_normal_layer(
+    input_image: np.ndarray, base_image: np.ndarray, label: np.ndarray
+) -> Tuple[List[np.ndarray], List[np.ndarray], List[np.ndarray]]:
+    """通常のレイヤーを取得する関数"""
+    base_image = base_image.astype(np.int32)
+    input_image = input_image.astype(np.int32)
+
+    base_image_hsv = cv2.cvtColor(
+        base_image[:, :, :3].astype(np.uint8), cv2.COLOR_RGB2HSV
+    )
+    input_image_hsv = cv2.cvtColor(
+        input_image[:, :, :3].astype(np.uint8), cv2.COLOR_RGB2HSV
+    )
+
+    bright_mask = base_image_hsv[:, :, 2] < input_image_hsv[:, :, 2]
+    bright_image = input_image.copy()
+    bright_image[:, :, 3] = bright_image[:, :, 3] * bright_mask
+
+    shadow_mask = base_image_hsv[:, :, 2] >= input_image_hsv[:, :, 2]
+    shadow_image = input_image.copy()
+    shadow_image[:, :, 3] = shadow_image[:, :, 3] * shadow_mask
+
+    [
+        base_layer_list,
+        bright_layer_list,
+        shadow_layer_list,
+    ] = _split_img_batch(
+        np.array(
+            [
+                base_image,
+                bright_image,
+                shadow_image,
+            ]
+        ),
+        label,
+    )
+
+    return (
+        [t.astype(np.uint8) for t in base_layer_list],
+        [t.astype(np.uint8) for t in bright_layer_list],
+        [t.astype(np.uint8) for t in shadow_layer_list],
+    )
+
+
+def get_composite_layer(
+    input_image: np.ndarray, base_image: np.ndarray, label: np.ndarray
+) -> Tuple[
+    List[np.ndarray],
+    List[np.ndarray],
+    List[np.ndarray],
+    List[np.ndarray],
+    List[np.ndarray],
+]:
+    """画像の合成を行う関数"""
+    base_image = base_image.astype(np.int32)
+    input_image = input_image.astype(np.int32)
+
+    diff_image = base_image - input_image
+
+    # Shadow (影)
+    shadow_mask = (diff_image[:, :, :3] > 0).all(axis=2)
+    shadow_image = input_image.copy()
+    shadow_image[:, :, 3] = shadow_image[:, :, 3] * shadow_mask
+    shadow_image[:, :, :3] = (shadow_image[:, :, :3] * 255) / base_image[:, :, :3]
+
+    # Screen (逆光)
+    screen_mask = (diff_image[:, :, :3] < 0).all(axis=2)
+    screen_image = input_image.copy()
+    screen_image[:, :, 3] = screen_image[:, :, 3] * screen_mask
+    screen_image[:, :, :3] = (screen_image[:, :, :3] - base_image[:, :, :3]) / (
+        1 - base_image[:, :, :3] / 255
+    )
+
+    # Residuals (残差)
+    residuals_mask = ~shadow_mask & ~screen_mask
+    residuals_image = input_image[:, :, 3].copy()
+    residuals_image = residuals_image * residuals_mask
+
+    # Addition (加算)
+    addition_image = input_image.copy()
+    addition_image[:, :, 3] = residuals_image
+    addition_image[:, :, :3] = input_image[:, :, :3] - base_image[:, :, :3]
+    addition_image[:, :, :3] = addition_image[:, :, :3].clip(0, 255)
+
+    # Subtract (減算)
+    subtract_image = input_image.copy()
+    subtract_image[:, :, 3] = residuals_image
+    subtract_image[:, :, :3] = base_image[:, :, :3] - input_image[:, :, :3]
+    subtract_image[:, :, :3] = subtract_image[:, :, :3].clip(0, 255)
+
+    [
+        base_layer_list,
+        shadow_layer_list,
+        screen_layer_list,
+        addition_layer_list,
+        subtract_layer_list,
+    ] = _split_img_batch(
+        np.array(
+            [
+                base_image,
+                shadow_image,
+                screen_image,
+                addition_image,
+                subtract_image,
+            ]
+        ),
+        label,
+    )
+
+    return (
+        [t.astype(np.uint8) for t in base_layer_list],
+        [t.astype(np.uint8) for t in shadow_layer_list],
+        [t.astype(np.uint8) for t in screen_layer_list],
+        [t.astype(np.uint8) for t in addition_layer_list],
+        [t.astype(np.uint8) for t in subtract_layer_list],
+    )

ldivider/ld_utils.py

@@ -0,0 +1,57 @@
+import random
+import string
+
+import numpy as np
+
+import pytoshop
+from pytoshop import layers
+
+
+def randomname(n):
+    randlst = [random.choice(string.ascii_letters + string.digits) for i in range(n)]
+    return "".join(randlst)
+
+
+def add_psd(psd: pytoshop.core.PsdFile, img, name, mode):
+    layer_1 = layers.ChannelImageData(image=img[:, :, 3], compression=1)
+    layer0 = layers.ChannelImageData(image=img[:, :, 0], compression=1)
+    layer1 = layers.ChannelImageData(image=img[:, :, 1], compression=1)
+    layer2 = layers.ChannelImageData(image=img[:, :, 2], compression=1)
+
+    new_layer = layers.LayerRecord(
+        channels={-1: layer_1, 0: layer0, 1: layer1, 2: layer2},
+        top=0,
+        bottom=img.shape[0],
+        left=0,
+        right=img.shape[1],
+        blend_mode=mode,
+        name=name,
+        opacity=255,
+    )
+    psd.layer_and_mask_info.layer_info.layer_records.append(new_layer)
+    return psd
+
+
+def save_psd(input_image: np.ndarray, layers, names, modes, output_dir, layer_mode):
+    psd = pytoshop.core.PsdFile(
+        num_channels=3, height=input_image.shape[0], width=input_image.shape[1]
+    )
+    if layer_mode == "normal":
+        for idx, output in enumerate(layers[0]):
+            psd = add_psd(psd, layers[0][idx], names[0] + str(idx), modes[0])
+            psd = add_psd(psd, layers[1][idx], names[1] + str(idx), modes[1])
+            psd = add_psd(psd, layers[2][idx], names[2] + str(idx), modes[2])
+    else:
+        for idx, output in enumerate(layers[0]):
+            psd = add_psd(psd, layers[0][idx], names[0] + str(idx), modes[0])
+            psd = add_psd(psd, layers[1][idx], names[1] + str(idx), modes[1])
+            psd = add_psd(psd, layers[2][idx], names[2] + str(idx), modes[2])
+            psd = add_psd(psd, layers[3][idx], names[3] + str(idx), modes[3])
+            psd = add_psd(psd, layers[4][idx], names[4] + str(idx), modes[4])
+
+    name = randomname(10)
+
+    with open(f"{output_dir}/output_{name}.psd", "wb") as fd2:
+        psd.write(fd2)
+
+    return f"{output_dir}/output_{name}.psd"

output/.gitignore

@@ -0,0 +1 @@
+*.psd

pyproject.toml

@@ -0,0 +1,18 @@
+[project]
+name = "layerdivider"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "gradio==5.6.0",
+    "gradio-client==1.4.3",
+    "numba>=0.61.0",
+    "numpy>=2",
+    "opencv-python>=4.11.0.86",
+    "pillow>=11.1.0",
+    "pytoshop-whl>=0.1.0",
+    "scikit-image>=0.25.1",
+    "scikit-learn>=1.6.1",
+    "setuptools>=75.8.0",
+]

requirements.txt

@@ -0,0 +1,197 @@
+# This file was autogenerated by uv via the following command:
+#    uv pip compile pyproject.toml -o requirements.txt
+aiofiles==23.2.1
+    # via gradio
+annotated-types==0.7.0
+    # via pydantic
+anyio==4.9.0
+    # via
+    #   gradio
+    #   httpx
+    #   starlette
+certifi==2025.1.31
+    # via
+    #   httpcore
+    #   httpx
+    #   requests
+charset-normalizer==3.4.1
+    # via requests
+click==8.1.8
+    # via
+    #   typer
+    #   uvicorn
+fastapi==0.115.12
+    # via gradio
+ffmpy==0.5.0
+    # via gradio
+filelock==3.18.0
+    # via huggingface-hub
+fsspec==2025.3.2
+    # via
+    #   gradio-client
+    #   huggingface-hub
+gradio==5.6.0
+    # via layerdivider (pyproject.toml)
+gradio-client==1.4.3
+    # via
+    #   layerdivider (pyproject.toml)
+    #   gradio
+h11==0.14.0
+    # via
+    #   httpcore
+    #   uvicorn
+httpcore==1.0.8
+    # via httpx
+httpx==0.28.1
+    # via
+    #   gradio
+    #   gradio-client
+    #   safehttpx
+huggingface-hub==0.30.2
+    # via
+    #   gradio
+    #   gradio-client
+idna==3.10
+    # via
+    #   anyio
+    #   httpx
+    #   requests
+imageio==2.37.0
+    # via scikit-image
+jinja2==3.1.6
+    # via gradio
+joblib==1.4.2
+    # via scikit-learn
+lazy-loader==0.4
+    # via scikit-image
+llvmlite==0.44.0
+    # via numba
+markdown-it-py==3.0.0
+    # via rich
+markupsafe==2.1.5
+    # via
+    #   gradio
+    #   jinja2
+mdurl==0.1.2
+    # via markdown-it-py
+networkx==3.4.2
+    # via scikit-image
+numba==0.61.2
+    # via layerdivider (pyproject.toml)
+numpy==2.2.4
+    # via
+    #   layerdivider (pyproject.toml)
+    #   gradio
+    #   imageio
+    #   numba
+    #   opencv-python
+    #   pandas
+    #   pytoshop-whl
+    #   scikit-image
+    #   scikit-learn
+    #   scipy
+    #   tifffile
+opencv-python==4.11.0.86
+    # via layerdivider (pyproject.toml)
+orjson==3.10.16
+    # via gradio
+packaging==24.2
+    # via
+    #   gradio
+    #   gradio-client
+    #   huggingface-hub
+    #   lazy-loader
+    #   scikit-image
+pandas==1.5.3
+    # via gradio
+pillow==11.1.0
+    # via
+    #   layerdivider (pyproject.toml)
+    #   gradio
+    #   imageio
+    #   scikit-image
+pydantic==2.11.3
+    # via
+    #   fastapi
+    #   gradio
+pydantic-core==2.33.1
+    # via pydantic
+pydub==0.25.1
+    # via gradio
+pygments==2.19.1
+    # via rich
+python-dateutil==2.9.0.post0
+    # via pandas
+python-multipart==0.0.12
+    # via gradio
+pytoshop-whl==0.1.0
+    # via layerdivider (pyproject.toml)
+pytz==2025.2
+    # via pandas
+pyyaml==6.0.2
+    # via
+    #   gradio
+    #   huggingface-hub
+requests==2.32.3
+    # via huggingface-hub
+rich==14.0.0
+    # via typer
+ruff==0.11.5
+    # via gradio
+safehttpx==0.1.6
+    # via gradio
+scikit-image==0.25.2
+    # via layerdivider (pyproject.toml)
+scikit-learn==1.6.1
+    # via layerdivider (pyproject.toml)
+scipy==1.15.2
+    # via
+    #   scikit-image
+    #   scikit-learn
+semantic-version==2.10.0
+    # via gradio
+setuptools==78.1.0
+    # via layerdivider (pyproject.toml)
+shellingham==1.5.4
+    # via typer
+six==1.17.0
+    # via
+    #   python-dateutil
+    #   pytoshop-whl
+sniffio==1.3.1
+    # via anyio
+starlette==0.46.1
+    # via
+    #   fastapi
+    #   gradio
+threadpoolctl==3.6.0
+    # via scikit-learn
+tifffile==2025.3.30
+    # via scikit-image
+tomlkit==0.12.0
+    # via gradio
+tqdm==4.63.0
+    # via huggingface-hub
+typer==0.15.2
+    # via gradio
+typing==3.10.0.0
+    # via pytoshop-whl
+typing-extensions==4.13.2
+    # via
+    #   anyio
+    #   fastapi
+    #   gradio
+    #   gradio-client
+    #   huggingface-hub
+    #   pydantic
+    #   pydantic-core
+    #   typer
+    #   typing-inspection
+typing-inspection==0.4.0
+    # via pydantic
+urllib3==2.4.0
+    # via requests
+uvicorn==0.34.0
+    # via gradio
+websockets==12.0
+    # via gradio-client