rebuild sim/ from the probe package

sim/calibration/T_gel_to_rigid_left.json

@@ -0,0 +1,166 @@
+{
+  "method": "dual_ball_multi_pose",
+  "refball_center_in_rigid_mm": [
+    -33.51740422401229,
+    12.100255314675977,
+    -17.699792261606614
+  ],
+  "gelball_center_in_rigid_mm": [
+    -43.47382768891848,
+    -41.22508071829758,
+    -35.7960391945282
+  ],
+  "gel_axis_in_rigid": [
+    -0.17411894520453713,
+    -0.9324875086795467,
+    -0.31646427772731606
+  ],
+  "gel_distance_mm": 57.19086670954521,
+  "depth_offset_mm": -5.0,
+  "gel_center_in_rigid_mm": [
+    -42.603232962895795,
+    -36.56264317489985,
+    -34.21371780589162
+  ],
+  "consistency": {
+    "refball_mean_deviation_mm": 0.4971205477445346,
+    "refball_max_deviation_mm": 0.6830937323295619,
+    "refball_std_mm": [
+      0.3822793790831837,
+      0.14607220822214068,
+      0.3370989262846435
+    ],
+    "gelball_mean_deviation_mm": 0.5311059103030308,
+    "gelball_max_deviation_mm": 0.7146199631539334,
+    "gelball_std_mm": [
+      0.23387391401966107,
+      0.402760954424785,
+      0.30624407553769517
+    ],
+    "axis_max_angle_deg": 1.069223796324866,
+    "ball_distance_std_mm": 0.09592190067940498
+  },
+  "mocap_scale": 1000.0,
+  "raw_data": [
+    {
+      "pose_id": 0,
+      "rigid_position_mm": [
+        209.704,
+        67.29599999999999,
+        288.7
+      ],
+      "rigid_quaternion": [
+        -0.03045,
+        0.5291786,
+        0.72056156,
+        0.447052
+      ],
+      "refball_mocap_mm": [
+        213.805,
+        32.849000000000004,
+        307.12899999999996
+      ],
+      "refball_rigid_mm": [
+        -33.064365762599664,
+        12.164420770736669,
+        -17.37287066173849
+      ],
+      "gelball_mocap_mm": [
+        247.768,
+        13.639999999999999,
+        265.48699999999997
+      ],
+      "gelball_rigid_mm": [
+        -43.61612381039666,
+        -40.65963065991089,
+        -36.20919744147588
+      ],
+      "ball_distance_mm": 57.0659899940411,
+      "axis_in_rigid": [
+        -0.18490449475946746,
+        -0.9256660830060691,
+        -0.33007973368558585
+      ]
+    },
+    {
+      "pose_id": 1,
+      "rigid_position_mm": [
+        207.22,
+        63.50699999999999,
+        137.26
+      ],
+      "rigid_quaternion": [
+        0.575241,
+        0.53501,
+        -0.513944,
+        0.344559
+      ],
+      "refball_mocap_mm": [
+        226.556,
+        69.48400000000001,
+        172.275
+      ],
+      "refball_rigid_mm": [
+        -33.99941004902249,
+        12.238224727792783,
+        -18.163744708359914
+      ],
+      "gelball_mocap_mm": [
+        179.374,
+        93.761,
+        193.90099999999998
+      ],
+      "gelball_rigid_mm": [
+        -43.661251420623046,
+        -41.44844032643957,
+        -35.70194717225823
+      ],
+      "ball_distance_mm": 57.29919483727493,
+      "axis_in_rigid": [
+        -0.16862089247570416,
+        -0.936953219093185,
+        -0.3060811327926228
+      ]
+    },
+    {
+      "pose_id": 2,
+      "rigid_position_mm": [
+        261.399,
+        57.67,
+        194.732
+      ],
+      "rigid_quaternion": [
+        -0.63276,
+        0.187712,
+        0.37411,
+        0.65147
+      ],
+      "refball_mocap_mm": [
+        235.038,
+        31.395,
+        208.37800000000001
+      ],
+      "refball_rigid_mm": [
+        -33.48843686041472,
+        11.898120445498478,
+        -17.562761414721432
+      ],
+      "gelball_mocap_mm": [
+        271.628,
+        16.011,
+        249.575
+      ],
+      "gelball_rigid_mm": [
+        -43.14410783573577,
+        -41.5671711685423,
+        -35.4769729698505
+      ],
+      "ball_distance_mm": 57.2074152973196,
+      "axis_in_rigid": [
+        -0.16878355585789684,
+        -0.9345867373341344,
+        -0.3131449211964034
+      ]
+    }
+  ]
+}

sim/calibration/T_gel_to_rigid_right.json

@@ -0,0 +1,166 @@
+{
+  "method": "dual_ball_multi_pose",
+  "refball_center_in_rigid_mm": [
+    -17.372443520938578,
+    0.2688573520951536,
+    38.571757518679924
+  ],
+  "gelball_center_in_rigid_mm": [
+    3.1680846750991996,
+    -53.986407194707084,
+    47.297869103141956
+  ],
+  "gel_axis_in_rigid": [
+    0.3501488269090003,
+    -0.9248037787338816,
+    0.148774224426762
+  ],
+  "gel_distance_mm": 58.67110647491247,
+  "depth_offset_mm": 0.0,
+  "gel_center_in_rigid_mm": [
+    3.1680846750991996,
+    -53.986407194707084,
+    47.297869103141956
+  ],
+  "consistency": {
+    "refball_mean_deviation_mm": 0.4043795279250868,
+    "refball_max_deviation_mm": 0.5722584634835464,
+    "refball_std_mm": [
+      0.305325273790818,
+      0.1894397197001601,
+      0.23772566675184065
+    ],
+    "gelball_mean_deviation_mm": 0.7191394130923946,
+    "gelball_max_deviation_mm": 1.044514511519201,
+    "gelball_std_mm": [
+      0.13210638866223554,
+      0.258334234777561,
+      0.7129747489275182
+    ],
+    "axis_max_angle_deg": 1.0670723640750364,
+    "ball_distance_std_mm": 0.1918993038441838
+  },
+  "mocap_scale": 1000.0,
+  "raw_data": [
+    {
+      "pose_id": 0,
+      "rigid_position_mm": [
+        308.47,
+        92.09,
+        161.42000000000002
+      ],
+      "rigid_quaternion": [
+        0.0631,
+        -0.18618,
+        -0.33139,
+        -0.92278
+      ],
+      "refball_mocap_mm": [
+        307.62899999999996,
+        91.333,
+        203.91500000000002
+      ],
+      "refball_rigid_mm": [
+        -17.42214690726894,
+        0.24440448450872054,
+        38.77517786663904
+      ],
+      "gelball_mocap_mm": [
+        359.197,
+        63.277,
+        203.299
+      ],
+      "gelball_rigid_mm": [
+        2.9816863949711774,
+        -54.181252282163626,
+        47.0400848891515
+      ],
+      "ball_distance_mm": 58.70926005324889,
+      "axis_in_rigid": [
+        0.3475402906412716,
+        -0.927037007744752,
+        0.14077688962552495
+      ]
+    },
+    {
+      "pose_id": 1,
+      "rigid_position_mm": [
+        353.27599999999995,
+        105.303,
+        229.32
+      ],
+      "rigid_quaternion": [
+        -0.28615,
+        -0.956937,
+        0.017508,
+        -0.045615
+      ],
+      "refball_mocap_mm": [
+        371.03799999999995,
+        93.362,
+        192.52700000000002
+      ],
+      "refball_rigid_mm": [
+        -17.719051737135942,
+        0.05003692040386909,
+        38.70185623252837
+      ],
+      "gelball_mocap_mm": [
+        324.832,
+        59.405,
+        181.358
+      ],
+      "gelball_rigid_mm": [
+        3.272234055436968,
+        -53.6213442033486,
+        48.27095310963361
+      ],
+      "ball_distance_mm": 58.419336233818946,
+      "axis_in_rigid": [
+        0.35932085411852144,
+        -0.9187263085108816,
+        0.163800164363485
+      ]
+    },
+    {
+      "pose_id": 2,
+      "rigid_position_mm": [
+        223.578,
+        72.762,
+        125.58900000000001
+      ],
+      "rigid_quaternion": [
+        0.267991,
+        -0.024821,
+        -0.319484,
+        -0.908567
+      ],
+      "refball_mocap_mm": [
+        204.961,
+        82.694,
+        161.719
+      ],
+      "refball_rigid_mm": [
+        -16.976131918410857,
+        0.5121306513728712,
+        38.23823845687237
+      ],
+      "gelball_mocap_mm": [
+        252.446,
+        62.707,
+        190.23399999999998
+      ],
+      "gelball_rigid_mm": [
+        3.250333574889453,
+        -54.15662509860903,
+        46.582569310640764
+      ],
+      "ball_distance_mm": 58.884723137669575,
+      "axis_in_rigid": [
+        0.3434925803423043,
+        -0.9284030362538862,
+        0.14170620848908067
+      ]
+    }
+  ]
+}

sim/calibration/T_mocap_to_cam_left.json

@@ -0,0 +1,115 @@
+{
+ "description": "T_mocap_to_cam: maps OptiTrack (mm) -> camera frame (mm)",
+ "T_mocap_to_cam": [
+  [
+   -0.810677868162443,
+   -0.4417948639462208,
+   -0.38421178048354576,
+   158.37843079282737
+  ],
+  [
+   -0.2945501948324127,
+   0.8748721945072194,
+   -0.3844981482430172,
+   284.86657177938224
+  ],
+  [
+   0.5060055106377637,
+   -0.19853448433171958,
+   -0.8393702888090293,
+   685.6891619250176
+  ],
+  [
+   0.0,
+   0.0,
+   0.0,
+   1.0
+  ]
+ ],
+ "camera_serial": "104122062574",
+ "intrinsics": {
+  "fx": 608.4557495117188,
+  "fy": 608.1494750976562,
+  "ppx": 316.0635986328125,
+  "ppy": 224.6374053955078,
+  "width": 640,
+  "height": 480
+ },
+ "mocap_scale": 1000.0,
+ "num_points": 6,
+ "rmse_mm": 4.747439312142084,
+ "residuals_mm": [
+  3.140296552809229,
+  4.349449571685337,
+  4.871127835377674,
+  2.593150843339738,
+  3.17090715166062,
+  8.120525615331562
+ ],
+ "points_cam_mm": [
+  [
+   16.711177825927734,
+   89.64736938476562,
+   786.0000610351562
+  ],
+  [
+   90.5625228881836,
+   48.319942474365234,
+   766.0000610351562
+  ],
+  [
+   83.88683319091797,
+   15.152631759643555,
+   811.0000610351562
+  ],
+  [
+   -216.6715087890625,
+   79.90221405029297,
+   928.0000610351562
+  ],
+  [
+   -252.9880828857422,
+   -4.093912601470947,
+   944.0000610351562
+  ],
+  [
+   -326.0710144042969,
+   26.836889266967773,
+   940.0000610351562
+  ]
+ ],
+ "points_mocap_mm": [
+  [
+   225.43099999999998,
+   47.395,
+   127.916
+  ],
+  [
+   169.44400000000002,
+   48.577000000000005,
+   192.14600000000002
+  ],
+  [
+   207.466,
+   27.64,
+   225.561
+  ],
+  [
+   487.104,
+   17.412,
+   63.24
+  ],
+  [
+   546.218,
+   51.876,
+   121.794
+  ],
+  [
+   589.725,
+   72.872,
+   64.61
+  ]
+ ],
+ "created_at": "2026-05-12T22:16:20",
+ "up_axis": "z"
+}

sim/calibration/T_mocap_to_cam_left.npy

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

sim/calibration/T_mocap_to_cam_middle.json

@@ -0,0 +1,137 @@
+{
+ "description": "T_mocap_to_cam: maps OptiTrack (mm) -> camera frame (mm)",
+ "T_mocap_to_cam": [
+  [
+   0.9987689323019825,
+   0.04789247635294343,
+   0.012920161653051267,
+   -394.4763993373926
+  ],
+  [
+   0.04826421351573066,
+   -0.9983784326630464,
+   -0.030183950818081413,
+   -270.493443209141
+  ],
+  [
+   0.011453626590133171,
+   0.030770373771911365,
+   -0.9994608539286934,
+   826.019809512672
+  ],
+  [
+   0.0,
+   0.0,
+   0.0,
+   1.0
+  ]
+ ],
+ "camera_serial": "217222066989",
+ "intrinsics": {
+  "fx": 609.06005859375,
+  "fy": 608.275390625,
+  "ppx": 332.47943115234375,
+  "ppy": 239.3525390625,
+  "width": 640,
+  "height": 480
+ },
+ "mocap_scale": 1000.0,
+ "num_points": 8,
+ "rmse_mm": 5.298559912741648,
+ "residuals_mm": [
+  5.6271211125758995,
+  10.154049290401456,
+  5.295565503833297,
+  3.904543899485634,
+  4.413577550470772,
+  1.7606626889517276,
+  3.887479237641652,
+  2.9745783556701872
+ ],
+ "points_cam_mm": [
+  [
+   -138.17422485351562,
+   -176.80650329589844,
+   783.0000610351562
+  ],
+  [
+   -203.81289672851562,
+   -122.2757797241211,
+   764.0000610351562
+  ],
+  [
+   -176.41786193847656,
+   -83.21672058105469,
+   799.0000610351562
+  ],
+  [
+   -160.75990295410156,
+   -65.39496612548828,
+   806.0000610351562
+  ],
+  [
+   -45.515159606933594,
+   -123.39057159423828,
+   804.0000610351562
+  ],
+  [
+   -18.994951248168945,
+   -117.36901092529297,
+   799.0000610351562
+  ],
+  [
+   36.103763580322266,
+   -105.6508560180664,
+   771.0000610351562
+  ],
+  [
+   53.24198913574219,
+   -181.49072265625,
+   781.0000610351562
+  ]
+ ],
+ "points_mocap_mm": [
+  [
+   261.084,
+   48.644,
+   84.548
+  ],
+  [
+   195.857,
+   50.153999999999996,
+   138.387
+  ],
+  [
+   228.08700000000002,
+   29.228,
+   177.35799999999998
+  ],
+  [
+   242.60999999999999,
+   20.526,
+   195.374
+  ],
+  [
+   355.329,
+   17.682,
+   130.42100000000002
+  ],
+  [
+   382.233,
+   28.935,
+   135.28799999999998
+  ],
+  [
+   437.52000000000004,
+   51.916,
+   144.34900000000002
+  ],
+  [
+   449.58799999999997,
+   50.361000000000004,
+   70.165
+  ]
+ ],
+ "created_at": "2026-05-12T20:34:29",
+ "up_axis": "z"
+}

sim/calibration/T_mocap_to_cam_middle.npy

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

sim/calibration/T_mocap_to_cam_right.json

@@ -0,0 +1,115 @@
+{
+ "description": "T_mocap_to_cam: maps OptiTrack (mm) -> camera frame (mm)",
+ "T_mocap_to_cam": [
+  [
+   -0.7060810935772296,
+   0.6950316252373175,
+   0.13557481039174474,
+   605.2919096634614
+  ],
+  [
+   0.5284341378626592,
+   0.644604762743106,
+   -0.5524871598419762,
+   -100.86727498691573
+  ],
+  [
+   -0.47138821711422957,
+   -0.3184583799633454,
+   -0.8224216734723081,
+   1061.7990457647895
+  ],
+  [
+   0.0,
+   0.0,
+   0.0,
+   1.0
+  ]
+ ],
+ "camera_serial": "143322063538",
+ "intrinsics": {
+  "fx": 608.547607421875,
+  "fy": 606.7799072265625,
+  "ppx": 314.88201904296875,
+  "ppy": 243.41900634765625,
+  "width": 640,
+  "height": 480
+ },
+ "mocap_scale": 1000.0,
+ "num_points": 6,
+ "rmse_mm": 7.520075033441005,
+ "residuals_mm": [
+  5.862949060495028,
+  5.926871764374507,
+  9.172862106825736,
+  3.5435031927827803,
+  8.811105858313384,
+  9.77106902542866
+ ],
+ "points_cam_mm": [
+  [
+   150.92872619628906,
+   131.20069885253906,
+   740.0000610351562
+  ],
+  [
+   138.0159454345703,
+   81.08906555175781,
+   799.0000610351562
+  ],
+  [
+   189.72586059570312,
+   98.56414794921875,
+   824.0000610351562
+  ],
+  [
+   216.35919189453125,
+   107.14408874511719,
+   838.0000610351562
+  ],
+  [
+   367.6980285644531,
+   -94.39984130859375,
+   964.0000610351562
+  ],
+  [
+   363.8806457519531,
+   -169.8037872314453,
+   1006.0000610351562
+  ]
+ ],
+ "points_mocap_mm": [
+  [
+   589.6700000000001,
+   72.957,
+   64.666
+  ],
+  [
+   545.219,
+   53.733999999999995,
+   120.568
+  ],
+  [
+   506.815,
+   28.365000000000002,
+   92.73
+  ],
+  [
+   487.085,
+   17.403,
+   63.273999999999994
+  ],
+  [
+   225.428,
+   47.405,
+   127.916
+  ],
+  [
+   169.442,
+   48.574,
+   192.152
+  ]
+ ],
+ "created_at": "2026-05-12T22:31:39",
+ "up_axis": "z"
+}

sim/calibration/T_mocap_to_cam_right.npy

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

sim/index.html

@@ -0,0 +1,428 @@
+<!doctype html><meta charset="utf-8">
+<title>React — interactive sensor simulator</title>
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<style>
+:root{color-scheme:dark}
+body{margin:0;background:#0e1116;color:#e8eaed;
+     font:14px/1.5 ui-sans-serif,system-ui,-apple-system,"Segoe UI",sans-serif}
+header{padding:14px 18px 6px}
+h1{font-size:17px;margin:0 0 4px;font-weight:600}
+.sub{color:#9aa3ad;font-size:12.5px;max-width:76ch}
+main{padding:10px 18px 28px}
+.row{display:flex;flex-wrap:wrap;gap:10px;margin-bottom:10px}
+.tile{position:relative;flex:0 0 auto;border-radius:6px;overflow:hidden;
+      background:#000;line-height:0}
+.tile img{display:block;width:100%;height:auto}
+/* width AND height, both, in CSS. The HTML width/height attributes are
+   presentational hints: setting only the CSS width let the img and its
+   canvas resolve to different heights and every marker sat ~90 px off
+   while every number in the page stayed correct. */
+.tile canvas{position:absolute;inset:0;width:100%;height:100%}
+.cap{position:absolute;left:0;top:0;padding:2px 6px;font-size:11px;
+     background:rgba(0,0,0,.55);color:#cfd6de;line-height:1.4;z-index:2}
+.frozen{position:absolute;right:0;bottom:0;padding:2px 6px;font-size:11px;
+        background:rgba(120,60,0,.72);color:#ffd9a8;line-height:1.4;z-index:2}
+.panel{display:flex;gap:22px;flex-wrap:wrap;align-items:flex-start;
+       background:#151a21;border:1px solid #232a33;border-radius:8px;
+       padding:12px 16px;margin-top:4px}
+.panel h2{font-size:12px;letter-spacing:.06em;text-transform:uppercase;
+          color:#8d97a2;margin:0 0 6px;font-weight:600}
+kbd{background:#222933;border:1px solid #333c47;border-bottom-width:2px;
+    border-radius:4px;padding:0 5px;font:12px ui-monospace,monospace;color:#dfe5ec}
+table{border-collapse:collapse;font-size:12.5px}
+td{padding:1px 10px 1px 0;vertical-align:top}
+.num{font:12.5px ui-monospace,monospace;color:#bfe6ff}
+.sel{font-weight:600}
+.warn{color:#ffb86b}
+.pill{display:inline-block;padding:1px 8px;border-radius:99px;font-size:12px;
+      background:#1d2630;border:1px solid #2c3844;margin-right:6px}
+</style>
+<header>
+  <h1>Interactive sensor simulator</h1>
+  <p class="sub" data-tactile-note>Drive either GelSight with the keyboard and
+  watch its projected frame move. <b>The photographs are frozen</b> — the three
+  camera views and both tactile images are a single recorded instant and do not
+  respond to the action. Only the overlay moves. No model is wired in yet, so
+  nothing here is a prediction of what the sensor would see.</p>
+</header>
+<main>
+  <div class="row" id="views"></div>
+  <div class="row" id="tactile"></div>
+  <div class="panel">
+    <div>
+      <h2>Driving</h2>
+      <table>
+        <tr><td><kbd>Tab</kbd></td><td>switch sensor</td></tr>
+        <tr><td><kbd>←</kbd><kbd>→</kbd></td><td>world x</td></tr>
+        <tr><td><kbd>↑</kbd><kbd>↓</kbd></td><td>world y</td></tr>
+        <tr><td><kbd>[</kbd><kbd>]</kbd></td><td>world z (up)</td></tr>
+        <tr><td><kbd>A</kbd><kbd>D</kbd></td><td>rotate about x</td></tr>
+        <tr><td><kbd>W</kbd><kbd>S</kbd></td><td>rotate about y</td></tr>
+        <tr><td><kbd>Q</kbd><kbd>E</kbd></td><td>rotate about z</td></tr>
+        <tr><td><kbd>R</kbd></td><td>reset</td></tr>
+      </table>
+    </div>
+    <div>
+      <h2>Action so far</h2>
+      <table>
+        <tr><td>driving</td><td class="num sel" id="side">—</td></tr>
+        <tr><td>translation</td><td class="num" id="tr">0, 0, 0 mm</td></tr>
+        <tr><td>rotation</td><td class="num" id="rt">0.0&deg;</td></tr>
+        <tr><td>gel centre</td><td class="num" id="gc">—</td></tr>
+      </table>
+    </div>
+    <div>
+      <h2>Frame</h2>
+      <table>
+        <tr><td>episode</td><td class="num" id="ep">—</td></tr>
+        <tr><td>row</td><td class="num" id="rw">—</td></tr>
+        <tr><td>world</td><td class="num" id="ua">—</td></tr>
+      </table>
+      <p class="sub" style="margin:8px 0 0;max-width:34ch">
+      Rotation pivots on the <b>gel centre</b>, not on the marker cluster the
+      pose vector describes — the cluster is 65.7&nbsp;mm away and moves.</p>
+    </div>
+  </div>
+</main>
+<script>
+const AXC = ["#ff5a5a", "#5aff8f", "#5aa8ff"];      // x, y, z
+const COL = {left: "#ffd23f", right: "#4fc3f7"};
+let D = null, S = null;
+
+/* ---- small matrix helpers, scalar-LAST quaternions (scipy from_quat) ---- */
+function quatMat(q){
+  const [x,y,z,w]=q, n=Math.hypot(x,y,z,w)||1;
+  const X=x/n,Y=y/n,Z=z/n,W=w/n;
+  return [[1-2*(Y*Y+Z*Z), 2*(X*Y-Z*W),   2*(X*Z+Y*W)],
+          [2*(X*Y+Z*W),   1-2*(X*X+Z*Z), 2*(Y*Z-X*W)],
+          [2*(X*Z-Y*W),   2*(Y*Z+X*W),   1-2*(X*X+Y*Y)]];
+}
+function matQuat(M){                       // -> x, y, z, w
+  const t=M[0][0]+M[1][1]+M[2][2];
+  let x,y,z,w;
+  if(t>0){const s=Math.sqrt(t+1)*2; w=.25*s;
+    x=(M[2][1]-M[1][2])/s; y=(M[0][2]-M[2][0])/s; z=(M[1][0]-M[0][1])/s;}
+  else if(M[0][0]>M[1][1]&&M[0][0]>M[2][2]){
+    const s=Math.sqrt(1+M[0][0]-M[1][1]-M[2][2])*2;
+    w=(M[2][1]-M[1][2])/s; x=.25*s; y=(M[0][1]+M[1][0])/s; z=(M[0][2]+M[2][0])/s;}
+  else if(M[1][1]>M[2][2]){
+    const s=Math.sqrt(1+M[1][1]-M[0][0]-M[2][2])*2;
+    w=(M[0][2]-M[2][0])/s; x=(M[0][1]+M[1][0])/s; y=.25*s; z=(M[1][2]+M[2][1])/s;}
+  else{const s=Math.sqrt(1+M[2][2]-M[0][0]-M[1][1])*2;
+    w=(M[1][0]-M[0][1])/s; x=(M[0][2]+M[2][0])/s; y=(M[1][2]+M[2][1])/s; z=.25*s;}
+  return [x,y,z,w];
+}
+function mv(M,v){return [M[0][0]*v[0]+M[0][1]*v[1]+M[0][2]*v[2],
+                         M[1][0]*v[0]+M[1][1]*v[1]+M[1][2]*v[2],
+                         M[2][0]*v[0]+M[2][1]*v[1]+M[2][2]*v[2]];}
+function mm(A,B){return A.map((r,i)=>[0,1,2].map(j=>
+  A[i][0]*B[0][j]+A[i][1]*B[1][j]+A[i][2]*B[2][j]));}
+function axisRot(k, deg){                  // rotation about world axis k
+  const t=deg*Math.PI/180, c=Math.cos(t), s=Math.sin(t);
+  if(k===0) return [[1,0,0],[0,c,-s],[0,s,c]];
+  if(k===1) return [[c,0,s],[0,1,0],[-s,0,c]];
+  return [[c,-s,0],[s,c,0],[0,0,1]];
+}
+const add=(a,b)=>[a[0]+b[0],a[1]+b[1],a[2]+b[2]];
+const sub=(a,b)=>[a[0]-b[0],a[1]-b[1],a[2]-b[2]];
+function project(Xw, cam){
+  const T=cam.T;
+  const c=[T[0]*Xw[0]+T[1]*Xw[1]+T[2]*Xw[2]+T[3],
+           T[4]*Xw[0]+T[5]*Xw[1]+T[6]*Xw[2]+T[7],
+           T[8]*Xw[0]+T[9]*Xw[1]+T[10]*Xw[2]+T[11]];
+  if(c[2]<=1) return null;
+  return [cam.fx*c[0]/c[2]+cam.ppx, cam.fy*c[1]/c[2]+cam.ppy];
+}
+
+/* ---- the pose a side is currently at ---------------------------------- */
+/* Composition matches react_toolbox.synth_actions.make_rotation_set:
+   the gel centre is the pivot, the delta pre-multiplies (world frame), and
+   the published origin is back-solved from the pivot. Rotating the origin
+   instead would drag the gel 30-50 mm sideways. */
+function poseOf(side){
+  const p = D.pose[side], g = D.gel[side];
+  const R0 = quatMat(p.slice(3,7));
+  const pivot = add([p[0]*1000, p[1]*1000, p[2]*1000], mv(R0, g));
+  const st = S.d[side];
+  const R = mm(st.R, R0);
+  const gel = add(pivot, st.t);
+  return {R, gel, origin: sub(gel, mv(R, g)), quat: matQuat(R)};
+}
+function pointsFor(side, view){
+  const cam = D.cams[view], g = D.gel[side], P = poseOf(side);
+  const tips = [];
+  for(let k=0;k<3;k++){const e=[0,0,0]; e[k]=60;
+    tips.push(project(add(P.origin, mv(P.R, add(g,e))), cam));}
+  return {centre: project(P.gel, cam), origin: project(P.origin, cam), tips};
+}
+
+/* ---- drawing ----------------------------------------------------------- */
+function gizmo(g, view, w){
+  if(view!=="middle") return;
+  const T=D.cams[view].T, ox=88, oy=84, L=42;
+  g.save();
+  g.globalAlpha=.55; g.fillStyle="#12161f";
+  g.beginPath(); g.arc(ox,oy,L+11,0,7); g.fill(); g.globalAlpha=1;
+  g.strokeStyle="#46505f"; g.lineWidth=1.5; g.beginPath();
+  g.arc(ox,oy,L+11,0,7); g.stroke();
+  const R=[[T[0],T[1],T[2]],[T[4],T[5],T[6]],[T[8],T[9],T[10]]];
+  for(let k=0;k<3;k++){
+    const e=[0,0,0]; e[k]=1; const d=mv(R,e);
+    const inp=Math.hypot(d[0],d[1]);
+    g.strokeStyle=AXC[k]; g.fillStyle=AXC[k]; g.lineWidth=3;
+    if(inp>0.12){
+      g.beginPath(); g.moveTo(ox,oy); g.lineTo(ox+d[0]*L, oy+d[1]*L); g.stroke();
+      g.font="600 15px ui-monospace,monospace";
+      g.fillText("xyz"[k], ox+d[0]*(L+14)-4, oy+d[1]*(L+14)+5);
+    }
+    if(Math.abs(d[2])>0.55){                  // out of plane: dot / cross
+      g.beginPath(); g.arc(ox,oy,5,0,7); g.stroke();
+      if(d[2]<0){g.beginPath(); g.arc(ox,oy,2,0,7); g.fill();}
+      else{g.beginPath(); g.moveTo(ox-3,oy-3); g.lineTo(ox+3,oy+3);
+           g.moveTo(ox-3,oy+3); g.lineTo(ox+3,oy-3); g.stroke();}
+      g.font="600 15px ui-monospace,monospace";
+      g.fillText("xyz"[k], ox+13, oy-11);
+    }
+  }
+  g.fillStyle="#dfe6ee"; g.font="600 13px ui-sans-serif";
+  g.fillText("world ("+D.up_axis+"-up)", ox-48, oy+L+30);
+  g.restore();
+}
+function drawView(cv, view){
+  const g=cv.getContext("2d");
+  g.clearRect(0,0,cv.width,cv.height);
+  for(const side of ["left","right"]){
+    const r=pointsFor(side,view);
+    if(!r.centre) continue;
+    if(r.origin){                                  // stem to the marker cluster
+      g.strokeStyle="rgba(200,200,200,.55)"; g.lineWidth=1;
+      g.beginPath(); g.moveTo(r.origin[0],r.origin[1]);
+      g.lineTo(r.centre[0],r.centre[1]); g.stroke();
+      g.fillStyle="rgba(220,220,220,.75)";
+      g.beginPath(); g.arc(r.origin[0],r.origin[1],2.5,0,7); g.fill();
+    }
+    for(let k=0;k<3;k++){const t=r.tips[k]; if(!t) continue;
+      g.strokeStyle=AXC[k]; g.lineWidth=(side===S.side)?3.2:1.6;
+      g.beginPath(); g.moveTo(r.centre[0],r.centre[1]);
+      g.lineTo(t[0],t[1]); g.stroke();}
+    g.fillStyle=COL[side];
+    g.beginPath(); g.arc(r.centre[0],r.centre[1],5,0,7); g.fill();
+    g.strokeStyle=(side===S.side)?"#fff":"rgba(255,255,255,.45)";
+    g.lineWidth=(side===S.side)?2:1; g.stroke();
+    g.fillStyle="#fff"; g.font="600 15px ui-sans-serif";
+    g.fillText(side[0].toUpperCase()+(side===S.side?" *":""),
+               r.centre[0]+8, r.centre[1]-8);
+  }
+  gizmo(g, view, cv.width);
+}
+function redraw(){
+  for(const v of ["left","middle","right"]){
+    const cv=document.querySelector(`[data-stream="view_${v}"] canvas`);
+    if(cv) drawView(cv, v);
+  }
+  const st=S.d[S.side], P=poseOf(S.side);
+  const tr=Math.acos(Math.min(1,Math.max(-1,(st.R[0][0]+st.R[1][1]+st.R[2][2]-1)/2)));
+  document.getElementById("side").textContent=S.side;
+  document.getElementById("tr").textContent =
+    st.t.map(v=>v.toFixed(1)).join(", ")+" mm";
+  document.getElementById("rt").textContent=(tr*180/Math.PI).toFixed(1)+"°";
+  document.getElementById("gc").textContent =
+    P.gel.map(v=>v.toFixed(1)).join(", ")+" mm";
+}
+
+/* ---- input ------------------------------------------------------------- */
+const TRANS={ArrowRight:[0,+1],ArrowLeft:[0,-1],ArrowUp:[1,+1],ArrowDown:[1,-1],
+             BracketRight:[2,+1],BracketLeft:[2,-1]};
+const ROT={KeyD:[0,+1],KeyA:[0,-1],KeyW:[1,+1],KeyS:[1,-1],
+           KeyE:[2,+1],KeyQ:[2,-1]};
+function apply(code){
+  if(code==="Tab"){S.side = S.side==="right" ? "left" : "right"; redraw(); return true;}
+  if(code==="KeyR"){reset(); redraw(); return true;}
+  const st=S.d[S.side];
+  if(TRANS[code]){const [k,s]=TRANS[code]; st.t[k]+=s*D.step_mm; redraw(); return true;}
+  if(ROT[code]){const [k,s]=ROT[code];
+    st.R = mm(axisRot(k, s*D.step_deg), st.R); redraw(); return true;}
+  return false;
+}
+function reset(){
+  S.d={left:{t:[0,0,0],R:[[1,0,0],[0,1,0],[0,0,1]]},
+       right:{t:[0,0,0],R:[[1,0,0],[0,1,0],[0,0,1]]}};
+}
+
+/* ---- build ------------------------------------------------------------- */
+function tile(stream, frozen){
+  const [w,h]=D.size[stream];
+  const d=document.createElement("div");
+  d.className="tile"; d.dataset.stream=stream;
+  // The cameras are what you drive; the tactile pair is frozen. Giving them
+  // equal area put the most weight on the one thing that does NOT respond.
+  d.style.width=(frozen?230:Math.min(w,470))+"px";
+  d.innerHTML=`<img src="${stream}.jpg" width="${w}" height="${h}" alt="${stream}">`
+    +`<canvas width="${w}" height="${h}"></canvas>`
+    +`<span class="cap">${stream.replace("_"," ")}</span>`
+    +(frozen?`<span class="frozen" data-frozen>frozen — not simulated</span>`:``);
+  return d;
+}
+/* The data is INLINED, not fetched. A page that fetch()es its own JSON is
+   blank when opened from file:// -- Chrome blocks the request as
+   cross-origin -- so it would only ever work on the Space. sim.json is still
+   written beside it for tools and tests, and test_sim.py asserts the two
+   copies are identical so they cannot drift. */
+(function(d){
+  D=d; S={side:"right", d:null}; reset();
+  const vs=document.getElementById("views"), ts=document.getElementById("tactile");
+  for(const v of ["left","middle","right"]) vs.appendChild(tile("view_"+v,false));
+  for(const s of ["left","right"]) ts.appendChild(tile("tactile_"+s,true));
+  document.getElementById("ep").textContent=D.key;
+  document.getElementById("rw").textContent=D.row;
+  document.getElementById("ua").textContent=D.up_axis+"-up";
+  redraw();
+  addEventListener("keydown", e=>{ if(apply(e.code)) e.preventDefault(); });
+  /* Test hooks. __sim() reports the state the page is actually drawing from,
+     so a test compares the PAGE against the library rather than against the
+     page's own arithmetic. */
+  window.__key = code => apply(code);
+  window.__sim = () => {
+    const P=poseOf(S.side), O=poseOf(S.side==="right"?"left":"right");
+    const pts={};
+    for(const v of ["left","middle","right"]){
+      pts[v]={};
+      for(const s of ["left","right"]) pts[v][s]=pointsFor(s,v);
+    }
+    return {side:S.side, gel_mm:P.gel, origin_mm:P.origin, quat:P.quat,
+            other_gel_mm:O.gel, t_mm:S.d[S.side].t, points:pts};
+  };
+})({
+ "date": "2026-05-10",
+ "episode": "episode_002",
+ "key": "2026-05-10/episode_002",
+ "row": 7016,
+ "streams": [
+  "view_left",
+  "view_middle",
+  "view_right",
+  "tactile_left",
+  "tactile_right"
+ ],
+ "size": {
+  "view_left": [
+   640,
+   480
+  ],
+  "view_middle": [
+   640,
+   480
+  ],
+  "view_right": [
+   640,
+   480
+  ],
+  "tactile_left": [
+   640,
+   480
+  ],
+  "tactile_right": [
+   640,
+   480
+  ]
+ },
+ "cams": {
+  "left": {
+   "T": [
+    -0.810677868162443,
+    -0.4417948639462208,
+    -0.38421178048354576,
+    158.37843079282737,
+    -0.2945501948324127,
+    0.8748721945072194,
+    -0.3844981482430172,
+    284.86657177938224,
+    0.5060055106377637,
+    -0.19853448433171958,
+    -0.8393702888090293,
+    685.6891619250176
+   ],
+   "fx": 608.4557495117188,
+   "fy": 608.1494750976562,
+   "ppx": 316.0635986328125,
+   "ppy": 224.6374053955078
+  },
+  "middle": {
+   "T": [
+    0.9987689323019825,
+    0.04789247635294343,
+    0.012920161653051267,
+    -394.4763993373926,
+    0.04826421351573066,
+    -0.9983784326630464,
+    -0.030183950818081413,
+    -270.493443209141,
+    0.011453626590133171,
+    0.030770373771911365,
+    -0.9994608539286934,
+    826.019809512672
+   ],
+   "fx": 609.06005859375,
+   "fy": 608.275390625,
+   "ppx": 332.47943115234375,
+   "ppy": 239.3525390625
+  },
+  "right": {
+   "T": [
+    -0.7060810935772296,
+    0.6950316252373175,
+    0.13557481039174474,
+    605.2919096634614,
+    0.5284341378626592,
+    0.644604762743106,
+    -0.5524871598419762,
+    -100.86727498691573,
+    -0.47138821711422957,
+    -0.3184583799633454,
+    -0.8224216734723081,
+    1061.7990457647895
+   ],
+   "fx": 608.547607421875,
+   "fy": 606.7799072265625,
+   "ppx": 314.88201904296875,
+   "ppy": 243.41900634765625
+  }
+ },
+ "gel": {
+  "left": [
+   -42.603232962895795,
+   -36.56264317489985,
+   -34.21371780589162
+  ],
+  "right": [
+   3.1680846750991996,
+   -53.986407194707084,
+   47.297869103141956
+  ]
+ },
+ "pose": {
+  "left": [
+   0.4233657121658325,
+   -0.24574513733386993,
+   0.08017350733280182,
+   -0.4738748027746301,
+   -0.05678169627152034,
+   -0.37848914494994457,
+   -0.7930728071362012
+  ],
+  "right": [
+   0.5881050825119019,
+   -0.31359246373176575,
+   0.12186302989721298,
+   -0.5861687022005775,
+   -0.6556183573677075,
+   -0.2969039358322237,
+   -0.3720468719533799
+  ]
+ },
+ "step_mm": 5.0,
+ "step_deg": 3.0,
+ "up_axis": "z",
+ "note": "the photos are frozen; only the projected sensor frame moves. No model is wired in yet."
+});
+</script>

sim/sim.json

@@ -0,0 +1,133 @@
+{
+ "date": "2026-05-10",
+ "episode": "episode_002",
+ "key": "2026-05-10/episode_002",
+ "row": 7016,
+ "streams": [
+  "view_left",
+  "view_middle",
+  "view_right",
+  "tactile_left",
+  "tactile_right"
+ ],
+ "size": {
+  "view_left": [
+   640,
+   480
+  ],
+  "view_middle": [
+   640,
+   480
+  ],
+  "view_right": [
+   640,
+   480
+  ],
+  "tactile_left": [
+   640,
+   480
+  ],
+  "tactile_right": [
+   640,
+   480
+  ]
+ },
+ "cams": {
+  "left": {
+   "T": [
+    -0.810677868162443,
+    -0.4417948639462208,
+    -0.38421178048354576,
+    158.37843079282737,
+    -0.2945501948324127,
+    0.8748721945072194,
+    -0.3844981482430172,
+    284.86657177938224,
+    0.5060055106377637,
+    -0.19853448433171958,
+    -0.8393702888090293,
+    685.6891619250176
+   ],
+   "fx": 608.4557495117188,
+   "fy": 608.1494750976562,
+   "ppx": 316.0635986328125,
+   "ppy": 224.6374053955078
+  },
+  "middle": {
+   "T": [
+    0.9987689323019825,
+    0.04789247635294343,
+    0.012920161653051267,
+    -394.4763993373926,
+    0.04826421351573066,
+    -0.9983784326630464,
+    -0.030183950818081413,
+    -270.493443209141,
+    0.011453626590133171,
+    0.030770373771911365,
+    -0.9994608539286934,
+    826.019809512672
+   ],
+   "fx": 609.06005859375,
+   "fy": 608.275390625,
+   "ppx": 332.47943115234375,
+   "ppy": 239.3525390625
+  },
+  "right": {
+   "T": [
+    -0.7060810935772296,
+    0.6950316252373175,
+    0.13557481039174474,
+    605.2919096634614,
+    0.5284341378626592,
+    0.644604762743106,
+    -0.5524871598419762,
+    -100.86727498691573,
+    -0.47138821711422957,
+    -0.3184583799633454,
+    -0.8224216734723081,
+    1061.7990457647895
+   ],
+   "fx": 608.547607421875,
+   "fy": 606.7799072265625,
+   "ppx": 314.88201904296875,
+   "ppy": 243.41900634765625
+  }
+ },
+ "gel": {
+  "left": [
+   -42.603232962895795,
+   -36.56264317489985,
+   -34.21371780589162
+  ],
+  "right": [
+   3.1680846750991996,
+   -53.986407194707084,
+   47.297869103141956
+  ]
+ },
+ "pose": {
+  "left": [
+   0.4233657121658325,
+   -0.24574513733386993,
+   0.08017350733280182,
+   -0.4738748027746301,
+   -0.05678169627152034,
+   -0.37848914494994457,
+   -0.7930728071362012
+  ],
+  "right": [
+   0.5881050825119019,
+   -0.31359246373176575,
+   0.12186302989721298,
+   -0.5861687022005775,
+   -0.6556183573677075,
+   -0.2969039358322237,
+   -0.3720468719533799
+  ]
+ },
+ "step_mm": 5.0,
+ "step_deg": 3.0,
+ "up_axis": "z",
+ "note": "the photos are frozen; only the projected sensor frame moves. No model is wired in yet."
+}