For an n-DOF serial manipulator, the joint configuration is \( \mathbf{q} \in \mathcal{Q} \subset \mathbb{R}^n \) (or a product of circles for revolute joints). The forward kinematics map \( f:\mathcal{Q} \rightarrow SE(3) \) assigns to each joint vector a pose of the end-effector frame relative to a base frame. Let \( T(\mathbf{q}) = \begin{bmatrix} \mathbf{R}(\mathbf{q}) & \mathbf{p}(\mathbf{q}) \\ \mathbf{0}^T & 1 \end{bmatrix} \in SE(3) \).

We distinguish several workspace notions:

• Reachable (position) workspace: \( \mathcal{W}_p = \{ \mathbf{p}(\mathbf{q}) \in \mathbb{R}^3 \mid \mathbf{q} \in \mathcal{Q} \} \).
• Reachable task-space workspace: \( \mathcal{W} = \{ T(\mathbf{q}) \in SE(3) \mid \mathbf{q} \in \mathcal{Q} \} \).
• Dexterous workspace: points where the end-effector can attain a neighborhood of orientations (or twists) while staying at the same position; formalized in terms of Jacobian rank and local surjectivity.

Workspace analysis is essential for:

• Determining whether desired tasks are physically realizable.
• Positioning robots with respect to work cells and fixtures.
• Understanding how singularities constrain reachable regions.

Conceptually, workspace is the image of the joint space under the forward kinematics, possibly intersected with joint limits and collision constraints.

flowchart TD
  A["Joint space Q (q1,...,qn)"] --> B["Forward kinematics f(q) = T"]
  B --> C["Position workspace \nW_p subset R3"]
  B --> D["Pose workspace \nW subset SE(3)"]
  C --> E["Reachable region \n(task points)"]
  D --> F["Dexterous subset \n(full orientation locally)"]
  B --> G["Singular set det(J) = 0"]
  G --> H["Workspace boundary & \nloss of dexterity"]
        

Let \( \mathcal{Q} \) denote the set of admissible joint configurations, including joint limits and mechanical stops. Then:

\[ \mathcal{W} = f(\mathcal{Q}) = \{\, T(\mathbf{q}) \in SE(3) \mid \mathbf{q} \in \mathcal{Q} \,\}. \]

If we are interested only in the end-effector origin, the position workspace is \( \mathcal{W}_p = \{ \mathbf{p}(\mathbf{q}) \mid \mathbf{q} \in \mathcal{Q} \} \subset \mathbb{R}^3 \).

Assuming \( f \) is continuous (which holds for smooth joint-to-transform maps), we have:

\[ \text{If } \mathcal{Q} \text{ is compact and connected, then } \mathcal{W} = f(\mathcal{Q}) \text{ is compact and connected.} \]

Sketch of argument. The set \( \mathcal{Q} \) is typically a product of closed intervals (for revolute/prismatic joints), hence compact and connected. A continuous image of a compact (connected) set is compact (connected). Therefore the reachable pose set \( \mathcal{W} \) is also compact and connected.

The dexterous workspace can be defined as:

\[ \mathcal{W}_d = \left\{ \mathbf{p}_0 \in \mathcal{W}_p \;\middle|\; \exists \mathbf{q}_0 \in \mathcal{Q}: \mathbf{p}(\mathbf{q}_0)=\mathbf{p}_0, \operatorname{rank} J(\mathbf{q}_0) = m \right\}, \]

where \( J(\mathbf{q}) \) is the Jacobian mapping joint velocities to end-effector twists, and \( m \le 6 \) is the task dimension (e.g., 3 for purely positional tasks, 6 for full pose). Full rank of \( J(\mathbf{q}_0) \) ensures that, locally, small changes in pose are achievable by small joint motions, implying local dexterity.

Consider a planar 2R manipulator with link lengths \( \ell_1, \ell_2 > 0 \) and joint angles \( \theta_1, \theta_2 \). The end-effector position in the base frame is

\[ \begin{aligned} x(\theta_1,\theta_2) &= \ell_1 \cos\theta_1 + \ell_2 \cos(\theta_1 + \theta_2),\\ y(\theta_1,\theta_2) &= \ell_1 \sin\theta_1 + \ell_2 \sin(\theta_1 + \theta_2). \end{aligned} \]

Define the radial distance \( r(\theta_1,\theta_2) = \sqrt{x^2 + y^2} \). Using trigonometric identities, one obtains:

\[ r^2(\theta_1,\theta_2) = \ell_1^2 + \ell_2^2 + 2 \ell_1 \ell_2 \cos\theta_2. \]

Since \( -1 \le \cos\theta_2 \le 1 \), we obtain tight bounds on \( r^2 \):

\[ (\ell_1 - \ell_2)^2 \le r^2(\theta_1,\theta_2) \le (\ell_1 + \ell_2)^2. \]

Taking square roots:

\[ |\ell_1 - \ell_2| \le r(\theta_1,\theta_2) \le \ell_1 + \ell_2. \]

Thus, with unrestricted revolute joints:

• The reachable workspace is the annulus in the plane between radii \( |\ell_1 - \ell_2| \) and \( \ell_1 + \ell_2 \).
• The outer boundary corresponds to the arm being fully stretched (\( \theta_2 = 0 \)), and the inner boundary to the arm being folded back (\( \theta_2 = \pi \)).

Note how this simple derivation already shows that workspace boundaries are linked with the geometry and joint configurations that often coincide with kinematic singularities (here, collinearity of links).

In practice, each joint is constrained to an interval \( \theta_i^{\min} \le \theta_i \le \theta_i^{\max} \). The admissible joint set is

\[ \mathcal{Q}_{\text{lim}} = \{\, \mathbf{q} \in \mathcal{Q} \mid \theta_i^{\min} \le \theta_i \le \theta_i^{\max},\; i=1,\dots,n \,\}. \]

The corresponding workspace is \( \mathcal{W}_{\text{lim}} = f(\mathcal{Q}_{\text{lim}}) \). For the planar 2R manipulator, joint limits carve out sectors of the annulus, resulting in a shape bounded by circular arcs (given by radial extremal values) and curves corresponding to fixed joint angles.

Singularities, studied in earlier lessons, occur where \( \operatorname{rank} J(\mathbf{q}) < m \). For full pose control (\( m = 6 \) in 3D), a loss of rank implies a loss of at least one instantaneous motion direction. Many workspace boundaries are associated with sequences of configurations that approach either:

• joint limits, or
• internal singular configurations (e.g., elbow fully stretched).

Intuitively, the manipulator cannot cross certain configurations without violating limits or passing through singular states where dexterity collapses. Thus, workspace computation and singularity analysis are deeply coupled.

From a differential viewpoint, a point \( \mathbf{p}_0 \in \mathcal{W}_p \) lies on the boundary if every preimage \( \mathbf{q}_0 \in f^{-1}(\mathbf{p}_0) \) lies on the boundary of \( \mathcal{Q}_{\text{lim}} \) or satisfies \( \operatorname{rank} J(\mathbf{q}_0) < m \).

For general 6R industrial manipulators, analytic expressions for workspace boundaries are rarely available in closed form. Instead, we resort to numerical algorithms. Two common strategies are:

1. Joint-space sampling: densely sample \( \mathbf{q} \in \mathcal{Q}_{\text{lim}} \), compute \( \mathbf{p}(\mathbf{q}) \), and visualize the resulting point cloud. This gives a direct approximation of \( \mathcal{W}_p \).
2. Task-space grid with IK: create a grid of candidate task-space points or poses, attempt to solve IK (using analytic or numerical IK from earlier chapters), and mark grid points as reachable/unreachable.

The joint-space sampling pipeline can be summarized as:

flowchart TD
  A["Specify joint limits and resolution"] --> B["Sample joint vectors q^k"]
  B --> C["Compute T(q^k) and p(q^k) via FK"]
  C --> D["Optionally compute J(q^k) and manipulability"]
  D --> E["Store points and metrics"]
  E --> F["Visualize 2D/3D point cloud, color by metric"]
        

To enrich the visualization, we can color workspace points by:

• Manipulability index \( w(\mathbf{q}) = \sqrt{\det(JJ^T)} \) (for square or tall Jacobians).
• Condition number \( \kappa(J) \), indicating sensitivity.
• Distance to joint limits, indicating operational safety margins.

Color-coding the workspace by such metrics yields a functional workspace, not only indicating reachability but also quality of motion and control.

For planar manipulators, \( \mathcal{W}_p \subset \mathbb{R}^2 \) can be visualized directly as a 2D scatter plot. When the manipulator is symmetric around the base axis, the planar workspace often generates a solid of revolution in 3D.

For spatial manipulators, standard approaches include:

• 3D point clouds of reachable positions, possibly plotted in a CAD model of the environment.
• Surface approximations of outer workspace boundaries, obtained via alpha-shapes or convex hulls of sampled points.
• Sectional views (e.g., constant height slices) to reveal internal structure.
• Scalar fields on a grid (e.g., mapping manipulability indices) to show regions of high/low dexterity.

In interactive environments (e.g., MATLAB, Python notebooks, or Simulink visualizations), users can overlay workspace plots with obstacles and fixtures to check whether task points lie inside safe zones and away from singular regions.

We now implement workspace sampling for the planar 2R arm using Python with numpy and matplotlib. In more advanced settings, one can integrate libraries such as modern_robotics or roboticstoolbox-python to handle SE(3) kinematics and Jacobians for general manipulators.

import numpy as np
import matplotlib.pyplot as plt

# Link lengths
l1 = 1.0
l2 = 0.7

# Joint limits (radians)
theta1_min, theta1_max = -np.pi, np.pi
theta2_min, theta2_max = -np.pi, np.pi

# Sampling resolution
n1 = 300
n2 = 300

theta1_vals = np.linspace(theta1_min, theta1_max, n1)
theta2_vals = np.linspace(theta2_min, theta2_max, n2)

xs = []
ys = []
manip_vals = []

for th1 in theta1_vals:
    for th2 in theta2_vals:
        # Forward kinematics (position of the end-effector)
        x = l1 * np.cos(th1) + l2 * np.cos(th1 + th2)
        y = l1 * np.sin(th1) + l2 * np.sin(th1 + th2)
        xs.append(x)
        ys.append(y)

        # Planar position Jacobian J_pos in R2 x R2
        # J = [ -l1 sin(th1) - l2 sin(th1 + th2),  -l2 sin(th1 + th2)
        #        l1 cos(th1) + l2 cos(th1 + th2),   l2 cos(th1 + th2) ]
        j11 = -l1 * np.sin(th1) - l2 * np.sin(th1 + th2)
        j12 = -l2 * np.sin(th1 + th2)
        j21 = l1 * np.cos(th1) + l2 * np.cos(th1 + th2)
        j22 = l2 * np.cos(th1 + th2)
        J = np.array([[j11, j12],
                      [j21, j22]])

        # Determinant as a simple manipulability measure
        manip = np.abs(np.linalg.det(J))
        manip_vals.append(manip)

xs = np.array(xs)
ys = np.array(ys)
manip_vals = np.array(manip_vals)

# Normalize manipulability for color mapping
if np.max(manip_vals) > 0:
    manip_norm = manip_vals / np.max(manip_vals)
else:
    manip_norm = manipul_vals

plt.figure()
sc = plt.scatter(xs, ys, c=manip_norm, s=2)
plt.colorbar(sc, label="Normalized manipulability")
plt.gca().set_aspect("equal")
plt.xlabel("x [m]")
plt.ylabel("y [m]")
plt.title("Planar 2R workspace colored by manipulability")
plt.show()
      

This script approximates the planar workspace and visualizes regions where the Jacobian determinant (and hence local dexterity) is large or small. Dark regions near the inner and outer radial limits typically correspond to singular or near-singular configurations.

In C++, workspace computations are often built upon the Eigen library for linear algebra and, in more advanced projects, libraries such as Orocos KDL for kinematics. Below is a minimal, self-contained 2R workspace sampler using standard C++ and Eigen for Jacobian handling.

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

int main() {
    double l1 = 1.0;
    double l2 = 0.7;

    double th1_min = -M_PI;
    double th1_max =  M_PI;
    double th2_min = -M_PI;
    double th2_max =  M_PI;

    int n1 = 300;
    int n2 = 300;

    std::ofstream out("workspace_2R.csv");
    out << "x,y,manip\n";

    for (int i = 0; i < n1; ++i) {
        double th1 = th1_min + (th1_max - th1_min) * i / (n1 - 1);
        for (int j = 0; j < n2; ++j) {
            double th2 = th2_min + (th2_max - th2_min) * j / (n2 - 1);

            double x = l1 * std::cos(th1) + l2 * std::cos(th1 + th2);
            double y = l1 * std::sin(th1) + l2 * std::sin(th1 + th2);

            double j11 = -l1 * std::sin(th1) - l2 * std::sin(th1 + th2);
            double j12 = -l2 * std::sin(th1 + th2);
            double j21 =  l1 * std::cos(th1) + l2 * std::cos(th1 + th2);
            double j22 =  l2 * std::cos(th1 + th2);

            Eigen::Matrix2d J;
            J(0,0) = j11; J(0,1) = j12;
            J(1,0) = j21; J(1,1) = j22;

            double manip = std::abs(J.determinant());
            out << x << "," << y << "," << manip << "\n";
        }
    }

    out.close();
    std::cout << "Saved workspace samples to workspace_2R.csv\n";
    return 0;
}
      

The generated CSV can be plotted with external tools (Python, MATLAB, etc.). In more advanced settings, one would replace this analytic 2R kinematics with calls to a kinematics library that supports arbitrary URDF-defined robots.

Java robotics projects often rely on numerical libraries such as EJML or Apache Commons Math for matrix computations. Here, to keep dependencies minimal, we implement a simple 2R workspace sampler using only arrays. The resulting samples can be exported for plotting.

public class Planar2RWorkspace {

    public static void main(String[] args) {
        double l1 = 1.0;
        double l2 = 0.7;

        double th1Min = -Math.PI;
        double th1Max =  Math.PI;
        double th2Min = -Math.PI;
        double th2Max =  Math.PI;

        int n1 = 300;
        int n2 = 300;

        StringBuilder sb = new StringBuilder();
        sb.append("x,y,manip\n");

        for (int i = 0; i < n1; i++) {
            double th1 = th1Min + (th1Max - th1Min) * i / (n1 - 1);
            for (int j = 0; j < n2; j++) {
                double th2 = th2Min + (th2Max - th2Min) * j / (n2 - 1);

                double x = l1 * Math.cos(th1) + l2 * Math.cos(th1 + th2);
                double y = l1 * Math.sin(th1) + l2 * Math.sin(th1 + th2);

                double j11 = -l1 * Math.sin(th1) - l2 * Math.sin(th1 + th2);
                double j12 = -l2 * Math.sin(th1 + th2);
                double j21 =  l1 * Math.cos(th1) + l2 * Math.cos(th1 + th2);
                double j22 =  l2 * Math.cos(th1 + th2);

                double detJ = j11 * j22 - j12 * j21;
                double manip = Math.abs(detJ);

                sb.append(x).append(",").append(y).append(",").append(manip).append("\n");
            }
        }

        // Save to file (omitting try-with-resources boilerplate for brevity)
        try {
            java.nio.file.Files.write(
                java.nio.file.Paths.get("workspace_2R_java.csv"),
                sb.toString().getBytes()
            );
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
      

In a larger project, this code could be integrated with a robot description loaded from a configuration file and combined with 3D visualization libraries (e.g., JavaFX) to render workspace volumes.

MATLAB's Robotics System Toolbox provides the rigidBodyTree class, which is well-suited for workspace exploration. Simulink can then be used for animation and integration with control and dynamics models.

% Define a simple 2R planar robot as a rigidBodyTree
robot = rigidBodyTree("DataFormat","row","MaxNumBodies",3);

% First body
body1 = rigidBody("link1");
jnt1 = rigidBodyJoint("joint1","revolute");
setFixedTransform(jnt1, trvec2tform([0 0 0]));
jnt1.JointAxis = [0 0 1];
body1.Joint = jnt1;
addBody(robot, body1, "base");

% Second body
body2 = rigidBody("link2");
jnt2 = rigidBodyJoint("joint2","revolute");
setFixedTransform(jnt2, trvec2tform([1.0 0 0])); % link1 length
jnt2.JointAxis = [0 0 1];
body2.Joint = jnt2;
addBody(robot, body2, "link1");

% End-effector frame
tool = rigidBody("tool");
setFixedTransform(tool.Joint, trvec2tform([0.7 0 0])); % link2 length
addBody(robot, tool, "link2");

% Joint limits
robot.Bodies{1}.Joint.PositionLimits = [-pi pi];
robot.Bodies{2}.Joint.PositionLimits = [-pi pi];

% Sampling
n1 = 200;
n2 = 200;
th1_vals = linspace(-pi, pi, n1);
th2_vals = linspace(-pi, pi, n2);

X = zeros(n1 * n2, 1);
Y = zeros(n1 * n2, 1);

k = 1;
for i = 1:n1
    for j = 1:n2
        config = [th1_vals(i) th2_vals(j)];
        T = getTransform(robot, config, "tool", "base");
        X(k) = T(1,4);
        Y(k) = T(2,4);
        k = k + 1;
    end
end

figure;
scatter(X, Y, 5, ".");

axis equal;
xlabel("x [m]");
ylabel("y [m]");
title("2R planar workspace (MATLAB rigidBodyTree)");
      

In Simulink, one can embed the same rigidBodyTree in a model with joint trajectory inputs and visualize workspace occupancy over time via 3D scopes or custom visualization blocks.

Wolfram Mathematica is convenient for symbolic manipulation of kinematics and for high-quality parametric plots. The following notebook fragment computes and visualizes the planar 2R workspace using ParametricPlot and RegionPlot.

(* Link lengths *)
l1 = 1.0;
l2 = 0.7;

(* Joint ranges *)
th1min = -Pi; th1max = Pi;
th2min = -Pi; th2max = Pi;

x[th1_, th2_] := l1 Cos[th1] + l2 Cos[th1 + th2];
y[th1_, th2_] := l1 Sin[th1] + l2 Sin[th1 + th2];

ParametricPlot[
  Evaluate[{x[th1, th2], y[th1, th2]}],
  {th1, th1min, th1max},
  {th2, th2min, th2max},
  PlotPoints -> {60, 60},
  MaxRecursion -> 2,
  AspectRatio -> 1,
  Frame -> True,
  FrameLabel -> {"x [m]", "y [m]"},
  PlotLabel -> "Planar 2R Workspace (Mathematica)"
]

(* Analytic annulus check *)
rmin = Abs[l1 - l2];
rmax = l1 + l2;
RegionPlot[
  rmin <= Sqrt[x^2 + y^2] && Sqrt[x^2 + y^2] <= rmax,
  {x, -2, 2}, {y, -2, 2},
  AspectRatio -> 1,
  PlotPoints -> 60,
  FrameLabel -> {"x [m]", "y [m]"},
  PlotLabel -> "Analytic Annulus for 2R Workspace"
]
      

The second plot illustrates the analytic annulus derived in Section 3, confirming the correctness of the sampled workspace.

In this lesson we formalized the workspace of a serial manipulator as the image of its joint space under the forward kinematics map, and distinguished reachable and dexterous workspaces. For the planar 2R manipulator, we derived an analytic annulus description and showed how joint limits carve out sectors of this region. We related workspace boundaries to singularities via the Jacobian determinant and explained how full-rank conditions characterize dexterous regions.

We then presented numerical workspace computation methods based on joint-space sampling and task-space grids with inverse kinematics, and discussed 2D and 3D visualization techniques, including quality metrics such as manipulability and condition numbers. Finally, we implemented workspace computation and visualization in Python, C++, Java, MATLAB/Simulink, and Wolfram Mathematica, using both low-level linear algebra and higher-level robotics libraries where available.

These ideas provide the geometric foundation on which later chapters will build when combining kinematic reachability with dynamics, constraints, and control objectives.