CTSpinoPelvic1K

A large-scale CT dataset for unified lumbar spine and pelvis segmentation, with dedicated coverage of lumbosacral transitional vertebrae (LSTV).

Derived from CTSpine1K and CTPelvic1K, fused into a single 10-class label scheme and matched to original TCIA DICOM series using world-space affine registration. Every volume pair is guaranteed to be voxel-aligned with identical affines — no resampling needed at training time.

---

At a Glance

Property	Value
Modality	CT (computed tomography)
Anatomy	Lumbar spine (L1–L6) + sacrum + bilateral hips
Label format	NIfTI-1 .nii.gz, integer labels, single file per case
Orientation	PIR — Posterior · Inferior · Right (canonical)
Voxel grid	Native TCIA DICOM resolution (typically 512×512×N, 0.625–0.977 mm in-plane, 0.8–1.0 mm slice)
Alignment	CT and label saved with identical affines — zero-cost overlay
LSTV coverage	Sacralization, lumbarization, and semi-LSTV cases explicitly labelled
Splits	70/15/15 train/val/test, LSTV-stratified, seed-fixed
License	CC BY-NC 4.0

---

Label Scheme

Every label volume uses a unified 10-class integer scheme:

Value	Structure	Notes
0	Background
1	L1
2	L2
3	L3
4	L4
5	L5
6	L6	LSTV only — lumbarized S1 in lumbarization phenotype
7	Sacrum	Pelvic sacrum label takes priority over spine sacrum
8	Left hip	Ilium/acetabulum
9	Right hip	Ilium/acetabulum

LSTV note: In sacralization cases, L5 (class 5) is fused to the sacrum and no L6 exists. In lumbarization cases, the transitional segment is labeled L6 (class 6). In both phenotypes, the sacrum (class 7) is always present. The has_l6 field in the manifest flags lumbarization cases explicitly.

---

Orientation

All volumes are stored in PIR orientation (Posterior–Inferior–Right):

Axis 0  →  P (Posterior)    — coronal axis
Axis 1  →  I (Inferior)     — axial/slice axis
Axis 2  →  R (Right)        — sagittal axis

This is the canonical orientation produced by nibabel's as_reoriented(). Tensor shape after loading is (P, I, R). When adding a channel dimension for a model: ct[None] → (1, P, I, R).

---

Repository Layout

CTSpinoPelvic1K/
├── ct/
│   ├── 0001_supine_ct.nii.gz
│   ├── 0002_supine_ct.nii.gz
│   └── ...
├── labels/
│   ├── 0001_supine_label.nii.gz
│   ├── 0002_supine_label.nii.gz
│   └── ...
├── manifest.json          # per-case metadata (token, config, LSTV label, splits, etc.)
├── manifest.csv           # same as manifest.json, CSV format
├── splits.json            # train/val/test file lists (LSTV-stratified)
└── dataset_interface.py   # self-contained Python interface (no extra dependencies)

QC figures (qc/) are excluded from this repository to minimize download size. They can be regenerated locally using export_hf.py --skip_export --out_dir <path>.

---

Installation

pip install nibabel numpy huggingface_hub

# Optional: 3–5× faster downloads
pip install hf_transfer

No other dependencies are required to load and iterate the dataset. MONAI or PyTorch are only needed for the training helper functions.

---

Quick Start

Load from HuggingFace (recommended)

from dataset_interface import CTSpinoPelvic1K

# Download and load in one line
# Files are cached at ~/.cache/huggingface/datasets/CTSpinoPelvic1K
ds = CTSpinoPelvic1K.from_hub()

# Specify a custom local directory
ds = CTSpinoPelvic1K.from_hub(local_dir="/data/ctspinopelvic1k")

# Private or gated repo
ds = CTSpinoPelvic1K.from_hub(token="hf_xxx")
# or: export HF_TOKEN=hf_xxx

Load from a local export directory

from dataset_interface import CTSpinoPelvic1K

ds = CTSpinoPelvic1K("/data/ctspinopelvic1k")
print(ds.stats())

Load a single case

case = ds[0]

# Arrays — ct.shape == lbl.shape guaranteed
ct, lbl = case.load()
print(ct.shape, lbl.shape, ct.dtype, lbl.dtype)
# → (512, 512, 347) (512, 512, 347) float32 int16

# nibabel images (with affine)
ct_img, lbl_img = case.load_nib()
print(ct_img.affine)

---

Case Metadata

Each Case object exposes the following fields:

case.token            # str  — patient identifier (de-identified)
case.position         # str  — "supine" | "prone" | "unknown"
case.config           # str  — "fused" | "spine_only" | "pelvic_native"
case.match_type       # str  — original placement: "fused" | "separate" |
                      #         "spine_only" | "pelvic_only"
case.lstv_label       # str  — "normal" | "sacralization" | "lumbarization" | "semi"
case.has_l6           # bool — True if L6 label present (lumbarization only)
case.n_lumbar_labels  # int  — number of lumbar classes present (1–6)
case.alignment_ok     # bool — CT/label affine alignment check passed
case.is_lstv          # bool — any LSTV phenotype
case.is_fused         # bool — full 10-class ground truth available
case.ct_path          # Path
case.label_path       # Path
case.qc_path          # Path | None  (None when qc/ not present)
case.exists()         # bool — both files present on disk

---

Filtering

# By export config
fused         = ds.filter(config="fused")          # full 10-class ground truth
spine_only    = ds.filter(config="spine_only")     # lumbar labels only
pelvic_native = ds.filter(config="pelvic_native")  # sacrum + hip labels only

# By original placement match_type
# "separate" = spine and pelvic placed on DIFFERENT CTs (prone/supine mismatch)
# These export as two entries sharing the same patient token
separate = ds.filter(match_type="separate")

# By LSTV phenotype
lstv          = ds.filter(lstv=True)
normal        = ds.filter(lstv=False)
sacralization = ds.filter(lstv_class="sacralization")
lumbarization = ds.filter(lstv_class="lumbarization")
semi          = ds.filter(lstv_class="semi")

# Combined filters
fused_lstv    = ds.filter(config="fused", lstv=True)
fused_sacral  = ds.filter(config="fused", lstv_class="sacralization")

# Patient position
supine = ds.filter(position="supine")
prone  = ds.filter(position="prone")

# Cases with L6 label (lumbarization)
has_l6 = ds.filter(has_l6=True)

# By patient token — returns all entries for one patient
patient_cases = ds.by_token("42")

# Exclude missing files (default: True)
present = ds.filter(config="fused", present_only=True)

---

Splits

Splits are 70/15/15 LSTV-stratified with a fixed random seed for reproducibility. Val and test contain fused cases only (full 10-class ground truth). Train contains fused + all partial cases.

train, val, test = ds.splits()

print(f"Train: {len(train)}  Val: {len(val)}  Test: {len(test)}")

# Inspect LSTV balance
from collections import Counter
print(Counter(c.lstv_label for c in test))

---

Training Integration

Phase 1 — Fused ground truth (full supervision)

from dataset_interface import CTSpinoPelvic1K, make_monai_datalist
from monai.data import CacheDataset, DataLoader
from monai.transforms import (
    Compose, LoadImaged, EnsureChannelFirstd,
    ScaleIntensityRanged, RandCropByPosNegLabeld,
    RandFlipd, RandRotate90d, ToTensord,
)

ds = CTSpinoPelvic1K.from_hub()
train, val, _ = ds.splits()

# MONAI datalist: {"image": str, "label": str, "weight": float, "meta": dict}
train_list = make_monai_datalist(train, pseudo_weight=1.0)

transforms = Compose([
    LoadImaged(keys=["image", "label"]),
    EnsureChannelFirstd(keys=["image", "label"]),
    ScaleIntensityRanged(
        keys=["image"], a_min=-175, a_max=250,
        b_min=0.0, b_max=1.0, clip=True,
    ),
    RandCropByPosNegLabeld(
        keys=["image", "label"],
        label_key="label", spatial_size=(96, 96, 96),
        pos=1, neg=1, num_samples=4,
    ),
    RandFlipd(keys=["image", "label"], prob=0.5, spatial_axis=0),
    RandRotate90d(keys=["image", "label"], prob=0.5, max_k=3),
    ToTensord(keys=["image", "label"]),
])

dataset    = CacheDataset(train_list, transform=transforms, cache_rate=0.1)
dataloader = DataLoader(dataset, batch_size=2, shuffle=True, num_workers=4)

Phase 2 — Curriculum with pseudo-label partials

In Phase 2, partial cases (spine_only, pelvic_native) are included with a reduced loss weight to provide soft supervision for their labelled classes while ignoring unlabelled regions.

from dataset_interface import CTSpinoPelvic1K, make_monai_datalist

ds = CTSpinoPelvic1K.from_hub()
train, val, _ = ds.splits()

# All cases: fused get weight=1.0, partials get weight=0.5
phase2_list = make_monai_datalist(ds.all(), pseudo_weight=0.5)

# Access per-sample weight in your loss function
for sample in dataloader:
    image  = sample["image"]   # (B, 1, P, I, R)
    label  = sample["label"]   # (B, 1, P, I, R)
    weight = sample["weight"]  # (B,) — 1.0 for fused, 0.5 for partials

    loss = criterion(pred, label)
    loss = (loss * weight.view(-1, 1, 1, 1, 1)).mean()
    loss.backward()

PyTorch Dataset (no MONAI)

from dataset_interface import CTSpinoPelvic1K, make_torch_dataset
import torch
from torch.utils.data import DataLoader

ds = CTSpinoPelvic1K.from_hub()
train, val, _ = ds.splits()

torch_ds = make_torch_dataset(train, pseudo_weight=0.5)
loader   = DataLoader(torch_ds, batch_size=2, shuffle=True, num_workers=4)

for batch in loader:
    image  = batch["image"]   # (B, 1, P, I, R) float32
    label  = batch["label"]   # (B, 1, P, I, R) int64
    weight = batch["weight"]  # (B,) float32
    meta   = batch["meta"]    # dict of per-sample metadata

Custom transforms

import torch
from monai.transforms import MapTransform

class MaskUnlabelledClasses(MapTransform):
    """
    Zero-out classes not present in a partial case before computing loss.
    Prevents the model from learning background for unlabelled regions.
    """
    def __call__(self, data):
        config = data["meta"]["config"]
        label  = data["label"]

        if config == "spine_only":
            # Mask out pelvic classes (7, 8, 9) — not labelled in this case
            label[(label == 7) | (label == 8) | (label == 9)] = 0
        elif config == "pelvic_native":
            # Mask out lumbar classes (1–6) — not labelled in this case
            label[(label >= 1) & (label <= 6)] = 0

        data["label"] = label
        return data

---

Evaluation

Evaluate a directory of predictions

from dataset_interface import (
    CTSpinoPelvic1K,
    evaluate_predictions,
    print_results_table,
)

ds = CTSpinoPelvic1K.from_hub()

# Evaluate on fused test set (ground truth)
_, _, test = ds.splits()
results = evaluate_predictions(ds, pred_dir="data/predictions", subset=test)
print_results_table(results)

Score a single case

from dataset_interface import score_case, junction_dice, CLASS_NAMES

dsc = score_case(
    pred_path="data/predictions/0001_supine_label.nii.gz",
    gt_path="data/ctspinopelvic1k/labels/0001_supine_label.nii.gz",
)

for cls_id, dice in sorted(dsc.items()):
    print(f"  {CLASS_NAMES[cls_id]:12s}  Dice={dice:.3f}")

# L5/S1 junction Dice (±40mm window)
jxn = junction_dice(
    pred_path="data/predictions/0001_supine_label.nii.gz",
    gt_path="data/ctspinopelvic1k/labels/0001_supine_label.nii.gz",
    window_mm=40.0,
)
print(f"Junction DSC: {jxn}")

---

Dataset Statistics

Property	Value
Total CT volumes	1,194
Fused (full 10-class)	338
Spine-only	450
Pelvic-native	376
Unique patients	804
LSTV cases	53 (6.6%)
Sacralization	28
Lumbarization	22
Semi-sacralization	3
Alignment failures	0
Train / Val / Test	236 fused + partials / 51 / 51

---

Data Construction

CTSpinoPelvic1K was constructed from three public TCIA datasets:

Source	Cohort	Cases	Content
CTSpine1K	COLONOG	784	Lumbar vertebrae (VerSe IDs 20–26)
CTPelvic1K	COLONOG	714	Sacrum + bilateral hips (4-class)
TCIA COLONOG	—	825	Reference CT DICOM series

Matching pipeline:

1. Each mask is matched to the TCIA DICOM series maximising bone coverage (HU > 200) under the placed label, via world-space affine resampling across all intrapatient candidate series.
2. Fused cases (spine + pelvic on same CT) produce a single 10-class label. Separate cases (different CTs, typically prone vs. supine) export as two independent entries.
3. All label maps are remapped to 10-class, reoriented to PIR, and stripped of PHI.

Label merge priority: Pelvic sacrum/hips written first; lumbar L1–L6 overwrite; spine sacrum fills remaining background only.

---

Separate Cases (Prone/Supine Mismatch)

match_type="separate" cases are patients whose spine and pelvic masks were registered to different CT acquisitions of the same patient. These export as two entries sharing the same token:

tok = list({c.token for c in ds.filter(match_type="separate")})[0]
for case in ds.by_token(tok):
    print(f"  {case.config:20s}  pos={case.position}  n_labels={case.n_lumbar_labels}")
# →   spine_only           pos=prone    n_labels=5
# →   pelvic_native        pos=supine   n_labels=0

---

Manifest Fields

manifest.json is a list of records, one per exported CT volume:

{
  "token":           "42",
  "position":        "supine",
  "config":          "fused",
  "match_type":      "fused",
  "lstv_label":      "sacralization",
  "has_l6":          false,
  "n_lumbar_labels": 5,
  "alignment_ok":    true,
  "ct_file":         "0042_supine_ct.nii.gz",
  "label_file":      "0042_supine_label.nii.gz",
  "qc_file":         "0042_supine_qc.png"
}

---

Licence and Attribution

This dataset is released under CC BY-NC 4.0 (non-commercial research use).

Derived from:

• CTSpine1K — Liu et al., 2021 (ar5iv), CC BY 3.0
• CTPelvic1K — Liu et al., 2021 (ar5iv), CC BY 3.0
• TCIA COLONOG — Clark et al., 2013 (DOI), CC BY 3.0

If you use CTSpinoPelvic1K in your research, please cite:

@dataset{ctspinopelvic1k_2026,
  title     = {{CTSpinoPelvic1K}: A CT-Native Benchmark for Lumbosacral
               Transitional Vertebra Segmentation via Patient-Anchored,
               Registration-Free Multi-Dataset Label Fusion},
  author    = {Anonymous},
  year      = {2026},
  publisher = {HuggingFace},
  url       = {https://huggingface.co/datasets/anonymous-mlhc/CTSpinoPelvic1K}
}

@article{liu2021ctspine1k,
  title  = {{CTSpine1K}: A Large-Scale Dataset for Spinal Vertebrae
            Segmentation in Diverse {CT} Scenarios},
  author = {Liu, Yang and others},
  year   = {2021},
  note   = {ar5iv: https://ar5iv.labs.arxiv.org/html/2105.14711}
}

@article{liu2021ctpelvic1k,
  title  = {{CTPelvic1K}: A Large-Scale Benchmark for Pelvic Bone
            Segmentation in {CT} Images},
  author = {Liu, Yang and others},
  year   = {2021},
  note   = {ar5iv: https://ar5iv.labs.arxiv.org/html/2012.08721}
}

---

Known Issues

• Token 85 — degenerate dcm2niix output (2-slice localizer series), excluded.
• 89 cases carry lstv_label="unknown" from the CTPelvic1K source annotation (annotator could not determine LSTV status). Treated as normal for training; excluded from LSTV subgroup evaluation.
• LSTV classification is derived from CTPelvic1K filename metadata and has not been independently verified by a radiologist for all cases. Use lstv_label as a weakly supervised signal, not a ground truth clinical diagnosis.

---

Contact

Dataset curation: anonymous submission. For issues, open a discussion on the HuggingFace repository page.