HOT3D approved raw v1.0 batch 1

HOT3D/raw/data/Aria/P0001_10a27bf7/Hot3DAria_v4.0.0_P0001_10a27bf7_ground_truth.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3ffcb990b1cd6f89c24bf3a93c0d707be2eb78bd581b561bab7694f909ee9dfd
+size 4770860

HOT3D/raw/data/Aria/P0001_10a27bf7/Hot3DAria_v4.0.0_P0001_10a27bf7_hand_data.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:45378e89461f6b5ec2cbf80d22a4e12abbfc570e29850cd23c10c5b1827f0fd1
+size 6957367

HOT3D/raw/doc/PUBLICATION.md

@@ -0,0 +1,8 @@
+# HOT3D publication layout
+
+[Standardized data](https://huggingface.co/datasets/ParityLab/Hand-Datasets-Raw/tree/main/HOT3D/shared-v1.0)
+
+[Original archives](https://huggingface.co/datasets/ParityLab/Hand-Datasets-Raw/tree/main/HOT3D/raw)
+
+Local raw archives are retained. Temporary files and runtime logs are excluded.
+Upload completion is recorded separately after all files match fixed remote commits.

HOT3D/raw/doc/SOURCES.md

@@ -0,0 +1,29 @@
+# HOT3D Aria 原始数据盘点与全新下载
+
+2026-09-18。用户确认仅处理 Aria，不下载 Quest；与 ARCTIC 并行，最多两个活动数据集。最新要求为从头下载，不复用已有数据；官方 ZIP 保持 ZIP，不展开，VRS 原样保留。此前提出的展开目录方案已撤销，未对本轮 raw 执行解压。
+
+本机旧目录 `F:/_research/dataset/dreamhand/datasets/HOT3D` 有 198 个序列。旧下载器明确筛选 RGB `214-1`，现存 VRS 合计 238.35 GB；官方 Aria 原始 VRS 清单合计 329.36 GB。现存媒体是派生子集，不能把它们改名后当作完整原始 VRS。
+
+| 信息 | 本机旧目录现状 | 本次补齐方式 |
+|---|---|---|
+| 相机图像 | 198 份筛选后 RGB VRS；未保留两路灰度流 | 下载全部 198 份官方 main_vrs，保留原字节和所有流 |
+| 手 MANO | 198 个序列有对应 JSONL 文件；是否缺帧仍需试点核验 | 下载原 hand_data ZIP，同时原样保留包内其他字段 |
+| 相机模型、头显轨迹、同步 | 198 个序列有选取的文件 | 保留完整 ground_truth、MPS 标定、MPS 轨迹与 summary ZIP |
+| 物体轨迹 dynamic_objects | 旧目录中 0 个对应文件 | 从完整 ground_truth 原包补齐，按官方标注可用性处理 |
+| 手/物体 2D 框及可见性 | 旧目录中 0 个 box2d_hands/objects 文件 | 从 ground_truth 原包补齐 |
+| 帧有效性、QA 等 masks CSV | 旧目录中 0 个 mask_hand_visible 文件 | 保留 ground_truth 包内全部 masks；这些是逐帧标志，不是像素分割图 |
+| 物体几何、纹理与材质 | 试点有官方 hot3d_models.zip | 全新下载原 ZIP、官方仓库 object_models 的 33 个 GLB 与 models_info.json |
+| 深度、像素分割 | 当前 Aria 原始下载清单未列出对应模态 | 不虚构为实测深度或现成分割；后续若从模型渲染，应明确是派生结果 |
+| Quest | 本次不处理 | 用户明确排除 |
+
+“文件存在/包可下载”不等于每一帧有完整标注。训练/测试与 GT 可用性仍按官方 metadata 和实际轨迹检查，不用 198 个文件推断 198 个完整监督序列。
+
+目标为 `E:/hand-datasets/HOT3D/raw/{data,script,doc}`。临时分片、断点状态、带时效的下载链接及日志均放 `tmp`；不上传日志和下载链接。原包不解压。旧 F 盘数据与前一次 E 盘尝试数据均不复用；本轮重新通过官方下载所有文件，仅允许本次 fresh_download_run 内断点续传。下载使用官方清单的 URL/大小/SHA1，附加计算 SHA256；ZIP 还检查全部成员 CRC。官方普通 Git 小文件核对 blob SHA1。原始包在发布后仍留在本地。
+
+官方默认下载器会解压 ZIP；项目适配器沿用官方清单、文件分组和摘要校验，改为保留压缩包，并增加断点续传、流式写入及 400 GB 空间余量检查。官方脚本固定提交快照保存在 raw/script/official。
+
+当前六类 Aria 包加物体资产的 raw 合计约 336.4 GB。预算同时为 ARCTIC 未完成 raw 预留空间，并额外留出 100 GB 临时/试点预算和 400 GB 空闲。这里只批准下载阶段容量；全量 share 必须在试点后重新计算峰值。
+
+校验通过清单写入 `raw/doc/file_checksums.json`，总体清单为 `raw/doc/download_manifest.json`。下载完成后先进行独立序列试点和本地人工审核；此盘点不代表转换验收通过。
+
+来源：[HOT3D 官方下载说明](https://github.com/facebookresearch/hot3d/blob/146b34afef8c1a32adeef7e981c070109f225c87/README.md)、[官方数据性质说明](https://facebookresearch.github.io/hot3d/)、[官方物体模型](https://huggingface.co/datasets/bop-benchmark/hot3d/tree/30fe9674782f32e1e5edba98476b6ff4300132c5/object_models)。

HOT3D/raw/script/download_hot3d_raw.py

@@ -0,0 +1,284 @@
+"""Fresh-download official HOT3D Aria raw; preserve ZIPs and complete VRS unchanged."""
+from __future__ import annotations
+import hashlib
+import json
+import os
+from pathlib import Path
+import shutil
+import sys
+import time
+import traceback
+import zipfile
+import threading
+from concurrent.futures import ThreadPoolExecutor, wait, FIRST_COMPLETED
+from urllib.parse import urlsplit
+import requests
+from download_recovery import SlowDownload, IncompleteDownload, error_fields, save_json
+
+WORK = Path(__file__).resolve().parents[1]
+ROOT = Path('E:/hand-datasets/HOT3D')
+TMP = ROOT / 'tmp'
+RESERVE = 400_000_000_000
+FRESH_RUN = '2026-09-18-aria-fresh'
+TLS=threading.local();LATEST={};LATEST_LOCK=threading.Lock();STOP=threading.Event()
+GROUPS = ['ground_truth', 'hand_data', 'mps_slam_calibration',
+          'mps_slam_trajectories', 'mps_slam_summary', 'main_vrs']
+
+
+def load(p):
+    return json.loads(p.read_text(encoding='utf-8'))
+
+
+def save(p, data):
+    save_json(p, data)
+
+
+def status(stage, **fields):
+    value=dict(stage=stage, time=time.strftime('%Y-%m-%dT%H:%M:%S%z'), pid=os.getpid(), **fields)
+    worker=getattr(TLS,'worker',None)
+    if worker is None:save(TMP/'download-status.json',value)
+    else:
+        with LATEST_LOCK:LATEST[worker]=value
+        save(TMP/'workers'/f'{worker}.json',value)
+
+
+def client(proxy=False):
+    s = requests.Session()
+    s.trust_env = False
+    if proxy:
+        s.proxies = {'http': 'http://127.0.0.1:7897', 'https': 'http://127.0.0.1:7897'}
+    return s
+
+
+def safe(base, rel):
+    p = (base / rel).resolve()
+    assert p.is_relative_to(base.resolve()) and p != base.resolve()
+    return p
+
+
+def digests(path):
+    sha1, sha256 = hashlib.sha1(), hashlib.sha256()
+    git = hashlib.sha1(f'blob {path.stat().st_size}\0'.encode())
+    with path.open('rb') as f:
+        for chunk in iter(lambda: f.read(4 * 1024 * 1024), b''):
+            sha1.update(chunk); sha256.update(chunk); git.update(chunk)
+    return {'sha1': sha1.hexdigest(), 'sha256': sha256.hexdigest(), 'git_blob_sha1': git.hexdigest()}
+
+
+def matches(result, item):
+    return all(result[alg] == item[alg] for alg in ('sha1', 'sha256', 'git_blob_sha1') if item.get(alg))
+
+
+def validate(path, item):
+    assert path.stat().st_size == item['size'], 'size mismatch'
+    result = digests(path)
+    assert matches(result, item), 'official content digest mismatch'
+    if item['path'].lower().endswith('.zip'):
+        with zipfile.ZipFile(path) as z:
+            assert z.testzip() is None, 'ZIP CRC mismatch'
+        result['zip_crc'] = 'passed_all_members'
+    result.update(size=path.stat().st_size, official_digest_match=True)
+    return result
+
+
+def prepare():
+    plan_path = ROOT / 'raw/doc/download_manifest.json'
+    if plan_path.exists():
+        plan = load(plan_path)
+        assert plan['scope'] == 'Aria only; all source VRS streams; no Quest'
+        assert plan.get('fresh_download_run') == FRESH_RUN, 'Separate previous data before starting the fresh run'
+        plan['raw_storage'] = 'Official ZIP archives, complete VRS and loose assets; no extraction or stream filtering'
+        save(plan_path, plan)
+        return plan
+    source = WORK / 'datasets/HOT3D/_private/Hot3DAria_download_urls.json'
+    cdn = load(source)
+    revision = (WORK / 'tmp/hot3d-official-revision.txt').read_text().strip()
+    asset_index = load(WORK / 'tmp/hot3d-official-assets.json')
+    for rel in ['raw/data', 'raw/doc', 'raw/script/official', 'tmp/downloads', 'tmp/private']:
+        (ROOT / rel).mkdir(parents=True, exist_ok=True)
+    files, urls, unavailable = [], {}, []
+    for seq, entries in cdn['sequences'].items():
+        for group in GROUPS:
+            entry = entries.get(group, {})
+            if not entry.get('download_url'):
+                unavailable.append({'sequence': seq, 'group': group})
+                continue
+            rel = f'Aria/{seq}/{entry["filename"]}'
+            safe(ROOT / 'raw/data', rel)
+            assert len(entry['sha1sum']) == 40 and entry['file_size_bytes'] > 0
+            assert urlsplit(entry['download_url']).hostname.endswith('.fbcdn.net')
+            files.append({'path': rel, 'sequence': seq, 'group': group, 'size': entry['file_size_bytes'],
+                          'sha1': entry['sha1sum'], 'source_locator': f'Hot3DAria_download_urls.json#/sequences/{seq}/{group}'})
+            urls[rel] = entry['download_url']
+    for entry in asset_index['files']:
+        if entry['type'] != 'file':
+            continue
+        rel = 'assets/' + entry['path']
+        item = {'path': rel, 'group': 'object_models', 'size': entry['size'],
+                'source_locator': f'https://huggingface.co/datasets/{asset_index["repo"]}/blob/{asset_index["revision"]}/{entry["path"]}'}
+        if entry.get('lfs'):
+            item['sha256'] = entry['lfs']['oid']
+        else:
+            item['git_blob_sha1'] = entry['oid']
+        files.append(item)
+        urls[rel] = f'https://huggingface.co/datasets/{asset_index["repo"]}/resolve/{asset_index["revision"]}/{entry["path"]}'
+    # Download and retain the official model ZIP anew.
+    model_rel = 'assets/hot3d_models.zip'
+    files.append({'path': model_rel, 'group': 'object_models_archive', 'size': 137336584,
+                  'sha256': '7b004ed35bcef4242ac50040cfb44140c37de4e37ce023a00affcf0f20a58f64',
+                  'source_locator': f'https://huggingface.co/datasets/{asset_index["repo"]}/blob/{asset_index["revision"]}/hot3d_models.zip'})
+    urls[model_rel] = f'https://huggingface.co/datasets/{asset_index["repo"]}/resolve/{asset_index["revision"]}/hot3d_models.zip'
+    # Keep signed download links in local temporary state, not in distributable docs.
+    save(TMP / 'private/download_urls.json', urls)
+    shutil.copyfile(source, TMP / 'private/Hot3DAria_download_urls.json')
+    save(ROOT / 'raw/doc/official_manifest_metadata.json', {'sequence_config': cdn['sequence_config'],
+         'source_file_sha256': hashlib.sha256(source.read_bytes()).hexdigest(), 'files': files})
+    sources = []
+    official_paths = ['README.md', 'VERSIONS.md', 'hot3d/data_downloader/dataset_downloader_base.py',
+                      'hot3d/data_downloader/dataset_downloader_base_main.py',
+                      'hot3d/data_downloader/dataset_download_status_manager.py', 'hot3d/data_downloader/utils.py']
+    with client(True) as s:
+        for rel in official_paths:
+            url = f'https://raw.githubusercontent.com/facebookresearch/hot3d/{revision}/{rel}'
+            r = s.get(url, timeout=(15,40)); r.raise_for_status()
+            dest = safe(ROOT / 'raw/script/official', rel); dest.parent.mkdir(parents=True, exist_ok=True); dest.write_bytes(r.content)
+            sources.append({'path': dest.relative_to(ROOT).as_posix(), 'url': url, 'sha256': hashlib.sha256(r.content).hexdigest()})
+    # Download phase only: reserve unfinished ARCTIC raw plus bounded temporary/pilot work.
+    arctic = load(Path('E:/hand-datasets/ARCTIC/raw/doc/download_manifest.json'))
+    arctic_done = load(Path('E:/hand-datasets/ARCTIC/raw/doc/archive_checksums.json'))
+    arctic_remaining = max(0, arctic['space_plan']['raw_budget_bytes'] - sum(x['size'] for x in arctic_done.values()))
+    total = sum(x['size'] for x in files)
+    peak_additional = total + arctic_remaining + 100_000_000_000
+    assert shutil.disk_usage(ROOT).free > RESERVE + peak_additional, 'Insufficient concurrent raw download budget'
+    plan = {'dataset': 'HOT3D', 'release': cdn['sequence_config']['release'],
+            'fresh_download_run': FRESH_RUN, 'reuse_previous_data': False,
+            'scope': 'Aria only; all source VRS streams; no Quest', 'sequence_count': len(cdn['sequences']),
+            'official_repo_revision': revision, 'asset_repo_revision': asset_index['revision'],
+            'files': files, 'files_total': len(files), 'bytes_total': total, 'official_sources': sources,
+            'missing_source_groups': unavailable,
+            'excluded_groups': ['Quest', 'video_main_rgb (preview duplicate)', 'mps_eye_gaze', 'mps_slam_points', 'mps_artifacts'],
+            'space_plan': {'hot3d_raw_bytes': total, 'arctic_remaining_raw_budget_bytes': arctic_remaining,
+                           'temporary_and_pilot_budget_bytes': 100_000_000_000, 'minimum_free_bytes': RESERVE,
+                           'full_share_processing': 'Rebudget after representative pilot; not started by this downloader.'}}
+    save(plan_path, plan)
+    shutil.copyfile(__file__, ROOT/'raw/script/download_hot3d_raw.py')
+    status('manifest_ready', files_total=len(files), bytes_total=total)
+    return plan
+
+
+def fetch(item, index, total, verified, urls):
+    dest = safe(ROOT / 'raw/data', item['path']); dest.parent.mkdir(parents=True, exist_ok=True)
+    old = verified.get(item['path'])
+    if old:
+        assert old.get('fresh_download_run') == FRESH_RUN
+    if dest.exists():
+        if old and old.get('official_digest_match') and dest.stat().st_size == old['size'] and dest.stat().st_mtime_ns == old['mtime_ns'] and matches(old, item):
+            return old
+        # A fresh-run file may have been renamed just before interruption, before indexing.
+        result = validate(dest, item)
+        return dict(result, mtime_ns=dest.stat().st_mtime_ns, acquisition='current_fresh_run_revalidated', fresh_download_run=FRESH_RUN)
+    part = safe(TMP / 'downloads', item['path'] + '.part'); part.parent.mkdir(parents=True, exist_ok=True)
+    meta = part.with_suffix('.resume.json')
+    url = urls[item['path']]
+    for attempt in range(6):
+        proxy = urlsplit(url).hostname == 'huggingface.co' or attempt >= 2
+        try:
+            if STOP.is_set():raise RuntimeError('Worker group stopped')
+            offset = part.stat().st_size if part.exists() else 0
+            assert offset <= item['size'], 'Partial file larger than official size'
+            if offset < item['size']:
+                assert shutil.disk_usage(ROOT).free > RESERVE + item['size'] - offset
+                headers = {'Accept-Encoding': 'identity'}
+                if offset:
+                    headers['Range'] = f'bytes={offset}-'
+                    if meta.exists() and load(meta).get('validator'):
+                        headers['If-Range'] = load(meta)['validator']
+                status('downloading', file=item['path'], file_index=index, files_total=total, bytes_downloaded=offset,
+                       bytes_total=item['size'], completed_files=len(verified), network='proxy' if proxy else 'direct')
+                with client(proxy) as s, s.get(url, headers=headers, stream=True, timeout=(15,75)) as response:
+                    response.raise_for_status()
+                    assert 'text/html' not in response.headers.get('Content-Type',''), 'HTML response instead of raw'
+                    if response.status_code == 206:
+                        cr = response.headers.get('Content-Range','')
+                        assert cr.startswith(f'bytes {offset}-') and int(cr.split('/')[-1]) == item['size']
+                    else:
+                        offset = 0
+                    save(meta, {'validator': response.headers.get('ETag') or response.headers.get('Last-Modified'), 'size': item['size']})
+                    last = time.monotonic(); window_bytes = offset; rate_start=last; rate_bytes=offset
+                    with part.open('ab' if offset else 'wb') as out:
+                        for chunk in response.iter_content(256*1024):
+                            if not chunk: continue
+                            if STOP.is_set():raise RuntimeError('Worker group stopped')
+                            out.write(chunk); offset += len(chunk)
+                            assert offset <= item['size'], 'Response larger than official size'
+                            now = time.monotonic()
+                            if now-rate_start >= 120:
+                                if (offset-rate_bytes)/(now-rate_start) < 256*1024:
+                                    raise SlowDownload('Slow transfer; preserve partial and reconnect')
+                                rate_start=now; rate_bytes=offset
+                            if now-last >= 20:
+                                assert shutil.disk_usage(ROOT).free > RESERVE
+                                status('downloading', file=item['path'], file_index=index, files_total=total,
+                                       bytes_downloaded=offset, bytes_total=item['size'], completed_files=len(verified),
+                                       download_MBps=round((offset-window_bytes)/(now-last)/1e6,3), network='proxy' if proxy else 'direct')
+                                last=now; window_bytes=offset
+            received_size = part.stat().st_size
+            if received_size < item['size']:
+                raise IncompleteDownload(received_size, item['size'])
+            status('verifying_file', file=item['path'], file_index=index, files_total=total, completed_files=len(verified))
+            try:
+                result = validate(part, item)
+            except AssertionError:
+                part.replace(part.with_name(part.name + '.invalid-' + str(int(time.time()))))
+                meta.unlink(missing_ok=True)
+                raise
+            part.replace(dest); meta.unlink(missing_ok=True)
+            return dict(result, mtime_ns=dest.stat().st_mtime_ns, acquisition='official_download', fresh_download_run=FRESH_RUN)
+        except Exception as e:
+            fields=error_fields(e)
+            status('retrying', file=item['path'], attempt=attempt+1, completed_files=len(verified), **fields)
+            if not fields['retryable']: raise
+            if attempt==5: raise
+            time.sleep(min(2**attempt,16))
+
+
+def worker_fetch(item,index,total,verified,urls):
+    TLS.worker=threading.current_thread().name.replace('_','-')
+    status('starting_file',file=item['path'],bytes_downloaded=0,download_MBps=0)
+    try:return fetch(item,index,total,verified,urls)
+    finally:status('idle',download_MBps=0)
+
+
+def main():
+    plan = prepare()
+    if '--prepare-only' in sys.argv: return
+    state = load(WORK/'tmp/dataset-work-state.json')
+    assert 'HOT3D' in state['active'] and len(state['active']) <= 2
+    urls = load(TMP/'private/download_urls.json')
+    record = ROOT/'raw/doc/file_checksums.json'
+    verified = load(record) if record.exists() else {}
+    # Download the model ZIP and small model assets before sequence downloads.
+    files = sorted(plan['files'], key=lambda x: (0 if x['group']=='object_models_archive' else 1 if x['group']=='object_models' else 2, x['path'] if x['group'].startswith('object_') else ''))
+    workers=max(1,min(2,int(os.environ.get('HOT3D_DOWNLOAD_WORKERS','2'))))
+    with ThreadPoolExecutor(max_workers=workers,thread_name_prefix='hot3d') as pool:
+        pending={pool.submit(worker_fetch,item,index,len(files),verified,urls):item for index,item in enumerate(files,1)}
+        try:
+            while pending:
+                done,_=wait(pending,timeout=20,return_when=FIRST_COMPLETED)
+                for future in done:
+                    item=pending.pop(future);verified[item['path']]=future.result();save(record,verified)
+                with LATEST_LOCK:active=[dict(v) for v in LATEST.values() if v['stage']!='idle']
+                status('downloading',files_total=len(files),completed_files=len(verified),bytes_verified=sum(v['size'] for v in verified.values()),download_workers=workers,download_MBps=round(sum(v.get('download_MBps',0) for v in active if v['stage']=='downloading'),3),active_files=active,network='direct_preferred')
+        except BaseException:
+            STOP.set()
+            for future in pending:future.cancel()
+            raise
+    status('raw_complete_verified', files_total=len(verified), bytes_total=sum(x['size'] for x in verified.values()), scope=plan['scope'], raw_storage='official_archives_and_complete_vrs')
+    state=load(WORK/'tmp/dataset-work-state.json');state['active']['HOT3D']['stage']='raw_complete_awaiting_pilot';save(WORK/'tmp/dataset-work-state.json',state)
+
+
+if __name__ == '__main__':
+    try: main()
+    except Exception as exc:
+        status('failed', **error_fields(exc), failure_location=[{'file':Path(f.filename).name,'line':f.lineno,'function':f.name} for f in traceback.extract_tb(exc.__traceback__)])
+        raise SystemExit(1)

HOT3D/raw/script/download_recovery.py

@@ -0,0 +1,50 @@
+"""Classify retryable download failures without recording credentials or URLs."""
+import errno
+import json
+import time
+import requests
+
+
+class SlowDownload(requests.RequestException):
+    pass
+
+
+class IncompleteDownload(requests.RequestException):
+    """The HTTP stream ended before all expected bytes arrived; keep the partial."""
+    def __init__(self, received_size, expected_size):
+        super().__init__('HTTP stream ended before expected file size')
+        self.received_size = received_size
+        self.expected_size = expected_size
+
+
+def save_json(path, value):
+    """Publish metadata atomically; tolerate brief Windows reader/AV sharing locks."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_name(path.name + '.next')
+    text = json.dumps(value, ensure_ascii=False, indent=2) + '\n'
+    for attempt in range(8):
+        try:
+            temporary.write_text(text, encoding='utf-8')
+            temporary.replace(path)
+            return
+        except PermissionError as error:
+            # Do not classify disk failures, persistent permission failures, or
+            # integrity errors as retryable network failures.
+            if getattr(error, 'winerror', None) not in (5, 32, 33) or attempt == 7:
+                raise
+            time.sleep(min(0.1 * 2**attempt, 1.0))
+
+
+def error_fields(error):
+    response = getattr(error, 'response', None)
+    code = getattr(response, 'status_code', None)
+    if isinstance(error, requests.HTTPError):
+        retryable = code in (408, 425, 429, 500, 502, 503, 504)
+    else:
+        retryable = isinstance(error, requests.RequestException)
+    result = {'error_type': type(error).__name__, 'retryable': retryable,
+            'http_status': code, 'winerror': getattr(error, 'winerror', None),
+            'disk_space_error': getattr(error, 'errno', None) == errno.ENOSPC}
+    if isinstance(error, IncompleteDownload):
+        result.update(received_size=error.received_size, expected_size=error.expected_size)
+    return result

HOT3D/raw/script/official/README.md

@@ -0,0 +1,272 @@
+# HOT3D Toolkit
+
+This repository hosts an official toolkit for [HOT3D](https://facebookresearch.github.io/hot3d/), an egocentric dataset for 3D hand and object tracking.
+
+The toolkit offers:
+
+- An API for downloading and using the full HOT3D dataset provided in a [VRS](https://github.com/facebookresearch/vrs)-based format (see [tutorial](https://github.com/facebookresearch/hot3d/blob/main/hot3d/HOT3D_Tutorial.ipynb)).
+- An API for [HOT3D-Clips](https://github.com/facebookresearch/hot3d/tree/main/hot3d/clips) which is a curated HOT3D subset provided in the [Webdataset](https://github.com/webdataset/webdataset) format and used in [BOP Challenge 2024](https://bop.felk.cvut.cz/challenges/bop-challenge-2024) and [Multiview Egocentric Hand Tracking Challenge](https://github.com/facebookresearch/hand_tracking_toolkit?tab=readme-ov-file#evaluation).
+
+Resources:
+- [HOT3D homepage](https://facebookresearch.github.io/hot3d/)
+- [Download full HOT3D dataset from projectaria.com](https://www.projectaria.com/datasets/hot3D/)
+- [Download HOT3D-Clips from Hugging Face](https://huggingface.co/datasets/bop-benchmark/hot3d)
+- [Read HOT3D paper](https://arxiv.org/pdf/2411.19167)
+
+The following instructions are relevant if you want to use the full HOT3D dataset in the VRS-based format. For HOT3D-Clips, please refer to the [dedicated page](https://github.com/facebookresearch/hot3d/tree/main/hot3d/clips).
+
+## Step 1: Install the downloader
+
+This Python repository can be used with Pixi and Conda environments and can run on:
+
+* x64 Linux distributions of:
+    * Fedora 36, 37, 38
+    * Ubuntu jammy (22.04 LTS) and focal (20.04 LTS)
+* Mac Intel or Mac ARM-based (M1) with MacOS 11 (Big Sur) or newer
+
+Python 3.9+ (3.10+ if you are on [Apple Silicon](https://support.apple.com/en-us/116943)).
+
+
+### Using Pixi
+
+[Pixi](https://prefix.dev/) is a package management tool for developers. Developers can install libraries and applications in a reproducible way, which makes it easier to install and use a Python environment for the HOT3D API.
+
+```
+# 1. Install pixi
+curl -fsSL https://pixi.sh/install.sh | bash
+
+# 2. Checkout this repository
+git clone https://github.com/facebookresearch/hot3d.git
+cd hot3d/hot3d
+
+# 3. Call `pixi install` to setup the environment
+pixi install
+
+# 4. (Optional) Install the third-party dependencies required for hands, by reviewing and accepting the licenses provided on the corresponding third-party repositories
+pixi run setup_hands
+
+```
+
+#### A quick introduction to the [PIXI environment](https://prefix.dev/)
+- Execute Pixi environment commands from within the `hot3d` folder.
+- The Pixi environment is located in the `.pixi` folder.
+- Activate the Pixi HOT3D environment by using the command `pixi shell`.
+- Exit the Pixi HOT3D environment by typing `exit`.
+- Remove the environment by executing the command `rm -rf .pixi`.
+
+
+### Using Conda
+
+[Conda](https://conda.io/projects/conda/en/latest/index.html) is a package manager used for managing software environments and dependencies in data science and scientific computing.
+
+```
+# 1. Install conda -> https://conda.io/projects/conda/en/latest/user-guide/getting-started.html
+# 2. Create your environment
+conda create --name hot3d
+conda activate hot3d
+
+# 2. Install dependencies
+python3 -m ensurepip
+python3 -m pip install projectaria_tools==1.5.1 torch requests rerun-sdk==0.16.0
+python3 -m pip install vrs
+python3 -m pip install matplotlib
+
+# 3. (Optional) Install the third-party dependencies required for hands by reviewing and accepting the licenses provided on the corresponding third-party repositories
+python3 -m pip install 'git+https://github.com/vchoutas/smplx.git'
+python3 -m pip install 'git+https://github.com/mattloper/chumpy'
+```
+
+#### A quick introduction to the [CONDA environment](https://docs.conda.io/projects/conda/en/4.6.1/user-guide/tasks/manage-environments.html#managing-environments)
+
+- Activate the Conda HOT3D environment by executing `conda activate hot3d`.
+- Exit the Conda HOT3D environment using `conda deactivate`.
+- Remove the Conda HOT3D environment by executing `conda remove --name hot3d --all`.
+
+
+## Step 2: Sign up and get the download links file
+
+1. Review the [HOT3D license agreement](https://www.projectaria.com/datasets/hot3d/license/).
+    * Examine the specific licenses applicable to the data types you wish to use, such as Sequence, Hand annotations, and 3D object models.
+2. Go to the [HOT3D website](https://www.projectaria.com/datasets/hot3D/) and sign up.
+    * Scroll down to the bottom of the page.
+    * Enter your email and select **Access the Datasets**.
+3. The HOT3D page will be refreshed to contain instructions and download links
+    * The download view is ephemeral, keep the tab open to access instructions and links
+    * Download links that last for 14 days
+    * Enter your email again on the HOT3D main page to get fresh links
+4. Select the Download button for any of the data types:
+    * “Download the HOT3D Aria Dataset"
+    * "Download the HOT3D Quest Dataset"
+    * "Download the HOT3D Assets Dataset"
+5. These will swiftly download JSON files with urls that the downloader will use
+
+
+## Step 3: Download the data
+Use the HOT3D downloader to download some, or all of the data.
+
+```
+# 1. Activate your environment (assuming from the hot3d folder):
+# conda: conda activate hot3d
+# pixi: pixi shell
+
+# 2. Go to the hot3d/data_downloader directory
+cd hot3d/data_downloader
+mkdir -p ../dataset
+
+# 3. Run the dataset downloader
+# Download HOT3D Object Library data
+python3 dataset_downloader_base_main.py -c Hot3DAssets_download_urls.json -o ../dataset --sequence_name all
+
+# Download one HOT3D Aria data sequence
+python3 dataset_downloader_base_main.py -c Hot3DAria_download_urls.json -o ../dataset --sequence_name P0003_c701bd11 --data_types all
+# Type answer `y`
+
+# Download one HOT3D Quest data sequence
+python3 dataset_downloader_base_main.py -c Hot3DQuest_download_urls.json -o ../dataset --sequence_name P0002_1464cbdc --data_types all
+# Type answer `y`
+```
+
+**Tip:** To download all sequences in a download links JSON file (such as the HOT3D Object Library data in step 3), pass sequence_name as 'all'.
+
+## Step 4: Run the dataset viewer
+
+### Viewing objects and headset pose trajectory
+```
+python3 viewer.py --sequence_folder <PATH>/hot3d_dataset/P0003_c701bd11 --object_library_folder <PATH>/hot3d_dataset/assets/
+```
+
+When using `pixi`, you can directly launch the viewer without explicitly activating the environment by using the following command:
+```
+pixi run viewer --sequence_folder <PATH>/hot3d_dataset/P0003_c701bd11 --object_library_folder <PATH>/hot3d_dataset/assets/
+```
+
+### Using hand annotations
+
+Hand pose annotations in HOT3D are provided in the [UmeTrack](https://github.com/facebookresearch/UmeTrack) and [MANO](https://mano.is.tue.mpg.de/) formats. Both hand poses annotation are accessible in the API by using either the `mano_hand_data_provider`, `umetrack_hand_data_provider` property once the `Hot3dDataProvider` is initialized. In order to choose the representation for the viewer, use the following:
+
+#### UmeTrack
+
+```
+python3 viewer.py --sequence_folder <PATH>/hot3d_dataset/P0003_c701bd11--object_library_folder <PATH>/hot3d_dataset/assets --hand_type UMETRACK
+```
+
+#### MANO
+
+Hand annotations in the MANO format can be downloaded after accepting their [license agreement](https://mano.is.tue.mpg.de/).
+- HOT3D only requires the `MANO_RIGHT.pkl` and `MANO_LEFT.pkl` files for loading and rendering of hand poses. These files can be obtained from the `mano_v1_2.zip` file located in the "Models & Code" section of the `MANO` website. After downloading, extract the zip file to your local disk, and the `*.pkl` files can be found at the following path: `mano_v1_2/models/`.
+
+```
+python3 viewer.py --sequence_folder <PATH>/hot3d_dataset/P0003_c701bd11 --object_library_folder <PATH>/hot3d_dataset/assets --mano_model_folder <PATH>/mano_v1_2/models/  --hand_type MANO
+```
+
+## Step 5: Run the python notebook tutorial
+
+```
+# Assuming you have downloaded the Aria `P0003_c701bd11` sequence and the object library above.
+#
+# Install Jupyter Notebook for your environment:
+python3 -m pip install Jupyter
+# Run Jupyter and open the notebook (conda)
+jupyter notebook ./HOT3D_Tutorial.ipynb
+# Run Jupyter and open the notebook (pixi, use a direct path to ensure jupyter will take the right python path)
+.pixi/envs/default/bin/jupyter notebook ./HOT3D_Tutorial.ipynb
+```
+
+
+## Step6: Mastering the dataset and its API
+
+### Using the HOT3D dataset API
+
+- Please refer to our notebook [tutorial](./hot3d/HOT3D_Tutorial.ipynb). The notebook explains how to instantiate a `Hot3dDataProvider` from a HOT3D sequence folder and how to use its API to retrieve each data modality (images, GT hand & object poses, ...).
+
+
+### Using "mask files"
+
+HOT3D utilizes mask files to identify and flag specific timestamps based on a particular property. For instance, we can use masks to mark specific timestamps in a camera stream as having inaccurate object pose (as determined through manual QA) or as having an over-saturated image. These masks can be combined using logical AND/OR operations to create a custom mask that meets the end user's requirements.
+
+Here is a list of the exported mask files:
+
+| File | Description |
+| -- | -- |
+| mask_object_pose_available.csv  | True if all dynamic objects in the scene have a valid pose, and false if even one object is missing a pose. The accuracy of the poses is not evaluated. |
+| mask_hand_pose_available.csv | True if both right and left hands have a valid pose, and false if even one hand is missing a pose. The accuracy of the poses is not evaluated. |
+| mask_headset_pose_available.csv | True if the headset has a valid pose, and false otherwise. The accuracy of the poses is not evaluated. |
+| mask_object_visibility.csv | True if at least one object is visible in the camera frame, false otherwise. Visibility is computed based on the pose, and accuracy of the pose is not evaluated. |
+| mask_hand_visible.csv | True if at least one hand is visible in the camera frame, false otherwise. Visibility is computed based on the pose, and accuracy of the pose is not evaluated. |
+| mask_good_exposure.csv | True if sufficient pixels on the hand and dynamic objects visible in the frame are not over-exposed, false otherwise. Visibility is computed based on the pose, and accuracy of the pose is not evaluated. |
+| mask_qa_pass.csv | True if manual QA indicated no issues with the pose of the objects and hands visible in a camera stream, false otherwise. |
+
+The masks are saved in csv format, with each row indicating the validity of the mask for a given timestamp and camera stream_id:
+```
+timestamp[ns],stream_id,mask
+43986008190448,214-1,True
+43986008283010,1201-2,True
+43986008283023,1201-1,True
+43986041551363,214-1,True
+43986041643100,1201-2,True
+43986041643113,1201-1,True
+43986074878771,214-1,False
+43986074971171,1201-2,False
+43986074971184,1201-1,False
+43986108202591,214-1,True
+```
+
+Here is how to load the mask files and combine them with a logical operator:
+
+```
+# Mask API example:
+# Let's check that we have at least a hand and an object that is visible in a given stream
+#
+
+import os
+from projectaria_tools.core.stream_id import StreamId
+from data_loaders.loader_masks import combine_mask_data, load_mask_data, MaskData
+
+sequence_folder = "<PATH>/hot3d_dataset/P0003_c701bd11/"
+
+# Select the desired masks
+example_mask_list = [
+    # Use the masks that depicting the visibility status
+    "masks/mask_hand_visible.csv",
+    "masks/mask_object_visible.csv",
+]
+
+# Load the referred masks
+mask_data_list = []
+for it in example_mask_list:
+    if os.path.exists(os.path.join(sequence_folder, it)):
+        ret = load_mask_data(os.path.join(sequence_folder, it))
+        mask_data_list.append(ret)
+
+# Combine the masks (you can choose logical "and"/"or")
+output = combine_mask_data(mask_data_list, "and")
+
+# Get the number of frames where we can see at least a hand and an object
+num_timestamps_with_at_least_a_hand_and_object_visible = output.num_true(StreamId("214-1"))
+print(f"Number of frames containing at least a hand and object visible: {num_timestamps_with_at_least_a_hand_and_object_visible}")
+
+total_frame_count = output.length(StreamId("214-1"))
+print(f"Total sequence frames: {total_frame_count}")
+```
+
+## Test/Train split
+
+The sequences corresponding to the following participant ids are defining the TEST set, and so does not have any GT information
+`TEST_SET_PARTICIPANT_ID = ["P0004", "P0005", "P0006", "P0008", "P0016", "P0020"]`
+
+i.e:
+- sequence `P0003_c701bd11` belong to the TRAIN set
+- sequence `P0004_a59ab32e` belong to the TEST set
+
+Note that the information is also shared in the `metadata.json` file under the field `gt_available_status` or can be accessed directly via the `Hot3dDataProvider -> get_sequence_metadata` API call.
+
+## License
+
+- [HOT3D API](https://github.com/facebookresearch/hot3d) (aka. this repository) is released by Meta under the [Apache 2.0 license](LICENSE)
+- [HOT3D dataset](https://www.projectaria.com/datasets/hot3d/) is released under the [HOT3D license agreement](https://www.projectaria.com/datasets/hot3d/license/)
+  - Using hands annotation requires installation of [SMPLX/MANO](https://github.com/vchoutas/smplx) third-party dependencies, please review and agree to their license listed on their website.
+
+
+## Contributing
+
+Go to [Contributing](.github/CONTRIBUTING.md) and the [Code of Conduct](.github/CODE_OF_CONDUCT.md).

HOT3D/raw/script/official/VERSIONS.md

@@ -0,0 +1,9 @@
+# HOT3D versions
+
+This file records shipped versions of the full HOT3D dataset available via [projectaria.com](https://www.projectaria.com/datasets/hot3D/).
+
+Only the last version is available for download. To find out what version you have, look for the field "version" in the "metadata.json" files stored in the sequence folders.
+
+- v1 (June 17, 2024): Initial release
+- v2 (July 3, 2024): More accurate thumbs on Mano hands
+- v3 (December 19, 2024): Updated visibility scores in box2d_hands/objects.csv

HOT3D/raw/script/official/hot3d/data_downloader/dataset_download_status_manager.py

@@ -0,0 +1,53 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+from typing import Final, List
+
+DOWNLOAD_STATUS_FILE: Final[str] = ".download_status.json"
+
+
+class DatasetDownloadStatusManager:
+    def __init__(self, data_groups: List[str]):
+        self.status = {data_group: False for data_group in data_groups}
+
+    # Read status file from json and assign to status
+    def from_json(self, json_path: str) -> None:
+        try:
+            with open(json_path, "r") as f:
+                data = json.load(f)
+                for expected_data_group in self.status:
+                    if expected_data_group not in data:
+                        error = f"{DOWNLOAD_STATUS_FILE} is missing data group {expected_data_group}.\n"
+                        error += f"Your data may be out of date, try clearing {DOWNLOAD_STATUS_FILE} in your sequence path"
+                        raise Exception(error)
+                self.status = data
+        except Exception as e:
+            print(f"[warning]: cannot read status json. {e}")
+
+    def to_json(self, json_path: str):
+        try:
+            json_object = json.dumps(self.status, indent=4)
+            with open(json_path, "w") as outfile:
+                outfile.write(json_object)
+        except Exception as e:
+            print(f"[warning]: can not write status json. {e}")
+
+    def set_download_status(self, data_type: str, value: bool):
+        if data_type not in self.status:
+            raise Exception(f"data type {data_type} is not supported")
+        self.status[data_type] = value
+
+    def get_download_status(self, data_type: str) -> bool:
+        return self.status[data_type]

HOT3D/raw/script/official/hot3d/data_downloader/dataset_downloader_base.py

@@ -0,0 +1,277 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import hashlib
+import json
+import os
+import shutil
+import tempfile
+from pathlib import Path
+from typing import List, Optional, Tuple
+from zipfile import is_zipfile, ZipFile
+
+import requests
+from dataset_download_status_manager import (
+    DatasetDownloadStatusManager,
+    DOWNLOAD_STATUS_FILE,
+)
+from requests.adapters import HTTPAdapter
+from requests.packages.urllib3.util.retry import Retry
+from tqdm import tqdm
+from utils import load_data_groups_from_cdn
+
+CHUCK_SIZE_BYTE = 8192
+STATUS_CODE_DEFAULT = 404
+
+
+DATA_TYPE_TO_SAVE_PATH = {
+    "mps_eye_gaze": os.path.join("mps", "eye_gaze"),
+    "mps_slam_trajectories": os.path.join("mps", "slam"),
+    "mps_slam_points": os.path.join("mps", "slam"),
+    "mps_slam_calibration": os.path.join("mps", "slam"),
+    "mps_slam_summary": os.path.join("mps", "slam"),
+    "mps_hand_tracking": os.path.join("mps", "hand_tracking"),
+}
+
+
+def calculate_file_sha1(file_path: str) -> str:
+    sha1 = hashlib.sha1()
+    with open(file_path, "rb") as file:
+        chunk = file.read(4096)  # Read the file in 4KB chunks
+        while chunk:
+            sha1.update(chunk)
+            chunk = file.read(4096)
+
+    sha1_sum = sha1.hexdigest()
+    return sha1_sum
+
+
+class DatasetDownloaderBase:
+    __KEY_URL: str = "download_url"
+    __KEY_FILENAME: str = "filename"
+    __KEY_CHECKSUM: str = "sha1sum"
+
+    def __init__(
+        self,
+        cdn_file: str,
+        data_types: List[str],
+        sequences: Optional[List[str]] = None,
+        overwrite: bool = False,
+    ):
+        # add slam summary if any slam data is requested
+        if "mps_slam_summary" not in data_types:
+            if (
+                "mps_slam_trajectories" in data_types
+                or "mps_slam_calibration" in data_types
+                or "mps_slam_points" in data_types
+            ):
+                data_types.append("mps_slam_summary")
+
+        self.data_types_selected = data_types
+        self.overwrite = overwrite
+
+        # load cdn file
+        with open(cdn_file, "r") as f:
+            cdn_file_data = json.load(f)
+            if "sequences" not in cdn_file_data:
+                raise Exception("invalid cdn_file, missing key: sequences")
+            self.sequences_data = cdn_file_data["sequences"]
+            if "sequence_config" not in cdn_file_data:
+                raise Exception("invalid cdn_file, missing key: sequence_config")
+            self.sequence_config = cdn_file_data["sequence_config"]
+
+        self.sequences = sequences
+        if sequences is None:
+            self.sequences = self.__get_all_sequences()
+
+        self.data_types_all = load_data_groups_from_cdn(cdn_file)
+
+    def download_data(self, output_folder: str):
+        if not os.path.exists(output_folder):
+            print(f"Creating local output folder {output_folder}")
+            os.makedirs(output_folder)
+
+        # download sequences
+        responses = {}
+        for sequence in self.sequences:
+            responses[sequence] = self.__download_sequence(
+                sequence=sequence,
+                output_folder=output_folder,
+            )
+        num_success_sequences = sum(1 for sequence in responses if responses[sequence])
+        print(
+            f"{num_success_sequences} of {len(self.sequences)} sequences are successfully downloaded"
+        )
+
+    def __download_sequence(
+        self,
+        sequence: str,
+        output_folder: str,
+    ) -> bool:
+        output_folder_seq = os.path.join(output_folder, sequence)
+        print(f"downloading sequence {sequence} to {output_folder_seq}")
+
+        if sequence not in self.sequences_data:
+            print(f"sequence {sequence} is not available in the selected data group")
+            return False
+
+        if not os.path.exists(output_folder_seq):
+            os.makedirs(output_folder_seq)
+
+        # check last download status
+        status_manager = DatasetDownloadStatusManager(self.data_types_all)
+        status_json = os.path.join(output_folder_seq, DOWNLOAD_STATUS_FILE)
+        if os.path.exists(status_json):
+            status_manager.from_json(status_json)
+
+        final_success = True
+        for data_type in self.data_types_selected:
+            # skip the data which has already been downloaded if overwrite is not set
+            if not self.overwrite and status_manager.get_download_status(data_type):
+                print(f"skip downloading datatype {data_type} since already downloaded")
+                continue
+            data_type_download_is_success = True
+            is_success, status_code = self.__download_data_from_url(
+                sequence=sequence,
+                data_type=data_type,
+                output_folder=output_folder_seq,
+            )
+            if not is_success:
+                data_type_download_is_success = False
+                final_success = False
+                print(f"{data_type} is NOT downloaded with error code {status_code}")
+
+            # log download status for each data_type
+            status_manager.set_download_status(data_type, data_type_download_is_success)
+
+        # write the download status to json
+        status_manager.to_json(status_json)
+        return final_success
+
+    def __download_data_from_url(
+        self,
+        sequence: str,
+        data_type: str,
+        output_folder: str,
+    ) -> Tuple[bool, int]:
+        status_code = STATUS_CODE_DEFAULT
+        is_success = True
+        sequence_data = self.sequences_data[sequence]
+
+        if data_type not in sequence_data:
+            print(f"Data type {data_type} is not available for sequence: {sequence}")
+            return is_success, status_code
+
+        network_link = sequence_data[data_type][self.__KEY_URL]
+        if not network_link:
+            print(
+                f"Url for sequence '{sequence}', data type '{data_type}' is not available"
+            )
+            return is_success, status_code
+
+        try:
+            with tempfile.TemporaryDirectory() as local_tmp_path:
+                download_filename = sequence_data[data_type][self.__KEY_FILENAME]
+                download_file_path = os.path.join(local_tmp_path, download_filename)
+                sha1sum = sequence_data[data_type][self.__KEY_CHECKSUM]
+                session = requests.Session()
+                # allow retry on errors of too many requests (429), internal server error (500),
+                # bad gateway (502), service unavailable (503), or gateway timeout (504)
+
+                retries = Retry(
+                    total=5,
+                    backoff_factor=2,  # final try is 2*(2**5) = 64 seconds
+                    status_forcelist=[429, 500, 502, 503, 504],
+                )
+
+                session.mount("https://", HTTPAdapter(max_retries=retries))
+
+                with session.get(network_link, stream=True, timeout=10) as r:
+                    # r.raise_for_status()
+                    total_size_in_bytes = int(r.headers.get("content-length", 0))
+
+                    _, _, free_disk_in_bytes = shutil.disk_usage("/")
+                    if free_disk_in_bytes < total_size_in_bytes:
+                        raise Exception(
+                            f"Insufficient disk space for sequence '{sequence}' data type '{data_type}'. Required \
+                            {total_size_in_bytes} bytes, available {free_disk_in_bytes} bytes"
+                        )
+                    with open(download_file_path, "wb") as f:
+                        print(f"Serializing to {download_file_path}")
+                        progress_bar = tqdm(
+                            total=total_size_in_bytes, unit="iB", unit_scale=True
+                        )
+                        for chunk in r.iter_content(chunk_size=CHUCK_SIZE_BYTE):
+                            # serialize chunk of 8KB
+                            progress_bar.update(len(chunk))
+                            f.write(chunk)
+                        progress_bar.close()
+                    status_code = r.status_code
+                    # raise exception if download fails and skip the unzip part below
+                    r.raise_for_status()
+
+                calculated_checksum = calculate_file_sha1(download_file_path)
+                if sha1sum != calculated_checksum:
+                    error = f"different checksum value for sequence '{sequence}' and data type '{data_type}'\n"
+                    error += f"Calculated checksum: {calculated_checksum}, expected checksum: {sha1sum}"
+                    raise Exception(error)
+
+                if is_zipfile(download_file_path):
+                    # unzip and reorganize
+                    with ZipFile(download_file_path) as zip_ref:
+                        unzipped_top_dir_name = sequence
+                        unzipped_dir = os.path.join(
+                            local_tmp_path, unzipped_top_dir_name
+                        )
+                        if not os.path.exists(unzipped_dir):
+                            os.makedirs(unzipped_dir)
+
+                        # MOVE MPS FILES
+                        if data_type in DATA_TYPE_TO_SAVE_PATH.keys():
+                            zip_ref.extractall(output_folder)
+                            for local_path in zip_ref.namelist():
+                                abs_path = os.path.join(output_folder, local_path)
+                                if os.path.isfile(abs_path):
+                                    move_filename = os.path.basename(abs_path)
+                                    move_path = os.path.join(
+                                        Path(abs_path).parent,
+                                        DATA_TYPE_TO_SAVE_PATH[data_type],
+                                    )
+                                    os.makedirs(move_path, exist_ok=True)
+                                    shutil.move(
+                                        abs_path, os.path.join(move_path, move_filename)
+                                    )
+                        else:
+                            zip_ref.extractall(output_folder)
+                else:
+                    output_filename = os.path.join(output_folder, download_filename)
+                    if data_type == "main_vrs":
+                        basename_old = os.path.basename(output_filename)
+                        basename_new = "recording.vrs"
+                        output_filename = output_filename.replace(
+                            basename_old, basename_new
+                        )
+                    shutil.copyfile(
+                        download_file_path,
+                        output_filename,
+                    )
+        except Exception as e:
+            # Handle request exceptions (e.g., ConnectionError, TooManyRedirects, etc.)
+            print(f"An error occurred: {e}. Status code: {status_code}")
+            is_success = False
+
+        return is_success, status_code
+
+    def __get_all_sequences(self) -> List[str]:
+        return list(self.sequences_data.keys())

HOT3D/raw/script/official/hot3d/data_downloader/dataset_downloader_base_main.py

@@ -0,0 +1,140 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import argparse
+
+from dataset_downloader_base import DatasetDownloaderBase
+from utils import load_data_groups_from_cdn, load_sequences_list_from_cdn
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(formatter_class=argparse.RawTextHelpFormatter)
+    parser.add_argument(
+        "-c",
+        "--cdn_file",
+        dest="cdn_file",
+        type=str,
+        required=True,
+        default=None,
+        help="input file listing the CDN urls",
+    )
+
+    parser.add_argument(
+        "-o",
+        "--output_folder",
+        dest="output_folder",
+        type=str,
+        required=True,
+        help="output folder for storing the downloaded dataset locally",
+    )
+
+    parser.add_argument(
+        "-w",
+        "--overwrite",
+        dest="overwrite",
+        action="store_true",
+        required=False,
+        default=False,
+        help="""
+        If set, re-download and overwrite sequences which have been downloaded before
+        """,
+    )
+
+    parser.add_argument(
+        "-d",
+        "--data_types",
+        dest="data_types",
+        nargs="+",
+        required=False,
+        default=[],
+        help="""
+        List (space separated) of data types to download for each sequence.
+        To get a list of all data types available for this dataset, leave this blank and it will list all options.
+        If not set, and IFF single data type exists, it will will be downloaded automatically",
+        """,
+    )
+
+    parser.add_argument(
+        "-l",
+        "--sequence_names",
+        dest="sequence_names",
+        nargs="+",
+        required=False,
+        help="a list of sequence names (separated by space) to be downloaded. If not set, all sequences will be downloaded",
+    )
+
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+
+    all_data_groups = load_data_groups_from_cdn(args.cdn_file)
+    all_data_groups_list = list(all_data_groups.keys())
+    # remove slam summary since this gets downloaded automatically if any slam data is requested
+    if "mps_slam_summary" in all_data_groups_list:
+        all_data_groups_list.remove("mps_slam_summary")
+
+    # If sequence_names is specified as "all", retrieve all sequences from the CDN file
+    if len(args.sequence_names) == 1 and "all" in args.sequence_names:
+        args.sequence_names = load_sequences_list_from_cdn(args.cdn_file)
+
+    # If data_types are not specified, ask the user to specify one
+    # If only one data type is available, automatically download it
+    if len(args.data_types) == 0 and len(all_data_groups_list) > 1:
+        print("-d(, --data_types) must be specified")
+        print("Available data types include:")
+        for i in range(len(all_data_groups_list)):
+            print(f"{i}: {all_data_groups_list[i]}")
+        exit(1)
+    elif len(all_data_groups_list) == 1:
+        args.data_types = [0]  # Download the only existing data type available
+    elif "all" in args.data_types:
+        args.data_types = [i for i in range(len(all_data_groups_list))]
+
+    data_types = []
+    for input_data_type in args.data_types:
+        data_types.append(all_data_groups_list[int(input_data_type)])
+
+    if args.sequence_names is None:
+        download_all = (
+            input(
+                """
+                -l(, --sequence_names) is not specified.
+                Do you want to download all sequences? [y/n]
+                """
+            ).lower()
+            == "y"
+        )
+        if not download_all:
+            print("Please rerun the command with -l(, --sequence_names) specified.")
+            print(
+                "Here is the list of available sequences:\n",
+                load_sequences_list_from_cdn(args.cdn_file),
+            )
+            exit(1)
+    else:
+        print(f"Downloading the following sequences: {args.sequence_names}")
+
+    downloader = DatasetDownloaderBase(
+        cdn_file=args.cdn_file,
+        data_types=data_types,
+        sequences=args.sequence_names,
+        overwrite=args.overwrite,
+    )
+    downloader.download_data(output_folder=args.output_folder)
+
+
+if __name__ == "__main__":
+    main()

HOT3D/raw/script/official/hot3d/data_downloader/utils.py

@@ -0,0 +1,120 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+import os
+from typing import Dict, Final, List
+
+
+###########################################################################
+
+# We require AT LEAST ONE of these files for eye_gaze
+MPS_EYE_GAZE_FILES_REQUIRED: Final[List[str]] = [
+    "general_eye_gaze.csv",
+    "generalized_eye_gaze.csv",
+    "personalized_eye_gaze.csv",
+    "calibrated_eye_gaze.csv",
+]
+
+MPS_EYE_GAZE_FILES: Final[List[str]] = MPS_EYE_GAZE_FILES_REQUIRED + ["summary.json"]
+
+# We requires ALL of these SLAM files
+MPS_SLAM_FILES_REQUIRED: Final[List[str]] = [
+    "closed_loop_trajectory.csv",
+    "open_loop_trajectory.csv",
+    "online_calibration.jsonl",
+    "semidense_observations.csv.gz",
+]
+
+MPS_SLAM_FILES: Final[List[str]] = MPS_SLAM_FILES_REQUIRED + [
+    "semidense_points.csv.gz",
+    "global_points.csv.gz",
+    "summary.json",
+]
+
+MPS_FOLDER: Final[str] = "mps"
+MPS_SLAM_FOLDER: Final[str] = "slam"
+MPS_EYE_GAZE_FOLDER: Final[str] = "eye_gaze"
+
+MPS_SLAM_GROUP_FILES: Final[Dict[str, List[str]]] = {
+    "mps_slam_trajectories": [MPS_SLAM_FILES[0], MPS_SLAM_FILES[1]],
+    "mps_slam_calibration": [MPS_SLAM_FILES[2]],
+    "mps_slam_points": [
+        MPS_SLAM_FILES[3],
+        MPS_SLAM_FILES[4],
+        MPS_SLAM_FILES[5],
+    ],
+    "mps_slam_summary": [MPS_SLAM_FILES[6]],
+}
+MPS_DATA_GROUP_FILES: Final[Dict[str, List[str]]] = {
+    **MPS_SLAM_GROUP_FILES,
+    **{
+        "mps_eye_gaze": MPS_EYE_GAZE_FILES,
+    },
+}
+###########################################################################
+
+
+# Load the list of sequences listed from the cdn file
+def load_sequences_list_from_cdn(cdn_file: str) -> List[str]:
+    if not os.path.exists(cdn_file):
+        raise Exception("CDN file does not exist")
+
+    # load sequences from cdn file
+    sequences_list = []
+    with open(cdn_file, "r") as f:
+        cdn_file_data = json.load(f)
+        if "sequences" not in cdn_file_data:
+            raise Exception("invalid cdn_file, missing key: sequences")
+        sequences_list = cdn_file_data["sequences"].keys()
+    return sequences_list
+
+
+# Load a list of data group name to all files included in that data group
+def load_data_groups_from_cdn(cdn_file: str) -> Dict[str, List[str]]:
+    if not os.path.exists(cdn_file):
+        raise Exception("CDN file does not exist")
+
+    # load sequence_config from cdn file
+    sequence_config = {}
+    with open(cdn_file, "r") as f:
+        cdn_file_data = json.load(f)
+        if "sequence_config" not in cdn_file_data:
+            raise Exception("invalid cdn_file, missing key: sequence_config")
+        sequence_config = cdn_file_data["sequence_config"]
+
+    data_groups = {}
+
+    # load main vrs data group
+    if "main" not in sequence_config:
+        raise Exception("invalid cdn_file, missing key: sequence_config/main")
+    main_data = sequence_config["main"]
+    if "recording" not in main_data:
+        raise Exception("invalid cdn_file, missing key: sequence_config/main/recording")
+
+    # Only add "recording" and "mps" data if they are defined as different than None
+    if main_data["recording"] != "None":
+        data_groups["main_vrs"] = main_data["recording"]
+    if main_data["mps"] != "None":
+        # next add mps data groups which are predefined
+        data_groups.update(MPS_DATA_GROUP_FILES)
+
+    # load custom data groups for this dataset
+    if "data_groups" not in sequence_config:
+        raise Exception("invalid cdn_file, missing key: sequence_config/data_groups")
+
+    for data_group, files in sequence_config["data_groups"].items():
+        data_groups[data_group] = files
+
+    return data_groups