For an \(n\)-DOF serial manipulator, the joint-space (or configuration space) is typically modeled as a subset \( \mathcal{Q} \subset \mathbb{R}^n \), where a configuration is a vector \( \mathbf{q} = (q_1,\dots,q_n)' \). The task-space (or workspace) is often a subset \( \mathcal{X} \subset \mathbb{R}^3 \) (for position only) or \( \mathcal{X} \subset SE(3) \) (for full pose, position and orientation).

The forward kinematics map

\[ f : \mathcal{Q} \to \mathcal{X}, \quad \mathbf{x} = f(\mathbf{q}) \]

is known from earlier chapters (via DH or PoE formulations). A joint-space trajectory is a time-parametrized curve

\[ \mathbf{q} : [0,T] \to \mathcal{Q}, \quad t \mapsto \mathbf{q}(t), \]

and it induces a task-space trajectory

\[ \mathbf{x}(t) = f(\mathbf{q}(t)), \quad t \in [0,T]. \]

Conceptually, we can think of the model as a deterministic “converter” from joint motion to end-effector motion.

flowchart TD
  A["Joint trajectory q(t) in R^n"] --> B["Forward kinematics model f"]
  B --> C["Task-space pose trajectory x(t)"]
  C --> D["Position path in R^3"]
  C --> E["Orientation path in SE(3)"]
  D --> F["Geometric path (no time info)"]
  E --> F
        

This lesson focuses on the mapping \( \mathbf{q}(t) \mapsto \mathbf{x}(t) \) at the level of position and pose. Velocity and acceleration mappings via Jacobians are treated more systematically in the next lesson.

Let \( \mathcal{Q} \) be the configuration manifold and \( \mathcal{X} \) the task-space. In most manipulator models, we can treat them as smooth manifolds embedded in Euclidean spaces (for example, \( \mathcal{Q} \subset \mathbb{R}^n \), \( \mathcal{X} \subset \mathbb{R}^m \) with \(m=3\) or \(m=6\)).

A geometric path in joint space is a continuous curve

\[ \gamma : [0,1] \to \mathcal{Q}. \]

A joint-space trajectory is a time-parameterized curve

\[ \mathbf{q} : [0,T] \to \mathcal{Q}, \]

where \(t\) has physical units of time. Given the forward kinematics \( f \), the induced task-space trajectory is simply the composition

\[ \mathbf{x}(t) = f(\mathbf{q}(t)) = (f \circ \mathbf{q})(t). \]

A basic but important regularity result can be stated and justified using multivariable calculus:

Proposition 1 (Regularity by composition). Suppose \(f\) is \(C^k\) (i.e., \(k\)-times continuously differentiable) on \(\mathcal{Q}\) and \(\mathbf{q}(t)\) is a \(C^k\) joint-space trajectory on \([0,T]\). Then the induced task-space trajectory \( \mathbf{x}(t) = f(\mathbf{q}(t)) \) is also \(C^k\).

Sketch of proof. The map \(f\) is a smooth function of \(\mathbf{q}\), and \(\mathbf{q}(t)\) is a smooth function of \(t\). The composition of two \(C^k\) functions is again \(C^k\) (standard result from analysis), so \( f \circ \mathbf{q} \) inherits the same degree of smoothness.

In particular, if the joint trajectory is piecewise polynomial (e.g., cubic splines) and the kinematics map \(f\) is smooth, then the resulting task-space trajectory is also at least piecewise \(C^2\), which is crucial when we later consider velocities and accelerations.

The geometric path traced by a trajectory \( \mathbf{q}(t) \) is the image set

\[ \mathcal{C}_{\mathcal{Q}} = \{\mathbf{q}(t) \in \mathcal{Q} \mid t \in [0,T]\}, \]

and analogously the task-space path is

\[ \mathcal{C}_{\mathcal{X}} = \{\mathbf{x}(t) = f(\mathbf{q}(t)) \in \mathcal{X} \mid t \in [0,T]\}. \]

Two different time-parameterizations of the same geometric path correspond to different trajectories sharing the same image set.

Definition (Time reparameterization). Let \( s : [0,T'] \to [0,T] \) be a strictly increasing, continuous bijection with continuous inverse. Define a new joint trajectory

\[ \tilde{\mathbf{q}}(t) = \mathbf{q}(s(t)), \quad t \in [0,T']. \]

Then \( \tilde{\mathbf{q}} \) is a reparameterization of \( \mathbf{q} \).

Proposition 2 (Path invariance under reparameterization). If \( \tilde{\mathbf{q}}(t) = \mathbf{q}(s(t)) \) with \(s\) strictly increasing and continuous, then the corresponding task-space paths are identical:

\[ \{\mathbf{x}(t) = f(\mathbf{q}(t)) \mid t \in [0,T]\} = \{\tilde{\mathbf{x}}(t) = f(\tilde{\mathbf{q}}(t)) \mid t \in [0,T']\}. \]

Proof. For any \(t \in [0,T']\), \(\tilde{\mathbf{x}}(t) = f(\tilde{\mathbf{q}}(t)) = f(\mathbf{q}(s(t)))\). Since \(s\) is surjective onto \([0,T]\), every value \(\mathbf{q}(\tau)\) appears as \(\tilde{\mathbf{q}}(t)\) for some \(t\). Thus the image sets of \(\mathbf{x}(t)\) and \(\tilde{\mathbf{x}}(t)\) coincide.

This distinction between path and time law is fundamental in trajectory design: one often chooses a geometric path in joint or task space, and then a separate time-parameterization \(s(t)\). In this chapter we focus on how the kinematic model transforms such design choices into task-space trajectories.

Consider a planar 2R arm with link lengths \( \ell_1, \ell_2 \), revolute joints \( q_1, q_2 \), and base at the origin. The forward kinematics map for end-effector position is

\[ \begin{aligned} x(\mathbf{q}) &= \ell_1 \cos q_1 + \ell_2 \cos(q_1 + q_2),\\ y(\mathbf{q}) &= \ell_1 \sin q_1 + \ell_2 \sin(q_1 + q_2). \end{aligned} \]

Suppose joints follow simple polynomial trajectories over \(t \in [0,T]\):

\[ \begin{aligned} q_1(t) &= q_{1,0} + \alpha_1 t + \beta_1 t^2, \\ q_2(t) &= q_{2,0} + \alpha_2 t + \beta_2 t^2, \end{aligned} \]

with constants \(q_{1,0}, q_{2,0}, \alpha_1, \alpha_2, \beta_1, \beta_2\). The induced task-space trajectory is then

\[ \begin{aligned} x(t) &= \ell_1 \cos\big(q_1(t)\big) + \ell_2 \cos\big(q_1(t) + q_2(t)\big), \\ y(t) &= \ell_1 \sin\big(q_1(t)\big) + \ell_2 \sin\big(q_1(t) + q_2(t)\big). \end{aligned} \]

Since trigonometric functions are smooth and polynomials are \(C^\infty\), Proposition 1 implies that \(x(t), y(t)\) are smooth on \([0,T]\). Note that even if each joint moves along a simple polynomial, the resulting task-space trajectory is typically not polynomial in \(t\), but remains smooth.

If we only care about the geometric path, we can parametrize it by \(u \in [0,1]\) with \(t = T u\), yielding

\[ \mathbf{p}(u) = \begin{bmatrix} x(Tu) \\[4pt] y(Tu) \end{bmatrix}, \quad u \in [0,1]. \]

Any other time law \(t = s(u)\) that monotonically spans \([0,T]\) produces the same geometric curve \(\mathbf{p}(u)\) in the plane.

In practice, we rarely manipulate continuous trajectories analytically. Instead, we sample the joint trajectory at discrete times

\[ t_k = k \Delta t, \quad k = 0,\dots,N, \quad \Delta t = T/N, \]

and compute discrete joint configurations

\[ \mathbf{q}_k = \mathbf{q}(t_k) \in \mathcal{Q}. \]

Applying the forward kinematics at each sample gives task-space samples

\[ \mathbf{x}_k = f(\mathbf{q}_k), \quad k = 0,\dots,N. \]

If \(f\) and \(\mathbf{q}(t)\) are continuous, then as \( \Delta t \to 0 \) (i.e., \(N \to \infty\)), the polygonal chain connecting successive \(\mathbf{x}_k\) converges uniformly to the continuous curve \(\mathbf{x}(t)\).

When representing orientation, we typically compute a homogeneous transform

\[ \mathbf{T}_k = \mathbf{T}(\mathbf{q}_k) \in SE(3), \]

and extract position and orientation (e.g., as rotation matrices, axis–angle, or quaternions) from \(\mathbf{T}_k\). All prior remarks about continuity and sampling extend to \(SE(3)\) with appropriate manifold-aware interpolation when needed.

We illustrate a simple pipeline in Python for the planar 2R example. In more complex cases, one would use robotics libraries such as roboticstoolbox-python or pytransform3d to build general DHRobot or SE3-based models of the manipulator. Here we explicitly implement the forward kinematics.

flowchart TD
  Tdef["Define time grid t_k"] --> Qdef["Evaluate joint trajectory q(t_k)"]
  Qdef --> FK["Forward kinematics f(q_k)"]
  FK --> Xdef["Store task-space samples x_k"]
  Xdef --> VIS["Visualize or log trajectory"]
        

import numpy as np

# Link lengths
l1 = 1.0
l2 = 0.8

def q_traj(t, q10, q20, a1, a2, b1, b2):
    """
    Simple polynomial joint trajectories:
      q1(t) = q10 + a1 * t + b1 * t**2
      q2(t) = q20 + a2 * t + b2 * t**2
    """
    q1 = q10 + a1 * t + b1 * t**2
    q2 = q20 + a2 * t + b2 * t**2
    return np.vstack((q1, q2))  # shape (2, len(t))

def fk_2r(q):
    """
    Forward kinematics for planar 2R:
      q: array of shape (2, N) or (2,)
      returns x, y arrays for each column of q
    """
    q = np.atleast_2d(q)
    q1 = q[0, :]
    q2 = q[1, :]
    x = l1 * np.cos(q1) + l2 * np.cos(q1 + q2)
    y = l1 * np.sin(q1) + l2 * np.sin(q1 + q2)
    return x, y

# Time discretization
T = 2.0
N = 200
t = np.linspace(0.0, T, N + 1)

# Parameters of joint trajectory
q10, q20 = 0.0, 0.5
a1, a2 = 0.8, -0.3
b1, b2 = -0.2, 0.15

# Evaluate joint-space trajectory
q = q_traj(t, q10, q20, a1, a2, b1, b2)  # shape (2, N+1)

# Map to task-space
x, y = fk_2r(q)

# x, y now describe the end-effector path in the plane as functions of t
# Example: save trajectory as (t, x, y)
traj = np.vstack((t, x, y)).T

# (Optional) quick plot if running in a Python environment with matplotlib:
if __name__ == "__main__":
    import matplotlib.pyplot as plt
    plt.figure()
    plt.plot(x, y, "-")
    plt.xlabel("x [m]")
    plt.ylabel("y [m]")
    plt.title("End-effector trajectory induced by q(t)")
    plt.axis("equal")
    plt.show()
      

For a general manipulator, the function fk_2r would be replaced by a call to a model object (e.g., a DHRobot instance) that returns an SE3 transform or a 4×4 homogeneous matrix, from which position and orientation can be extracted.

In C++, forward kinematics can be implemented either with custom code (as below) or using libraries like Eigen plus robotics toolkits such as Orocos KDL or Pinocchio. The following example uses simple scalar math to compute the planar 2R trajectory.

#include <cmath>
#include <vector>

struct Vec2 {
    double x;
    double y;
};

struct Planar2R {
    double l1;
    double l2;

    Vec2 fk(double q1, double q2) const {
        Vec2 p;
        double q12 = q1 + q2;
        p.x = l1 * std::cos(q1) + l2 * std::cos(q12);
        p.y = l1 * std::sin(q1) + l2 * std::sin(q12);
        return p;
    }
};

int main() {
    Planar2R robot{1.0, 0.8};

    double T = 2.0;
    std::size_t N = 200;
    double dt = T / static_cast<double>(N);

    // Parameters for joint polynomials
    double q10 = 0.0, q20 = 0.5;
    double a1 = 0.8, a2 = -0.3;
    double b1 = -0.2, b2 = 0.15;

    std::vector<double> t(N + 1);
    std::vector<Vec2> xtraj(N + 1);

    for (std::size_t k = 0; k <= N; ++k) {
        double tk = k * dt;
        t[k] = tk;

        double q1 = q10 + a1 * tk + b1 * tk * tk;
        double q2 = q20 + a2 * tk + b2 * tk * tk;

        xtraj[k] = robot.fk(q1, q2);
    }

    // xtraj[k].x, xtraj[k].y now hold the task-space samples
    // (Export to file or use in further computations)

    return 0;
}
      

This pattern generalizes to higher-DOF arms by letting Planar2R store DH parameters or twist coordinates and implementing a more general fk using homogeneous transformations or Product of Exponentials.

Java implementations often use numeric libraries such as Apache Commons Math for vectors and matrices, but for a small planar arm we can work with primitive arrays. The structure mirrors the Python and C++ examples.

public class Planar2R {
    private final double l1;
    private final double l2;

    public Planar2R(double l1, double l2) {
        this.l1 = l1;
        this.l2 = l2;
    }

    public double[] fk(double q1, double q2) {
        double q12 = q1 + q2;
        double x = l1 * Math.cos(q1) + l2 * Math.cos(q12);
        double y = l1 * Math.sin(q1) + l2 * Math.sin(q12);
        return new double[] { x, y };
    }

    public static void main(String[] args) {
        Planar2R robot = new Planar2R(1.0, 0.8);

        double T = 2.0;
        int N = 200;
        double dt = T / (double) N;

        double q10 = 0.0, q20 = 0.5;
        double a1 = 0.8, a2 = -0.3;
        double b1 = -0.2, b2 = 0.15;

        double[] t = new double[N + 1];
        double[][] traj = new double[N + 1][2]; // [k][0]=x, [k][1]=y

        for (int k = 0; k <= N; ++k) {
            double tk = k * dt;
            t[k] = tk;

            double q1 = q10 + a1 * tk + b1 * tk * tk;
            double q2 = q20 + a2 * tk + b2 * tk * tk;

            double[] p = robot.fk(q1, q2);
            traj[k][0] = p[0];
            traj[k][1] = p[1];
        }

        // traj now contains the task-space samples
    }
}
      

For higher-dimensional robots, one would typically encapsulate the kinematic parameters in a more general class and possibly integrate with robotics middleware (e.g., ROS) that provides FK services.

MATLAB, together with Robotics System Toolbox, offers convenient functionality for kinematic modeling. Below we show a basic script implementing 2R forward kinematics and generating the task-space trajectory. The same idea applies if using a rigidBodyTree model constructed from DH parameters.

% Parameters
l1 = 1.0;
l2 = 0.8;

% Time grid
T = 2.0;
N = 200;
t = linspace(0, T, N+1);

% Joint trajectory parameters
q10 = 0.0; q20 = 0.5;
a1 = 0.8; a2 = -0.3;
b1 = -0.2; b2 = 0.15;

% Joint trajectories
q1 = q10 + a1 * t + b1 * t.^2;
q2 = q20 + a2 * t + b2 * t.^2;

% Forward kinematics for planar 2R
x = l1 * cos(q1) + l2 * cos(q1 + q2);
y = l1 * sin(q1) + l2 * sin(q1 + q2);

% Plot in task space
figure;
plot(x, y, '-');
axis equal;
xlabel('x [m]');
ylabel('y [m]');
title('End-effector trajectory');
      

In Simulink, a typical workflow is:

• Create a Clock block to provide time \(t\).
• Use MATLAB Function blocks to compute \(q_1(t)\), \(q_2(t)\), and then \(x(t), y(t)\) via the planar 2R kinematics.
• Log the outputs with To Workspace blocks or display them with a Scope or XY Graph.

For general manipulators modeled as a rigidBodyTree, a MATLAB Function block can call getTransform(robot, q, bodyName) at each time step, using joint vectors provided by signal lines that encode \(\mathbf{q}(t)\).

Wolfram Mathematica is well suited to symbolic and numeric work. We can define the joint trajectories and forward kinematics symbolically, then evaluate numerically over a time grid.

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

(* Joint trajectories *)
q1[t_] := q10 + a1 t + b1 t^2;
q2[t_] := q20 + a2 t + b2 t^2;

(* Forward kinematics *)
x[t_] := l1 Cos[q1[t]] + l2 Cos[q1[t] + q2[t]];
y[t_] := l1 Sin[q1[t]] + l2 Sin[q1[t] + q2[t]];

(* Parameters *)
q10 = 0.0; q20 = 0.5;
a1 = 0.8; a2 = -0.3;
b1 = -0.2; b2 = 0.15;
T = 2.0;

(* Plot the trajectory in task space *)
ParametricPlot[{x[t], y[t]}, {t, 0, T},
  AxesLabel -> {"x", "y"},
  AspectRatio -> 1,
  PlotLabel -> "End-effector trajectory"
]

(* Discrete samples as a list of {t, x, y} *)
Npts = 200;
tgrid = Subdivide[0, T, Npts];
traj = { #, x[#], y[#] } & /@ tgrid;
      

The symbolic definitions make it easy to change the functional form of the joint trajectories (e.g., splines, trigonometric functions) and immediately observe their effect on the workspace motion.

In this lesson we formalized the relationship between joint-space and task-space trajectories using the forward kinematics map \(f : \mathcal{Q} \to \mathcal{X}\). We emphasized the distinction between geometric paths and time-parameterized trajectories, showed how time reparameterization preserves geometric paths, and analyzed regularity properties of the induced task-space motion. Through a planar 2R example, we derived explicit expressions for the workspace trajectory and implemented the mapping computationally in Python, C++, Java, MATLAB/ Simulink, and Wolfram Mathematica. These constructions set the stage for the next lesson, where we will study how velocities and accelerations transform via Jacobians and their time derivatives.