#!/usr/bin/env python3 """V2 pipeline: pack GelSLAM, TactileTracking, RealTactileMNIST, FeelAnyForce into the unified parquet schema used by `yxma/gelsight-mini-pretrain`. Adaptive subsampling per source: - per-source frame budget = min(200_000, contact_frames_available) - dynamism-aware stride (high inter-frame delta -> denser sample) - validity filter: drop frames where central deformation < threshold - perceptual-hash dedupe Outputs sit alongside existing fota_*/threedcal/feats: /media/yxma/Disk1/yuxiang/mini_data_parquet/_{/{train|...}-####-of-####.parquet

Usage:
python make_parquet_v2.py probe _{# measure dynamism + empty fraction
python make_parquet_v2.py process _{# full pipeline + write
python make_parquet_v2.py stats # show row counts across all subs
"""

import io
import json
import os
import sys
import time
from collections import defaultdict
from glob import glob
from typing import Iterator, Optional, Tuple

import numpy as np
import pyarrow as pa
import pyarrow.parquet as pq
from PIL import Image

BASE_DATA = "/media/yxma/Disk1/yuxiang/mini_data"
BASE_OUT = "/media/yxma/Disk1/yuxiang/mini_data_parquet"
BUDGET = 200_000 # max kept frames per source
SHARD_TGT = 2 * 1024 ** 3 # 2 GB shard target

# Validity filter — area + intensity rule (replaces former mean-deform tau).
# A frame is valid iff, on the central-50%-crop |frame - baseline| diff:
# n_pixels_above(PIXEL_THRESH) >= A_min AND their mean diff >= I_min
PIXEL_THRESH = 10 # sensor-noise floor, grey-levels
EMPTY_BUDGET = 0.03 # ≤ 3 % of kept frames may sneak below A_min/I_min
PHASH_DIST = 4 # max hamming distance for "duplicate"

# Per-source validity thresholds (A_min in pixels, I_min in grey-levels).
# Calibrated visually for each sensor/recording style.
VALIDITY_THRESH = {
"gelslam": dict(A_min=200, I_min=12),
"tactile_tracking": dict(A_min=200, I_min=12),
# All non-listed sources are entered in SKIP_EMPTY_FILTER below and use
# source-specific selection (e.g. RTM has its own area+intensity inside
# the iterator).
}

# Existing schema + 3 new nullable cols
SCHEMA = pa.schema([
("image", pa.binary()),
("image_format", pa.string()),
("source", pa.string()),
("markered", pa.bool_()),
("capture", pa.string()),
("split", pa.string()),
("height", pa.int32()),
("width", pa.int32()),
("obj_name", pa.string()),
("init_pose", pa.int32()),
("side", pa.string()),
("x_mm", pa.float32()),
("y_mm", pa.float32()),
("z_mm", pa.float32()),
("quat_x", pa.float32()),
("quat_y", pa.float32()),
("quat_z", pa.float32()),
("quat_w", pa.float32()),
("indenter", pa.string()),
("indenter_param", pa.string()),
("f_x", pa.float32()),
("f_y", pa.float32()),
("f_z", pa.float32()),
("grid_z_max", pa.float32()),
("grid_z_mean", pa.float32()),
# NEW columns (nullable for old data)
("episode", pa.string()),
("frame_idx", pa.int32()),
("digit_class", pa.int32()),
("gel_variant", pa.string()),
# v3 — distinguish real-world capture vs synthetic
("domain", pa.string()), # "real" | "sim"
])

# ─────────────────────────────────────────────────────────────────
# helpers
# ─────────────────────────────────────────────────────────────────

def encode_jpeg(arr_rgb: np.ndarray, q=92) -> bytes:
im = Image.fromarray(arr_rgb)
buf = io.BytesIO()
im.save(buf, format="JPEG", quality=q, optimize=True)
return buf.getvalue()

def grey_center(arr: np.ndarray) -> np.ndarray:
"""Central 50% crop, greyscale, float32."""
if arr.ndim == 3:
g = arr.mean(axis=2)
else:
g = arr
h, w = g.shape
return g[h//4:3*h//4, w//4:3*w//4].astype(np.float32)

def phash(arr_rgb: np.ndarray) -> int:
"""8x8 DCT-low-freq perceptual hash, returned as 64-bit int."""
im = Image.fromarray(arr_rgb).convert("L").resize((32, 32), Image.LANCZOS)
a = np.array(im, dtype=np.float32)
# 2D DCT via numpy
def dct1(x): return np.fft.fft(np.concatenate([x, x[::-1]], axis=-1)).real[..., :x.shape[-1]]
d = dct1(dct1(a).T).T
low = d[:8, :8].flatten()
med = np.median(low[1:]) # skip DC
h = 0
for bit in (low > med):
h = (h << 1) | int(bit)
return h

def hamming(a: int, b: int) -> int:
return bin(a ^ b).count("1")

# ─────────────────────────────────────────────────────────────────
# Per-source iterators
# Each yields (frame_rgb_np, base_meta_dict) for ONE frame at a time.
# Within each episode/capture, frames are emitted in order so we can
# compute a baseline image for the validity filter.
# ─────────────────────────────────────────────────────────────────

def iter_gelslam():
"""GelSLAM: gelsight.avi per episode under tracking_dataset/ and reconstruction_dataset/."""
import cv2
root = f"{BASE_DATA}/markerless/GelSLAM"
# The HF download puts content under root or root/dataset/ depending on extraction
for sub in ("tracking_dataset", "reconstruction_dataset"):
candidates = (
glob(f"{root}/{sub}/*/gelsight.avi") +
glob(f"{root}/dataset/{sub}/*/gelsight.avi")
)
for vid in candidates:
episode = os.path.basename(os.path.dirname(vid))
split = "train" if sub == "tracking_dataset" else "recon"
cap = cv2.VideoCapture(vid)
fi = 0
while True:
ok, fr = cap.read()
if not ok:
break
fr = fr[:, :, ::-1] # BGR->RGB
yield fr, {
"source": "gelslam",
"markered": False,
"capture": f"{sub}/{episode}",
"split": split,
"obj_name": episode,
"episode": episode,
"frame_idx": fi,
}
fi += 1
cap.release()

def iter_tactile_tracking():
import cv2
import re
root = f"{BASE_DATA}/markerless/TactileTracking"
candidates = sorted(glob(f"{root}/normalflow_dataset/*/gelsight.avi"))
obj_re = re.compile(r"^([a-zA-Z]+)(\d+)$")
for vid in candidates:
trial_dir = os.path.basename(os.path.dirname(vid)) # e.g. 'corner3'
m = obj_re.match(trial_dir)
if m:
obj, trial = m.group(1), m.group(2)
else:
obj, trial = trial_dir, "0"
cap = cv2.VideoCapture(vid)
fi = 0
while True:
ok, fr = cap.read()
if not ok:
break
fr = fr[:, :, ::-1]
yield fr, {
"source": "tactile_tracking",
"markered": False,
"capture": f"{obj}/{trial}",
"split": "train",
"obj_name": obj,
"episode": trial,
"frame_idx": fi,
}
fi += 1
cap.release()

def iter_real_tactile_mnist():
"""RTM seq-320x240: parquet with 'sensor_video' list-of-struct{bytes,path}.

Frame-picking strategy (v4 — area+intensity rule):
1. Decode all frames in the touch video clip (~60-73 frames).
2. Compute a per-clip baseline = median of first 5 frames (no-contact prologue).
3. Use `touch_start_time_rel`/`touch_end_time_rel` to find frames inside
the contact window. Within that window, pick the frame with maximum
mean-|diff| from baseline (the peak-contact frame).
4. On the picked frame, compute:
pixel_diff = |frame - baseline| on central 50% crop (grey-levels)
mask = pixel_diff > PIXEL_THRESH (default 10)
contact_area = mask.sum() (in pixels)
contact_int = pixel_diff[mask].mean() (avg deformation in lit pixels)
5. Keep iff `contact_area >= RTM_A_MIN` AND `contact_int >= RTM_I_MIN`.
Tunables: RTM_PIXEL_THRESH=10, RTM_A_MIN=40, RTM_I_MIN=15.
Probe at these values: ~16% keep, ~24K final rows, every kept frame
visually shows a clear digit-edge imprint.
"""
import cv2
root = f"{BASE_DATA}/markerless/RealTactileMNIST"
pq_files = sorted(glob(f"{root}/data/*.parquet"))
PIXEL_THRESH = 10
A_MIN = 40
I_MIN = 15
for p in pq_files:
split = "test" if "test" in os.path.basename(p).lower() else "train"
pf = pq.ParquetFile(p)
for batch in pf.iter_batches(batch_size=4):
cols = batch.to_pydict()
n = len(cols.get("label", cols.get("id", [])))
for i in range(n):
round_id = cols.get("id", [None]*n)[i]
label = cols.get("label", [None]*n)[i]
obj_id = cols.get("object_id", [None]*n)[i]
videos = cols["sensor_video"][i] or []
ts_seq = cols.get("time_stamp_rel_seq", [None]*n)[i] or []
t_start = cols.get("touch_start_time_rel", [None]*n)[i] or []
t_end = cols.get("touch_end_time_rel", [None]*n)[i] or []
for tj, vid_struct in enumerate(videos):
if not vid_struct: continue
vid_bytes = vid_struct.get("bytes") if isinstance(vid_struct, dict) else None
if not vid_bytes: continue
tmpf = f"/tmp/_rtm_{os.getpid()}.mp4"
with open(tmpf, "wb") as f: f.write(vid_bytes)
cap = cv2.VideoCapture(tmpf)
frames = []; grays = []
while True:
ok, fr = cap.read()
if not ok: break
rgb = fr[:, :, ::-1]
frames.append(rgb)
g = cv2.cvtColor(fr, cv2.COLOR_BGR2GRAY).astype(np.float32)
h, w = g.shape
grays.append(g[h//4:3*h//4, w//4:3*w//4])
cap.release()
try: os.remove(tmpf)
except: pass
if len(frames) < 8: continue

baseline = np.median(np.stack(grays[:5]), axis=0)
deforms = [float(np.abs(g - baseline).mean()) for g in grays]

in_window = list(range(len(frames)))
try:
ts = ts_seq[tj] if tj < len(ts_seq) else None
ts0 = t_start[tj] if tj < len(t_start) else None
ts1 = t_end[tj] if tj < len(t_end) else None
if ts is not None and ts0 is not None and ts1 is not None \
and len(ts) == len(frames):
in_window = [k for k, t in enumerate(ts) if ts0 <= t <= ts1]
if not in_window:
in_window = list(range(len(frames)))
except Exception:
pass

peak_idx = in_window[int(np.argmax([deforms[k] for k in in_window]))]

# area + intensity rule on the picked peak frame
pixel_diff = np.abs(grays[peak_idx] - baseline)
mask = pixel_diff > PIXEL_THRESH
contact_area = int(mask.sum())
if contact_area < A_MIN: continue
contact_int = float(pixel_diff[mask].mean())
if contact_int < I_MIN: continue

yield frames[peak_idx], {
"source": "real_tactile_mnist",
"markered": False,
"capture": f"r{round_id}_t{tj}",
"split": split,
"obj_name": f"digit_{label}",
"digit_class": int(label) if label is not None else None,
"episode": str(obj_id) if obj_id is not None else None,
"frame_idx": peak_idx,
}

def iter_feelanyforce():
"""FAF: loose 320x240 PNG per indentation under dataset/}}}