In planning for manipulation and grasping, we rarely simulate full deformable contact mechanics. Instead, we use contact models: simplified mathematical descriptions of the forces and torques that can be transmitted at each contact between a rigid object and a fingertip, palm, or environment.

Let the robot configuration be \( \mathbf{q} \in \mathbb{R}^n \) and consider a candidate grasp with \( N \) contacts indexed by \( i = 1,\dots,N \). For each contact we specify:

• A contact frame \( \mathcal{F}_i^c \) with origin at the contact point.
• A surface normal \( \mathbf{n}_i \in \mathbb{R}^3 \) (pointing into the object).
• A set of admissible wrenches \( \mathcal{W}_i \subset \mathbb{R}^6 \) that the contact can transmit.

At the planning level, the detailed physics is compressed into the constraints \( \mathbf{w}_i \in \mathcal{W}_i \), where \( \mathbf{w}_i \) is the wrench applied by contact \( i \) to the object. The choice of \( \mathcal{W}_i \) is the contact model.

A common modeling chain in grasp planning is summarized below.

flowchart TD
  A["Physical fingertip & object surfaces"] --> B["Local geometry & normal n_i"]
  B --> C["Choose contact type (P, P+F, soft-finger, line, planar)"]
  C --> D["Define admissible wrench set W_i"]
  D --> E["Assemble grasp map G from all contacts"]
  E --> F["Apply equilibrium & friction constraints in planner"]
  F --> G["Score / filter grasps for later quality analysis"]
        

In later lessons we will use these models to build grasp wrench spaces and define quality metrics, but here we focus on the local contact-level formulation.

For a rigid object, the effect of a contact on the object is a wrench (force and torque) expressed in some object-fixed frame \( \mathcal{F}^o \). However, contact models are most convenient in a local contact frame \( \mathcal{F}^c \).

Let \( \mathbf{f}_c \in \mathbb{R}^3 \) and \( \boldsymbol{\tau}_c \in \mathbb{R}^3 \) be the contact force and torque expressed in \( \mathcal{F}^c \). The corresponding wrench in \( \mathcal{F}^c \) is

\[ \mathbf{w}_c = \begin{bmatrix} \mathbf{f}_c \\[2pt] \boldsymbol{\tau}_c \end{bmatrix} \in \mathbb{R}^6. \]

Let \( \mathbf{R}_{oc} \in SO(3) \) be the rotation from contact frame to object frame and \( \mathbf{p}_{oc} \in \mathbb{R}^3 \) the vector from the object frame origin to the contact point, expressed in the object frame. The wrench transformation from \( \mathcal{F}^c \) to \( \mathcal{F}^o \) is given by the dual adjoint:

\[ \mathbf{w}_o = \mathbf{Ad}^*_{\!oc}\,\mathbf{w}_c = \begin{bmatrix} \mathbf{R}_{oc} & \mathbf{0} \\ \widehat{\mathbf{p}}_{oc}\,\mathbf{R}_{oc} & \mathbf{R}_{oc} \end{bmatrix} \begin{bmatrix} \mathbf{f}_c \\[2pt] \boldsymbol{\tau}_c \end{bmatrix}, \]

where \( \widehat{\mathbf{p}}_{oc} \) is the skew-symmetric matrix representing the cross product \( \mathbf{p}_{oc} \times \cdot \). This linear map will later define the grasp map when multiple contacts are present.

From a planning perspective, once \( \mathbf{Ad}^*_{\!oc} \) is known, everything about the local contact can be summarized as a set \( \mathcal{W}_c \subset \mathbb{R}^6 \). Its image in object coordinates is \( \mathcal{W}_o = \mathbf{Ad}^*_{\!oc}\mathcal{W}_c \).

The simplest physically meaningful friction model for rigid contact is Coulomb friction. Let the contact frame be chosen with \( \mathbf{e}_3 = \mathbf{n}_c \) aligned with the contact normal. Decompose the contact force:

\[ \mathbf{f}_c = f_n \mathbf{n}_c + \mathbf{f}_t, \quad \mathbf{n}_c^\top \mathbf{f}_t = 0, \]

where \( f_n \) is the normal component and \( \mathbf{f}_t \) is the tangential component. Coulomb friction imposes the inequalities

\[ f_n \ge 0, \quad \left\lVert \mathbf{f}_t \right\rVert_2 \le \mu f_n, \]

where \( \mu > 0 \) is the friction coefficient. Geometrically, the admissible forces form a friction cone with axis along \( \mathbf{n}_c \).

Half-angle of the friction cone.

Consider the 2D plane spanned by \( \mathbf{n}_c \) and \( \mathbf{f}_t \). On the cone boundary we have \( \left\lVert \mathbf{f}_t \right\rVert_2 = \mu f_n \). The angle \( \alpha \) between \( \mathbf{f}_c \) and \( \mathbf{n}_c \) satisfies

\[ \tan(\alpha) = \frac{\left\lVert \mathbf{f}_t \right\rVert_2}{f_n} = \mu. \]

Thus the friction cone half-angle is \( \alpha = \arctan(\mu) \). As \( \mu \) increases, the cone widens and the contact can resist larger tangential disturbances.

The set of admissible contact forces (ignoring torques) in the contact frame is

\[ \mathcal{C}_\mu = \left\{ \mathbf{f}_c \in \mathbb{R}^3 \,\bigg|\, f_n \ge 0,\; \left\lVert \mathbf{f}_t \right\rVert_2 \le \mu f_n \right\}. \]

For optimization-based planning, the nonlinear norm constraint is often approximated by a polyhedral cone, replacing the circular cross-section by a polygon with \( m \) edges. We will implement this approximation in code below.

Using Coulomb friction, we define standard contact types used by grasp planners. Each type corresponds to a set of admissible wrenches \( \mathcal{W}_c \subset \mathbb{R}^6 \) in the contact frame.

(a) Point contact without friction (P).

The contact can only transmit a compressive normal force; no tangential force or torque:

\[ \mathcal{W}_{\text{P}} = \left\{ \begin{bmatrix} \mathbf{f}_c \\[2pt] \boldsymbol{\tau}_c \end{bmatrix} \,\bigg|\, \mathbf{f}_c = f_n \mathbf{n}_c,\; f_n \ge 0,\; \boldsymbol{\tau}_c = \mathbf{0} \right\}. \]

This is appropriate for very smooth fingertips or when friction is neglected to simplify analysis.

(b) Point contact with friction (P+F).

The contact can transmit tangential force limited by the friction cone, but no torque:

\[ \mathcal{W}_{\text{P+F}} = \left\{ \begin{bmatrix} \mathbf{f}_c \\[2pt] \boldsymbol{\tau}_c \end{bmatrix} \,\bigg|\, \mathbf{f}_c \in \mathcal{C}_\mu,\; \boldsymbol{\tau}_c = \mathbf{0} \right\}. \]

(c) Soft-finger contact (SF).

Soft pads or compliant materials can transmit a torsional moment about the normal in addition to forces in the cone. A simple model is:

\[ \mathcal{W}_{\text{SF}} = \left\{ \begin{bmatrix} \mathbf{f}_c \\[2pt] \boldsymbol{\tau}_c \end{bmatrix} \,\bigg|\, \mathbf{f}_c \in \mathcal{C}_\mu,\; \boldsymbol{\tau}_c = \begin{bmatrix} 0 \\ 0 \\ \tau_n \end{bmatrix},\; \left|\tau_n\right| \le \gamma f_n \right\}, \]

where \( \gamma > 0 \) is a torsional friction parameter that depends on pad size and compliance.

(d) Line and planar contacts.

When a contact patch is large (e.g., a flat object lying on a table), we sometimes idealize it as a line or planar contact. These can transmit more complex wrench sets with multiple independent normal and tangential directions, but in planning they are often approximated by a small number of equivalent point contacts extracted from the support region.

For example, a planar patch may be modeled as three P+F point contacts at vertices of the support polygon, each with its own \( \mathcal{C}_\mu \).

Let \( N \) contacts act on a rigid object. For contact \( i \) we have a wrench \( \mathbf{w}_{o,i} \in \mathbb{R}^6 \) in the object frame, obtained from the local wrench \( \mathbf{w}_{c,i} \) by the dual adjoint \( \mathbf{Ad}^*_{\!o c_i} \). Define the grasp map

\[ \mathbf{G} = \begin{bmatrix} \mathbf{G}_1 & \mathbf{G}_2 & \dots & \mathbf{G}_N \end{bmatrix} \in \mathbb{R}^{6 \times m}, \]

where \( \mathbf{G}_i \) maps the parameterization of contact \( i \) (e.g., the coefficients of friction-cone generators) to its contribution to the object wrench, and \( m \) is the total number of scalar contact force parameters across all contacts.

Let \( \boldsymbol{\lambda} \in \mathbb{R}^m \) collect these parameters (e.g., edge coefficients of all linearized friction cones). Then the net wrench on the object is

\[ \mathbf{w}_{\text{net}} = \mathbf{G}\boldsymbol{\lambda}. \]

In quasi-static grasp analysis, we seek forces \( \boldsymbol{\lambda} \) such that the object is in equilibrium under external wrench \( \mathbf{w}_{\text{ext}} \) (e.g., gravity):

\[ \mathbf{G}\boldsymbol{\lambda} + \mathbf{w}_{\text{ext}} = \mathbf{0}, \quad \boldsymbol{\lambda} \in \mathcal{K}, \]

where \( \mathcal{K} \) is a cone defined by contact models (e.g., nonnegativity and friction-cone constraints). Whether such a \( \boldsymbol{\lambda} \) exists is a key question in grasp planning; in the next lesson we will relate this to force closure.

In motion and manipulation planning, we must reason about which contacts are active and how they behave (sticking vs sliding vs separating). A common approach is to describe normal and tangential interactions via complementarity constraints.

Let \( \phi_i(\mathbf{q}) \) be the signed distance between bodies at contact \( i \) (positive when separated), and \( \lambda_{n,i} \) the normal contact force parameter. The rigid unilateral contact conditions are

\[ \phi_i(\mathbf{q}) \ge 0,\quad \lambda_{n,i} \ge 0,\quad \lambda_{n,i}\,\phi_i(\mathbf{q}) = 0. \]

At the planning level, these constraints are often relaxed or handled through discrete contact modes:

• Separate: \( \phi_i(\mathbf{q}) > 0,\, \lambda_{n,i} = 0 \).
• Sticking contact: \( \phi_i(\mathbf{q}) = 0 \) and tangential velocity zero within friction cone.
• Sliding contact: \( \phi_i(\mathbf{q}) = 0 \) and tangential force on the friction-cone boundary.

Planners may treat contact modes as discrete variables in a hybrid search or mixed-integer optimization. The contact model determines, for each mode, the algebraic constraints on \( \boldsymbol{\lambda} \) and \( \mathbf{q} \).

In this lesson we keep a quasi-static focus and use contact models mainly to define the feasible space of balancing wrenches for grasp candidates; dynamic mode-switching will appear later in the course.

For concreteness, consider a planar object (motion in the \( x\text{-}y \) plane, rotation about \( z \)). Each contact contributes a planar wrench \( (f_x, f_y, \tau_z) \). We will:

1. Approximate a 2D friction cone by a polygon with \( m \) edges.
2. Build a planar grasp map for a two-finger grasp.
3. Check if a candidate equilibrium wrench is feasible.

import numpy as np

def friction_cone_generators_2d(mu, m_edges):
    """
    Approximate a 2D Coulomb friction cone in the contact frame
    (tangent axis x, normal axis y) by m_edges rays.

    Returns an array Gc of shape (2, m_edges) whose columns are
    unit vectors on or inside the true cone.
    """
    if mu <= 0.0:
        raise ValueError("mu must be positive")

    # True cone half-angle
    alpha = np.arctan(mu)

    # Sample directions between -alpha and +alpha
    angles = np.linspace(-alpha, alpha, m_edges)
    # In contact frame: normal is along +y
    Gc = np.vstack([np.sin(angles), np.cos(angles)])
    return Gc  # shape (2, m_edges)

def planar_contact_wrench_generators(p_obj, mu, m_edges):
    """
    p_obj: 2D contact position in object frame (x, y).
    mu: friction coefficient.
    m_edges: number of edges in the polyhedral cone.

    Returns W (3 x m_edges): wrench generators in the object frame (2D).
    """
    Gc = friction_cone_generators_2d(mu, m_edges)  # (2, m_edges)
    # Forces in object frame assumed identical to contact frame for planar case
    fx = Gc[0, :]
    fy = Gc[1, :]

    # Torque about origin tau_z = p x f (in 2D)
    tau_z = p_obj[0] * fy - p_obj[1] * fx

    W = np.vstack([fx, fy, tau_z])
    return W  # (3, m_edges)

def assemble_planar_grasp_map(contacts, mu, m_edges):
    """
    contacts: list of 2D positions (x, y) for each contact in object frame.
    Returns G (3 x m) where m = len(contacts) * m_edges.
    """
    W_list = []
    for p in contacts:
        W_i = planar_contact_wrench_generators(np.array(p), mu, m_edges)
        W_list.append(W_i)
    return np.hstack(W_list)

# Example: two-finger pinch grasp of a 2D object
mu = 0.8
m_edges = 8
contacts = [(-0.05, 0.0), (0.05, 0.0)]  # left and right

G = assemble_planar_grasp_map(contacts, mu, m_edges)
print("Grasp map shape:", G.shape)

# Check if we can balance gravity wrench (assuming object COM at origin)
mass = 0.5
g = 9.81
w_ext = np.array([0.0, -mass * g, 0.0])  # gravity in -y, no external torque

# Feasibility check via nonnegative combination of generators:
# G * lambda + w_ext = 0, lambda >= 0
# Here we solve a small NNLS problem (or LP). For illustration, try least-squares
# and check if lambda is approximately nonnegative.

lambda_ls, *_ = np.linalg.lstsq(G, -w_ext, rcond=None)
print("Candidate lambda (LS):", lambda_ls)

print("All lambda >= 0 ?", np.all(lambda_ls >= -1e-6))
      

In a full planner, the nonnegativity constraint on \( \boldsymbol{\lambda} \) and exact satisfaction of equilibrium would be enforced via a linear or quadratic program. Python robotics stacks such as pydrake (Drake), and pinocchio (via Python bindings) provide built-in grasp maps and contact Jacobians that can replace the hand-written geometry here.

We now sketch a minimal C++ class to generate 3D friction-cone rays and map them to object-frame wrenches using Eigen, which is standard in many robotics codebases (e.g., ROS-based grasp planners).

#include <Eigen/Dense>
#include <vector>
#include <stdexcept>

struct ContactPoint {
  Eigen::Vector3d p_obj;   // contact position in object frame
  Eigen::Vector3d n_obj;   // normal in object frame (unit, into object)
  double mu;               // friction coefficient
};

std::vector<Eigen::Vector3d>
frictionConeGenerators3D(const Eigen::Vector3d& n, double mu, int m_azimuth) {
  if (mu <= 0.0) {
    throw std::runtime_error("mu must be positive");
  }
  // Build orthonormal basis {t1, t2, n}
  Eigen::Vector3d t1;
  if (std::abs(n.x()) > 0.5) {
    t1 = Eigen::Vector3d(-n.y(), n.x(), 0.0);
  } else {
    t1 = Eigen::Vector3d(0.0, -n.z(), n.y());
  }
  t1.normalize();
  Eigen::Vector3d t2 = n.cross(t1);

  double alpha = std::atan(mu);
  std::vector<Eigen::Vector3d> rays;
  rays.reserve(m_azimuth);

  for (int k = 0; k < m_azimuth; ++k) {
    double theta = 2.0 * M_PI * static_cast<double>(k) / m_azimuth;
    // Tangential direction on the cone boundary
    Eigen::Vector3d t = std::cos(theta) * t1 + std::sin(theta) * t2;
    Eigen::Vector3d f = std::sin(alpha) * t + std::cos(alpha) * n;
    f.normalize();
    rays.push_back(f);
  }
  return rays;
}

Eigen::MatrixXd contactWrenchGenerators3D(const ContactPoint& cp, int m_azimuth) {
  // Rays are unit directions of force in object frame
  auto rays = frictionConeGenerators3D(cp.n_obj, cp.mu, m_azimuth);
  const int m = static_cast<int>(rays.size());
  Eigen::MatrixXd W(6, m);
  for (int j = 0; j < m; ++j) {
    Eigen::Vector3d f = rays[j];         // assume scaled later by nonneg coeffs
    Eigen::Vector3d tau = cp.p_obj.cross(f);
    W.block<3,1>(0, j) = f;
    W.block<3,1>(3, j) = tau;
  }
  return W; // each column is a wrench generator
}
      

In a multi-contact grasp, the global grasp map \( \mathbf{G} \) is obtained by horizontally stacking these generator matrices. Libraries such as GraspIt! and OpenRAVE implement similar constructions internally.

Java-based robotics projects (e.g., some industrial control stacks) can implement compact planar contact models using linear algebra libraries such as EJML or Apache Commons Math. Below we use plain arrays to keep the example lightweight.

public class PlanarContact {

    public static double[][] frictionConeGenerators2D(double mu, int mEdges) {
        if (mu <= 0.0) {
            throw new IllegalArgumentException("mu must be positive");
        }
        double alpha = Math.atan(mu);
        double[] angles = new double[mEdges];
        double[][] Gc = new double[2][mEdges];

        for (int k = 0; k < mEdges; ++k) {
            double t = (double) k / (double) (mEdges - 1);
            angles[k] = -alpha + 2.0 * alpha * t;
            Gc[0][k] = Math.sin(angles[k]); // tangent
            Gc[1][k] = Math.cos(angles[k]); // normal
        }
        return Gc;
    }

    public static double[][] planarWrenchGenerators(
            double px, double py, double mu, int mEdges) {

        double[][] Gc = frictionConeGenerators2D(mu, mEdges);
        double[][] W = new double[3][mEdges];

        for (int j = 0; j < mEdges; ++j) {
            double fx = Gc[0][j];
            double fy = Gc[1][j];
            double tau = px * fy - py * fx;
            W[0][j] = fx;
            W[1][j] = fy;
            W[2][j] = tau;
        }
        return W;
    }
}
      

In a Java-based planner, these generators would be aggregated into a global grasp map and combined with an LP or QP solver to enforce equilibrium and friction constraints during planning.

MATLAB is widely used for prototyping contact models. Simulink (with Simscape Multibody) provides block-level contact models, but it is often useful to have an analytic representation for planning and analysis.

function W = planarContactWrenchGenerators(p_obj, mu, mEdges)
%PLANARCONTACTWRENCHGENERATORS  2D friction cone wrench generators.
%   p_obj: [2x1] contact position [x; y] in object frame.
%   mu: scalar friction coefficient.
%   mEdges: number of edges for polyhedral cone approximation.
%
%   W: [3 x mEdges] matrix, columns are wrench generators [fx; fy; tau_z].

if mu <= 0
    error('mu must be positive');
end

alpha = atan(mu);
angles = linspace(-alpha, alpha, mEdges);

fx = sin(angles);
fy = cos(angles);

px = p_obj(1);
py = p_obj(2);
tau_z = px .* fy - py .* fx;

W = [fx; fy; tau_z];

end

% Example usage:
pL = [-0.05; 0.0];
pR = [0.05; 0.0];
mu = 0.8;
mEdges = 8;

WL = planarContactWrenchGenerators(pL, mu, mEdges);
WR = planarContactWrenchGenerators(pR, mu, mEdges);
G = [WL, WR];  % 3 x (2*mEdges)

% In Simulink, one may:
% 1) Use Simscape Multibody blocks to simulate actual contacts.
% 2) Use MATLAB Function blocks that call planarContactWrenchGenerators
%    to compute linearized cones for model-predictive control or planning.
      

This separation between high-fidelity Simulink simulation and analytic cone models is typical in advanced planning pipelines: the planner uses the cone abstraction, and Simulink validates planned grasps in more detailed dynamics.

Mathematica is convenient for symbolic and geometric reasoning about contact models. The friction cone can be defined as a semi-algebraic region and manipulated analytically.

(* 3D Coulomb friction cone with normal along +y *)
Clear[mu, fx, fy, fz];
mu > 0;

frictionConeRegion[mu_] := 
  ImplicitRegion[
    fy >= 0 && fx^2 + fz^2 <= (mu fy)^2,
    { {fx, -Infinity, Infinity},
     {fy, 0, Infinity},
     {fz, -Infinity, Infinity} }
  ];

(* Example: visualize cross-section for mu = 0.5 *)
muVal = 0.5;
reg = frictionConeRegion[muVal];

(* Slice at constant fy, e.g. fy = 1 *)
ContourPlot[
  fx^2 + fz^2 == (muVal)^2,
  {fx, -1, 1}, {fz, -1, 1},
  PlotLegends -> None,
  AxesLabel -> {"fx", "fz"}
]
      

More sophisticated use cases include computing intersections of friction cones with linear subspaces (e.g., due to kinematic constraints) or performing exact feasibility checks for particular contact forces using Reduce or Solve.

Problem 1 (Friction Cone Half-Angle): Assume a point contact with Coulomb friction coefficient \( \mu > 0 \). Show that the half-angle of the friction cone is \( \alpha = \arctan(\mu) \), and quantify how the solid angle of the cone changes with \( \mu \).

Solution:

On the friction cone boundary we have equality \( \left\lVert \mathbf{f}_t \right\rVert_2 = \mu f_n \). Choose coordinates so that the normal is along the vertical axis and \( \mathbf{f}_t \) lies in the horizontal plane. Consider the 2D cross-section spanned by \( \mathbf{n}_c \) and \( \mathbf{f}_t \). The force vector is

\[ \mathbf{f}_c = \begin{bmatrix} \mathbf{f}_t \\[2pt] f_n \end{bmatrix}, \quad \tan(\alpha) = \frac{\left\lVert \mathbf{f}_t \right\rVert_2}{f_n} = \mu. \]

Hence \( \alpha = \arctan(\mu) \). In 3D, the friction cone is a circular cone; its solid angle is \( \Omega = 2\pi(1 - \cos\alpha) \). Since \( \cos\alpha = 1/\sqrt{1+\mu^2} \), we obtain \( \Omega(\mu) = 2\pi\left(1 - 1/\sqrt{1+\mu^2}\right) \), which is strictly increasing in \( \mu \). Thus higher friction widens the set of admissible directions in which the contact can resist disturbances.

Problem 2 (Feasibility of a 2D Grasp): A 2D object of mass \( m \) is grasped by two opposing fingertips at positions \( p_1 = (-a, 0) \) and \( p_2 = (a, 0) \) (object frame). Gravity acts as \( \mathbf{w}_{\text{ext}} = (0, -mg, 0) \). Contacts are P+F with identical coefficient \( \mu \). Assume friction cones are not linearized. Show that there exists a static equilibrium if and only if \( \mu \ge 0 \), and that the minimum possible normal force at each contact is \( f_{n,\min} = mg/2 \).

Solution:

By symmetry, consider normal forces \( f_{n,1} = f_{n,2} \). Because the contact normals are horizontal (pointing from object to fingertips), normal forces cannot directly balance the vertical gravity component; only tangential forces (friction) can contribute vertical force.

Due to symmetry, equal and opposite tangential forces at the two contacts can produce a net vertical force with zero torque. However, these tangential forces are bounded by the Coulomb constraint \( \left| f_{t,i} \right| \le \mu f_{n,i} \). To balance gravity we require

\[ 2 f_t = mg,\quad \left| f_t \right| \le \mu f_n. \]

The smallest normal force consistent with friction is thus \( f_n = mg/(2\mu) \). As long as \( \mu > 0 \), we can choose \( f_n \) large enough to satisfy the inequality. There is no upper bound on \( f_n \), so equilibrium exists for any \( \mu > 0 \). In the limit \( \mu \to \infty \), the minimum normal force tends to zero; for finite \( \mu \) the minimum is \( f_{n,\min} = mg/(2\mu) \). If we additionally impose a maximum allowed normal force due to hardware limits, the condition becomes \( mg/(2\mu) \le f_{n,\max} \).

If \( \mu = 0 \) (frictionless point contacts), then no tangential forces can be generated and static equilibrium is impossible for a nonzero gravity torque, so the grasp cannot balance the object.

Problem 3 (Mapping Local Forces to Object Wrench): Let the contact frame origin be at \( \mathbf{p}_{oc} = (p_x, p_y, p_z)^\top \) in the object frame and the rotation be identity \( \mathbf{R}_{oc} = \mathbf{I}_3 \). Given a contact force \( \mathbf{f}_c = (f_x, f_y, f_z)^\top \) and zero local torque, derive the expression for the resulting wrench \( \mathbf{w}_o = (\mathbf{f}_o, \boldsymbol{\tau}_o)^\top \) in the object frame.

Solution:

With rotation identity, the force in the object frame is \( \mathbf{f}_o = \mathbf{f}_c \). The torque is \( \boldsymbol{\tau}_o = \mathbf{p}_{oc} \times \mathbf{f}_c \), i.e.

\[ \boldsymbol{\tau}_o = \begin{bmatrix} p_y f_z - p_z f_y \\ p_z f_x - p_x f_z \\ p_x f_y - p_y f_x \end{bmatrix}. \]

Thus the wrench is

\[ \mathbf{w}_o = \begin{bmatrix} f_x \\ f_y \\ f_z \\ p_y f_z - p_z f_y \\ p_z f_x - p_x f_z \\ p_x f_y - p_y f_x \end{bmatrix}, \]

which matches the general adjoint formula derived earlier for \( \mathbf{R}_{oc} = \mathbf{I}_3 \).

Problem 4 (Linearized Friction Cone as Convex Cone): Suppose a friction cone is approximated by \( m \) unit vectors \( \{\mathbf{d}_j\}_{j=1}^m \) in force space. Show that the set \( \mathcal{K} = \left\{ \sum_{j=1}^m \lambda_j \mathbf{d}_j \mid \lambda_j \ge 0 \right\} \) is a convex cone and that it converges (in Hausdorff distance on compact sections) to the true friction cone as \( m \to \infty \), assuming the directions are sampled uniformly over the cone boundary.

Solution:

To show that \( \mathcal{K} \) is a cone, note that if \( \mathbf{f}_1, \mathbf{f}_2 \in \mathcal{K} \) and \( a_1, a_2 \ge 0 \), then

\[ a_1 \mathbf{f}_1 + a_2 \mathbf{f}_2 = \sum_{j=1}^m (a_1 \lambda_{1j} + a_2 \lambda_{2j}) \mathbf{d}_j, \]

which is in \( \mathcal{K} \) because \( a_1 \lambda_{1j} + a_2 \lambda_{2j} \ge 0 \) for all \( j \). Hence \( \mathcal{K} \) is closed under nonnegative scaling and addition, i.e., it is a convex cone. For convergence, note that the true friction cone is rotationally symmetric, and uniform sampling of boundary directions ensures that the polyhedral cone approximates the smooth circular base by a regular polygon. As \( m \to \infty \), the polygon converges to the circle, and cross-sections of \( \mathcal{K} \) at fixed normal force converge in Hausdorff distance to the corresponding cross-sections of the smooth cone. Because both cones are closed and pointed, convergence of bounded cross-sections implies convergence of the cones themselves in the appropriate topology.

Problem 5 (Planning Flow with Contact Models): Sketch the decision flow a planner might follow when selecting a contact model for a manipulation task, considering the trade-off between physical fidelity and computational complexity.

Solution (flow):

flowchart TD
  S["Start"] --> T["Task type: pick, place, in-hand?"]
  T --> F["Needed accuracy: \nqualitative vs quantitative forces"]
  F -->|low| M1["Use simple 'P' \n(no friction) model"]
  F -->|medium| M2["Use 'P+F' with \npolyhedral cone"]
  F -->|high| M3["Use soft-finger or \ndistributed patch"]
  M1 --> C["Assemble grasp map G; plan grasps"]
  M2 --> C
  M3 --> C
  C --> V["Validate with higher-fidelity simulator if available"]
        

This flow emphasizes that contact models are abstractions: we choose the simplest model that is still adequate for the planner's objectives, and rely on higher-fidelity tools only where necessary.

In this lesson we constructed contact models for grasping from a planning perspective. We defined local contact frames and the adjoint mapping from contact forces and torques to object-frame wrenches. Using Coulomb friction, we characterized the friction cone and derived its dependence on the friction coefficient. We then formalized canonical contact types (P, P+F, soft-finger, and area contacts) as sets of admissible wrenches.

At the multi-contact level, we introduced the grasp map \( \mathbf{G} \) and quasi-static equilibrium conditions, together with contact-mode and complementarity concepts that appear in planning under contact. We implemented friction-cone approximations and contact wrench generators in Python, C++, Java, MATLAB/Simulink, and Wolfram Mathematica, emphasizing the role of polyhedral cone approximations for optimization-based planning.

These constructions form the foundation for the next lesson, where we will use contact models to define force closure, form closure, and grasp-quality metrics.