Sensing Cable Tension for Surgical Robots

# Illustrative sketch (not from the paper)
import torch, torch.nn as nn, numpy as np
class TensionNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc = nn.Sequential(nn.Linear(1,16), nn.ReLU(), nn.Linear(16,1))
    def forward(self, x): return self.fc(x)
net = TensionNet()
# net.load_state_dict(torch.load('tension_net.pth'))

def strain_to_tension(s): return net(torch.tensor([[s]], dtype=torch.float32)).item()

def static_beam_parallel(tensions): return np.mean(tensions)*0.01

def estimate_contact_force(prox, tension): return prox - tension

def locate_contact(moment, length):
    pos = np.linspace(0,1,100)
    cost = (moment-pos)**2 + (length-pos)**2
    return pos[np.argmin(cost)]

# Example usage
raw = 0.35
tension = strain_to_tension(raw)
shape = static_beam_parallel([tension])
prox = 5.0
force = estimate_contact_force(prox, tension)
loc = locate_contact(0.2, 0.05)

// Illustrative sketch (not from the paper)
const tf = require('@tensorflow/tfjs-node');
// Simple NN mapping strain to tension
function createModel(){ const m=tf.sequential(); m.add(tf.layers.dense({units:16,inputShape:[1],activation:'relu'})); m.add(tf.layers.dense({units:1})); return m;}
const net=createModel();
// await net.loadWeights('tension_net_weights.bin');
function strainToTension(s){ return net.predict(tf.tensor2d([s],[1,1])).dataSync()[0]; }
function staticBeamParallel(t){ return t.reduce((a,b)=>a+b,0)/t.length*0.01; }
function estimateContactForce(p,c){ return p-c; }
function locateContact(m,l){ const pos=Array.from({length:100},(_,i)=>i/99); const costs=pos.map(p=> (m-p)**2+(l-p)**2); return pos[costs.indexOf(Math.min(...costs))]; }
// Example usage
const raw=0.35, tension=strainToTension(raw);
const shape=staticBeamParallel([tension]);
const prox=5.0, force=estimateContactForce(prox,tension);
const loc=locateContact(0.2,0.05);