scripts: update make_parquet_v2.py for v3 schema (domain column) + 10-subset coverage

scripts/make_parquet_v2.py

@@ -35,9 +35,23 @@ 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
-EMPTY_TAU   = 4.0                    # mean |frame - baseline| threshold (greylevels)
-EMPTY_BUDGET= 0.03                   # allow up to 3% empties through
-PHASH_DIST  = 4                      # max hamming distance for "duplicate"
+
+# 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([
@@ -71,6 +85,8 @@ SCHEMA = pa.schema([
     ("frame_idx", pa.int32()),
     ("digit_class", pa.int32()),
     ("gel_variant", pa.string()),
+    # v3 — distinguish real-world capture vs synthetic
+    ("domain", pa.string()),    # "real" | "sim"
 ])
 
 
@@ -189,16 +205,29 @@ def iter_tactile_tracking():
 
 def iter_real_tactile_mnist():
     """RTM seq-320x240: parquet with 'sensor_video' list-of-struct{bytes,path}.
-    Each row is one 'round' = one digit touched ~256 times. Each touch video
-    is 60-75 frames long but the actual contact window is only ~6 frames
-    (typically near the end of the video). We pick the frame at the *middle
-    of the touch window* using `touch_start_time_rel` / `touch_end_time_rel`
-    plus the per-frame `time_stamp_rel_seq`. As a fallback when timestamps
-    are missing or stale, we pick the frame with highest central std.
+
+    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)
@@ -220,41 +249,47 @@ def iter_real_tactile_mnist():
                     tmpf = f"/tmp/_rtm_{os.getpid()}.mp4"
                     with open(tmpf, "wb") as f: f.write(vid_bytes)
                     cap = cv2.VideoCapture(tmpf)
-                    frames = []
+                    frames = []; grays = []
                     while True:
                         ok, fr = cap.read()
                         if not ok: break
-                        frames.append(fr[:, :, ::-1])
+                        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 not frames: continue
+                    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]
 
-                    pick_idx = None
-                    # Try timestamp-based pick first
+                    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):
-                            t_mid = (ts0 + (ts1 - ts0) / 2)
-                            diffs = [abs((t - t_mid).total_seconds()) for t in ts]
-                            pick_idx = int(np.argmin(diffs))
+                            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:
-                        pick_idx = None
-
-                    # Fallback: frame with max central-region std
-                    if pick_idx is None:
-                        stds = []
-                        for fr in frames:
-                            g = np.asarray(Image.fromarray(fr).convert("L"),
-                                           dtype=np.float32)
-                            h, w = g.shape
-                            stds.append(float(g[h//4:3*h//4, w//4:3*w//4].std()))
-                        pick_idx = int(np.argmax(stds))
-
-                    yield frames[pick_idx], {
+                        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}",
@@ -262,7 +297,7 @@ def iter_real_tactile_mnist():
                         "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": pick_idx,
+                        "frame_idx": peak_idx,
                     }
 
 
@@ -290,11 +325,151 @@ def iter_feelanyforce():
             }
 
 
+def iter_sim_tactile_mnist():
+    """Sim Tactile MNIST seq-320x240 (Taxim Mini-calibrated).
+    Schema: parquet rows, each row = one digit, with `sensor_image` = list of
+    32 JPEG-bytes structs (one image per touch, already at peak contact).
+    No video decoding, no filtering — sim frames are by construction valid.
+    """
+    root = f"{BASE_DATA}/markerless/SimTactileMNIST"
+    pq_files = sorted(glob(f"{root}/data/*.parquet"))
+    for p in pq_files:
+        fn = os.path.basename(p).lower()
+        if "test" in fn: split = "test"
+        elif "val" in fn: split = "val"
+        else: split = "train"
+        pf = pq.ParquetFile(p)
+        for batch in pf.iter_batches(batch_size=8):
+            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]
+                images = cols["sensor_image"][i] or []
+                for tj, img_struct in enumerate(images):
+                    if not img_struct: continue
+                    img_bytes = img_struct.get("bytes") if isinstance(img_struct, dict) else None
+                    if not img_bytes: continue
+                    try:
+                        rgb = np.array(Image.open(io.BytesIO(img_bytes)).convert("RGB"))
+                    except Exception:
+                        continue
+                    yield rgb, {
+                        "source": "sim_tactile_mnist",
+                        "markered": False,
+                        "domain": "sim",
+                        "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": tj,
+                    }
+
+
+def iter_sim_starstruck():
+    """Sim Star-Struck (Taxim Mini-calibrated). Same schema as sim_tactile_mnist
+    but objects are star-shapes instead of digits.
+    """
+    root = f"{BASE_DATA}/markerless/SimStarStruck"
+    pq_files = sorted(glob(f"{root}/data/*.parquet"))
+    for p in pq_files:
+        fn = os.path.basename(p).lower()
+        if "test" in fn: split = "test"
+        elif "val" in fn: split = "val"
+        else: split = "train"
+        pf = pq.ParquetFile(p)
+        for batch in pf.iter_batches(batch_size=8):
+            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]
+                obj_id = cols.get("object_id", [None]*n)[i]
+                images = cols["sensor_image"][i] or []
+                for tj, img_struct in enumerate(images):
+                    if not img_struct: continue
+                    img_bytes = img_struct.get("bytes") if isinstance(img_struct, dict) else None
+                    if not img_bytes: continue
+                    try:
+                        rgb = np.array(Image.open(io.BytesIO(img_bytes)).convert("RGB"))
+                    except Exception:
+                        continue
+                    yield rgb, {
+                        "source": "sim_starstruck",
+                        "markered": False,
+                        "domain": "sim",
+                        "capture": f"r{round_id}_t{tj}",
+                        "split": split,
+                        "obj_name": "starstruck",
+                        "episode": str(obj_id) if obj_id is not None else None,
+                        "frame_idx": tj,
+                    }
+
+
+def iter_tacquad_mini():
+    """TacQuad multi-sensor → keep only the GelSight Mini frames per
+    `contact_*.csv` index ranges.
+    """
+    import csv
+    root = f"{BASE_DATA}/multi_sensor/TacQuad"
+    # extracted layout: per-object folders + contact_*.csv index files
+    csv_files = sorted(glob(f"{root}/**/contact_*.csv", recursive=True))
+    for csv_path in csv_files:
+        sub_dir = os.path.dirname(csv_path)
+        split = "train"  # tacquad has no formal splits in csv naming
+        with open(csv_path) as f:
+            reader = csv.DictReader(f)
+            for row in reader:
+                folder = row.get("folder", "")
+                try:
+                    mini_start = int(row.get("GelSight Mini start", "-1") or -1)
+                    mini_end   = int(row.get("GelSight Mini end",   "-1") or -1)
+                except Exception:
+                    continue
+                if mini_start < 0 or mini_end < 0: continue
+                obj_folder = os.path.join(sub_dir, folder)
+                # The Mini frames live in a per-sensor subfolder; common layouts:
+                #   <folder>/gelsight_mini/<idx>.png
+                #   <folder>/GelSight_Mini/<idx>.png
+                cand_dirs = [
+                    os.path.join(obj_folder, "gelsight_mini"),
+                    os.path.join(obj_folder, "GelSight_Mini"),
+                    os.path.join(obj_folder, "gs_mini"),
+                ]
+                d = next((c for c in cand_dirs if os.path.isdir(c)), None)
+                if d is None: continue
+                for idx in range(mini_start, mini_end + 1):
+                    for ext in (".png", ".jpg", ".jpeg"):
+                        fp = os.path.join(d, f"{idx}{ext}")
+                        if os.path.isfile(fp):
+                            try:
+                                rgb = np.array(Image.open(fp).convert("RGB"))
+                            except Exception:
+                                rgb = None
+                            if rgb is None: continue
+                            text = row.get("text", "")
+                            yield rgb, {
+                                "source": "tacquad_mini",
+                                "markered": False,
+                                "domain": "real",
+                                "capture": f"{folder}_{idx}",
+                                "split": split,
+                                "obj_name": folder,
+                                "episode": folder,
+                                "frame_idx": idx,
+                            }
+                            break
+
+
 SOURCE_ITERS = {
     "gelslam":            iter_gelslam,
     "tactile_tracking":   iter_tactile_tracking,
     "real_tactile_mnist": iter_real_tactile_mnist,
     "feelanyforce":       iter_feelanyforce,
+    "sim_tactile_mnist":  iter_sim_tactile_mnist,
+    "sim_starstruck":     iter_sim_starstruck,
+    "tacquad_mini":       iter_tacquad_mini,
 }
 
 # Per-source overrides for the validity filter.
@@ -309,6 +484,9 @@ SKIP_EMPTY_FILTER = {
     "real_tactile_mnist": True,
     "gelslam":            False,
     "tactile_tracking":   False,
+    "sim_tactile_mnist":  True,   # sim frames already at peak contact by construction
+    "sim_starstruck":     True,
+    "tacquad_mini":       True,   # tacquad CSV already picks contact frames
 }
 
 
@@ -460,7 +638,7 @@ def process(sub: str, probe_info: dict):
         g_center = grey_center(fr)
         skip_empty = SKIP_EMPTY_FILTER.get(sub, False)
 
-        # Build baseline from first BASE_FRAMES (only when empty-filter is active)
+        # Build baseline from first BASE_FRAMES (only when validity filter is active)
         if not skip_empty and cap_baseline is None:
             cap_buffer.append(g_center)
             cap_seen_within += 1
@@ -471,11 +649,16 @@ def process(sub: str, probe_info: dict):
 
         n_seen += 1
         if skip_empty:
-            deformation = 0.0
             is_empty = False
         else:
-            deformation = float(np.abs(g_center - cap_baseline).mean())
-            is_empty = deformation < EMPTY_TAU
+            # Area + intensity validity rule (replaces former mean-deform tau)
+            pixel_diff = np.abs(g_center - cap_baseline)
+            mask = pixel_diff > PIXEL_THRESH
+            contact_area = int(mask.sum())
+            contact_intensity = float(pixel_diff[mask].mean()) if contact_area > 0 else 0.0
+            thresh = VALIDITY_THRESH.get(sub, dict(A_min=200, I_min=12))
+            is_empty = (contact_area < thresh["A_min"]) \
+                       or (contact_intensity < thresh["I_min"])
 
         # Stride decision (uniform stride based on target/total estimate later)
         # We use a live rate-limiter: every K frames, keep 1 (K adjusted live)