Grasping: friction, closure, and candidates

The previous lesson ended with an object pose in the robot base frame, good to a few millimeters. Everything before that — kinematics, Jacobians, IK, calibration — was infrastructure for this moment: choosing where two fingers touch an object and squeezing. Grasping is where your pipeline cashes out into a binary. There is no partial credit; the mug is either in the gripper or on the floor, and every budgeted error term — 0.6 mm depth noise, 2–5 mm registration error, 1–2 mm FK error — is now spent against one physical tolerance. The theory half of this lesson is elegant: one inequality about friction generates the entire geometry of what can be held. The practice half is where that elegance meets the WidowX AI's parallel-jaw gripper — 100 N of squeeze, silicone pads, and not a single tactile sensor — and you learn why the field quietly stopped trusting the elegant part.

Contact models: one inequality generates everything

Zoom into where a finger meets an object and you find a contact patch a few millimeters across. The classical idealization is a point contact with friction: a point $\mathbf{p}$ with inward unit normal $\hat{\mathbf{n}}$, through which the finger applies a force $\mathbf{f}$. Two physical facts constrain $\mathbf{f}$. Contact is unilateral — a finger pushes, never pulls, so the normal component $f_n = \mathbf{f}\cdot\hat{\mathbf{n}}$ is non-negative. And the tangential component is friction, which Coulomb's model bounds by the normal load:

Now derive the admissible set's shape. Write any candidate force by the angle $\theta$ it makes with the inward normal: normal component $\|\mathbf{f}\|\cos\theta$, tangential component $\|\mathbf{f}\|\sin\theta$. Substitute into the Coulomb bound and the magnitude cancels:

So the transmissible forces form a cone: axis along the inward normal, half-angle $\alpha = \arctan\mu$. Real numbers: bare aluminum on smooth ABS gives $\mu \approx 0.3$, a $16.7°$ cone; the molded silicone pads on the WidowX AI's precision-grip fingers raise $\mu$ to $0.6$–$1.0$ on most household surfaces — a $31°$–$45°$ cone. That factor of two is the cheapest reliability upgrade in robotics: a wider cone keeps required forces admissible when contact placement is off by the several millimeters your perception stack guarantees.

Real fingertips also deform: a compliant pad flattens into a patch, and a patch — unlike a point — resists torsion about the contact normal. The soft-finger model adds one constraint: $|\tau_n| \le \gamma f_n$, a torsional budget proportional to squeeze force. It does quiet load-bearing work below, because two ideal point contacts cannot stop an object from pinwheeling about the line between the fingers. Your grasps work because your fingertips are soft, not despite it.

Foundations: Wrenches, Antipodal Geometry, and the Friction Cone

Before deriving the closure conditions, we must rigorously define the geometric and physical quantities that the subsequent logic relies upon. The primary abstraction is the wrench, a six-dimensional vector that unifies force and torque. While force describes linear acceleration, torque describes angular acceleration. For a rigid body, these are coupled: a force applied at a point away from the center of mass generates a moment. We define the wrench $\mathbf{w} \in \mathbb{R}^6$ as the concatenation of the force vector $\mathbf{f} \in \mathbb{R}^3$ and the torque vector $\boldsymbol{\tau} \in \mathbb{R}^3$ about the object's center of mass (COM):

This definition is critical for the antipodal condition. In 2D, antipodal points are often described intuitively as 'opposite sides.' For the frictionless idealization in 3D, two smooth convex-surface contacts $\mathbf{p}_1$ and $\mathbf{p}_2$ are antipodal when the segment joining them is parallel to both inward surface normals, with opposite orientations. If $\mathbf{u}$ points from $\mathbf{p}_1$ to $\mathbf{p}_2$, the ideal condition is $\mathbf{u} \cdot \hat{\mathbf{n}}_1 = 1$ and $(-\mathbf{u}) \cdot \hat{\mathbf{n}}_2 = 1$. With friction, exact alignment relaxes to the friction-cone inequalities derived below. Equal and opposite collinear squeeze forces then have zero net force and zero net torque, leaving frictional margin to resist disturbances.

The friction cone derivation requires explicit vector decomposition to justify the geometric interpretation. Let $\mathbf{f}$ be the total contact force. We decompose $\mathbf{f}$ into a normal component $f_n \hat{\mathbf{n}}$ and a tangential component $\mathbf{f}_t$. By the Pythagorean theorem in 3D, $\|\mathbf{f}\|^2 = f_n^2 + \|\mathbf{f}_t\|^2$. Coulomb's law states $\|\mathbf{f}_t\| \le \mu f_n$. Substituting $\|\mathbf{f}_t\| = \sqrt{\|\mathbf{f}\|^2 - f_n^2}$ and dividing by $f_n$ yields the half-angle $\alpha = \arctan \mu$. This confirms that the admissible forces form a cone of constant half-angle, independent of the magnitude of the squeeze.

Worked Example: Sizing a Grasp for a 200g Object

Consider a parallel-jaw gripper with silicone pads ($\mu = 0.6$) grasping a 200 g object ($m = 0.2$ kg). The object is to be lifted with an acceleration $a = 2$ m/s². The gripper has a maximum force capacity of 100 N. We must determine the minimum squeeze force, apply a safety factor, and verify the aperture constraint.

To account for uncertainty in $\mu$ (which may drop to 0.4 due to wear or contamination), we calculate the worst-case force: $F_{n, worst} = \frac{0.2(11.81)}{2(0.4)} \approx 2.95$ N. Applying a safety factor $S=3$, the commanded force is $F_{cmd} = 3 \times 2.95 \approx 8.85$ N. This is well within the 100 N limit. For the aperture, if the object width is $w=30$ mm and the pad thickness is $w_{pad}=2$ mm, the required finger position is $x_f = (w - w_{pad})/2 = 14$ mm. Since the gripper's maximum aperture is 40 mm (finger position 20 mm), the grasp is feasible.

Closure: force, form, and the antipodal test

A single contact constrains an object; a grasp immobilizes it. Immobilization is about the contact's effect on the whole rigid body — its wrench, force and torque stacked into a 6-vector: a contact at $\mathbf{p}$ transmitting $\mathbf{f}$ contributes $\mathbf{w} = (\mathbf{f},\; \mathbf{p}\times\mathbf{f}) \in \mathbb{R}^6$ — the same wrench objects from the force side of the Jacobian lesson, now sourced from fingers.

Two notions of “held” live here. Form closure is pure geometry: the contacts immobilize the object even with $\mu = 0$, like a peg caged in a matching hole. It is the stronger guarantee and the useless one for you — first-order form closure of a 3-D object needs at least seven frictionless contacts, and your gripper has two fingers. Force closure recruits friction: fewer contacts, conditional on $\mu$ and on actually supplying squeeze force. Everything a parallel-jaw gripper does is force closure — a deliberate trade that lets two actuated surfaces do the work of seven.

For two contacts, force closure collapses to a clean geometric test. Take contacts at $\mathbf{p}_1, \mathbf{p}_2$, let $\mathbf{u}$ be the unit vector from the first to the second, and squeeze: contact 1 pushes with $\lambda\mathbf{u}$, contact 2 with $-\lambda\mathbf{u}$. Net force cancels by construction; net torque is $\mathbf{p}_1\times\lambda\mathbf{u} + \mathbf{p}_2\times(-\lambda\mathbf{u}) = -\lambda\,(\mathbf{p}_2-\mathbf{p}_1)\times\mathbf{u} = \mathbf{0}$, since $\mathbf{p}_2-\mathbf{p}_1$ is parallel to $\mathbf{u}$. A squeeze along the connecting line is always internally balanced — the only question is whether the friction cones permit it, a pair of angle conditions:

This is Nguyen's condition: a two-contact grasp with friction achieves force closure exactly when the segment joining the contacts lies inside both friction cones. When it holds, small tilts of each force within its cone — scaled by the squeeze — generate wrenches in every direction, promoting “balanced” to “resists anything.” One honest asterisk: ideal point contacts cannot resist torque about the connecting axis, so the 3-D result formally needs soft-finger contacts — the torsional term above. Perfectly antipodal contacts with $\mu = 0.6$ pads enjoy $31°$ of margin each; that margin is what pays for your combined perception-plus-calibration error.

From point cloud to candidates

Now make the test operational. The registration lesson hands you a segmented object cloud — typically 30k–80k points after a tabletop crop at 0.4–0.6 m. The antipodal test needs normals, and the standard estimator is local PCA: for each point, take its $k \approx 30$ nearest neighbors, form the $3\times 3$ covariance, and the eigenvector of the smallest eigenvalue is the normal — the direction the local patch does not extend. PCA leaves a sign ambiguity; flip each normal to face the camera, since every observed surface faced it. Keep the eigenvalue ratio $\lambda_0 / (\lambda_0+\lambda_1+\lambda_2)$ too: a curvature score near zero on planes and large at edges, which becomes your data-quality filter.

Candidate generation is a sampling funnel with a familiar shape: retrieval-then-rerank. A cheap proposal stage (random point pairs) feeds a cascade of filters; only survivors reach the expensive verifier — the physical arm, at ~10 s per attempt. Sample ~5,000 pairs; the antipodal dot products kill most; the aperture constraint (the WidowX AI's gripper opens to 40 mm, so anything wider is unreachable by definition) and the approach constraint kill more. For a tabletop WidowX AI the latter is blunt: approach roughly top-down within a $\pm 30°$ cone — steeper hits the table or the wrist limits your IK lesson predicted — with the grasp axis near-horizontal so the fingers straddle the object. A few dozen candidates survive to ranking.

import numpy as np
from scipy.spatial import cKDTree

def estimate_normals(points, k=30):
    """PCA normals for an N x 3 cloud in the camera frame.
    Returns unit normals oriented toward the camera (at the origin)
    and a curvature score for edge filtering."""
    tree = cKDTree(points)
    _, idx = tree.query(points, k=k)
    normals = np.empty_like(points)
    curvature = np.empty(len(points))
    for i, nb in enumerate(idx):
        q = points[nb] - points[nb].mean(axis=0)
        w, v = np.linalg.eigh(q.T @ q)      # ascending eigenvalues
        n = v[:, 0]                         # smallest-eigenvalue direction
        if n @ points[i] > 0.0:             # flip to face the camera
            n = -n
        normals[i] = n
        curvature[i] = w[0] / max(w.sum(), 1e-12)
    return normals, curvature

def antipodal_pairs(points, normals, curvature, mu=0.5,
                    max_width=0.040, n_samples=5000,
                    curv_max=0.03, seed=0):
    """Sample point pairs; keep those passing Nguyen's condition
    and the gripper aperture limit."""
    rng = np.random.default_rng(seed)
    cos_alpha = 1.0 / np.sqrt(1.0 + mu * mu)
    clean = np.flatnonzero(curvature < curv_max)
    i = rng.choice(clean, n_samples)
    j = rng.choice(clean, n_samples)
    d = points[j] - points[i]
    width = np.linalg.norm(d, axis=1)
    ok = (width > 5e-3) & (width < max_width)
    u = d / np.maximum(width, 1e-9)[:, None]
    inward_i = -normals[i]                  # camera-facing -> inward
    inward_j = -normals[j]
    ok &= np.einsum("nd,nd->n", u, inward_i) >= cos_alpha
    ok &= np.einsum("nd,nd->n", -u, inward_j) >= cos_alpha
    return i[ok], j[ok], width[ok]

def rank(points, i, j, width, normals, max_width=0.040):
    """Higher is better: cone margin and width margin reward,
    gravity torque arm penalizes."""
    axis = points[j] - points[i]
    axis /= np.linalg.norm(axis, axis=1)[:, None]
    c1 = np.einsum("nd,nd->n", axis, -normals[i])
    c2 = np.einsum("nd,nd->n", -axis, -normals[j])
    cone_margin = np.minimum(c1, c2)        # cos of worst contact angle
    mid = 0.5 * (points[i] + points[j])
    torque_arm = np.linalg.norm(mid - points.mean(axis=0), axis=1)
    width_margin = (max_width - width) / max_width
    score = 2.0 * cone_margin + width_margin - 5.0 * torque_arm
    return np.argsort(-score)

Each ranking heuristic is a proxy for a distinct failure mode:

• Cone margin — how far inside both cones the grasp axis sits. Every degree absorbs a degree of combined pose, calibration, and normal error; below ~5° you are executing your error bars.
• Torque arm — centroid-to-grasp-axis distance. Gravity applies torque $mgd$ against the soft-finger torsional budget: a 200 g object gripped 30 mm off-centroid carries a standing 59 mN·m twist that grows under acceleration.
• Width margin — aperture minus object width. Fingers must descend around the object; a 40 mm gripper on a 36 mm box leaves 2 mm per side — less than your perception error, so the pre-grasp itself collides.
• Approach feasibility — approach axis inside the arm's comfortable IK region, checked with your solver; reject anything whose approach ray hits the table or the object's own cloud.
• Data quality at the contacts — curvature and neighbor density on both patches; prefer well-observed surface over the occluded far side, where normals are extrapolated fiction.

Note the systems profile: normals for a 50k-point cloud take ~5 ms vectorized (the loop above is the teaching version), and 5,000 antipodal tests are microseconds of einsum. The classical planner is effectively free next to a $\pi_0$-class VLA forward pass at ~100 ms on your RTX box — which is why it makes a good oracle: run it every frame, log every candidate, and later diff its ranked list against whatever a learned policy chooses.

Grasp quality: where the theory meets its correlation problem

The classical literature went past binary closure into continuous quality metrics. The canonical one is the Ferrari–Canny epsilon metric: cap each contact force at unit magnitude, take the convex hull of all achievable wrenches, and report the radius of the largest origin-centered ball inside it — the worst-case disturbance resisted per unit squeeze. Principled minimax; it dominated grasp research for two decades. Benchmarked against physical trials at scale, the result was deflating: epsilon-style rankings correlate weakly with real success — better than random, nowhere near enough to trust. The Dex-Net 2.0 (opens in a new tab) line made the point operationally: what transferred to physical benchmarks was training on millions of simulated grasps labeled with robustness — success probability under sampled pose, friction, and gripper noise — not nominal analytic quality.

The failure is no mystery; each assumption breaks in a known way. The metric assumes exact contact locations — perception delivers millimeters of error. It assumes known $\mu$ — you have a guess. It assumes the object holds still while fingers arrive — the first finger to touch moves the object, sometimes helpfully (funneling it into the jaw), sometimes fatally (skating it off the table), and quasi-statics is silent on which. And it scores the final configuration while ignoring the approach that produces it. The metrics answer a precise question about an idealized snapshot the physical episode only loosely visits.

Your gripper: current, compliance, and the grasp state machine

Time to land on the bench. The WidowX AI's gripper is two parallel fingers with molded silicone pads, driven by an integrated actuator — 40 mm of finger travel, up to 100 N of gripping force, and no dedicated force or tactile sensor. Readable from the driver's ~500 Hz state stream: position (which maps to finger aperture) and effort (roughly proportional to squeeze force, once past transmission friction). Writable: a position target or, since the driver exposes an effort mode, a squeeze effort directly. The standard configuration is effort-limited closing: command the fingers well past the object's width and let the effort limit — not the position target — set the squeeze. The actuator stalls against the object and holds: a crude but real force-controlled gripper. How hard to squeeze comes from the friction model, inverted: the pads must carry the weight plus the inertial load of the lift:

The effort trace is also your only tactile sensor, and it is a good one. A healthy hold is boring: aperture pinned at the object width, effort at the limit. Slip announces itself as aperture creep — the reported position drifts while the target has not changed — often with an effort transient as the object rotates through the pads. A lost object is unambiguous: effort collapses to near zero within ~100 ms as the suddenly-unloaded fingers reach their target. This is fingerprinting an unobservable phenomenon in the one telemetry channel you have — a move you know well. Log aperture and effort at 50 Hz or better (the driver streams ~500 Hz) for every grasp from day one; those traces are how you will debug every mysterious drop in this course.

Which brings us to the real deliverable: grasping is not an action, it is a state machine, and the verify states are where the phase goal — separating perception, planning, and execution failures — becomes executable code. A minimal recoverable pick:

1. PERCEIVE — capture cloud, register pose, generate and rank candidates. Output: a ranked list, not one pose; the list is your retry budget.
2. APPROACH — move to a pre-grasp waypoint 80–100 mm back along the approach axis, full speed, collision-checked.
3. DESCEND — straight-line to the grasp pose at 0.05–0.10 m/s; slow, because this is where unmodeled contact happens.
4. CLOSE — effort-limited close with the limit from your force calculation; wait for effort saturation or a 1 s timeout.
5. VERIFY-GRASP — the predicate below. On failure, classify and branch: back to PERCEIVE or to the next candidate.
6. LIFT — up 100 mm at modest acceleration (the $m(g+a)$ term you sized the squeeze for).
7. VERIFY-HOLD — re-check aperture and effort under the dynamic load; optionally re-observe the scene to confirm the object left the table.

The verify predicate needs only the two telemetry channels, and its power is that different failures produce separable signatures. Define an expected aperture band from the object's known width, say $w \pm 4\,\text{mm}$. After CLOSE: aperture in band, effort at the limit for 200 ms $\Rightarrow$ HOLDING. Aperture far below band, near-zero effort $\Rightarrow$ AIR — closed on nothing, indicting perception or calibration: re-perceive rather than retry the same pose. Aperture far above band, effort at the limit $\Rightarrow$ JAMMED — stalled on wrong geometry (a knuckle, a neighbor, the table), indicting the candidate: try the next one. HOLDING after CLOSE but AIR at VERIFY-HOLD $\Rightarrow$ the transport shook it loose — an execution failure: raise the effort limit or lower the lift acceleration. Four outcomes, three subsystems, one if-statement each — the debuggability no end-to-end policy gives you, and the oracle you will hold the learned stack accountable to.

Where this goes next: Pose estimation and point-cloud registration told you where the object is; this lesson turned that pose into a ranked list of gripper placements and a state machine that knows when it has been lied to. But a grasp pose is a destination, not a route — Motion planning: RRT, optimization, and time generates the collision-free, time-parameterized path to the pre-grasp waypoint and through the descend, where the approach-axis constraints you imposed here stop being filters and become boundary conditions.