Add dataset metadata: annotations, camera info, transforms, README

archive_index.parquet

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

bad_files.parquet

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

build_dataset.py

@@ -0,0 +1,315 @@
+#!/usr/bin/env python3
+"""
+Build dataset from merged_result.parquet + LakeFS.
+Downloads PCD and JPG files, packages into ~250 MB ZIP archives in 3D_o/.
+"""
+
+import pandas as pd
+import numpy as np
+import requests
+import os
+import sys
+import json
+import time
+import shutil
+import zipfile
+import concurrent.futures
+import pickle
+from pathlib import Path
+from collections import defaultdict
+
+# Config
+LAKEFS_BASE = 'http://10.248.52.100:8001'
+AK = os.environ['LAKEFS_ACCESS_KEY']
+SK = os.environ['LAKEFS_SECRET_KEY']
+OUTPUT_DIR = Path('/workspace/3D_o')
+PCD_SIZE_FILE = '/workspace/pcd_file_sizes.parquet'
+JPG_SIZE_FILE = '/workspace/jpg_file_sizes.parquet'
+MERGED_FILE = '/workspace/merged_result.parquet'
+PLAN_FILE = '/workspace/chunks_data.pkl'
+CHUNK_TARGET = 250 * 1024 * 1024  # 250 MB
+CHUNK_MIN = 200 * 1024 * 1024     # 200 MB
+MAX_WORKERS = 30  # parallel downloads per chunk
+REQUEST_TIMEOUT = 120
+
+OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+
+session = requests.Session()
+session.auth = (AK, SK)
+
+# ----- STEP 0: Load sizes -----
+print("[0] Loading data...")
+merged = pd.read_parquet(MERGED_FILE)
+pcd_sizes = pd.read_parquet(PCD_SIZE_FILE)
+jpg_sizes = pd.read_parquet(JPG_SIZE_FILE)
+pcd_size_map = dict(zip(pcd_sizes['path'], pcd_sizes['size']))
+jpg_size_map = dict(zip(jpg_sizes['path'], jpg_sizes['size']))
+
+# ----- STEP 1: Build deduplicated PCD list -----
+print("[1] Building deduplicated PCD list...")
+# For each unique PCD, get its bag_id (first occurrence's bag_id and timestamp)
+pcd_info = merged.drop_duplicates(subset='path')[['path', 'path_to_jpg', 'bag_id', 'main_timestamp']].copy()
+pcd_info = pcd_info.sort_values(['bag_id', 'main_timestamp']).reset_index(drop=True)
+print(f"  Unique PCDs: {len(pcd_info)}")
+
+# Add sizes
+pcd_info['pcd_size'] = pcd_info['path'].map(pcd_size_map)
+pcd_info['jpg_size'] = pcd_info['path_to_jpg'].map(jpg_size_map).fillna(0).astype(int)
+pcd_info['total_size'] = pcd_info['pcd_size'] + pcd_info['jpg_size']
+
+missing_sizes = pcd_info['pcd_size'].isna().sum()
+if missing_sizes:
+    print(f"  WARNING: {missing_sizes} PCDs missing sizes, estimating at 5MB")
+    pcd_info['pcd_size'] = pcd_info['pcd_size'].fillna(5_000_000).astype(int)
+    pcd_info['total_size'] = pcd_info['pcd_size'] + pcd_info['jpg_size']
+
+total_data_size = pcd_info['total_size'].sum()
+print(f"  Total dataset size: {total_data_size / 1e9:.1f} GB")
+print(f"  Estimated archives: {total_data_size / CHUNK_TARGET:.0f}")
+
+# Count how many PCDs have JPGs
+with_jpg = (pcd_info['jpg_size'] > 0).sum()
+print(f"  PCDs with JPGs: {with_jpg}")
+
+# ----- STEP 2: Build chunk plan -----
+chunk_plan_path = Path(PLAN_FILE)
+if chunk_plan_path.exists():
+    print("[2] Loading existing chunk plan...")
+    with open(chunk_plan_path, 'rb') as f:
+        chunks = pickle.load(f)
+    print(f"  Loaded {len(chunks)} chunks")
+else:
+    print("[2] Building chunk plan...")
+    chunks = []
+    current_chunk = []
+    current_size = 0
+    chunk_idx = 0
+    
+    for idx, row in pcd_info.iterrows():
+        item_size = int(row['total_size'])
+        
+        if current_size > 0 and current_size + item_size > CHUNK_TARGET and current_size >= CHUNK_MIN:
+            chunks.append({
+                'index': chunk_idx,
+                'name': f'data_{chunk_idx:04d}.zip',
+                'files': current_chunk,
+                'total_size': current_size,
+                'bag_ids': list(set(f['bag_id'] for f in current_chunk)),
+            })
+            chunk_idx += 1
+            current_chunk = []
+            current_size = 0
+        
+        current_chunk.append({
+            'pcd_path': row['path'],
+            'jpg_path': row['path_to_jpg'] if pd.notna(row['path_to_jpg']) else None,
+            'bag_id': row['bag_id'],
+            'pcd_size': int(row['pcd_size']),
+            'jpg_size': int(row['jpg_size']),
+            'main_timestamp': int(row['main_timestamp']),
+        })
+        current_size += item_size
+    
+    # Last chunk
+    if current_chunk:
+        chunks.append({
+            'index': chunk_idx,
+            'name': f'data_{chunk_idx:04d}.zip',
+            'files': current_chunk,
+            'total_size': current_size,
+            'bag_ids': list(set(f['bag_id'] for f in current_chunk)),
+        })
+    
+    with open(chunk_plan_path, 'wb') as f:
+        pickle.dump(chunks, f)
+    print(f"  Created {len(chunks)} chunks, saved plan")
+
+# Summary
+total_planned = sum(c['total_size'] for c in chunks)
+print(f"  Total planned size: {total_planned / 1e9:.1f} GB")
+print(f"  Chunks: {len(chunks)}, avg size: {total_planned/len(chunks)/1e6:.0f} MB")
+
+# ----- STEP 3: Process chunks (download + zip) -----
+# Find out which chunks are already done
+existing_zips = set(f.name for f in OUTPUT_DIR.iterdir() if f.suffix == '.zip')
+done_indices = set()
+for c in chunks:
+    if c['name'] in existing_zips:
+        # Verify zip is valid
+        try:
+            with zipfile.ZipFile(OUTPUT_DIR / c['name'], 'r') as zf:
+                if zf.testzip() is None:
+                    done_indices.add(c['index'])
+        except:
+            pass
+
+todo_chunks = [c for c in chunks if c['index'] not in done_indices]
+print(f"\n[3] Processing chunks ({len(todo_chunks)} remaining, {len(done_indices)} done)...")
+
+def download_file(file_info):
+    """Download a single PCD or JPG file to temp directory."""
+    result = {}
+    
+    # Download PCD
+    pcd_uuid = Path(file_info['pcd_path']).stem
+    pcd_tmp = OUTPUT_DIR / f'tmp_{pcd_uuid}.pcd'
+    if not pcd_tmp.exists():
+        url = f'{LAKEFS_BASE}/api/v1/repositories/astraldb/refs/main/objects'
+        r = session.get(url, params={'path': file_info['pcd_path']}, timeout=REQUEST_TIMEOUT)
+        if r.status_code != 200:
+            return {'error': f'PCD download failed: {r.status_code}', 'pcd_uuid': pcd_uuid}
+        with open(pcd_tmp, 'wb') as f:
+            f.write(r.content)
+    result['pcd_tmp'] = str(pcd_tmp)
+    result['pcd_arc'] = f"pcd/{pcd_uuid}.pcd"
+    
+    # Download JPG if exists
+    if file_info['jpg_path']:
+        jpg_uuid = Path(file_info['jpg_path']).stem
+        jpg_tmp = OUTPUT_DIR / f'tmp_{jpg_uuid}.jpg'
+        if not jpg_tmp.exists():
+            url = f'{LAKEFS_BASE}/api/v1/repositories/ros2bags/refs/main/objects'
+            r = session.get(url, params={'path': file_info['jpg_path']}, timeout=REQUEST_TIMEOUT)
+            if r.status_code != 200:
+                result['jpg_error'] = f'JPG download failed: {r.status_code}'
+            else:
+                with open(jpg_tmp, 'wb') as f:
+                    f.write(r.content)
+        if jpg_tmp.exists():
+            result['jpg_tmp'] = str(jpg_tmp)
+            result['jpg_arc'] = f"jpg/{jpg_uuid}.jpg"
+    
+    return result
+
+def process_chunk(chunk):
+    """Download all files for a chunk and create ZIP."""
+    chunk_name = chunk['name']
+    zip_path = OUTPUT_DIR / chunk_name
+    
+    if zip_path.exists():
+        try:
+            with zipfile.ZipFile(zip_path, 'r') as zf:
+                if zf.testzip() is None:
+                    return {'index': chunk['index'], 'name': chunk_name, 'status': 'already_done'}
+        except:
+            pass
+    
+    # Parallel download
+    with concurrent.futures.ThreadPoolExecutor(max_workers=MAX_WORKERS) as ex:
+        dl_results = list(ex.map(download_file, chunk['files']))
+    
+    errors = [r for r in dl_results if 'error' in r]
+    if errors:
+        # Clean up temps
+        for r in dl_results:
+            for key in ['pcd_tmp', 'jpg_tmp']:
+                if key in r and Path(r[key]).exists():
+                    Path(r[key]).unlink()
+        return {'index': chunk['index'], 'name': chunk_name, 'status': 'error', 'errors': errors}
+    
+    # Create ZIP
+    with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED, compresslevel=1) as zf:
+        for r in dl_results:
+            zf.write(r['pcd_tmp'], r['pcd_arc'])
+            if 'jpg_tmp' in r:
+                zf.write(r['jpg_tmp'], r['jpg_arc'])
+    
+    # Clean up temp files
+    for r in dl_results:
+        for key in ['pcd_tmp', 'jpg_tmp']:
+            if key in r and Path(r[key]).exists():
+                Path(r[key]).unlink()
+    
+    actual_size = zip_path.stat().st_size
+    return {'index': chunk['index'], 'name': chunk_name, 'status': 'ok', 'size': actual_size}
+
+# Process chunks one by one to manage disk space
+for i, chunk in enumerate(todo_chunks):
+    print(f"  Chunk {i+1}/{len(todo_chunks)}: {chunk['name']} ({chunk['total_size']/1e6:.0f} MB, {len(chunk['files'])} files)...", end=' ')
+    sys.stdout.flush()
+    result = process_chunk(chunk)
+    if result['status'] == 'ok':
+        print(f"OK ({result['size']/1e6:.0f} MB)")
+    elif result['status'] == 'error':
+        print(f"ERROR: {result['errors'][:2]}")
+    elif result['status'] == 'already_done':
+        print("already done")
+
+# Save updated plan (in case we need to resume)
+final_chunks = []
+for c in chunks:
+    zip_path = OUTPUT_DIR / c['name']
+    c['actual_size'] = zip_path.stat().st_size if zip_path.exists() else 0
+    final_chunks.append(c)
+with open(chunk_plan_path, 'wb') as f:
+    pickle.dump(final_chunks, f)
+
+print(f"\n[3] Done processing. Zips in {OUTPUT_DIR}:")
+for f in sorted(OUTPUT_DIR.glob('*.zip')):
+    print(f"  {f.name}: {f.stat().st_size / 1e6:.0f} MB")
+
+# ----- STEP 4: Update merged_result.parquet -----
+print("\n[4] Updating merged_result.parquet...")
+
+# Build PCD -> archive mapping
+pcd_to_archive = {}
+pcd_to_arcpath = {}
+for c in chunks:
+    zip_path = OUTPUT_DIR / c['name']
+    if not zip_path.exists():
+        continue
+    for f_info in c['files']:
+        pcd_path = f_info['pcd_path']
+        pcd_uuid = Path(pcd_path).stem
+        pcd_to_archive[pcd_path] = c['name']
+        pcd_to_arcpath[pcd_path] = f'pcd/{pcd_uuid}.pcd'
+
+# Update merged_result
+merged['archive'] = merged['path'].map(pcd_to_archive)
+merged['pcd_path'] = merged['path'].map(pcd_to_arcpath)
+
+# Build JPG path mapping
+jpg_to_arcpath = {}
+for c in chunks:
+    for f_info in c['files']:
+        if f_info['jpg_path']:
+            jpg_uuid = Path(f_info['jpg_path']).stem
+            jpg_to_arcpath[f_info['jpg_path']] = f'jpg/{jpg_uuid}.jpg'
+
+merged['jpg_path'] = merged['path_to_jpg'].map(jpg_to_arcpath)
+
+# Drop old path columns
+merged = merged.drop(columns=['path', 'path_to_jpg'])
+
+# Reorder columns
+col_order = ['frame_id', 'label', 'data', 'main_timestamp', 'bag_id', 'archive', 'pcd_path', 'jpg_path']
+available_cols = [c for c in col_order if c in merged.columns]
+merged = merged[available_cols]
+
+# Save updated merged_result
+merged.to_parquet('/workspace/merged_result.parquet')
+print(f"  Saved {len(merged)} rows to merged_result.parquet")
+print(f"  Columns: {merged.columns.tolist()}")
+
+# ----- STEP 5: Create archive_index.parquet -----
+print("\n[5] Creating archive_index.parquet...")
+archive_index = []
+for c in chunks:
+    zip_path = OUTPUT_DIR / c['name']
+    if not zip_path.exists():
+        continue
+    timestamps = [f['main_timestamp'] for f in c['files']]
+    archive_index.append({
+        'archive': c['name'],
+        'bag_ids': ','.join(c['bag_ids']),
+        'min_timestamp': min(timestamps),
+        'max_timestamp': max(timestamps),
+        'size_mb': round(zip_path.stat().st_size / 1e6, 1),
+        'file_count': len(c['files']),
+    })
+
+index_df = pd.DataFrame(archive_index)
+index_df.to_parquet('/workspace/archive_index.parquet')
+print(f"  Saved {len(index_df)} entries to archive_index.parquet")
+
+print("\nDone!")

camera_info.parquet

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

cleanup_dataset.py

@@ -0,0 +1,180 @@
+#!/usr/bin/env python3
+"""
+Clean dataset: remove black JPGs (brightness < 30), update metadata.
+No PCD issues found — all PCD sizes are 2-6 MB (healthy).
+"""
+import pandas as pd
+import zipfile
+import io
+import shutil
+import concurrent.futures
+from pathlib import Path
+from collections import defaultdict
+from PIL import Image
+
+ZIP_DIR = Path('/workspace/3D_o')
+MERGED_FILE = '/workspace/merged_result.parquet'
+INDEX_FILE = '/workspace/archive_index.parquet'
+CATALOG_FILE = '/workspace/file_catalog.parquet'
+BAD_FILE = '/workspace/bad_files.parquet'
+
+BRIGHTNESS_THRESHOLD = 30  # below this = black frame
+
+print("=" * 60)
+print("Finding black JPGs (brightness < 30)...")
+print("=" * 60)
+
+catalog = pd.read_parquet(CATALOG_FILE)
+jpg_catalog = catalog[catalog['path'].str.startswith('jpg/')]
+suspicious = jpg_catalog[jpg_catalog['size'] < 500_000]
+print(f"  Suspicious JPGs (< 500 KB): {len(suspicious)}")
+
+def check_archive(archive):
+    bad = []
+    rows = suspicious[suspicious['archive'] == archive]
+    if len(rows) == 0:
+        return bad
+    try:
+        with zipfile.ZipFile(ZIP_DIR / archive, 'r') as zf:
+            for _, row in rows.iterrows():
+                data = zf.read(row['path'])
+                img = Image.open(io.BytesIO(data))
+                gray = img.convert('L')
+                pixels = gray.getdata()
+                n = gray.width * gray.height
+                mean = sum(pixels) / n
+                if mean < BRIGHTNESS_THRESHOLD:
+                    bad.append((archive, row['path'], row['size'], mean))
+    except Exception as e:
+        print(f"  ERROR {archive}: {e}")
+    return bad
+
+archives = suspicious['archive'].unique()
+bad_jpgs = []
+with concurrent.futures.ThreadPoolExecutor(max_workers=8) as ex:
+    results = ex.map(check_archive, archives)
+    for r in results:
+        bad_jpgs.extend(r)
+
+print(f"  Black JPGs found: {len(bad_jpgs)}")
+
+bad_records = []
+for a, p, sz, b in bad_jpgs:
+    bad_records.append({'archive': a, 'path': p, 'type': 'jpg', 'reason': f'black_frame:brightness={b:.1f}'})
+
+bad_df = pd.DataFrame(bad_records)
+bad_df.to_parquet(BAD_FILE)
+print(f"  Saved to {BAD_FILE}")
+
+if len(bad_df) == 0:
+    print("  No bad files found. Dataset is clean!")
+    exit(0)
+
+# Show affected archives
+arc_counts = bad_df.groupby('archive').size().sort_index()
+print(f"\n  Affected archives:")
+for arc, cnt in arc_counts.items():
+    print(f"    {arc}: {cnt} black JPGs")
+
+# ─── Phase 2: Update merged_result.parquet ────────────────────────────────
+print("\n" + "=" * 60)
+print("Updating merged_result.parquet...")
+print("=" * 60)
+
+bad_set = set(zip(bad_df['archive'], bad_df['path']))
+
+merged = pd.read_parquet(MERGED_FILE)
+print(f"  Original rows: {len(merged)}")
+
+# Find rows with bad JPGs
+merged['_bad_jpg'] = merged.apply(
+    lambda r: pd.notna(r['jpg_path']) and (r['archive'], r['jpg_path']) in bad_set, axis=1
+)
+n_bad = merged['_bad_jpg'].sum()
+print(f"  Rows with black JPG: {n_bad}")
+
+# Clear jpg_path for rows with bad JPGs (keep the row, PCD is fine)
+merged.loc[merged['_bad_jpg'], 'jpg_path'] = None
+merged = merged.drop(columns=['_bad_jpg'])
+
+merged.to_parquet(MERGED_FILE)
+print(f"  Saved {len(merged)} rows")
+
+# ─── Phase 3: Repack ZIPs ────────────────────────────────────────────────
+print("\n" + "=" * 60)
+print("Repacking affected ZIP archives...")
+print("=" * 60)
+
+bad_by_archive = defaultdict(list)
+for _, row in bad_df.iterrows():
+    bad_by_archive[row['archive']].append(row['path'])
+
+def repack(archive):
+    zip_path = ZIP_DIR / archive
+    tmp_path = zip_path.with_suffix('.tmp.zip')
+    bad_files = set(bad_by_archive[archive])
+    try:
+        with zipfile.ZipFile(zip_path, 'r') as zin:
+            with zipfile.ZipFile(tmp_path, 'w', zipfile.ZIP_DEFLATED, compresslevel=1) as zout:
+                for info in zin.infolist():
+                    if info.filename not in bad_files:
+                        zout.writestr(info, zin.read(info.filename))
+        orig_size = zip_path.stat().st_size
+        shutil.move(tmp_path, zip_path)
+        new_size = zip_path.stat().st_size
+        removed = sum(1 for f in bad_files)
+        return (archive, 'ok', orig_size, new_size, removed)
+    except Exception as e:
+        if tmp_path.exists():
+            tmp_path.unlink()
+        return (archive, 'error', str(e)[:100])
+
+archives_to_fix = sorted(bad_by_archive.keys())
+print(f"  Archives to repack: {len(archives_to_fix)}")
+
+with concurrent.futures.ThreadPoolExecutor(max_workers=4) as ex:
+    results = list(ex.map(repack, archives_to_fix))
+
+for r in results:
+    if r[1] == 'ok':
+        saving = (r[2] - r[3]) / 1e6
+        print(f"    {r[0]}: {r[2]/1e6:.0f} MB -> {r[3]/1e6:.0f} MB ({r[4]} files removed, -{saving:.0f} MB)")
+    else:
+        print(f"    {r[0]}: ERROR - {r[2]}")
+
+# ─── Phase 4: Update archive_index.parquet ────────────────────────────────
+print("\n" + "=" * 60)
+print("Updating archive_index.parquet...")
+print("=" * 60)
+
+records = []
+for zp in sorted(ZIP_DIR.glob('*.zip')):
+    try:
+        with zipfile.ZipFile(zp, 'r') as zf:
+            info_list = zf.infolist()
+        records.append({
+            'archive': zp.name,
+            'size_mb': round(zp.stat().st_size / 1e6, 1),
+            'file_count': len(info_list),
+            'pcd_count': sum(1 for i in info_list if i.filename.startswith('pcd/')),
+            'jpg_count': sum(1 for i in info_list if i.filename.startswith('jpg/')),
+        })
+    except Exception as e:
+        print(f"  ERROR {zp.name}: {e}")
+
+new_index = pd.DataFrame(records)
+new_index.to_parquet(INDEX_FILE)
+print(f"  Saved {len(new_index)} entries")
+
+# ─── Summary ──────────────────────────────────────────────────────────────
+print("\n" + "=" * 60)
+print("CLEANUP SUMMARY")
+print("=" * 60)
+print(f"  Black JPGs removed: {len(bad_jpgs)}")
+print(f"  Archives repacked: {len(archives_to_fix)}")
+print(f"  Rows with cleared jpg_path: {n_bad}")
+print(f"  Total dataset size: {new_index['size_mb'].sum():.0f} MB")
+print(f"  Total valid files: {new_index['file_count'].sum()}")
+print(f"  Total valid PCDs: {new_index['pcd_count'].sum()}")
+print(f"  Total valid JPGs: {new_index['jpg_count'].sum()}")
+print("\nDone! Dataset is clean.")

file_catalog.parquet

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

merged_result.parquet

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

tf.parquet

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