Upload README for frame WebDataset directories

README.md

@@ -1,95 +1,84 @@
----
-pretty_name: SpatialEncoder native WebDataset shards
-task_categories:
-- object-detection
----
-
-# SpatialEncoder WDS release (in progress)
-
-This repository contains a partition of `spatialencoder-wds-native-v1`, released
-as **uncompressed WebDataset tar shards**, normally about 1 GiB. All five
-repositories are parts of the same release; consult each `manifest.json`.
-The manifest lists **only uploaded shards whose remote size and SHA-256 have
-been verified**. An incomplete manifest is not a complete dataset.
-
-## Scope and splits
-
-All 23 sources in the current SpatialEncoder training catalog are in scope.
-Original train/val/test labels are retained, including val-only HOPEImage.
-ScanNetpp is regenerated from all 856 official labeled training scenes and 50
-validation scenes, using all good DSLR frames (`frame_stride=1`). Official
-COLMAP poses, pinhole undistorted intrinsics and mesh-derived visible boxes are
-used. This is not the two-scene smoke catalog. The configured pinhole training
-source does not include iPhone or equirectangular panorama imagery. Unlabeled
-test scenes are not relabeled as training data. DSLR has no released dense
-depth target here; the native invalid-depth mask is preserved.
-
-## Sample layout
-
-Each sample's entries are contiguous, with one shared basename:
-
-```
-<key>.meta.json
-<key>.asset00000.jpg
-<key>.asset00001.npy
-...
+# SpatialEncoder frame WebDatasets
+
+Each dataset has its own directory. ATEK's ten source packages share `ATEK/`.
+The independent HOPEImage and HOPEVideo indexes have separate directories.
+
+```text
+<dataset>/
+  manifest.json
+  shards/<split>/job-000001-00000.tar
+  scene_index/job-000001.jsonl.gz
+  metadata/job-000001.tar
+  source_info/<source-package>/support.tar
 ```
 
-JSON contains dataset, original split, camera intrinsics/poses, object
-annotations, native scale/depth conventions, source identity and asset
-bindings. Ordinary video blocks own 64 clip starts plus up to 14 lookahead
-frames, preserving every native 15-frame window across shard boundaries.
-Singleton-image sources use one frame per sample. Original image and depth
-encodings are retained byte-for-byte; random training augmentation is not
-frozen during export.
-
-Kubric stores the complete native TFRecord *record* containing a sequence,
-not an entire multi-record source shard. UCO3D stores a sequence MP4, HDF5
-depth, camera/box metadata and its filtered frame list; official excluded
-observations are retained as an explicit exclusion list. CA-1M stores native
-wide RGB/depth, shape records, official registered poses and JSON-converted
-annotations. Metadata never requires remote pickle execution.
+One WebDataset sample is one frame. All its members are contiguous in one TAR:
 
-## Streaming from HF or S3
+```text
+<key>.json
+<key>.rgb.jpg             # or rgb.png
+<key>.depth.npy           # or depth.png; absent for SceneVersepp
+```
 
-`reader.py` adapts raw WDS samples to the matching SpatialEncoder native
-training loader, preserving camera/depth corrections. Use it alongside the
-SpatialEncoder checkout and its dependencies (WebDataset, torch, OpenCV,
-Pillow, numpy, h5py, protobuf, etc.). Linux is required for its memory-backed
-seekable asset handles. HDF5 additionally needs one sequence-sized temporary
-file per active worker, deleted after decoding; set `SPATIAL_WDS_TMPDIR` to a
-local SSD or sufficiently large tmpfs. No original source directories or
-whole-shard downloads are needed.
+TARs are uncompressed, with a target of 2 GiB. Samples are never split across
+TARs. Assets retain their original bytes; there is no image recompression, depth
+quantization, unit conversion, resizing, or missing-depth synthesis.
+
+JSON contains dataset, scene_id, scene_key, frame_id, frame_index, num_frames,
+split, output_split, indexed, source, scene_metadata, frame, objects, components.
+`frame` is the original frame dictionary. `objects` contains objects annotated
+in this frame, retaining their non-frame attributes and this frame's original
+annotation dictionary. `scene_metadata` retains all original scene-level fields
+except frames/objects. Full original scene JSON bytes are preserved in metadata
+TARs, including objects without annotations in an individual frame.
+
+Original rgb_path/depth_path values inside JSON are provenance, not local paths
+to extract before training. Read the corresponding WDS fields using
+`sample[meta['components']['rgb']]` and the optional depth component instead.
+
+`scene_key = sha256(JSON([dataset, source_package, scene_json_relative_path]))[:32]`;
+`key = sha256(JSON([scene_key, frame_id]))[:32]`, using compact UTF-8 JSON with
+ensure_ascii=False. This avoids collisions across scenes, datasets and packages.
+Frame order follows the original scene JSON insertion order. Each scene index
+row lists every frame key and its shard, and locates the complete scene JSON.
+A scene can span shards; use this index to construct multiframe training inputs.
+
+Only original index entries appear in ordinary train/val splits. Additional
+scene JSONs omitted from source indexes are preserved in `unindexed_train`,
+`unindexed_test`, etc. They retain `indexed=false` and their directory-derived
+source split. They are never silently promoted into the original training set.
+Assets not referenced by any scene JSON remain in the unchanged raw_data source.
+Source indexes, READMEs, manifests, licenses, configs, scripts, reports and QA
+are preserved separately in support.tar, not mixed into frame sample streams.
+
+Depth/geometry semantics remain dataset-specific: ATEK and Synscapes use metre
+NPY depths; HOI4D, HOPE and SUN_RGB-D use millimetre PNG depths; ABO and ShapeNet
+use normalized geometry. SceneVersepp has no dense depth. Do not interpret all
+camera poses as valid temporal pose supervision; keep original supervision flags.
 
 ```python
-import webdataset as wds
-from reader import SpatialWDSDecoder
-
-# Replace with your uploaded S3 object(s); use an IAM role or standard AWS
-# credentials outside this code. This does not require a full local download.
-urls = ["pipe:aws s3 cp s3://YOUR_BUCKET/PREFIX/shard-000000.tar -"]
-raw = wds.WebDataset(
-    urls, shardshuffle=False,
-    nodesplitter=wds.split_by_node, workersplitter=wds.split_by_worker,
-)
-decoder = SpatialWDSDecoder(training=True)
-data = raw.map(decoder).select(lambda sample: sample is not None)
+from read_wds import dataset
+
+for sample in dataset('raw_data_wds/ATEK', split='train'):
+    meta = sample['json']
+    rgb = sample[meta['components']['rgb']]
+    depth_field = meta['components']['depth']
+    depth = sample[depth_field] if depth_field else None
+    # meta['frame'], meta['objects'], meta['scene_metadata'] are annotations.
+    break
 ```
 
-For HTTPS, pass shard URLs from `urls/train.txt` (authenticated HTTP access
-is needed for private repos). HF shard URLs are pinned to their upload commit.
-The `pipe:` command must contain only trusted bucket/key strings.
-
-The default adapter samples one owned clip start per block visit. For an exact
-clip-coverage pass, flatten `decoder.iter_block(raw_sample)` instead. Dataset
-mixing weights, epochs, worker seeds and distributed batch sizing remain
-training configuration choices; equal source weighting must not be inferred
-from a concatenated shard list. Native filtering may return `None` for a clip
-with no usable objects, just as in the original loader.
+`decode=True` decodes JSON, RGB as PIL images, and depth as NumPy arrays. PNG
+depth retains its original integer precision (it is never converted to RGB).
+Use `decode=False` to receive original encoded bytes. The TAR payload is
+unchanged regardless of decoding choice.
 
-Each repo manifest includes logical source, split, byte count, sample count,
-SHA-256 and pinned URL per shard. `frames` includes temporal lookahead overlap;
-it must not be interpreted as a count of unique training frames.
+Every completed shard has its byte size, sample count and SHA-256 in manifest.
+The converter reads back its first sample with the installed WebDataset library
+and compares every component SHA-256 against source bytes before publication.
+Original scene metadata and scene-to-shard indexes are also retained. A .partial
+file is unfinished; only shards in a completed manifest should be consumed.
 
-Source datasets retain their own licenses and access terms. This format does
-not grant additional redistribution rights or combine their licenses.
+Restart the converter with the same output and options to resume completed jobs.
+The conversion plan is immutable for an existing output. Completion receipts
+are reused only if all associated output files still exist at their recorded size.