ChangChrisLiu/E3D-Desktop-Disassembly

E3D: End-of-Life Desktop Disassembly Dataset

66 end-of-life business desktop PCs taken apart by hand, one step at a time, photographed after every step from four cameras and filmed from two. For every step the dataset gives the pictures; instance masks of every part (visible and amodal), with states, layer order and relations; the precedence constraints between parts; template-generated vision–language questions with checkable answers; and face-masked video clips of the hands doing the step.

Status (5 November 2026): pre-release; the annotation is sealed. The final data version is the sealed v7 snapshot (v4 re-paired the RAM latches from the masks; v5 applied the owner's precedence rulings — fan leads, card latches, loose parts, dynamic occlusion —; v6 re-confirmed D07 frames 1–4 and D63 frame 1; v7 added the owner's D09 re-check; 0 open conflicts, every scanner frame verified). The scanner annotations and the components gallery were updated from v7 by re-exporting only the changed desktops, and the VLM pack was rebuilt from v7 in a final round (§2). Every component is uploaded and checked against its manifest. A licence and a citation are added with the first tagged release; until then the data is provided for inspection and research evaluation — please do not redistribute copies or train models for release on it before then without permission (the same text is in each folder's LICENSE_NOTE.txt).

New here, or an AI agent continuing the work? Read HANDOFF.md — the complete, self-contained guide: the research goal, the data model, every folder, how the data was made, what to run next and the rules (Chinese companion: docs/handoff_agent_zh.md).

At a glance

component	folder	size	contents
Raw captures	raw/	≈ 382 GB	scanner, 2 × OAK-D Pro, RealSense — every step of all 66 desktops, folders exactly as the capture rigs wrote them
Scanner annotations (sealed release, 2026-11-02; updated from the final seal v7)	annotations/scanner/	9.5 GB	2 800 frames (each with its picture) · 3 217 parts · 84 225 mask annotations (54 872 clean) · relations, states, step sequence · per-part 3D extraction kit
Components gallery	annotations/components/	0.26 GB	the parts laid out after the teardown: 59 scanner shots (D01–D17) + 5 OAK / RealSense shots (D01) · 626 mask annotations, part ids shared with the scanner annotations
VLM evaluation pack (final round, from v7)	vlm/vlmpack_2026-11-05/	31.8 GB	184 263 QA items in per-camera perception units + a multi-view action unit · a frozen 5 347-item evaluation subset (eval_v3) with its 8 551 images · reasoning chains for training · scorer, references, audit sheets, model driver
Closed-model run kit (Codex)	vlm/closed_model_run_2026-11-05/	2.1 GB	items.jsonl (the 300 audit items' exact prompts), the 984 marked images, the chat requests and score_all.py
Level-1 benchmark kit	benchmarks/level1/	—	detection / instance segmentation on the scanner view: COCO train / val / test builder (48 / 6 / 12 desktops), pycocotools scorer (AP over IoU 0.50:0.95, AP50, per class, by occlusion), YOLO11n-seg and Mask R-CNN v2 baselines, Slurm templates
Face-masked work videos	video/hand_work_selected/	140 GB	3 179 paired clips (video camera 1 + video camera 2, two Logitech webcams), 11.1 h, desktops 02–65
Taxonomy	taxonomy.yaml	—	25 part classes with attributes, states and verbs
Handoff	HANDOFF.md, docs/	—	repository layout, how each release was made, the complete project handoff

The scanner annotations, the components gallery and the VLM pack are exports of the same sealed annotation database (sealed 2 November 2026; the final snapshot is v7), so their part keys, steps and states agree. On D63 the v7 update adds the loose instance cover.06 (a broken slot-cover piece) and shifts the instance ids after it by one: join on key, not on ids from an older copy.

Sizes are decimal (1 GB = 10⁹ bytes).

The capture

66 desktops — Dell OptiPlex / Precision, HP Compaq / EliteDesk / ProDesk / Z, one Lenovo, one Apple G4, one custom build; small-form-factor and tower cases — disassembled at Texas A&M University in May–June 2025, 2 814 steps in total (2 800 of them with a scanner picture). After every step:

view	camera	image
scanner	structured-light scanner, top-down	1600 × 1600 PNG, a burst of up to 10 exposures per step (P_0 … P_9); the main view — sharpest, no operator in the way
oak Camera_1	OAK-D Pro, near top-down	12 MP JPEG + aligned 1280 × 800 PNG + depth (NPY / PNG) + point cloud
oak Camera_2	OAK-D Pro, oblique	as Camera_1; the operator is sometimes in view
realsense	Intel RealSense, oblique	1280 × 720 colour + depth + point cloud

Each desktop also has components shots (the removed parts laid out on the bench) from every camera. A capture log names, per step, the part acted on and the action.

Step numbering. S<nn> / step nn: S01 is the untouched machine; every other picture is taken after that step's action (on S05 the part removed at step 5 is already gone). Capture-folder numbers and step numbers are not always the same (duplicate shots, a few missed shots); annotations/scanner/D<NN>/frames.json maps every step to its raw file.

1. Scanner annotations — annotations/scanner/

Every scanner frame of all 66 desktops, annotated and confirmed by a human annotator, with no open conflict (on 3 frames — 2 of D02, 1 of D17 — masks corrected on that frame only overlap, 58 517 px in all; the label map resolves it). Only the scanner view is annotated; OAK and RealSense pictures are raw.

annotations/scanner/
  README.md                    every field, in detail (written by the exporter)
  LICENSE_NOTE.txt             the pre-release terms above
  manifest.json                counts; size and sha256 of every file in the folder
  clean_parts.csv              every (frame, part) annotation where the part is not covered at all
  HOW_TO_EXTRACT_3D_PARTS.md   taking each part's 3D points out of a scanner reconstruction (section 1b)
  parts_3d_plan.csv            per part: route, best frame, leaving frames, raw picture path
  tools/parts3d.py             plan / where / extract / diff — numpy + Pillow only
  D<NN>/
    images/S<nn>.png           the scanner picture the masks were drawn on (the raw file, byte for byte)
    labels/S<nn>.png           16-bit instance-id map of the visible masks (0 = background; ids per desktop)
    annotations.json           COCO, one annotation per (frame, part)
    instances.json             the parts: id, key, class, attributes, relations, states per step, leaving step
    frames.json                per step: raw source file and its sha256, ROI, pose segment, step name and actions
    sequence.json              the step table and each part's state timeline
    notes.json                 the annotator's notes on some frames (where there are any)

What a mask means. Every part has an amodal shape (the whole part, hidden pixels included) and a place in the layer order; its visible mask is the shape minus everything above it. The layer order follows the physical stacking as the disassembly order shows it (the CPU socket frame above the CPU, covers above what they hide, the HP optical bracket above the board-side parts under it). Per frame each part carries a state (installed / loosened / open / displaced / removed …) and a visibility label (visible, visible_tiny, too_small, occluded_partial, occluded_full, out_of_view; with the occluder cable or viewpoint when the annotator says so).

COCO fields (annotations.json): visible segmentation, bbox, area; amodal_segmentation, amodal_bbox, amodal_area; visibility, occlusion_ratio (= 1 − area / amodal area), occluders (who takes the hidden pixels, from the label map), occluded_unlabelled_px, shared_px, label_px, clean, iscrowd (1 = present but fully covered, empty mask); attributes carry the instance key, state, placement and the confirmed values.

clean means the part is not covered at all on that frame: visible mask = amodal shape, label visible, inside the ROI, every pixel its own in the label map, no pixel shared with another mask. 54 941 annotations are clean.

Relations and constraints. instances.json gives each part's parent / attached / mounted on / fastens / socket host / cable, its leaving step (removed, displaced or changed, with the frames before and after), and its state per step.

Conventions.

• Unplugged connectors are not drawn (from the step a connector is unplugged it has no mask); a connector hidden by cables carries visibility = occluded_full with occluder cable.
• An optical drive that is never taken out — installed to the end, or only opened / pushed out (33 desktops: D22–D34, D37–D41, D43, D48, D52–D57, D59–D62, D64–D66) — is one instance drive_cage with attrs.of = optical together with its bracket (questions: "the optical drive cage"); a drive the log takes out is optical_drive (28 desktops).
• attrs.two_ended marks a plug whose cable is detachable at both ends (the HP drive-end plugs on D23–D27, which ride on the optical bracket); attrs.stops / attrs.in_gallery mark the last motherboard screw on the 20 Dell desktops with a drive-cage latch, which doubles as the latch's stop screw.
• screw_hole (35 instances, 7 desktops) is the hole a removed fan screw leaves — a detection class, not a part.

Changes in round 3 (2026-11-02) — the annotator's check round: 67 picture-based rulings on which part blocks which (new covered_by edges and not_blocks rulings; an unplugged connector counts as out of the way); layer order corrected wherever it contradicted the disassembly order (the CPU socket frame on all 65 desktops with both, Dell screw covers and expansion-slot covers, the Dell fan shroud, the HP optical bracket); the two drive-end SATA plugs on D23–D27; the latch stop screws; every within-tolerance stale row re-signed before the export.

1b. Each part's 3D points

The masks select each part's points in a 3D reconstruction of the same scanner frame. Read annotations/scanner/HOW_TO_EXTRACT_3D_PARTS.md (Chinese summary first, then the full English). In short:

1. The frame's picture is D<NN>/images/S<nn>.png. If your reconstruction gives, for each 3D point, the pixel of that picture it came from (an organized cloud cloud[y, x], or a depth map registered to it), the points of a part are the points under labels/S<nn>.png == instance_id. An unorganized cloud is projected into the picture with the scanner calibration first (nearest point per pixel).

2. parts_3d_plan.csv says, for every one of the 3 216 parts, which route to take and on which frame:

   route	parts	how
   clean	2 801	on best_frame nothing covers it: take the points under its pixels
   diff	270	never fully uncovered (heatsinks under fans, motherboards under everything): take the points that are on before_frame inside its amodal outline and gone on after_frame (same camera pose)
   visible	111	never uncovered, no same-pose leaving pair (the chassis 58, connectors that stay partly hidden 41, a few parts whose leaving crosses a pose change 12): visible pixels only
   none	34	covered on every frame: no points from this view

3. tools/parts3d.py extract writes one PLY per part from an organized cloud; tools/parts3d.py diff does route 2. Parts that leave together (left_with), displaced parts and pose changes are explained in the guide.

1c. Components gallery — annotations/components/

After each desktop was taken apart its parts were laid out on the table and photographed by every camera ("all components" shots, raw/scanner/*/*_allcompoentsrgb/, raw/oak/Desktop NN/Components/, RealSense Components). They are not teardown steps: each part is drawn on them on its own, so a part can be recognised out of the machine as well as inside it. Annotated and confirmed: the scanner shots of D01–D17 (59 shots, 591 annotations) and the OAK camera 1 / 2 and RealSense shots of D01 (5 shots, 35 annotations); the shots of the other desktops are not annotated.

annotations/components/
  README.md, LICENSE_NOTE.txt, manifest.json
  <view>/D<NN>/                 view = cmp_scan | cmp_oak1 | cmp_oak2 | cmp_rs
    images/C<shot>.<ext>        the picture the masks were drawn on (the raw file, byte for byte)
    labels/C<shot>.png          16-bit instance-id map of the confirmed visible masks
    annotations.json            COCO (RLE masks + amodal); each image's extra.hf_path = the same file under raw/
    instances.json              per part: id, key, class, attrs, in_sequence

A part's instance_id is the id annotations/scanner/D<NN>/instances.json gives the same key, so the gallery masks join the teardown masks on (desktop, instance_id).

2. VLM evaluation pack — vlm/vlmpack_2026-11-05/

Question–answer items generated by rule from the annotations and the precedence graph, each with a strict JSON answer format, evidence boxes, a truth source and a reasoning chain. Rebuilt in a final round from the final sealed v7 snapshot (evaluation subset eval_v3, chat format chat-v5). The earlier pack vlm/vlmpack_2026-11-02/ (eval_v2) is superseded and has been removed.

What the truth rests on. Disassembly is treated as an AND/OR graph: the logged order is one valid path, actions of one interchangeable kind (connectors, RAM latches, the screws of one part) have no order among themselves, and an action is doable when its preconditions are met and its part is visible. The preconditions are the owner's general precedence rules of desktop disassembly (the cooler after its screws and fan lead, RAM modules after their latches, the CPU after the socket lever, expansion cards after the case card latch, everything mounted on the board before the board, …), dynamic occlusion (a part lying above another and covering at least 20 % of it comes first; cables, a drive cage over a plug and brackets that never move do not count; listed exceptions) and loose parts first (parts lying loose in the machine are taken out before anything else). One desktop taken apart several parts at a time (D66) has no step-wise tasks. No question, option, answer or reasoning names a part by an ordinal.

group	code	images	asks	graded by
Perception	V1 Enumeration	one camera	list the visible parts with class and box	class-aware F1 at IoU ≥ 0.5; COCO-style average over IoU 0.50:0.05:0.95 (f1_50_95)
Perception	V8 Grounding	one camera	where is the named part	hit at IoU ≥ 0.5; COCO-style average (hit_50_95)
Perception	V2 State	one camera	what state is this part in — or cannot_tell ("cannot tell from this image"; the right answer for a hidden part); Screw count form: how many screws of a role are left	exact match; counts exact = 1, off by one = 0.8
Perception	V15 Cross-view	two cameras	were the two pictures taken at the same moment	accuracy
Understanding	V3 Action	every camera, before and after (≤ 8)	what was just done: free form (also give the change region), with a yellow dashed hint box, or over 2–3 steps (which actions were carried out)	verb + the part acted on; region IoU / hit as extra metrics; span form: F1 over action groups
Understanding	V12 State change	every camera, before and after (≤ 8)	did anything change: adjacent steps and 2- / 3-step spans, no-change pairs included	accuracy
Understanding	V10 Progress	every camera	what has been done, how far along	done / started F1, progress bin
Planning	V4 Feasibility	the scanner image, parts outlined	can this action be done now; if not, what has to be dealt with first (visible reasons, e.g. a covering part or a loose part)	feasible accuracy; blockers F1
Planning	V6 Next action	every camera, no outlines	open: list every action doable now; multiple choice (one verb, exactly one option possible); with an extra rule in words	open / constrained: precision / recall / F1 over the groups of doable actions (+ constraint_violation); choice: accuracy
Planning	V7 Plan	the outlined scanner image (every camera when the CPU is out of sight)	the plan to take out a target part, free (gold = the shortest rule-legal plan) or under a rule in words	validity, goal reached, recall of the required steps; constrained also count_exact / count_abs_error for the plugs
Planning	V16 Plan check	the outlined scanner image	can this sequence (up to five steps) be carried out; the first step that cannot	validity accuracy; first error — from a step-by-step replay under the rules

Replies are parsed strictly (one JSON object) and leniently, and both parse-failure rates are reported. Every box answer is scored in the frame of the image sent and in that frame × 1.25 (a model's internally resized frame), the better kept and the winning frame recorded, for every model. Scores carry 95 % intervals from a cluster bootstrap over desktops and stand beside reference lines: chance, the most frequent train answer, the question without its picture (blind), a protocol prior from the previous action, a state-table oracle and a ground-truth mask overlay.

The camera units hold the perception tasks (V1 V2 V8 V15), the multi unit the action tasks (V3 V4 V6 V7 V10 V12 V16), one record per moment; the truth of a multi record is read off the annotated scanner frame and the other cameras are shown, not read (rs has no items of its own; its pictures appear in multi).

unit	items	tasks (forms)
scan (scanner)	81 388	V1 2 790 · V2 34 236 (state 30 730, cannot_tell 712, count 2 794) · V8 29 068 (single 15 877, set 13 191) · V15 15 294
oak1 (OAK Camera_1)	10 393	V1 14 · V2 113 · V8 78 · V15 10 188
oak2 (OAK Camera_2)	5 068	V15 5 068
multi (action tasks)	87 414	V3 6 587 (free 2 331, roi 2 331, span 1 925) · V4 38 488 · V6 4 901 (open 2 412, choice 1 380, constrained 1 109) · V7 13 938 (free 7 186, constrained 6 752) · V10 2 641 · V12 7 947 (1, 2 and 3 steps apart: 2 708, 2 652, 2 587) · V16 12 912 (valid 6 600, invalid 6 312)

Gold answers score 1.0 on all 184 263 items; an independent re-derivation agrees on all of them and the invariant checks find 0 violations. Text-only shortcuts on eval_v3 stay near the majority answer (e.g. V4 0.5525 vs 0.5225, V16 0.63 vs 0.5).

vlm/vlmpack_2026-11-05/
  README.md, LICENSE_NOTE.txt, manifest.json   the pack's own card, terms, sha256 of every file
  data/vlm_<unit>.jsonl (+ .images_manifest / .oracle / .summary / .masks)   every item of each unit
  eval_v3/   the frozen evaluation subset: 5 347 items (scan 1 097, oak1 137, oak2 66, multi 4 047; 300–600 per
                    task, no desktop above 20 % of a task, seed 0, byte-for-byte reproducible); table.md; audit/ =
                    the 300-item author-audit sample (64 desktops, about 19 per task / form) with fillable review
                    pages (the model's view first, the reviewer layer behind a toggle)
  reasoning/<unit>.jsonl   {id, task, question, answer, reasoning}: the gold answers' reasoning chains in visible
                    physical reasons — for training only, never shown to a model under test
  images/           the 8 551 pictures the subset needs (23.9 GB)
  overlays/         the subset's scanner pictures with the confirmed masks painted (the GT-mask reference)
  tools/            scorer, format converters, references, audit sheets, self-check; tools/vlm_run/ = model driver
                    (OpenAI-compatible APIs, vLLM, transformers) + Slurm templates; runs without the annotation tool
  docs/vlm_run_hprc.md   step-by-step guide for running the evaluation on a Slurm cluster

The self-check (gold answers through the scorer) gives 1.0 on every task, also in a fresh environment without the annotation tool. No model has been run on this pack yet. The open models answer the whole evaluation subset; a closed model (GPT-6, thinking effort Medium, through Codex, one isolated session per item) answers only the 300 audit items, which the owner also audits. How to run everything: HANDOFF.md §7–§8.

3. Videos — video/hand_work_selected/

The disassembly sessions cut down to the moments the hands actually work on the machine, from the two synchronised video cameras (video camera 1 and video camera 2: two Logitech webcams at an angle from two sides — not the OAK / RealSense cameras of raw/), 30 fps, no audio, cropped to the workspace. Faces are masked in every frame (burned in); the unmasked room recordings are not published.

video/hand_work_selected/
  README.md                    English description (README.txt: the original Chinese note)
  desktop_NN/video_camera_1.mp4, video_camera_2.mp4   per desktop, the montage of all kept segments (equal frame counts)
  desktop_NN/clips/NNNN_video_camera_1.mp4, NNNN_video_camera_2.mp4   the paired segments one by one
  desktop_NN/selected_segments.csv             that desktop's segments
  all_selected_segments.csv    all 3 179 segments: original-video times for both cameras, frames, duration, step label
  uncertain_segments.csv       80 candidates left out
  index.html                   a local viewer that plays the two cameras side by side
  summary.json, final_audit.json, verification.json   counts, the delivery audit and per-desktop checks

Selection: removal, installation, handling tools and parts — not repositioning the machine, photo / scan preparation or waiting; reviewed by sampling, not frame by frame. Step labels refer to the capture log (the same steps as annotations/scanner/*/sequence.json): the scanner frame of a step shows the state after the action, the clip shows the action itself.

4. Raw captures — raw/

raw/scanner/<batch>/<batch>/<NN>/RGB<n>1/P_0..P_9.png      scanner captures of desktop NN (n = capture number)
raw/scanner/<batch>/<batch>_allcompoentsrgb/...             scanner all-components scans
raw/oak/Desktop NN/{Disassemble,Components,Side view,Calibration}/Camera_1|2/NNN/
raw/realsense/Desktop NN/

Folders are kept exactly as the capture rigs wrote them (including the original spelling allcompoents). The scanner picture of an annotated frame is raw/scanner/<source_folder without the leading "UGA DATA/">/<file_name> from frames.json, and annotations/scanner/D<NN>/images/S<nn>.png is the same file.

Repository layout

README.md                  this card
HANDOFF.md                 start here: the complete guide (goal, data model, every folder, next steps, rules)
splits.json                platform-disjoint split (12 test / 54 train) and per-desktop models and counts
taxonomy.yaml              part taxonomy, states and verbs
raw/                       section 4
annotations/scanner/       section 1
annotations/components/    section 1c (components gallery)
vlm/vlmpack_2026-11-05/    section 2 (vlm/vlmpack_2026-11-02/: superseded)
benchmarks/level1/         Level-1 detection / instance-segmentation kit: make_coco.py, eval_coco.py, YOLO and
                           Mask R-CNN baselines, slurm/ (read its README.md)
video/hand_work_selected/  section 3
docs/handoff/              the complete project handoff: overview, task ledger, design spec, every task brief / report,
                           internal handoff, the controller agent's memory
docs/handoff_internal.md   the detailed internal handoff (Chinese)
docs/vlm_run_hprc.md       running the VLM evaluation on a Slurm cluster (also inside the pack)
docs/handoff_agent_zh.md   Chinese companion of HANDOFF.md
docs/vlm_qa_preparation_zh.md   how the VLM questions were designed and generated (Chinese)

The code that made all of this (annotation tool, exporters, evaluation scripts, ≈ 6 000 tests) is public: github.com/ChangChrisLiu/DataLabelToolForEoLDesktopDisassembly.

Provenance and privacy

Captured May–June 2025 at Texas A&M University by the authors. The published videos have every face masked; the unmasked room recordings are not published. The raw still pictures show the machine and the bench; the oblique cameras (OAK Camera_2, RealSense) sometimes catch the operator. Contact: Chang Liu (ChangChrisLiu on Hugging Face and GitHub).