Coordinate frames in robotics

The idea that every position and orientation is relative to a frame is fundamental to robotics because spatial quantities have no meaning in the absolute‍​‌‌​​‌‌​​‌‌‌​​‌​​‌‌​​‌​‌​‌‌​​‌​‌​​‌​‌‌​‌​‌‌‌​​‌‌​‌‌​​​​‌​‌‌​‌‌​‌​‌‌‌​​​​​‌‌​‌‌​​​‌‌​​‌​‌‍. A position is always a position relative to some origin and axes, and getting this relationship right is the entire basis of a robot knowing where anything is. Consider what a coordinate actually is: '(2, 0)' means 'two units along the first axis and zero along the second, starting from the origin'. But that is only meaningful once you specify which origin and which axes. That is, which frame. The very same physical point in space has different coordinates in different frames: a chair might be at (2, 0) relative to the robot's camera, at (1.5, 0.3) relative to the robot's body, and at (7.2, 4.1) relative to the world origin, three different coordinate triples, all describing the one chair. So a coordinate without a frame is genuinely meaningless (or worse, ambiguous: it looks like a definite location but isn't). This is why 'relative to a frame' is foundational: it's not a technicality, it's what makes spatial data mean anything. A robot's entire grasp of space (where it is, where obstacles are, where its goal is, which way it's facing) rests on coordinates, and every one of those coordinates is only correct in a particular frame‍​‌‌​​‌‌​​‌‌‌​​‌​​‌‌​​‌​‌​‌‌​​‌​‌​​‌​‌‌​‌​‌‌‌​​‌‌​‌‌​​​​‌​‌‌​‌‌​‌​‌‌‌​​​​​‌‌​‌‌​​​‌‌​​‌​‌‍. Get the frame wrong and the number, however precise, points to the wrong place. A robot must use several frames at once, rather than one global coordinate system, because each thing it deals with is naturally described in its own frame, and forcing everything into a single frame would be both unnatural and impossible to maintain directly. A sensor measures in its own frame: a camera or lidar inherently reports where things are relative to itself (it has no direct knowledge of the world origin): 'a point 2 m ahead of me'. The robot's body has its own frame (base_link) in which its motion, its wheels, and its parts are naturally described. The robot moves and turns, so 'forward' and 'left' are most naturally expressed relative to the body. And the world/map has a fixed frame in which the map, goals, and global positions live, because you want the map and destination to stay put as the robot moves. These frames are moving relative to each other: as the robot drives, its body frame and sensor frames move continuously within the fixed world frame. You cannot just pick one global frame and put everything in it directly, because the sensor physically measures in its own frame and the robot ‍​‌‌​​‌‌​​‌‌‌​​‌​​‌‌​​‌​‌​‌‌​​‌​‌​​‌​‌‌​‌​‌‌‌​​‌‌​‌‌​​​​‌​‌‌​‌‌​‌​‌‌‌​​​​​‌‌​‌‌​​​‌‌​​‌​‌‍physically moves in its body frame. The data is born in those local frames. What you can do (and must) is know the relationships between the frames, the transformations, and convert as needed: take the sensor's measurement (in the sensor frame), transform it through the body frame into the world frame to place the obstacle on the map; take the goal (in the world frame), transform it into the body frame to decide how to drive toward it. So robotics uses many frames because the sensors, the body, and the world are each intrinsically their own frame, and the robot's job is to relate them by transformation, which is exactly why frames and frame transformations are the geometric backbone of everything: kinematics (relating wheel/joint motion in the body frame to motion in the world), perception (sensor frame to map frame), localization (tracking the body frame's pose in the world frame), and navigation (goals in the world frame, control in the body frame) are all about expressing and converting spatial quantities between the right frames. Mastering 'everything is relative to a frame, and we convert between frames' is mastering the language in which all of robotics is spoken.

Most 'the robot thinks the obstacle or goal is in the wrong place' problems are actually frame errors because placing something in space requires both a measurement and the correct frame relationship to express that measurement in the frame you're reasoning in, and since the measurement itself is often fine, the thing that silently goes wrong is the frame conversion. Think about how an obstacle gets onto the robot's map: the lidar correctly measures a point '2 m ahead' in the ‍​‌‌​​‌‌​​‌‌‌​​‌​​‌‌​​‌​‌​‌‌​​‌​‌​​‌​‌‌​‌​‌‌‌​​‌‌​‌‌​​​​‌​‌‌​‌‌​‌​‌‌‌​​​​​‌‌​‌‌​​​‌‌​​‌​‌‍lidar frame; to put it on the map, that point must be transformed from the lidar frame, through the robot body frame, into the world/map frame, using the current relationships between those frames (where the lidar is mounted on the body, and where the body currently is in the world). If any of those frame relationships is wrong: the lidar's mounting transform is mis-specified, the robot's pose in the world is stale or wrong, an axis is flipped, units or angle conventions differ, or the wrong frame is assumed, then the correctly measured point gets placed at the wrong world location. The obstacle appears somewhere it isn't (a 'phantom' obstacle), or the real obstacle is mapped to the wrong spot, or the goal (specified in the world frame) is interpreted as if in the body frame and the robot drives to the wrong place. The sensor was working and the number was right. The error is purely in which frame the number was treated as being in, or how it was converted. That's why these bugs are so often frame errors: the spatial data pipeline is a chain of frame transformations, and a mistake anywhere in that chain corrupts the final position while leaving the raw measurement looking correct, so it ‍​‌‌​​‌‌​​‌‌‌​​‌​​‌‌​​‌​‌​‌‌​​‌​‌​​‌​‌‌​‌​‌‌‌​​‌‌​‌‌​​​​‌​‌‌​‌‌​‌​‌‌‌​​​​​‌‌​‌‌​​​‌‌​​‌​‌‍presents as a perception or planning fault ('the robot sees an obstacle that isn't there', 'the robot goes to the wrong place') but its cause is a frame mistake. What this reveals about the discipline frames impose is that spatial correctness is a bookkeeping discipline: you must, rigorously and always, know which frame every quantity is in, know the (current) relationships between your frames, and convert correctly and consistently between them. The frame framework is unforgiving in that a single inconsistency (a flipped axis, a wrong or stale transform, an assumed frame) doesn't throw an error. It just yields a confidently-wrong location. So frames impose the habit captured in the lesson: the first question to ask of any robotics coordinate is 'which frame is this in?', and the first thing to check when something is mis-located is the chain of transforms, not the sensor or the planner. This is also why robotics builds explicit machinery to manage frames rigorously. The transform tree and tools like ROS 2's tf2, which track all the frame relationships over time so conversions are done consistently and correctly. The deeper lesson is that because every spatial quantity is frame-relative and conversions are silent when wrong, robotics demands ‍​‌‌​​‌‌​​‌‌‌​​‌​​‌‌​​‌​‌​‌‌​​‌​‌​​‌​‌‌​‌​‌‌‌​​‌‌​‌‌​​​​‌​‌‌​‌‌​‌​‌‌‌​​​​​‌‌​‌‌​​​‌‌​​‌​‌‍disciplined frame bookkeeping as the foundation of spatial reasoning, and that internalising 'always know and convert frames correctly' prevents the single largest class of navigation and perception bugs, because those bugs are, more often than not, frames being wrong while the sensors and algorithms are blamed.

Coordinate frames are best understood through giving directions relative to different landmarks. First, a position is meaningless until you say what it's relative to. If I say 'it's two blocks north of me' and you say 'it's two blocks north of the station', we've used the same words but pointed at different places, because 'two blocks north' only means something once you say what it's relative to (me, or the station). It's the same with a robot: a position like '(2, 0)' is just numbers until you say which origin and which directions they're measured from. That reference is the frame, and the same spot has different numbers depending on which frame you use. Second, a robot naturally uses several frames: its sensors, its body, and the world: each measuring from its own viewpoint. A camera or lidar inherently reports where things are relative to itself ('2 m ahead of me'): that's the sensor frame‍​‌‌​​‌‌​​‌‌‌​​‌​​‌‌​​‌​‌​‌‌​​‌​‌​​‌​‌‌​‌​‌‌‌​​‌‌​‌‌​​​​‌​‌‌​‌‌​‌​‌‌‌​​​​​‌‌​‌‌​​​‌‌​​‌​‌‍. The robot's body has its own frame (forward, left, relative to the robot, which moves as the robot moves). And the world/map has a fixed frame, where the map and the goal stay put no matter how the robot drives. Each thing is naturally described from its own landmark: the sensor sees from the sensor, the robot moves relative to its body, the map is fixed to the world, so the robot juggles all of them. Third, converting between frames is how 'the obstacle is 2 m ahead of my camera' becomes 'the obstacle is at this spot on the map'. Just as you have to translate 'left of me' into 'east of the station' before someone else can use your directions, the robot has to translate the obstacle's position from the camera's frame into the map's frame before it can plan around it, and to do that it needs to know how the frames relate (where the camera is on the robot, where the robot is in the world). That translation is a frame transformation. So: every position is relative to a frame (a landmark), a robot sees and moves and plans using several frames at once, and it constantly ‍​‌‌​​‌‌​​‌‌‌​​‌​​‌‌​​‌​‌​‌‌​​‌​‌​​‌​‌‌​‌​‌‌‌​​‌‌​‌‌​​​​‌​‌‌​‌‌​‌​‌‌‌​​​​​‌‌​‌‌​​​‌‌​​‌​‌‍converts between them, and 'which frame is this in?' is the first question to ask, because most 'the robot put the obstacle in the wrong place' problems are really a frame mix-up, not a broken sensor.

What a frame is, and why a position needs one: a coordinate frame is a reference (an origin (the '(0,0,0)' point) plus axes (directions)) against which you measure position and orientation. A position is meaningless without a frame: '(2, 0)' is 'two along axis 1, zero along axis 2', but from which origin, whose axes? The same physical point has different coordinates in different frames, so a coordinate is really 'numbers in a particular frame' (state the frame or it's ambiguous).

The sensor/robot/world frames (local vs global): a robot uses a sensor frame (where a sensor measures from), a robot/body frame (base_link, fixed to the robot: moves with it), and a world/map frame (fixed to the environment). Local frames (body/sensor) move with the robot ('where relative to me?'); the ‍​‌‌​​‌‌​​‌‌‌​​‌​​‌‌​​‌​‌​‌‌​​‌​‌​​‌​‌‌​‌​‌‌‌​​‌‌​‌‌​​​​‌​‌‌​‌‌​‌​‌‌‌​​​​​‌‌​‌‌​​​‌‌​​‌​‌‍global frame (world/map) is fixed ('where in the world?'). Both are needed. Measuring and moving happen in local frames; maps and goals live in the global frame.

Frame transformations: a transformation converts a point's coordinates from one frame to another (sensor -> robot -> world). It's how 'the lidar sees a point 2 m ahead' (sensor frame) becomes 'an obstacle at (x, y) on the map' (world frame), and how a goal (world frame) becomes 'drive this way' (body frame).

Why several frames: each thing is naturally described in its own frame: a sensor physically measures in its own frame, the robot moves in its body frame, the map/goals live in the fixed world frame: and these frames move relative to each other as the robot drives. The data is born local, so you know the relationships between frames and convert rather than forcing one global frame.

Why 'always know your frame' prevents bugs: a quantity in the wrong frame is silently wrong‍​‌‌​​‌‌​​‌‌‌​​‌​​‌‌​​‌​‌​‌‌​​‌​‌​​‌​‌‌​‌​‌‌‌​​‌‌​‌‌​​​​‌​‌‌​‌‌​‌​‌‌‌​​​​​‌‌​‌‌​​​‌‌​​‌​‌‍: treating a sensor-frame measurement as world-frame (or a stale/wrong robot pose, a flipped axis, mismatched units) puts the correctly-measured obstacle/goal in the wrong place, looking like a perception/planning bug but really a frame mistake. Since conversions fail silently (a confidently-wrong location, no error), robotics demands disciplined frame bookkeeping: 'which frame is this in?' is the first question, and the chain of transforms is the first thing to check when something is mislocated. This is why robotics builds the transform tree and tf2 (the Nav2 SLAM lesson) to track frame relationships over time, and why frames are the geometric backbone of kinematics, perception, localization, and navigation. The math of converting between frames is the next lesson (rotations & homogeneous transformations).