cubert-gmbh/XMR_Industrial_Foreign_Object_Detection_Lentils

Hyperspectral Foreign-Object Detection in Lentils — Full Dataset

The larger counterpart to the small tutorial demo at cubert-gmbh/XMR_Demo_Industrial_Foreign_Object_Detection_Lentils. Captured with a Cubert Ultris XMR camera — 61 bands per pixel, 430–910 nm, 1080 × 1000 pixels. Three acquisition days, 15 merged .cu3s capture sessions, 1,136 frames total, 696 frames with pixel-level COCO annotations across 7 foreign-object classes.

Foreign-object detection in food sorting is an industrial-inspection problem — the rejected target could be a stone, a stem, a piece of packaging, a metal shard, or an insect. In this dataset the bulk product is bag-grade lentils (Emershofer Beluga and dark green marbled). Contaminants span seven classes (stem_k, stone, alu_shard, blue_paper, white_paper, fly, rubber). The same hyperspectral pipeline carries over to any product whose foreign objects differ spectrally from the bulk — even when they look near-identical in visible RGB.

Summary

Total frames	1,136
Annotated frames	696 (61.3 %)
Annotated foreign-object regions	1,536
Hyperspectral cubes (merged .cu3s files)	15
Spectral resolution	61 bands · 430–910 nm · ≈8 nm spacing
Spatial resolution	1080 × 1000
Processing mode	Reflectance (55 % gray reference + dark reference)
Splits	train 808 · val 148 · test 180 (71.1 / 13.0 / 15.8 %)
Total size on disk	~57 GB
License	Apache-2.0

Per-day breakdown

Day	Capture date	Subfolders	Frames	Annotated	Foreign-object regions
day2	2026-03-03	6	384	188	368
day3	2026-03-10	6	492	328	648
day4	2026-03-17	3	260	180	520
Total		15	1,136	696	1,536

Foreign-object classes

id	name	object count
0	Unlabeled	(background / normal lentils + belt)
1	stem_k	288
2	stone	516
3	alu_shard	112
4	blue_paper	80
5	white_paper	60
6	fly	420
7	rubber	60

Class id 0 (Unlabeled) is the implicit background. Five subfolders are normal/background captures (no foreign objects); their frames appear in splits.csv with has_annotation=0 and contribute to the splits as normal-class examples for SSL / unsupervised methods.

Why hyperspectral

An RGB sensor collapses incoming light into three bands; the human eye does the same. Hyperspectral video records 61 continuous bands per pixel, per frame — a material fingerprint that separates dyes, fabrics, coatings, pigments, organic-vs-mineral matter, and surface chemistry.

Foreign objects that are colour-matched to the bulk product (small stones in brown lentils, aluminium shards under warm lighting) are often near-isoluminant in visible RGB. They typically reveal themselves in the near-infrared (different surface scattering, different moisture content) or in narrow visible bands the eye can't resolve.

The three views below show the same frame rendered through three 3-channel projections of the 61-band cube (per-channel min-max, uint8). Bands chosen with cuvis_ai.node.channel_selector classes FixedWavelengthSelector (defaults 650 / 550 / 450 nm) and CIRSelector (defaults NIR=860, R=670, G=560 nm).

Example frames

All examples were rendered by downloading the .cu3s + .json from this dataset on Hugging Face, applying cuvis.ProcessingContext(sf).processing_mode = ProcessingMode.Reflectance, picking the canonical band indices via cuvis_ai's FixedWavelengthSelector (RGB) and CIRSelector (CIR), min-max-normalising each channel to [0, 255] and saving as PNG.

Train · 1 foreign object (stone)

data/day3/2026_03_10_10-58-55.cu3s · image_id=0 · split=train · 1 annotation (stone)

RGB composite	RGB + annotation	CIR composite	CIR + annotation

Train · 3 foreign objects (alu_shard + fly + stone)

data/day4/2026_03_17_11-41-54.cu3s · image_id=40 · split=train · 3 annotations

RGB composite	RGB + annotations	CIR composite	CIR + annotations

Train · normal / background (no foreign objects)

data/day2/2026_03_03_11-11-01.cu3s · image_id=0 · split=train · 0 annotations

RGB composite	CIR composite

Split-loader sanity check

Verified by downloading the cu3s via huggingface_hub, opening with cuvis.SessionFile, and asserting get_measurement(splits.local_image_id).name matches the camera_name predicted by splits.csv:

split	cu3s	local_image_id	expected	got	ok
train	data/day2/2026_03_03_11-11-01.cu3s	0	Auto_000_4261	Auto_000_4261	✅
val	data/day2/2026_03_03_11-31-31.cu3s	14	Auto_000_1339	Auto_000_1339	✅
test	data/day3/2026_03_10_10-58-55.cu3s	12	Auto_000_1370	Auto_000_1370	✅

Polygon-bounds sanity: every annotation polygon vertex in the loaded frames lies inside (0..1080, 0..1000). See splits_verification.md for the full seven-check audit (coverage, per-day, per-subfolder, annotation equivalence, split distribution, no-group-leakage, physical round-trip).

Acquisition setup

• Camera: Cubert Ultris XMR hyperspectral, operated through Cuvis Next
• Illumination: 4 halogen lamps in 4 configurations (l0–l3) per scene arrangement
• Background: blue FDA-compliant conveyor-belt material (belt stationary during capture)
• Field of view: ≈12.5 × 12 cm at 46.6 cm working distance
• Exposure: 15 ms
• White reference: 55 % gray target; dark reference acquired by covering the lens
• Lentils: Emershofer Beluga and Emershofer dark green marbled

For each scene arrangement, four captures under different lighting conditions form a grouped unit (group_id in splits.csv). All four images of a group are always kept in the same train / val / test split to prevent lighting-only information leakage.

The setup is a lab proof-of-concept with production-relevant design elements, not a full production deployment study. See the whitepaper PDF for the full acquisition protocol, method comparison (RGB AdaCLIP / finetuned AdaCLIP / Dinomaly

• custom selector), and limitations discussion.

Repository layout

README.md
LICENSE                                 (Apache-2.0)
.gitattributes                          (LFS for *.cu3s)
splits.csv                              # primary split file — 1 row per saved frame
splits_verification.md                  # proof that splits.csv mirrors the asai2 reference
annotations_canonical/                  # reference: per-day concatenated COCO (time-ordered global ids)
  day{2,3,4}_global_coco.json
assets/
  examples/                             # rendered example frames (see Example frames above)
whitepaper/
  lentils_hsi_whitepaper.pdf            # full whitepaper PDF
  lentils_hsi_whitepaper.md             # markdown source
data/
  day2/
    <subfolder>.cu3s                    # merged hyperspectral cube (capture session)
    <subfolder>.info                    # sensor sidecar (frame indexing)
    <subfolder>.json                    # per-cu3s COCO annotations (image_ids are local 0..N-1)
    <subfolder>_README.md               # data log for this capture session
    …                                   # 6 subfolders for day2
  day3/                                 # 6 subfolders for day3
  day4/                                 # 3 subfolders for day4

<subfolder> is the capture-session timestamp YYYY_MM_DD_HH-MM-SS (with _1/_2 suffix when the camera was restarted at the same wall-clock second).

Per-<subfolder>.json COCO schema

Standard COCO with extra per-image fields for hyperspectral and traceability:

{
  "info": { "subfolder": "…", "day": "…", "frame_count": N, "annotation_count": M },
  "categories": [ { "id": 0..7, "name": "Unlabeled|stem_k|…|rubber" } ],
  "images": [
    {
      "id": <local_image_id>,           // 0..N-1, matches index inside the .cu3s
      "file_name": "<subfolder>.cu3s",
      "width": 1080, "height": 1000,
      "global_frame_id": <int>,         // 0..(day_total-1) — keys to splits.csv & canonical day COCO
      "camera_frame_num": <int>,        // raw camera frame counter (matches `.info`)
      "camera_name": "Auto_000_<n>"
    }
  ],
  "annotations": [
    { "id": …, "image_id": <local_image_id>, "category_id": 1..7,
      "bbox": [x, y, w, h], "segmentation": [[…polygon…]],
      "iscrowd": 0, "area": 0.0, "mask": {"counts": [], "size": []}, "auxiliary": {} }
  ]
}

Annotations are semantic masks, not instance-level. Individual objects of the same class in the same frame share a polygon contour, not separate instance ids.

splits.csv columns

column	meaning
day	day2 / day3 / day4
subfolder	capture-session timestamp
cu3s_path	path inside this repo, e.g. data/day2/2026_03_03_13-58-04_2.cu3s
json_path	matching per-cu3s COCO path
local_image_id	0..N-1 inside the merged .cu3s
global_image_id	0..(day_total-1), in time order across the whole day — join key to annotations_canonical/day*_global_coco.json
camera_frame_num	raw camera frame counter (matches .info)
camera_name	Auto_000_<n> — single-cu3s identifier used by the original stratified split
split	train / val / test
group_id	4-frame lighting-quad group; all 4 frames of a group share one split
group_index	0..3, position inside the lighting quad
has_annotation	1 if the frame contains any foreign-object annotation, else 0
category_labels	semicolon-separated category ids present in the frame (empty for normal frames)

Splits

split	frames	annotated	normal/background
train	808	500	308
val	148	84	64
test	180	112	68

The split was originally generated on the single-cu3s form of the data using stratified group-aware splitting (lighting quads kept intact, category balance preserved across splits). splits.csv in this repo remaps each single-cu3s row to its position inside the corresponding merged .cu3s. See splits_verification.md for the seven-check audit proving this remapping is bit-faithful.

How to load

List the test set

import csv
from huggingface_hub import hf_hub_download

splits_csv = hf_hub_download(
    repo_id="cubert-gmbh/XMR_Industrial_Foreign_Object_Detection_Lentils",
    repo_type="dataset",
    filename="splits.csv",
)
with open(splits_csv) as f:
    test_rows = [r for r in csv.DictReader(f) if r["split"] == "test"]
print(len(test_rows), "test frames")

Stream one cu3s + annotations and render an RGB composite

from huggingface_hub import hf_hub_download
import json, cuvis, numpy as np
from PIL import Image

repo = "cubert-gmbh/XMR_Industrial_Foreign_Object_Detection_Lentils"
sub  = "data/day4/2026_03_17_11-11-50"

cu3s = hf_hub_download(repo_id=repo, repo_type="dataset", filename=f"{sub}.cu3s")
js   = hf_hub_download(repo_id=repo, repo_type="dataset", filename=f"{sub}.json")

cuvis.init()  # or cuvis.init("/path/to/cuvis/user/settings")
sf = cuvis.SessionFile(cu3s)
m  = sf.get_measurement(0)

# Cubes are stored in Preview mode; convert to Reflectance for analysis:
ctx = cuvis.ProcessingContext(sf)
ctx.processing_mode = cuvis.ProcessingMode.Reflectance
ctx.apply(m)

cube = m.cube.array         # shape (1000, 1080, 61), dtype uint16
wl   = list(m.cube.wavelength)  # 430..910 nm

# RGB composite (FixedWavelengthSelector defaults — 650 / 550 / 450 nm)
RGB = (650, 550, 450)
idx = [int(np.argmin(np.abs(np.asarray(wl) - t))) for t in RGB]
sel = cube[..., idx].astype(np.float32)
u8  = np.zeros_like(sel, dtype=np.uint8)
for c in range(3):
    lo, hi = np.percentile(sel[..., c], (0.5, 99.5))
    u8[..., c] = (np.clip((sel[..., c] - lo) / max(hi - lo, 1e-6), 0, 1) * 255).astype(np.uint8)
Image.fromarray(u8, "RGB").save("frame_rgb.png")

anns = json.load(open(js))
print("frames:", len(anns["images"]), "annotations:", len(anns["annotations"]))

Mirror everything to a local directory

huggingface-cli download \
  cubert-gmbh/XMR_Industrial_Foreign_Object_Detection_Lentils \
  --repo-type=dataset \
  --local-dir=./lentils_full

Or programmatically with huggingface_hub.snapshot_download(...) using allow_patterns= to fetch only specific days / files.

Citation

@techreport{raj2026lentilshsi,
  title  = {Spectral Foreign Object Detection in Lentils Using a Compact Hyperspectral Channel Selector},
  author = {Raj, Anish},
  institution = {Cubert GmbH},
  year   = {2026},
  note   = {Whitepaper, May 2026},
  url    = {https://huggingface.co/datasets/cubert-gmbh/XMR_Industrial_Foreign_Object_Detection_Lentils/resolve/main/whitepaper/lentils_hsi_whitepaper.pdf}
}

License

Released under the Apache License 2.0 — see LICENSE. Matches the licensing of other Cubert public datasets on Hugging Face.

Contact

Recorded and processed by the AI Team @ Cubert. Reach out for collaboration, evaluation pilots, or to discuss running this methodology on your own product line.

• Author: Anish Raj — raj@cubert-gmbh.de
• Team: cuvis.ai@cubert-gmbh.de