Points, vectors and coordinate frames

Every question a robot asks about its own body begins with geometry. Where is the gripper? Which way is the camera pointing? How far must the elbow bend to reach the cup? Kinematics is the study of motion without asking what forces cause it, and robot kinematics is the art of describing positions and orientations precisely enough that a computer can calculate them. This course builds that language step by step. ROB-100 introduced frames and simple 2-D transforms informally; here we make the ideas exact, extend them to three dimensions and use them to model real arms and mobile robots. This first lesson sets out the vocabulary: points, vectors, coordinate frames, and the notation that keeps them straight.

Why kinematics needs careful notation

A modern robot arm has six or seven joints, a camera bolted to its wrist, a tool with its own tip, a table it is mounted on and objects it must find. Each of these has a natural coordinate system. The camera reports an object's position relative to the camera; the controller commands joint angles; the task is specified relative to the table. Most of the bugs in real robot software are not clever algorithmic failures but simple confusions between these systems: a vector expressed in the camera frame used as if it were in the base frame, an angle in degrees fed to a function expecting radians, a transform applied in the wrong order. A consistent notation, written down and followed rigidly, prevents most of them.

Kinematics deliberately ignores mass, force and torque. Those belong to dynamics, the subject of ROB-300. Separating the two is useful because geometry alone answers a surprising number of practical questions: whether a target is reachable, which joint angles reach it, how fast the tool moves when the joints move, and where the robot loses the ability to move in some direction.

Points and vectors

A point is a location in space. It has no size and no direction; it simply marks a place, such as the tip of a gripper finger or the centre of a bolt hole. A vector is a displacement: it has a length and a direction but no fixed location. The arrow from the robot's base to its gripper is a vector, and so is a velocity or a force. The distinction matters because the two transform differently. Moving the whole scene one metre to the left changes the coordinates of every point but leaves every displacement vector unchanged.

To calculate with points and vectors we describe them by coordinates, and coordinates only make sense relative to a frame. In three dimensions a vector \( \mathbf{v} \) is written as a column of three numbers, its components along three perpendicular axes:

The length, or norm, of a vector is a property of the vector itself: it does not depend on which frame we use to write it down, provided the frames have the same units and perpendicular axes. A vector of length one is a unit vector, often marked with a hat, and it represents a pure direction. Dividing any non-zero vector by its length gives the unit vector in its direction.

The dot product and the cross product

Two products appear throughout kinematics. The dot product of two vectors is a scalar that measures how much they point in the same direction:

If the dot product is zero, the vectors are perpendicular. The dot product of a vector with a unit vector gives the component of the vector along that direction, which is exactly how coordinates are defined: \( v_x = \mathbf{v} \cdot \hat{\mathbf{x}} \). It also gives the angle between two directions, as the first worked example shows.

The cross product of two vectors is a third vector perpendicular to both, with a length equal to the area of the parallelogram they span:

Its direction follows the right-hand rule: point the fingers of your right hand along \( \mathbf{a} \), curl them towards \( \mathbf{b} \), and your thumb points along \( \mathbf{a} \times \mathbf{b} \). The cross product is not commutative: \( \mathbf{b} \times \mathbf{a} = -\mathbf{a} \times \mathbf{b} \). In robotics it gives the velocity of a point on a rotating body, \( \mathbf{v} = \boldsymbol{\omega} \times \mathbf{r} \), the torque of a force about a joint, and the columns of the Jacobian matrix in lesson 10.

Coordinate frames

A coordinate frame is an origin point plus three mutually perpendicular unit axes, conventionally called x, y and z. Robotics uses right-handed frames exclusively: if x points to your right and y points up, z points out of the page towards you, and \( \hat{\mathbf{x}} \times \hat{\mathbf{y}} = \hat{\mathbf{z}} \). A left-handed frame, which some graphics and game engines use, flips the sign of one axis, and mixing the two silently mirrors the world. Before trusting data from any library or sensor, check its handedness and its axis conventions.

A robot system contains many frames. The world or map frame is fixed to the environment. The base frame is attached to the robot's base, so it moves if the robot is mobile. Each link has its own frame, which moves with that link. The tool frame, sometimes called the tool centre point (TCP), sits at the working point of the end effector: the tip of a welding torch, the centre between gripper fingers or the nozzle of a glue dispenser. Sensors have their own frames, such as a camera's optical frame, which by the ROS convention points z forward out of the lens, x to the right and y down in the image.

In ROS 2 the conventional names for mobile robots come from REP 105: map for the global frame, odom for a smooth but drifting odometry frame, and base_link attached to the robot body. Arms add a frame per link, and the tf2 library, covered in ROB-110, keeps track of all the transforms between them as they change over time. This course supplies the mathematics that tf2 performs internally.

Notation: who is described relative to whom

Because every coordinate is relative to a frame, good notation records the frame. This course follows the convention used by Craig and by Lynch and Park, with a leading superscript for the frame in which a quantity is expressed. The position of point P expressed in frame A is written \( {}^{A}\mathbf{p} \). The position of the origin of frame B, expressed in frame A, is \( {}^{A}\mathbf{p}_{B} \). In the next lessons we write the rotation that describes frame B's orientation relative to A as \( {}^{A}R_{B} \) and the full transform as \( {}^{A}T_{B} \).

The payoff of this notation is that frame labels cancel like units. A transform \( {}^{A}T_{B} \) takes coordinates in B and returns coordinates in A, so \( {}^{A}T_{B}\,{}^{B}\mathbf{p} = {}^{A}\mathbf{p} \). Chaining transforms works when the inner labels match: \( {}^{A}T_{B}\,{}^{B}T_{C} = {}^{A}T_{C} \). If you ever find yourself multiplying \( {}^{A}T_{B} \) by \( {}^{C}T_{D} \) with B and C different, the expression is wrong before you compute a single number. In code, the same discipline appears as variable names such as T_base_tool or p_cam, which make mismatches visible.

Changing frames by translation only

The simplest change of frame is a pure translation, where two frames have parallel axes but different origins. Then the coordinates of a point in frame A equal its coordinates in frame B plus the position of B's origin in A:

Note that this applies to points, not to free vectors. A displacement between two points is the difference of their positions, so the translation cancels: a vector has the same coordinates in two frames that differ only by translation. Once the frames are also rotated relative to each other, both points and vectors change, and we need the rotation matrices of the next lesson.

Degrees of freedom and configuration

A rigid body moving freely in space has six degrees of freedom (DOF): three for position and three for orientation. A body confined to a plane has three: two for position and one for heading. The configuration of a robot is a complete specification of where every point of it is, and for a robot made of rigid links connected by joints, the configuration is captured by the joint variables. A revolute joint, marked R, rotates and is described by an angle; a prismatic joint, marked P, slides and is described by a displacement. The vector of all joint variables, \( \mathbf{q} \), lives in the joint space or configuration space of the robot.

The tool, in contrast, is described by its pose in the task space or Cartesian space: its position and orientation relative to the base. The central job of kinematics is to translate between the two spaces. Forward kinematics, lessons 5 to 7, computes the tool pose from the joint variables; it always has exactly one answer. Inverse kinematics, lessons 8 and 9, finds joint variables that produce a desired pose, and may have no answer, several answers or infinitely many. Velocity kinematics, lessons 10 and 11, relates joint speeds to tool speeds through the Jacobian matrix.

Grübler's formula, introduced in ROB-100, counts the degrees of freedom of a mechanism. For a serial chain where each joint adds one freedom, the robot's DOF equals its number of joints. A six-joint arm can therefore reach a general pose, position and orientation, within its workspace; a seven-joint arm has one degree of redundancy that can be used to avoid obstacles or joint limits; and a four-joint SCARA robot trades orientation freedom for speed and stiffness in pick-and-place work.

Computing with vectors in code

Throughout this course we use Python with NumPy to check calculations. Arrays of shape (3,) hold vectors; numpy.dot and numpy.cross implement the two products; and numpy.linalg.norm gives lengths. The listing below repeats the first worked example and computes a velocity from the cross product.

import numpy as np
a = np.array([0.0, 0.6, 0.8])   # camera axis
b = np.array([0.0, 0.0, 1.0])   # approach axis
cos_t = a @ b / (np.linalg.norm(a) * np.linalg.norm(b))
print(f"angle = {np.degrees(np.arccos(cos_t)):.1f} deg")
print("axis  =", np.cross(a, b))

# velocity of a point 0.5 m out along x on a body spinning at 2 rad/s about z
omega = np.array([0.0, 0.0, 2.0])
r = np.array([0.5, 0.0, 0.0])
print("v     =", np.cross(omega, r), "m/s")

angle = 36.9 deg
axis  = [0.6 0.  0. ]
v     = [0. 1. 0.] m/s

Units and angles

Kinematic formulas assume consistent units: metres or millimetres for lengths, radians for angles in calculations. Industrial controllers often display millimetres and degrees, ROS uses metres and radians (REP 103), and CAD files may be in inches. Convert at the boundary of your code and keep one system inside it. Remember that trigonometric functions in almost every programming language expect radians, and that a small error in an angle grows into a large position error at the end of a long arm: a 1-degree error at a shoulder joint moves a tool 1 m away by about 17 mm.