Modern robot models are almost always designed first in a CAD system, which stores detailed geometric and material information for each link. From this, the CAD system can compute:

• Link mass \( m \)
• Center of mass (CoM) position \( \mathbf{c} \in \mathbb{R}^3 \)
• Inertia tensor about a chosen reference point and frame

In contrast, the analytical dynamics model for an \(n\)-DOF manipulator derived in previous chapters requires, for each link, inertial parameters and a spatial inertia tensor consistent with the link frames used in the kinematic description. The joint-space dynamics equation is

\[ \mathbf{M}(\mathbf{q}) \ddot{\mathbf{q}} + \mathbf{C}(\mathbf{q},\dot{\mathbf{q}})\dot{\mathbf{q}} + \mathbf{g}(\mathbf{q}) = \boldsymbol{\tau}, \]

where all matrices and vectors depend on per-link inertial parameters introduced in Lessons 1–4 of this chapter.

Goal of this lesson. Define a mathematically precise and reproducible pipeline CAD → inertial parameters → spatial inertia → dynamics, and implement it in software.

For each rigid link \(i\), CAD can provide (or we can compute):

• Mass \( m_i > 0 \)
• CoM position in some CAD frame \(C_i\): \( \mathbf{c}_i^C \in \mathbb{R}^3 \)
• Inertia tensor about the CoM, expressed in the same frame: \( \mathbf{I}_{C_i}^{C_i} \in \mathbb{R}^{3\times 3} \)

Recall from Lesson 3 that the standard 10-parameter inertial vector for a link, referred to a chosen link frame \(L_i\), is

\[ \boldsymbol{\pi}_i^L = \begin{bmatrix} m_i \\ m_i c_{x,i}^L \\ m_i c_{y,i}^L \\ m_i c_{z,i}^L \\ I_{xx,i}^L \\ I_{yy,i}^L \\ I_{zz,i}^L \\ I_{xy,i}^L \\ I_{yz,i}^L \\ I_{xz,i}^L \end{bmatrix} \in \mathbb{R}^{10}, \]

where the CoM coordinates \( (c_{x,i}^L, c_{y,i}^L, c_{z,i}^L) \) and inertia components \( I_{\alpha\beta,i}^L \) are defined relative to the link frame \(L_i\) used in the kinematic chain (PoE or DH).

The CAD system rarely uses the same frame as \(L_i\). Therefore, we need to:

1. Rotate the inertia tensor from CAD frame \(C_i\) to link frame \(L_i\)
2. Apply a translation (parallel-axis theorem) to move from CoM to the link origin
3. Collect the resulting components into the 10-parameter vector

Let \(C\) denote the CAD frame and \(L\) the link frame. Assume we know:

• Rotation \( \mathbf{R}_{LC} \in \mathrm{SO}(3) \) from frame \(C\) to \(L\)
• Position of the CoM relative to the link origin, expressed in \(L\): \( \mathbf{p} = \mathbf{c}^L \)

The inertia tensor about the CoM in frame \(L\) is

\[ \mathbf{I}_C^L = \mathbf{R}_{LC} \, \mathbf{I}_C^C \, \mathbf{R}_{LC}^\top. \]

To obtain the inertia about the link origin \(O_L\) (used, e.g., in URDF inertial tags), we apply the parallel-axis theorem:

\[ \mathbf{I}_O^L = \mathbf{I}_C^L + m \left( \|\mathbf{p}\|^2 \mathbf{I}_3 - \mathbf{p}\mathbf{p}^\top \right). \]

Using the skew-symmetric matrix \( [\mathbf{p}]_\times \) from Chapter 2, we can also write

\[ [\mathbf{p}]_\times = \begin{bmatrix} 0 & -p_z & p_y \\ p_z & 0 & -p_x \\ -p_y & p_x & 0 \end{bmatrix}, \qquad [\mathbf{p}]_\times[\mathbf{p}]_\times^\top = \mathbf{p}\mathbf{p}^\top - \|\mathbf{p}\|^2 \mathbf{I}_3. \]

This identity is useful in spatial vector formulations. Rewriting the parallel-axis theorem:

\[ \mathbf{I}_O^L = \mathbf{I}_C^L - m \, [\mathbf{p}]_\times[\mathbf{p}]_\times^\top. \]

Once \( \mathbf{I}_O^L \) is known, its entries populate the last six components of \( \boldsymbol{\pi}_i^L \), while \( m\mathbf{c}^L \) give the linear momentum-related parameters.

Recall from Lesson 2 (Spatial Inertia Tensors) that the spatial inertia matrix of a rigid body in frame \(L\) is

\[ \mathbf{I}_s^L = \begin{bmatrix} \mathbf{I}_O^L + m [\mathbf{c}^L]_\times [\mathbf{c}^L]_\times^\top & m [\mathbf{c}^L]_\times \\ -m [\mathbf{c}^L]_\times & m \mathbf{I}_3 \end{bmatrix} \in \mathbb{R}^{6\times 6}, \]

where \( \mathbf{c}^L \) is the CoM in frame \(L\) and \( \mathbf{I}_O^L \) is the inertia about the link origin.

The spatial kinetic energy for a spatial velocity \( \mathbf{v}_s^L \in \mathbb{R}^6 \) is

\[ T = \tfrac{1}{2} (\mathbf{v}_s^L)^\top \mathbf{I}_s^L \mathbf{v}_s^L, \]

from which we can prove that \( \mathbf{I}_s^L \) is symmetric positive semidefinite:

• Symmetry follows because both \( \mathbf{I}_O^L \) and \( [\mathbf{c}^L]_\times[\mathbf{c}^L]_\times^\top \) are symmetric, and the off-diagonal blocks are negatives of each other.
• Positive semidefiniteness follows since \( T \ge 0 \) for all physical velocities.

Conclusion: From CAD, once we know \( m \), \( \mathbf{c}^L \), and \( \mathbf{I}_O^L \), we can construct \( \mathbf{I}_s^L \) directly, guaranteeing the physical consistency constraints discussed in Lesson 4.

A common route is to export a CAD assembly as a URDF file. For each link, the URDF <inertial> element typically contains:

• <mass value="m"/>
• <origin xyz="c_x c_y c_z" rpy="r p y"/>
• <inertia ixx="..." ixy="..." ixz="..." iyy="..." iyz="..." izz="..."/>

By convention (and assuming default exporters):

• xyz gives CoM coordinates \( \mathbf{c}^L \) in the link frame.
• ixx, ixy, \dots\) define the inertia tensor \( \mathbf{I}_O^L \) about the link origin, expressed in the link frame.

Hence, given a URDF with consistent frames, the mapping to the 10-D inertial parameter vector is straightforward:

\[ \boldsymbol{\pi}^L = \begin{bmatrix} m \\ m c_x^L \\ m c_y^L \\ m c_z^L \\ I_{xx}^L \\ I_{yy}^L \\ I_{zz}^L \\ I_{xy}^L \\ I_{yz}^L \\ I_{xz}^L \end{bmatrix}. \]

When the CAD exporter provides inertia about the CoM instead of the origin, we must first apply the parallel-axis theorem to obtain \( \mathbf{I}_O^L \), as in Section 3.

The overall pipeline from CAD geometry to equations of motion can be summarized as follows.

flowchart TD
  A["CAD model (geometry, assemblies)"] --> B["Assign materials and densities"]
  B --> C["Compute per-link mass, com, inertia in CAD"]
  C --> D["Export mass properties or URDF/SDF"]
  D --> E["Parse model in Python/C++/Matlab"]
  E --> F["Build inertial parameters and spatial inertia tensors"]
  F --> G["Assemble multibody model and equations of motion M(q)ddq + C(q,dq)dq + g(q) = tau"]
  G --> H["Run validation: symmetry, positive definiteness, energy checks"]
        

Each of the following sections implements parts of nodes E, F, and G in different programming environments.

We now implement the core transformations in Python using numpy. We assume that the URDF exporter has provided CoM and inertia about the link origin in the link frame. For more complex cases, an additional rotation/translation step would be added before building the spatial inertia.

import numpy as np
from dataclasses import dataclass

@dataclass
class LinkInertialURDF:
    mass: float               # m > 0
    com: np.ndarray           # shape (3,), CoM in link frame
    I_origin: np.ndarray      # shape (3,3), inertia about link origin

def skew(v: np.ndarray) -> np.ndarray:
    """Return the 3x3 skew-symmetric matrix [v]_x."""
    vx, vy, vz = v
    return np.array([
        [0.0, -vz,  vy],
        [vz,  0.0, -vx],
        [-vy, vx,  0.0],
    ])

def spatial_inertia_from_urdf(link: LinkInertialURDF) -> np.ndarray:
    """
    Build 6x6 spatial inertia matrix from URDF-like inertial data.
    Assumes:
      - com is expressed in the same frame as I_origin.
      - I_origin is inertia about link origin, expressed in link frame.
    """
    m = link.mass
    c = link.com.reshape(3, 1)
    I_O = link.I_origin

    S = skew(c.flatten())
    upper_left = I_O + m * S @ S.T
    upper_right = m * S
    lower_left = -m * S
    lower_right = m * np.eye(3)

    I_spatial = np.block([
        [upper_left,  upper_right],
        [lower_left,  lower_right],
    ])
    return I_spatial

def inertial_parameters_10d(link: LinkInertialURDF) -> np.ndarray:
    """Return 10-dim inertial parameter vector [m, mc, I_components]^T."""
    m = link.mass
    cx, cy, cz = link.com
    I = link.I_origin
    pi = np.array([
        m,
        m * cx, m * cy, m * cz,
        I[0, 0], I[1, 1], I[2, 2],
        I[0, 1], I[1, 2], I[0, 2],
    ])
    return pi

# Example: simple numeric test
link = LinkInertialURDF(
    mass=5.0,
    com=np.array([0.1, 0.0, 0.0]),
    I_origin=np.array([
        [0.2, 0.0, 0.0],
        [0.0, 0.3, 0.0],
        [0.0, 0.0, 0.4],
    ])
)

I_spatial = spatial_inertia_from_urdf(link)
pi_10 = inertial_parameters_10d(link)

print("Spatial inertia:\n", I_spatial)
print("10D inertial parameters:\n", pi_10)

# Simple symmetry and positive-definiteness checks
sym_err = np.linalg.norm(I_spatial - I_spatial.T)
eigvals = np.linalg.eigvalsh(I_spatial)
print("Symmetry error:", sym_err)
print("Eigenvalues:", eigvals)
      

The eigenvalues of the spatial inertia must be nonnegative in a physically consistent model. Small negative values arise only from numerical round-off and indicate that the CAD-to-dynamics pipeline is correctly enforcing positive definiteness.

In C++, robotics libraries such as RBDL and Pinocchio use Eigen to represent spatial inertia. The following minimal example shows how to construct a 6x6 spatial inertia matrix from mass, CoM, and inertia about the origin.

#include <iostream>
#include <Eigen/Dense>

struct RigidBodyInertia {
    double mass;
    Eigen::Vector3d com;     // CoM in link frame
    Eigen::Matrix3d I_origin; // Inertia about link origin
};

inline Eigen::Matrix3d skew(const Eigen::Vector3d& v) {
    Eigen::Matrix3d S;
    S <<  0.0,   -v.z(),  v.y(),
           v.z(),  0.0,   -v.x(),
          -v.y(),  v.x(),  0.0;
    return S;
}

Eigen::Matrix<double,6,6> spatialInertia(const RigidBodyInertia& rb) {
    const double m = rb.mass;
    const Eigen::Matrix3d S = skew(rb.com);

    Eigen::Matrix<double,6,6> I = Eigen::Matrix<double,6,6>::Zero();
    I.block<3,3>(0,0) = rb.I_origin + m * S * S.transpose();
    I.block<3,3>(0,3) = m * S;
    I.block<3,3>(3,0) = -m * S;
    I.block<3,3>(3,3) = m * Eigen::Matrix3d::Identity();
    return I;
}

int main() {
    RigidBodyInertia link;
    link.mass = 5.0;
    link.com  = Eigen::Vector3d(0.1, 0.0, 0.0);
    link.I_origin <<
        0.2, 0.0, 0.0,
        0.0, 0.3, 0.0,
        0.0, 0.0, 0.4;

    Eigen::Matrix<double,6,6> Isp = spatialInertia(link);

    std::cout << "Spatial inertia:\n" << Isp << std::endl;
    return 0;
}
      

In a full robotics codebase, this function would be called for each link after parsing the URDF or a CAD export, and the resulting spatial inertias would be passed to the recursive Newton–Euler or articulated body algorithms described in Chapters 11 and 12.

Java is less common for low-level robot dynamics, but we can still implement the basic inertial parameter handling in a straightforward way using arrays. Below is a minimal class that stores a link's inertial parameters and provides a method to compute the 10-D parameter vector.

public final class LinkInertial {
    private final double mass;
    private final double[] com;  // length 3
    private final double[][] Iorigin; // 3x3 inertia about origin

    public LinkInertial(double mass, double[] com, double[][] Iorigin) {
        if (com.length != 3) {
            throw new IllegalArgumentException("com must have length 3");
        }
        if (Iorigin.length != 3 || Iorigin[0].length != 3) {
            throw new IllegalArgumentException("Iorigin must be 3x3");
        }
        this.mass = mass;
        this.com = com.clone();
        this.Iorigin = new double[3][3];
        for (int i = 0; i < 3; ++i) {
            System.arraycopy(Iorigin[i], 0, this.Iorigin[i], 0, 3);
        }
    }

    public double[] inertialParameters10d() {
        double[] pi = new double[10];
        pi[0] = mass;
        pi[1] = mass * com[0];
        pi[2] = mass * com[1];
        pi[3] = mass * com[2];
        pi[4] = Iorigin[0][0];      // Ixx
        pi[5] = Iorigin[1][1];      // Iyy
        pi[6] = Iorigin[2][2];      // Izz
        pi[7] = Iorigin[0][1];      // Ixy
        pi[8] = Iorigin[1][2];      // Iyz
        pi[9] = Iorigin[0][2];      // Ixz
        return pi;
    }
}
      

A higher-level Java robotics framework could read URDF XML, fill this structure, and then hand off the parameter vectors to dynamics routines or numerical optimization (e.g., for identification or simulation).

MATLAB's Robotics System Toolbox can import URDF models directly into a rigidBodyTree object, which stores mass and inertia for each link and can compute the joint-space inertia matrix \( \mathbf{M}(\mathbf{q}) \).

% Import URDF exported from CAD
robot = importrobot("my_manipulator.urdf");

% Use joint-space data format for direct matrix computation
robot.DataFormat = "row";

% Inspect one link's inertial parameters
body = robot.Bodies{3};  % third link
inertial = body.Inertia; % [Ixx Iyy Izz Ixy Iyz Ixz]
mass = body.Mass;
com  = body.CenterOfMass; % [cx cy cz]

fprintf("Mass: %.3f\n", mass);
fprintf("CoM:  [%.3f %.3f %.3f]\n", com(1), com(2), com(3));
fprintf("Inertia (Ixx Iyy Izz Ixy Iyz Ixz):\n");
disp(inertial);

% Compute joint-space inertia at a configuration q
q = homeConfiguration(robot);
q_vec = [q.JointPosition];  % row vector
M = massMatrix(robot, q_vec);

% Basic checks: symmetry and positive definiteness
symErr = norm(M - M.');
eigM   = eig(M);

fprintf("M symmetry error: %.3e\n", symErr);
fprintf("Eigenvalues of M(q):\n");
disp(eigM);

% Simulink: use 'Rigid Body Tree' block to simulate dynamics
% - Set the 'Robot description' parameter to 'robot'
% - Connect joint torques and states to other Simulink blocks
      

In Simulink, the same rigidBodyTree can be used in a dedicated block to simulate dynamics under arbitrary torque inputs, providing a direct interface from CAD-based URDF to time-domain simulations.

Mathematica is convenient for symbolic manipulation of inertia parameters and for verifying physical consistency analytically. Suppose we have CAD-derived parameters \( m \), \( \mathbf{c} \), and \( \mathbf{I}_O \) (all possibly symbolic).

(* Mass and center of mass *)
m  = Symbol["m", Positive -> True];
cx = Symbol["cx"]; cy = Symbol["cy"]; cz = Symbol["cz"];
c  = {cx, cy, cz};

(* Inertia tensor about origin in link frame *)
Ixx = Symbol["Ixx"]; Iyy = Symbol["Iyy"]; Izz = Symbol["Izz"];
Ixy = Symbol["Ixy"]; Iyz = Symbol["Iyz"]; Ixz = Symbol["Ixz"];

Iorigin = {
  {Ixx, Ixy, Ixz},
  {Ixy, Iyy, Iyz},
  {Ixz, Iyz, Izz}
};

(* Skew-symmetric matrix of c *)
S[v_] := {
  {0, -v[[3]],  v[[2]]},
  {v[[3]], 0,  -v[[1]]},
  {-v[[2]], v[[1]], 0}
};

Scc = S[c];

(* Spatial inertia matrix (6x6) *)
Ispatial = ArrayFlatten[{
  {Iorigin + m Scc . Transpose[Scc], m Scc},
  {-m Scc, m IdentityMatrix[3]}
}];

(* Verify symmetry symbolically *)
Simplify[Transpose[Ispatial] - Ispatial]

(* Kinetic energy expression *)
vs = Array[Subscript[v, #] &, 6]; (* spatial velocity components *)
T  = 1/2 vs . Ispatial . vs;

(* Check that T is quadratic and nonnegative in vs when m > 0 and Iorigin is positive semidefinite *)
      

Symbolic checks of the kinetic energy and symmetry properties can be used to validate CAD export scripts or to derive minimal parameter sets (e.g., by eliminating dependent combinations of symbolic parameters).

In this lesson we connected CAD-based mass properties to the inertial parameters and spatial inertia tensors required by analytical robot dynamics. Starting from CAD outputs \( (m, \mathbf{c}, \mathbf{I}) \), we used rotations and the parallel-axis theorem to construct inertia tensors about the link origins, built the 10-dimensional inertial parameter vector, and assembled the 6x6 spatial inertia matrix used in recursive algorithms. We implemented these steps in Python, C++, Java, MATLAB/Simulink, and Wolfram Mathematica and emphasized validation checks (symmetry, positive definiteness, energy interpretation) that ensure physical consistency. These CAD-to-dynamics pipelines are the foundation for identification (Chapter 19) and for model-based control based on the equations of motion.