LayerFolio / README.md
FolioWeaver's picture
Clarify synthetic image source description
3d9b7fe verified
|
Raw History Blame Contribute Delete
11.3 kB
metadata
pretty_name: LayerFolio
license: other
license_name: layerfolio-component-specific-licenses
license_link: LICENSE
size_categories:
  - 100K<n<1M
tags:
  - image
  - layered-images
  - scene-graphs
  - rgba
  - parquet
  - datasets
configs:
  - config_name: default
    data_files:
      - split: train
        path: data/train-*.parquet

LayerFolio

LayerFolio: 100,377 paired scenes, 869,762 PNG assets, six visual domains and 55 subcategories.

Overview  ·  Quick start  ·  Inside a sample  ·  Data reference  ·  Licensing

LayerFolio connects what a scene says, how it is structured, and the pixels that make it up. Each sample pairs a scene description with a LayerGraph, a full-scene composite, and its individual PNG assets. A shared representation spans graphic design, photography, UI content, 3D graphics, drawing, and illustration.

Paired scenes Visual domains Subcategories Embedded PNGs Parquet shards
100,377 6 55 869,762 183

Release at a glance: one train split · approximately 194.33 GB · one complete sample per row · PNG bytes preserved, including alpha channels.

Overview

LayerFolio provides aligned supervision for scene planning, layer-conditioned image generation, composition, and layer-level inspection or editing. Its LayerGraph representation links layer assets to descriptions, geometry, stacking order, appearance attributes, and explicit inter-layer relations.

What is paired What it provides
Scene description The overall visual intent, preserved in global_prompt.
LayerGraph Layer identities, prompts, asset references, geometry, and typed relations.
Composite The complete scene, embedded in whole_image.
Layer assets Background and other PNG assets, embedded in layer_images.

Across visual domains

Six actual LayerFolio composites showing graphic design, UI content, 3D graphics, photography, drawing and illustration.

Representative examples from the release. These panels illustrate visual variety; they are not a random or balanced evaluation subset. Sample IDs and source routing are listed in preview-samples.json.

Sample counts across the six LayerFolio visual domains.

Exact domain counts
Domain Scenes Share
Graphic design 44,717 44.5%
Photography 19,473 19.4%
3D & computer graphics 14,692 14.6%
UI & screen content 11,208 11.2%
Painting & drawing 6,712 6.7%
Illustration & animation 3,575 3.6%
Total 100,377 100%

Exact subcategory counts are available in stats.json. Percentages above are rounded independently.

Quick start

Start with streaming to inspect samples without downloading the entire release. Image features decode to Pillow images when accessed.

pip install -U datasets pillow
import json
from datasets import load_dataset

dataset = load_dataset(
    "FolioWeaver/LayerFolio",
    split="train",
    streaming=True,
)
sample = next(iter(dataset))
graph = json.loads(sample["layergraph_json"])

print(sample["graph_id"])
print(sample["global_prompt"])
print("Annotated layers:", sample["num_layers"])
print("Stored layer assets:", sample["num_layer_images"])

composite = sample["whole_image"]  # Pillow image
layer_assets = dict(zip(sample["layer_image_paths"], sample["layer_images"]))
Access the original PNG bytes

Turn off decoding before reading a sample. The stored bytes are the original PNG file bytes, including any alpha channel.

from datasets import Image, List

raw_dataset = dataset.cast_column("whole_image", Image(decode=False))
raw_dataset = raw_dataset.cast_column("layer_images", List(Image(decode=False)))
raw_sample = next(iter(raw_dataset))

composite_png = raw_sample["whole_image"]["bytes"]
layer_pngs = {
    path: image["bytes"]
    for path, image in zip(raw_sample["layer_image_paths"], raw_sample["layer_images"])
}

When images are decoded, use layer_image_paths to retain the asset-to-path mapping.

Read a local download

From the root of a downloaded repository:

from datasets import load_dataset

dataset = load_dataset(
    "parquet",
    data_files={"train": "data/train-*.parquet"},
    split="train",
    streaming=True,
)

Rows may contain many images. Use streaming or selective column reads for inspection instead of materializing the entire collection in memory.

Inside a sample

A real 3D scene shown alongside its background, nightstand and armchair layer assets; checkerboards indicate transparency.

Example 3D_Product_Object_001517 from the Poly Haven source stream. The LayerGraph records the layer identities and their placement in the scene. Checkerboards are added only for this preview to make transparency visible.

The accompanying LayerGraph connects these assets to their roles and relations. For this example, it records that the armchair is left_of the nightstand and that both objects are supported_by the background.

Scene description
      │
      ├── LayerGraph ── layer IDs, prompts, boxes, stacking, relations
      ├── whole_image ─ full-scene PNG
      └── layer_images
            ├── base_image.png
            ├── layer_00.png
            └── layer_01.png

Match layers by asset path. num_layers counts annotations, while num_layer_images counts stored PNG assets other than the whole image. The asset list includes base_image.png and every other PNG in the sample, including files that a particular layer does not reference. These counts need not be equal, so a layer's position in the JSON is not an image-list index.

for layer in graph["layers"]:
    path = layer.get("rgba_path")
    if path in layer_assets:
        image = layer_assets[path]
        print(layer["id"], image.size)

Data reference

Record fields

Field Contents
graph_id Released sample identifier.
sample_path Sample directory relative to the dataset root.
category, subcategory Scene taxonomy labels.
split train for every sample in this release.
global_prompt, language Scene description and its source annotation language.
num_layers Number of annotated layers in the LayerGraph.
num_layer_images Number of embedded PNG assets other than the whole image.
whole_image Hugging Face Image feature storing the full scene as {bytes, path}.
layer_images Variable-length list of Image features, including the base image.
layer_image_paths Relative paths aligned with layer_images.
layergraph_json Complete LayerGraph annotation as UTF-8 JSON text.
layergraph_sha256 SHA-256 of the exported annotation text.
source_layergraph_sha256 SHA-256 of the original source annotation file.
whole_image_sha256 SHA-256 of the original composite PNG bytes.
layer_image_sha256 PNG checksums aligned with layer_images.

The full feature specification is in schema.json.

Packaging and integrity

LayerFolio/
├── data/train-00000.parquet … train-00182.parquet
├── manifest.jsonl          # Shard sizes, row counts, and SHA-256 checksums
├── SHA256SUMS              # Per-shard checksums
├── stats.json              # Exact release statistics
├── schema.json             # Record feature specification
├── source_index.jsonl      # Sample-to-source routing
├── SOURCE_PROVENANCE.md    # Reconstruction method and limits
├── LICENSE
├── THIRD_PARTY_NOTICES.md
├── licenses/               # Component license texts and notices
└── assets/                 # Dataset-card artwork and preview sample IDs

PNG assets are embedded directly without decoding or re-encoding. The full annotation text is preserved, including whitespace and nested attributes, with only its top-level split set to train. All stored asset paths are relative to the dataset root.

To reconstruct a sample, write layergraph_json.encode("utf-8") to sample_path + "/layergraph.json" and each raw Image's bytes to its path under a chosen output directory. Validate that each path remains relative and inside that directory before writing. Exported and source annotation hashes may differ because of the split override; PNG byte hashes are unchanged.

Split, coverage, and provenance

  • Split: all 100,377 samples are released as train. This package does not designate an official validation or test set.
  • Coverage: domain and subcategory sizes are uneven. The Photography category includes synthetic imagery and should not be interpreted as a guarantee of camera-captured photographs.
  • Source routing: source_index.jsonl covers every released sample. Its mapping was reconstructed and sample-validated; SOURCE_PROVENANCE.md explains the method and limits.

Licensing and attribution

This is a component-licensed collection. Read LICENSE and THIRD_PARTY_NOTICES.md before redistributing material. Original copyrightable LayerFolio contributions are offered under CC BY 4.0 only to the extent the contributors hold the relevant rights. Third-party content and applicable adaptations retain their upstream terms, including CC BY-SA 4.0, Apache-2.0, CC0, and Crello's CDLA / VistaCreate notices. The full legal texts and source notices are included in licenses/.

The publisher's academic research purpose adds no dataset-wide non-commercial restriction. Permission for a particular use depends on the applicable component terms and rights; this is not a statement that all third-party redistribution permissions have been individually cleared. In particular, the scope of Crello template/asset redistribution under VistaCreate remains to be confirmed, as explained in the third-party notices.

For the synthetic image stream, captions derived from real photographs were used as prompts for Qwen-Image to generate new images. The original photograph files are not distributed as part of that stream. Qwen-Image's model license is distinct from the rights in generated outputs. This process description follows the dataset publisher's confirmation.

source_index.jsonl provides sample-to-source routing; SOURCE_PROVENANCE.md explains that it was reconstructed and sample-validated, and does not supply every native upstream asset ID or per-work creator credit. Required source attribution and permissions still apply.