Add card

README.md

@@ -0,0 +1,249 @@
+---
+license: cc-by-4.0
+pretty_name: Amazon Berkeley Objects GLB
+tags:
+- 3d
+- gltf
+- glb
+- web
+- three.js
+- 67js
+- furniture
+- pbr
+- amazon-berkeley-objects
+size_categories:
+- 1K<n<10K
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path:
+    - "thumbs/*.webp"
+    - "thumbs/metadata.jsonl"
+---
+
+# Amazon Berkeley Objects GLB
+
+![7,953 Amazon products on one floor, rendered with 67js](https://huggingface.co/datasets/codepawl/abo-glb/resolve/main/assets/banner.jpg)
+
+The 7,953 3D models of [Amazon Berkeley Objects](https://amazon-berkeley-objects.s3.amazonaws.com/index.html)
+(ABO), made small enough to load in a browser. Each product is one `.glb` with its full PBR material (colour, normal,
+metallic and roughness maps), at real size in metres, Y up. Most stand on Y = 0.
+
+<video src="https://huggingface.co/datasets/codepawl/abo-glb/resolve/main/assets/preview.mp4" autoplay loop muted playsinline width="100%"></video>
+
+| | Amazon's files | This dataset |
+|---|---|---|
+| Models | 7,953 | 7,953 |
+| Total size | 165.6 GB | 12.2 GB |
+| Average file | 20.8 MB | 1.5 MB |
+| Triangles | 340,137,126 | 340,137,126 (not simplified) |
+| Textures | PNG or JPEG, up to 4096 px | WebP, up to 2048 px |
+| Geometry | plain buffers | `EXT_meshopt_compression` |
+
+Example: the Stone & Beam Bradbury Chesterfield leather sofa is 57.1 MB in ABO and
+2.2 MB here.
+
+Every model also comes as a GPU-ready copy with KTX2 textures, three simpler levels of detail and a collision hull,
+for games and WebGPU. See [For games and WebGPU](#for-games-and-webgpu).
+
+## Credit and licence
+
+The 3D models, images and listing text are by **Amazon.com**, from the Amazon Berkeley Objects dataset, licensed
+[CC BY 4.0](https://creativecommons.org/licenses/by/4.0/). The dataset was built by Matthieu Guillaumin, Thomas
+Dideriksen, Kenan Deng, Himanshu Arora, Arnab Dhua, Xi (Brian) Zhang, Tomas Yago-Vicente (Amazon.com), Jasmine Collins,
+Shubham Goel and Jitendra Malik (UC Berkeley).
+
+This dataset changes the files: it re-encodes the textures, resizes them to at most 2048 px and compresses the geometry.
+The `lods/` copies also have fewer triangles. The other files do not change what the models show.
+A copy of the licence is in `LICENSE-CC-BY-4.0.txt`. CodePawl is not
+affiliated with Amazon, and Amazon does not endorse this dataset. Brand and product names belong to their owners.
+
+If you use the models in a publication, cite the ABO paper:
+
+```bibtex
+@article{collins2022abo,
+  title={ABO: Dataset and Benchmarks for Real-World 3D Object Understanding},
+  author={Collins, Jasmine and Goel, Shubham and Deng, Kenan and Luthra, Achleshwar and
+          Xu, Leon and Gundogdu, Erhan and Zhang, Xi and Yago Vicente, Tomas F and
+          Dideriksen, Thomas and Arora, Himanshu and Guillaumin, Matthieu and
+          Malik, Jitendra},
+  journal={CVPR},
+  year={2022}
+}
+```
+
+## What is in it
+
+- `objects/<id>/<id>.glb`: one file per product, WebP textures. The id is ABO's `3dmodel_id`, an Amazon product code.
+- `objects_ktx2/<id>/<id>.glb`: the same model with KTX2 (Basis Universal) textures and mipmaps, 9.2 GB in total.
+- `lods/<id>/<id>_lod1.glb`, `_lod2`, `_lod3`: simplified copies with KTX2 textures, 4.7 GB in total.
+- `collision_hulls.json`: one convex hull per model (at most 64 points, in the glb's frame) with its faces and volume.
+- `thumbs/<id>.webp`: a 512 px render of each pack file, with `thumbs/metadata.jsonl` for the Dataset Viewer.
+- `metadata.jsonl`: one line per model: English product name where a listing has one, product type, brand, colour,
+  material, style, the catalogue size and weight, every Amazon item id that uses the model, the model's measured size
+  in metres, triangles, and bytes before and after.
+
+Most types: chair (1,184), sofa (859), rug (817), wall art (599), table (584), home furniture and decor (549), lamp (345), stool seating (340), ottoman (288), pillow (275), headboard (206), light fixture (195).
+
+## Download
+
+All files, about 12.2 GB:
+
+```bash
+hf download codepawl/abo-glb --repo-type dataset --local-dir abo-glb
+```
+
+One model from Python:
+
+```python
+from huggingface_hub import hf_hub_download
+
+path = hf_hub_download("codepawl/abo-glb", "objects/B0714QGC72/B0714QGC72.glb", repo_type="dataset")
+```
+
+## Loading in 67js
+
+[67js](https://github.com/anxuanng/67.js) is a WebGL2 engine for scenes that AI agents build and render. The preview
+above is 67js drawing the pack files. Its glTF addon reads the meshopt geometry, the WebP textures and all four PBR maps.
+WebP textures need a 67js release after 0.15.0. Until then, build 67js from the main branch.
+
+```bash
+npm install 67js@npm:@codepawlhq/67js three
+```
+
+```js
+import { Renderer67 } from '67js';
+import { loadGltf } from '67js/addons/gltf';
+import { MeshoptDecoder } from 'three/addons/libs/meshopt_decoder.module.js';
+
+const url = 'https://huggingface.co/datasets/codepawl/abo-glb/resolve/main/objects/B0714QGC72/B0714QGC72.glb';
+const asset = await loadGltf(url, { decoders: { meshopt: MeshoptDecoder } });
+const renderer = new Renderer67(document.querySelector('canvas'), asset.parts, { samples: 4 });
+renderer.render({ eye: [1.6, 1.1, 2.4], target: [0, 0.4, 0] });
+```
+
+## Loading in three.js
+
+```js
+import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';
+import { MeshoptDecoder } from 'three/addons/libs/meshopt_decoder.module.js';
+
+const loader = new GLTFLoader();
+loader.setMeshoptDecoder(MeshoptDecoder);
+loader.load('B0714QGC72.glb', (gltf) => scene.add(gltf.scene));
+```
+
+## For games and WebGPU
+
+The WebP files are small to download, but a browser decodes WebP into plain RGBA, 4 bytes a pixel. The KTX2 copies
+stay compressed on the GPU: Basis Universal transcodes to BC7 on desktop and ASTC on phones, 1 byte a pixel.
+
+| Level | Triangles, whole pack | Texture edge | Files, whole pack |
+|---|---|---|---|
+| lod0 (`objects_ktx2/`) | 340,137,126 | 2048 px (normal map 1024 px) | 9.2 GB |
+| lod1 | 170,725,368 | 1024 px | 3.1 GB |
+| lod2 | 69,775,173 | 512 px | 1.1 GB |
+| lod3 | 24,144,651 | 256 px | 0.4 GB |
+
+Texture memory on the GPU with mip chains, worked out from the texture sizes in each file:
+
+| | WebP copy | KTX2 copy |
+|---|---|---|
+| One model, median | 64 MiB | 12 MiB |
+| All 7,953 models | 482 GiB | 91 GiB |
+
+### Whole set, 7,953 objects
+
+| Level | Triangles, sum | Triangles vs lod0 (median per object) | File size, sum | File size median (p10, p90) | Texture |
+| --- | --- | --- | --- | --- | --- |
+| lod0 | 340,137,126 | 100% | 9236.9 MB | 1066 (p10 449, p90 1801) KiB | 2048 px |
+| lod1 | 170,725,368 | 50% | 3063.9 MB | 330 (p10 156, p90 561) KiB | 1024 px |
+| lod2 | 69,775,173 | 20% | 1144.8 MB | 115 (p10 59, p90 203) KiB | 512 px |
+| lod3 | 24,144,651 | 6% | 448.7 MB | 40 (p10 23, p90 81) KiB | 256 px |
+
+WebP pack (objects/): 12228.0 MB, median 1194 (p10 318, p90 3091) KiB.
+KTX2 pack (objects_ktx2/): 9236.9 MB. All LODs together: 4657.4 MB.
+
+### Measured load time and VRAM: 20 objects, 5 runs each (3 for LODs)
+
+Measured on an RTX 3060 in headless Chrome 156 with the WebGPU backend. KTX2 textures transcode to BC7 on this GPU.
+
+| Metric | WebP pack | KTX2 | Change |
+| --- | --- | --- | --- |
+| Texture VRAM, MiB (three, as uploaded) | 64.00 (p10 64.00, p90 64.00) | 12.00 (p10 12.00, p90 12.00) | 0.19x |
+| Geometry VRAM, KiB (three) | 293 (p10 42, p90 1239) | 293 (p10 42, p90 1239) | 1.00x |
+| Texture + geometry, MiB (three) | 64.27 (p10 64.01, p90 69.17) | 12.27 (p10 12.01, p90 17.17) | 0.19x |
+| Texture VRAM, MiB (67js accounting) | 64.00 (p10 64.00, p90 64.00) | 12.00 (p10 12.00, p90 12.00) | 0.19x |
+| three load ms (fetch + parse + decode) | 104.1 (p10 51.8, p90 329.1) | 69.6 (p10 40.2, p90 182.2) | 0.67x |
+| three load + first frame ms | 114.7 (p10 60.2, p90 338.4) | 75.6 (p10 48.3, p90 187.0) | 0.66x |
+| 67js load ms | 171.7 (p10 101.4, p90 576.3) | 103.2 (p10 81.0, p90 203.0) | 0.60x |
+
+Texture formats seen: three webp rgba8, three ktx2 bc7, 67js webp rgba8, 67js ktx2 bc7.
+
+| LOD | Triangles (median) | Texture + geometry VRAM, MiB (three) | three load ms | 67js load ms |
+| --- | --- | --- | --- | --- |
+| lod0 (objects_ktx2) | 19484 | 12.27 | 69.6 | 103.2 |
+| lod1 | 9742 | 3.15 | 23.7 | 39.0 |
+| lod2 | 3896 | 0.82 | 9.3 | 20.1 |
+| lod3 | 1168 | 0.21 | 6.9 | 14.6 |
+
+Encoding: colour and metallic-roughness maps are ETC1S, normal maps are UASTC at half the edge so that their
+directions survive. Each KTX2 texture was encoded from Amazon's own image, not from the WebP copy. The LODs come from
+meshoptimizer's simplifier at 50%, 20% and 6% of the triangles, and stop early when the error grows too large.
+
+Load a KTX2 model in three.js with `WebGPURenderer`:
+
+```js
+import * as THREE from 'three';
+import { WebGPURenderer } from 'three/webgpu';
+import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';
+import { KTX2Loader } from 'three/addons/loaders/KTX2Loader.js';
+import { MeshoptDecoder } from 'three/addons/libs/meshopt_decoder.module.js';
+
+const renderer = new WebGPURenderer({ antialias: true });
+await renderer.init(); // the transcoder needs to know which compressed formats this device takes
+
+const ktx2Loader = new KTX2Loader()
+  .setTranscoderPath('https://cdn.jsdelivr.net/npm/three@0.187.0/examples/jsm/libs/basis/')
+  .detectSupport(renderer);
+const loader = new GLTFLoader().setKTX2Loader(ktx2Loader).setMeshoptDecoder(MeshoptDecoder);
+const gltf = await loader.loadAsync('https://huggingface.co/datasets/codepawl/abo-glb/resolve/main/objects_ktx2/B0714QGC72/B0714QGC72.glb');
+scene.add(gltf.scene); // far away: lods/B0714QGC72/B0714QGC72_lod2.glb
+```
+
+The same file in 67js:
+
+```js
+import { KTX2Loader } from 'three/addons/loaders/KTX2Loader.js';
+import { MeshoptDecoder } from 'three/addons/libs/meshopt_decoder.module.js';
+import { loadGltf, ktx2WorkerConfigFor } from '67js/addons/gltf';
+
+const ktx2 = new KTX2Loader().setTranscoderPath('https://cdn.jsdelivr.net/npm/three@0.187.0/examples/jsm/libs/basis/');
+ktx2.workerConfig = ktx2WorkerConfigFor(renderer.context); // renderer: your Renderer67
+const asset = await loadGltf('https://huggingface.co/datasets/codepawl/abo-glb/resolve/main/objects_ktx2/B0714QGC72/B0714QGC72.glb', {
+  decoders: { ktx2, meshopt: MeshoptDecoder },
+});
+```
+
+## How the files were made
+
+1. List the 7,953 GLB files under `3dmodels/original/` in ABO's public S3 bucket (165.6 GB on 2026-11-04).
+2. Download each file and check its byte size against the listing.
+3. Optimize with glTF Transform: dedup, prune and weld. Convert every texture to WebP at quality 88, at most 2048 px.
+   Compress the geometry with meshopt. Triangles, materials and node transforms stay as they are.
+4. From the same source file, write the KTX2 copy and the three LODs with toktx 4.4.2.
+5. Build the convex hull with quickhull3d and cut it to 64 points by farthest point sampling.
+6. Join the ABO listings to each model by `3dmodel_id` for the names and product data.
+7. Render a 512 px thumbnail of every pack file in headless Chrome.
+
+Before the full run, 32 objects were rendered from Amazon's file and from the pack file with the
+same camera. The mean pixel difference was 0.12 to 1.75 out of 255.
+
+## Known gaps
+
+ABO places some products by use, so 1,338 models reach below Y = 0: most are wall art (598), pillows (192), light
+fixtures (179) and mirrors (107). Wall art and mirrors have their back on
+Z = 0. Listing text comes from many Amazon stores, so some names are in other languages and some fields are empty. The
+textures are lossy WebP or Basis, so use ABO's own files when you need the 4096 px maps. The hulls are convex, so a chair or a
+shelf collides as one solid block.