csmp-hub/human-lung

Human Lung

Overview

Human Lung contains 68 microscope images of human lung tissue, with outlines of individual nuclei and whole cells, plus labels for tissue, cell types and debris. The tissue came from lung surgery and does not include the removed tumours. Each field is 1024 × 1024 pixels, recorded at 40× magnification.

Each image has four channels: DIC shows tissue structure, DAPI highlights nuclei, CD68 marks alveolar macrophages, and proSPC highlights cytoplasm in alveolar epithelial type 2 cells. These cells help maintain the lung's air sacs.

License: CC BY-NC 4.0. Noncommercial use and sharing are allowed with credit to the creators, a license link and a description of changes.

Files and splits

Split	File	Images	Nuclei	Whole cells
train	train.parquet	51	5,872	1,622
val	val.parquet	7	802	268
test	test.parquet	10	1,377	399

The original train, validation and test sets are kept. The source's validation split is called val here. Image names such as Image0_L3 are unchanged.

The filename groups (L1–L9) do not cross these splits. The release does not explain which patients or slides they identify, so patient independence is unconfirmed.

Some fields within the training set overlap, as do two validation fields. Object counts can therefore include the same tissue more than once. No shared-view candidates were found across splits.

Fields

Each row holds one four-channel image and its masks. Decode image as TIFF and the masks as PNG.

Field	Contents
id	Original image name, such as Image0_L3
image	TIFF bytes; float32, shape (4, 1024, 1024), axes channel, height, width
image_format, image_axes, image_dtype	tiff, CYX, float32
channel_names	DIC, DAPI, CD68, proSPC, in that order
inst	Nucleus instance mask; uint16 PNG, shape (1024, 1024)
inst_cell	Whole-cell instance mask; uint16 PNG, same shape
type	Nucleus classes; uint8 PNG, original values 5, 6 and 7, with 0 elsewhere
sem	Full semantic mask; original uint8 PNG, values 0–8
pairs	List of inferred links, each with nucleus_id and cell_id
source_group, source_split	Original filename group and split name
source_image_files	Four original image paths, in channel order
source_nuclei_file, source_cell_file, source_semantic_file	Original mask paths

The original float values are kept. DIC includes negative values (about −11.33 to 16.91 across this release); fluorescence values range from 0 to 1. The source already corrected the DIC background and normalized the fluorescence. No further normalization is applied here.

Zero is background in the instance masks. Positive numbers identify objects within each mask. A nucleus and a cell with the same number are not a matched pair; use pairs instead.

Labels

Value	Meaning
0	Background
1	Normal tissue
2	Erythrocytes
3	Alveolar epithelial type 2 cells
4	Alveolar macrophages
5	Other nuclei
6	Alveolar epithelial type 2 cell nuclei
7	Alveolar macrophage nuclei
8	Cell debris

There are 8,051 nuclei and 2,289 whole-cell instances. Whole-cell outlines mark alveolar epithelial type 2 cells and alveolar macrophages; many other marked nuclei have no whole-cell outline.

The two masks are kept independently. pairs contains 1,316 links where every pixel of a nucleus lies inside one cell. These links are inferred from the outlines, rather than supplied by the creators. Some cells contain several linked nuclei. Unmatched nuclei, unmatched cells and partial overlaps are all kept. A missing link does not mean the objects are unrelated. See pairing-audit.json for the overlaps.

Download and read a sample

from io import BytesIO

import numpy as np
import polars as pl
import tifffile
from huggingface_hub import hf_hub_download
from PIL import Image

path = hf_hub_download(
    repo_id="csmp-hub/human-lung", filename="train.parquet", repo_type="dataset"
)
row = pl.scan_parquet(path).head(1).collect().to_dicts()[0]


def decode_png(data):
    with Image.open(BytesIO(data)) as image:
        return np.array(image)


image = tifffile.imread(BytesIO(row["image"]))  # CYX float32, (4, 1024, 1024)
nuclei = decode_png(row["inst"])  # HW uint16, original nucleus numbers
cells = decode_png(row["inst_cell"])  # HW uint16, original whole-cell numbers
nucleus_classes = decode_png(row["type"])  # HW uint8, values 0, 5, 6, 7
semantic = decode_png(row["sem"])  # HW uint8, original classes 0–8
pairs = row["pairs"]  # links between independent nucleus and cell numbers
channel_names = row["channel_names"]  # DIC, DAPI, CD68, proSPC

Plot examples

The following shows all four channels for two training images, followed by nucleus and whole-cell outlines over DIC. Contrast is adjusted only for display; the stored values stay unchanged.

import matplotlib.pyplot as plt
from matplotlib.patches import Patch
from skimage.segmentation import find_boundaries

samples = (
    pl.scan_parquet(path)
    .filter(pl.col("id").is_in(["Image0_L3", "Image12_L1"]))
    .sort("id")
    .collect()
    .to_dicts()
)
class_colors = np.array(
    [
        [0, 0, 0],
        [80, 140, 110],
        [255, 110, 80],
        [255, 210, 50],
        [210, 100, 255],
        [70, 160, 255],
        [255, 150, 30],
        [255, 80, 180],
        [180, 180, 180],
    ],
    dtype=np.uint8,
)
class_names = [
    "Background",
    "Normal tissue",
    "Erythrocytes",
    "Type 2 cells",
    "Macrophages",
    "Other nuclei",
    "Type 2 cell nuclei",
    "Macrophage nuclei",
    "Cell debris",
]


def display_channel(channel):
    low, high = np.percentile(channel, [1, 99])
    return np.clip((channel - low) / max(high - low, 1e-12), 0, 1)


fig, axes = plt.subplots(2, 5, figsize=(15, 6))
for row_axes, sample in zip(axes, samples):
    channels = tifffile.imread(BytesIO(sample["image"]))
    for ax, channel in zip(row_axes[:4], channels):
        ax.imshow(display_channel(channel), cmap="gray", vmin=0, vmax=1)
    overlay = np.repeat(display_channel(channels[0])[..., None], 3, axis=-1)
    overlay[find_boundaries(decode_png(sample["inst_cell"]), mode="inner")] = [
        0,
        1,
        0.3,
    ]
    overlay[find_boundaries(decode_png(sample["inst"]), mode="inner")] = [0.2, 0.65, 1]
    row_axes[4].imshow(overlay)
    row_axes[0].text(0, 1.03, sample["id"], transform=row_axes[0].transAxes, fontsize=9)
    for ax in row_axes:
        ax.axis("off")
for ax, title in zip(axes[0], ["DIC", "DAPI", "CD68", "proSPC", "DIC with outlines"]):
    ax.set_title(title, pad=28)
fig.legend(
    handles=[
        Patch(color=(0.2, 0.65, 1), label="Nuclei"),
        Patch(color=(0, 1, 0.3), label="Whole cells"),
    ],
    loc="lower center",
    ncol=2,
)
fig.subplots_adjust(
    left=0.01, right=0.99, bottom=0.08, top=0.87, hspace=0.18, wspace=0.03
)
plt.show()

To see the masks without the image:

from skimage.color import label2rgb

mask_fig, mask_axes = plt.subplots(2, 3, figsize=(10, 7))
instance_colors = [(1, 0.3, 0.3), (0.2, 1, 0.5), (0.3, 0.7, 1), (1, 0.8, 0.2)]
for row_axes, sample in zip(mask_axes, samples):
    for ax, field in zip(row_axes[:2], ["inst", "inst_cell"]):
        ax.imshow(
            label2rgb(
                decode_png(sample[field]),
                colors=instance_colors,
                bg_label=0,
                bg_color=(0, 0, 0),
            ),
            interpolation="nearest",
        )
    row_axes[2].imshow(class_colors[decode_png(sample["sem"])], interpolation="nearest")
    row_axes[0].text(0, 1.02, sample["id"], transform=row_axes[0].transAxes, fontsize=9)
    for ax in row_axes:
        ax.axis("off")
for ax, title in zip(
    mask_axes[0], ["Nucleus instances", "Whole-cell instances", "Semantic labels"]
):
    ax.set_title(title, pad=28)
mask_fig.legend(
    handles=[
        Patch(color=class_colors[i] / 255, label=class_names[i]) for i in range(1, 9)
    ],
    loc="lower center",
    ncol=4,
    fontsize=8,
)
mask_fig.subplots_adjust(
    left=0.01, right=0.99, bottom=0.10, top=0.90, hspace=0.14, wspace=0.03
)
plt.show()

Instance colours distinguish objects within each mask; they do not show pairings or cell types. The semantic colours follow the legend.

Preparation and validation

The four image channels were combined into one lossless TIFF per field. Every original float value, instance number and semantic label was checked against the source after saving. Semantic PNG files are unchanged.

The supplied split lists were checked for repeated images and shared filename groups. Exact duplicate, rotated or reflected whole-image, and shared-view checks found no candidates across splits. These checks cannot rule out every overlap. Details are in manifest.json, pairing-audit.json and split-audit.json.

Limitations

• Whole-cell and nucleus outlines do not always fit together exactly. Use the separate masks when a strict pairing would omit useful labels.
• Patient and slide identities are not documented in the release. Keep the supplied splits when comparing results, and do not treat the filename groups as verified patient IDs.
• The source reports 40× magnification, but does not provide a verified micrometre-per-pixel scale for each image.

License and citation

The original data and this prepared version use CC BY-NC 4.0. Keep the creator credits, link to the source and license, and state any changes when sharing the data. Commercial use requires separate permission. The full license is in LICENSE; NOTICE.md records the preparation changes.

Credit the dataset creators:

Dohmen, Melanie; Mittermaier, Mirja; Hocke, Andreas (2024). Human Lung Tissue Microscopy (DIC, Fluorescence, Cell and Nuclei Semantic Instance Annotations), version v1. Zenodo. doi:10.5281/zenodo.10669918.

Related paper:

Dohmen, M.; Mittermaier, M.; Rumberger, J. L.; Yang, L.-L.; Gruber, A. D.; Toennies, M.; Hippenstiel, S.; Kainmueller, D.; Hocke, A. C. (2024). Simultaneous Lung Cell and Nucleus Segmentation From Labelled Versus Unlabelled Human Lung DIC Images. IEEE ISBI, pp. 1–5. doi:10.1109/ISBI56570.2024.10635198.