See-through: Anime Character Layer Decomposition

Skill by ara.so — Daily 2026 Skills collection.

See-through is a research framework (SIGGRAPH 2026, conditionally accepted) that decomposes a single anime illustration into up to 23 fully inpainted, semantically distinct layers with inferred drawing orders — exporting a layered PSD file suitable for 2.5D animation workflows.

What It Does

• Decomposes a single anime image into semantic layers (hair, face, eyes, clothing, accessories, etc.)

• Inpaints occluded regions so each layer is complete

• Infers pseudo-depth ordering using a fine-tuned Marigold model

• Exports layered .psd files with depth maps and segmentation masks

• Supports depth-based and left-right stratification for further refinement

Installation

# 1. Create and activate environment

conda create -n see_through python=3.12 -y

conda activate see_through

# 2. Install PyTorch with CUDA 12.8

pip install torch==2.8.0+cu128 torchvision==0.23.0+cu128 torchaudio==2.8.0+cu128 \

  --index-url https://download.pytorch.org/whl/cu128

# 3. Install core dependencies

pip install -r requirements.txt

# 4. Create assets symlink

ln -sf common/assets assets

Optional Annotator Tiers

Install only what you need:

# Body parsing (detectron2 — for body attribute tagging)

pip install --no-build-isolation -r requirements-inference-annotators.txt

# SAM2 (language-guided segmentation)

pip install --no-build-isolation -r requirements-inference-sam2.txt

# Instance segmentation (mmcv/mmdet — recommended for UI)

pip install -r requirements-inference-mmdet.txt

Always run all scripts from the repository root as the working directory.

Models

Models are hosted on HuggingFace and downloaded automatically on first use:

Model

HuggingFace ID

Purpose

LayerDiff 3D

layerdifforg/seethroughv0.0.2_layerdiff3d

SDXL-based transparent layer generation

Marigold Depth

24yearsold/seethroughv0.0.1_marigold

Anime pseudo-depth estimation

SAM Body Parsing

24yearsold/l2d_sam_iter2

19-part semantic body segmentation

Key CLI Commands

Main Pipeline: Layer Decomposition to PSD

# Single image → layered PSD

python inference/scripts/inference_psd.py \

  --srcp assets/test_image.png \

  --save_to_psd

# Entire directory of images

python inference/scripts/inference_psd.py \

  --srcp path/to/image_folder/ \

  --save_to_psd

Output is saved to workspace/layerdiff_output/ by default. Each run produces:

• A layered .psd file with semantically separated layers

• Intermediate depth maps

• Segmentation masks

Heuristic Post-Processing

After the main pipeline, further split layers using heuristic_partseg.py:

# Depth-based stratification (e.g., separate near/far handwear)

python inference/scripts/heuristic_partseg.py seg_wdepth \

  --srcp workspace/test_samples_output/PV_0047_A0020.psd \

  --target_tags handwear

# Left-right stratification

python inference/scripts/heuristic_partseg.py seg_wlr \

  --srcp workspace/test_samples_output/PV_0047_A0020_wdepth.psd \

  --target_tags handwear-1

Synthetic Training Data Generation

python inference/scripts/syn_data.py

Python API Usage

Running the Full Pipeline Programmatically

import subprocess

import os

def decompose_anime_image(image_path: str, output_dir: str = "workspace/layerdiff_output") -> str:

    """

    Run See-through layer decomposition on a single anime image.

    Returns path to the output PSD file.

    """

    result = subprocess.run(

        [

            "python", "inference/scripts/inference_psd.py",

            "--srcp", image_path,

            "--save_to_psd",

        ],

        capture_output=True,

        text=True,

        cwd=os.getcwd()  # Must run from repo root

    )

    if result.returncode != 0:

        raise RuntimeError(f"Decomposition failed:\n{result.stderr}")

    # Derive expected output filename

    base_name = os.path.splitext(os.path.basename(image_path))[0]

    psd_path = os.path.join(output_dir, f"{base_name}.psd")

    return psd_path

# Example usage

psd_output = decompose_anime_image("assets/test_image.png")

print(f"PSD saved to: {psd_output}")

Batch Processing a Directory

import subprocess

from pathlib import Path

def batch_decompose(input_dir: str, output_dir: str = "workspace/layerdiff_output"):

    """Process all images in a directory."""

    result = subprocess.run(

        [

            "python", "inference/scripts/inference_psd.py",

            "--srcp", input_dir,

            "--save_to_psd",

        ],

        capture_output=True,

        text=True,

    )

    if result.returncode != 0:

        raise RuntimeError(f"Batch processing failed:\n{result.stderr}")

    output_psds = list(Path(output_dir).glob("*.psd"))

    print(f"Generated {len(output_psds)} PSD files in {output_dir}")

    return output_psds

# Example

psds = batch_decompose("path/to/my_anime_images/")

Post-Processing: Depth and LR Splits

import subprocess

def split_by_depth(psd_path: str, target_tags: list[str]) -> str:

    """Apply depth-based layer stratification to a PSD."""

    tags_str = " ".join(target_tags)

    result = subprocess.run(

        [

            "python", "inference/scripts/heuristic_partseg.py",

            "seg_wdepth",

            "--srcp", psd_path,

            "--target_tags", *target_tags,

        ],

        capture_output=True, text=True,

    )

    if result.returncode != 0:

        raise RuntimeError(result.stderr)

    # Output naming convention: original name + _wdepth suffix

    base = psd_path.replace(".psd", "_wdepth.psd")

    return base

def split_by_lr(psd_path: str, target_tags: list[str]) -> str:

    """Apply left-right layer stratification to a PSD."""

    result = subprocess.run(

        [

            "python", "inference/scripts/heuristic_partseg.py",

            "seg_wlr",

            "--srcp", psd_path,

            "--target_tags", *target_tags,

        ],

        capture_output=True, text=True,

    )

    if result.returncode != 0:

        raise RuntimeError(result.stderr)

    return psd_path.replace(".psd", "_wlr.psd")

# Full post-processing pipeline example

psd = "workspace/test_samples_output/PV_0047_A0020.psd"

depth_psd = split_by_depth(psd, ["handwear"])

lr_psd = split_by_lr(depth_psd, ["handwear-1"])

print(f"Final PSD with depth+LR splits: {lr_psd}")

Loading and Inspecting PSD Output

from psd_tools import PSDImage  # pip install psd-tools

def inspect_psd_layers(psd_path: str):

    """List all layers in a See-through output PSD."""

    psd = PSDImage.open(psd_path)

    print(f"Canvas size: {psd.width}x{psd.height}")

    print(f"Total layers: {len(list(psd.descendants()))}")

    print("\nLayer structure:")

    for layer in psd:

        print(f"  [{layer.kind}] '{layer.name}' — "

              f"bbox: {layer.bbox}, visible: {layer.is_visible()}")

    return psd

psd = inspect_psd_layers("workspace/layerdiff_output/my_character.psd")

Interactive Body Part Segmentation (Notebook)

Open and run the provided demo notebook:

jupyter notebook inference/demo/bodypartseg_sam.ipynb

This demonstrates interactive 19-part body segmentation with visualization using the SAM body parsing model.

Dataset Preparation for Training

See-through uses Live2D model files as training data. Setup requires a separate repo:

# 1. Clone the CubismPartExtr utility

git clone https://github.com/shitagaki-lab/CubismPartExtr

# Follow its README to download sample model files and prepare workspace/

# 2. Run data parsing scripts per README_datapipeline.md

# (scripts are in inference/scripts/ — check docstrings for details)

Launching the UI

# Requires workspace/datasets/ at repo root (contains sample data)

# Recommended: install mmdet tier first

pip install -r requirements-inference-mmdet.txt

# Then follow ui/README.md for launch instructions

cd ui

# See ui/README.md for the specific launch command

Directory Structure

see-through/

├── inference/

│   ├── scripts/

│   │   ├── inference_psd.py        # Main pipeline

│   │   ├── heuristic_partseg.py    # Depth/LR post-processing

│   │   └── syn_data.py             # Synthetic data generation

│   └── demo/

│       └── bodypartseg_sam.ipynb   # Interactive segmentation demo

├── common/

│   ├── assets/                     # Test images, etc.

│   └── live2d/

│       └── scrap_model.py          # Full body tag definitions

├── ui/                             # User interface

├── workspace/                      # Runtime outputs (auto-created)

│   ├── layerdiff_output/           # Default PSD output location

│   ├── datasets/                   # Required for UI

│   └── test_samples_output/        # Sample outputs

├── requirements.txt

├── requirements-inference-annotators.txt

├── requirements-inference-sam2.txt

├── requirements-inference-mmdet.txt

└── README_datapipeline.md

Common Patterns

Pattern: End-to-End Single Image Workflow

# Step 1: Decompose

python inference/scripts/inference_psd.py \

  --srcp assets/test_image.png \

  --save_to_psd

# Step 2: Depth-split a specific part tag

python inference/scripts/heuristic_partseg.py seg_wdepth \

  --srcp workspace/layerdiff_output/test_image.psd \

  --target_tags arm sleeve

# Step 3: Left-right split

python inference/scripts/heuristic_partseg.py seg_wlr \

  --srcp workspace/layerdiff_output/test_image_wdepth.psd \

  --target_tags arm-1 sleeve-1

Pattern: Check Available Body Tags

# Body tag definitions are in common/live2d/scrap_model.py

import importlib.util, sys

spec = importlib.util.spec_from_file_location(

    "scrap_model", "common/live2d/scrap_model.py"

)

mod = importlib.util.module_from_spec(spec)

spec.loader.exec_module(mod)

# Inspect the module for tag constants/enums

print(dir(mod))

ComfyUI Integration

A community-maintained ComfyUI node is available:

https://github.com/jtydhr88/ComfyUI-See-through

Install via ComfyUI Manager or clone into ComfyUI/custom_nodes/.

Troubleshooting

Problem

Solution

ModuleNotFoundError for detectron2/mmcv

Install the appropriate optional tier: pip install --no-build-isolation -r requirements-inference-annotators.txt

Scripts fail with path errors

Always run from the repository root, not from within subdirectories

UI fails to launch

Install mmdet tier: pip install -r requirements-inference-mmdet.txt; ensure workspace/datasets/ exists

CUDA out of memory

Use a GPU with ≥16GB VRAM; SDXL-based LayerDiff 3D is memory-intensive

Assets not found

Re-run ln -sf common/assets assets from repo root

SAM2 install fails

Use --no-build-isolation flag as shown in the install commands

Output PSD empty or malformed

Check workspace/layerdiff_output/ for intermediate depth/mask files to diagnose which stage failed

Citation

@article{lin2026seethrough,

  title={See-through: Single-image Layer Decomposition for Anime Characters},

  author={Lin, Jian and Li, Chengze and Qin, Haoyun and Chan, Kwun Wang and

          Jin, Yanghua and Liu, Hanyuan and Choy, Stephen Chun Wang and Liu, Xueting},

  journal={arXiv preprint arXiv:2602.03749},

  year={2026}

}