File size: 4,572 Bytes
8420318 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 | """Calibration-free depth / height-map reconstruction for GelSight Mini.
Uses the GelSight-Inc pretrained markerless-Mini network (`nnmini.pt`,
RGB+xy -> surface-normal regression) so NO per-sensor calibration is needed.
The network architecture is reimplemented clean-room from the published
state-dict (fc 5->64->64->64->2, ReLU); only the public weight file is
downloaded on demand. Height is recovered by fast DCT Poisson integration.
Result is an APPROXIMATE relative height map (the pretrained net was fit to a
reference Mini, not this exact unit) — good for visualization, point clouds,
and relative geometry; not a metric-calibrated measurement. For metric depth,
collect a ball-indenter calibration and retrain.
Optional dependency: torch. Weights: GelSight Inc (GPL-3.0) — only the .pt
file is fetched; no GPL code is vendored here.
"""
from __future__ import annotations
import os
from pathlib import Path
import numpy as np
_WEIGHTS_URL = "https://raw.githubusercontent.com/gelsightinc/gsrobotics/main/models/nnmini.pt"
_CACHE = Path(os.path.expanduser("~/.cache/react_toolbox/nnmini.pt"))
def _ensure_weights():
if _CACHE.exists():
return _CACHE
_CACHE.parent.mkdir(parents=True, exist_ok=True)
import urllib.request
urllib.request.urlretrieve(_WEIGHTS_URL, str(_CACHE))
return _CACHE
class _RGB2NormNet:
"""Clean-room MLP matching nnmini.pt: (R,G,B,x,y) -> (nx,ny), ReLU."""
def __init__(self):
import torch
import torch.nn as nn
self.torch = torch
net = nn.Sequential(
nn.Linear(5, 64), nn.ReLU(),
nn.Linear(64, 64), nn.ReLU(),
nn.Linear(64, 64), nn.ReLU(),
nn.Linear(64, 2))
ck = torch.load(str(_ensure_weights()), map_location="cpu", weights_only=False)
sd = ck["state_dict"]
mapping = {"fc1": 0, "fc2": 2, "fc3": 4, "fc4": 6}
with torch.no_grad():
for name, idx in mapping.items():
net[idx].weight.copy_(sd[f"{name}.weight"])
net[idx].bias.copy_(sd[f"{name}.bias"])
net.eval()
self.net = net
_NET = None
def _get_net():
global _NET
if _NET is None:
_NET = _RGB2NormNet()
return _NET
def normals(frame, reference, mask=None):
"""Predict per-pixel surface normals (nx, ny, nz) for a GelSight frame.
Inputs are the difference image (frame-reference) plus normalized pixel
coords, matching the gsrobotics convention. Returns (H, W, 3) float32.
"""
net = _get_net(); torch = net.torch
H, W = frame.shape[:2]
# Background-subtracted RGB normalized to [-1,1]/255 scale + xy in [0,1].
# (Verified: this keeps predicted nx,ny in valid range; feeding 0-255 diff
# pushes the MLP out of distribution and nz->0 blows up the gradients.)
diff = (frame.astype(np.float32) - reference.astype(np.float32)) / 255.0
ys, xs = np.mgrid[0:H, 0:W].astype(np.float32)
xs /= (W - 1); ys /= (H - 1)
feat = np.stack([diff[..., 0], diff[..., 1], diff[..., 2], xs, ys], axis=-1)
feat = feat.reshape(-1, 5)
with torch.no_grad():
out = net.net(torch.from_numpy(feat)).numpy() # (HW, 2) = nx,ny
nx = out[:, 0].reshape(H, W); ny = out[:, 1].reshape(H, W)
nz = np.sqrt(np.clip(1 - nx**2 - ny**2, 1e-6, 1.0))
n = np.stack([nx, ny, nz], axis=-1).astype(np.float32)
if mask is not None:
n[~mask] = [0, 0, 1]
return n
def poisson_integrate(gx, gy):
"""Fast Poisson solver (DCT, Neumann BC): integrate gradients -> surface."""
from scipy.fftpack import dct, idct
H, W = gx.shape
gxx = np.zeros_like(gx); gyy = np.zeros_like(gy)
gxx[:, 1:] = gx[:, 1:] - gx[:, :-1]
gyy[1:, :] = gy[1:, :] - gy[:-1, :]
f = gxx + gyy
fcos = dct(dct(f, axis=0, norm="ortho"), axis=1, norm="ortho")
x, y = np.meshgrid(np.arange(W), np.arange(H))
denom = (2 * np.cos(np.pi * x / W) - 2) + (2 * np.cos(np.pi * y / H) - 2)
denom[0, 0] = 1.0
z = fcos / denom; z[0, 0] = 0
return idct(idct(z, axis=0, norm="ortho"), axis=1, norm="ortho")
def height_map(frame, reference, mask=None):
"""Reconstruct a relative height map (H, W) float32 from one frame.
height>0 = pushed in (contact). Approximate (uncalibrated). Requires torch
+ scipy; raises a clear error if torch is unavailable.
"""
n = normals(frame, reference, mask=mask)
nx, ny, nz = n[..., 0], n[..., 1], n[..., 2]
gx = -nx / nz; gy = -ny / nz
h = poisson_integrate(gx, gy).astype(np.float32)
return h - h.min()
|