Coordinate Systems and Transformations: Rotation Matrices, Homogeneous Transformations, Euler Angles and Quaternions, from Camera to Table Tennis Table

Status: Draft (2026-10-18), Measured. The numbers were calculated directly using Python 3.9.6 and numpy 2.0.2 on a laptop (Apple M1 Max, macOS 26.5). Times are the medians of 7 repetitions (dropping the first run). Raw data and code: working directory measure/robot-arm-basics/'s m02_frames.py, m02b_float32.py, out/m02_frames.json. No experiments calibrated with a real camera were performed (Unmeasured). References were accessed on 2026-10-18. Writing convention: Measured data is the default, unmeasured items are marked as "Unmeasured", and unverified items are marked as "Unverified".

Table of Contents

• 1. Intuition: The Same Ball, Four Descriptions
• 2. Diagram: The Coordinate System Chain
• 3. Calculations
  • 3.1 Rotation Matrix
  • 3.2 Homogeneous Transformation
  • 3.3 Euler Angles
  • 3.4 Quaternion
  • 3.5 From Camera to Table Tennis Table: Determining Pose via Marker Points
• 4. Measurements
  • 4.1 Does Orthogonality Breakdown When Multiplying Rotations Repeatedly?
  • 4.2 Computation Time
  • 4.3 Noise Amplification Near Gimbal Lock
  • 4.4 Determining Camera Pose via Marker Points
• 5. Limitations
• 6. Conclusion
• References

1. Intuition: The Same Ball, Four Descriptions

A ball is hovering. The camera describes it as "3.1 m in front of my lens, slightly down and to the left." Relative to the table tennis table, it is "0.8 m from the center toward the robot, at a height of 25 cm." Relative to the robot base, it is "0.9 m forward, 0.4 m up," and relative to the racket, it is "3 cm in front of the face." All of these refer to the same point.

Many bugs in robot software stem from mixing up these four descriptions. Therefore, each coordinate system (frame) is given a name, and moving a point always requires going through a transformation. This series uses the following four names.

2. Diagram: The Coordinate System Chain

• A single arrow represents a single 4×4 transformation matrix. Camera→Table is obtained once via calibration, Table→Robot base is measured during installation, and Robot base→Racket is recalculated via forward kinematics whenever joint angles change.
• The notation ᴮT_T means "the transformation that converts an expression in {T} to an expression in {B}." Because subscripts and the superscripts of the next transformation must match for multiplication, following this notation makes it difficult to get the multiplication order wrong.

3. Calculations

3.1 Rotation Matrix

A rotation matrix R is 3×3, and each column is a unit vector of the rotated coordinate system viewed from the original coordinate system. Therefore, it always satisfies the following two properties.

Rᵀ R = I        (열들이 서로 수직이고 길이가 1)
det R = +1      (오른손 좌표계를 유지, -1 이면 거울상)

A rotation by θ around the z-axis is as follows. Connecting two rotations is done by multiplying matrices, and reversing them requires only a transpose. There is no need to compute an inverse matrix separately.

Rz(θ) = [ cos θ  −sin θ  0 ]
        [ sin θ   cos θ  0 ]
        [   0       0    1 ]

3.2 Homogeneous Transformation

A 4×4 matrix is used to handle rotation and translation simultaneously. This is called a homogeneous transformation. A 1 is appended as the fourth component to points.

T = [ R  p ]        점 변환:   [x']   = T [x]
    [ 0  1 ]                   [1 ]       [1]

역변환:  T⁻¹ = [ Rᵀ  −Rᵀ p ]
               [ 0     1   ]

Inverse transformations are also calculated using the formula above rather than a general inverse matrix. It is numerically safer and faster.

3.3 Euler Angles

A human-readable pose representation is Euler angles. The ZYX order (yaw, pitch, roll), which is common in robotics and aviation, is R = Rz(요)·Ry(피치)·Rx(롤) . The following formula is used to extract them back from a rotation matrix (r_ij is row i, column j).

피치 = asin(−r31)
요   = atan2(r21, r11)
롤   = atan2(r32, r33)

When the pitch reaches ±90°, r11, r21, r32, and r33 all become 0, making it impossible to determine yaw and roll independently. This means two rotation axes have aligned, causing the loss of one degree of freedom, which is called gimbal lock. What is actually more important than the problem occurring only at exactly 90° is that noise swells significantly near it. We measure this in Section 4.3.

3.4 Quaternion

A unit quaternion q = (w, x, y, z) is expressed in terms of the rotation axis k and rotation angle θ as q = (cos θ/2, k·sin θ/2) . It represents rotations with four numbers, has no gimbal lock, and makes it easy to smoothly interpolate between two rotations. However, one must always remember that q and −q represent the same rotation (double cover). If signs are not aligned when calculating pose error, two close poses will appear to be nearly 360° apart.

In the code for this series, quaternion multiplication is implemented as a single pure Python function.

def qmul(a, b):
    aw, ax, ay, az = a
    bw, bx, by, bz = b
    return (aw*bw - ax*bx - ay*by - az*bz,
            aw*bx + ax*bw + ay*bz - az*by,
            aw*by - ax*bz + ay*bw + az*bx,
            aw*bz + ax*by - ay*bx + az*bw)

3.5 From Camera to Table Tennis Table: Determining Pose via Marker Points

Triangulation with two cameras yields 3D points in camera coordinates {C}. If N points whose table tennis table coordinates {T} are known—such as table corners—are also measured by the camera, R and p that best align the two point sets can be found. This method involves subtracting the centroids of the two sets and performing Singular Value Decomposition (SVD) on the covariance matrix, commonly known as the Kabsch algorithm.

def kabsch(P, Q):                       # Q ≈ R·P + t 가 되는 R, t (P, Q 는 N×3)
    pc, qc = P.mean(0), Q.mean(0)
    U, _, Vt = np.linalg.svd((P - pc).T @ (Q - qc))
    d = np.sign(np.linalg.det(Vt.T @ U.T))      # 거울상(det = -1) 방지
    R = Vt.T @ np.diag([1, 1, d]) @ U.T
    return R, qc - R @ pc

d If the line correcting the sign to is omitted, a reflection matrix may result when the points are nearly coplanar (which the table tennis surface is).

4. Measurements

4.1 Does Orthogonality Breakdown When Multiplying Rotations Repeatedly?

Like gyro integration, we measured how much RᵀR deviates from the identity matrix while repeatedly multiplying small rotations (0.06~0.6°). The same rotation sequence was also multiplied using quaternions.

When float64 matrices were reset to the nearest rotation matrix via SVD every 1,000 operations, the error remained at 1.2×10⁻¹⁵ even after one million times.

There are two interpretations. First, drift is hardly a concern with float64 on PCs. One million times corresponds to 17 minutes at 1 kHz control. Second, the story is different for microcontrollers using float32. An error of 2.6×10⁻⁴ after 100,000 times (100 seconds at 1 kHz) is comparable to an axis skew of about 0.015° and continues to grow. Code that accumulates rotations in float32, such as motor controllers or IMU firmware, must periodically re-normalize. Quaternions make this easier than matrices because only a single length needs to be divided by 1.

4.2 Computation Time

Numpy takes almost the same time, 0.6~0.7 µs, for both 3×3 and 4×4 matrices. This is because function call overhead dominates over the multiplication itself at this size. Therefore, speed should not be the criterion when choosing a representation in Python. They should be chosen based on properties such as gimbal lock, interpolation, and ease of normalization.

4.3 Noise Amplification Near Gimbal Lock

After creating a ZYX pose and adding a small random rotation noise of 0.0057° (10⁻⁴ rad), angles were re-extracted using the formula in Section 3.3. This was attempted 2,000 times for each pitch as it approached 90°.

Since the slope on a logarithmic axis is nearly 1, the error grows roughly as "noise ÷ angle remaining until 90° (in radians)." Because table tennis rackets are frequently tilted from nearly vertical to horizontal, they often pass near a pitch of 90°. Rather than storing or filtering racket poses using Euler angles, it is safer to keep the internal representation as a rotation matrix or quaternion and convert to Euler angles only when displaying to humans.

4.4 Determining Camera Pose via Marker Points

The camera was placed 2 m behind the robot-side endline at a height of 1.6 m, pointing down at the center of the table tennis table. The four corners of the table, two points on top of the net posts, and both ends of the center line were used as basic markers, and arbitrary points on the table were added when more points were needed. Gaussian noise σ was added to each point in camera coordinates, and the pose was calculated using the function in Section 3.5. These are the medians of 500 trial runs for each condition.

• The camera position error is larger than the error of the points on the table tennis table. Because the camera is more than 3 m away from the center of the marker points, small rotational errors are magnified like a lever. However, what we care about is not the camera itself, but the position of the ball on the table. Since the ball flies near the marker points, the remaining error is small.
• Increasing the number of points from 8 to 32 reduced the error by a factor of 1.7 rather than √4 = 2. This is presumed to be because the arbitrarily added points lay only on the table surface, providing less information than points widely spread out like the corners (Estimated).
• In the time budget of Part 1, ball position noise is covered in Part 6, but calibration error, unlike per-frame noise, is a bias that remains in the same direction across all frames. Kalman filters reduce noise, but they do not reduce bias.

5. Limitations

• It was assumed that 3D points were already obtained via dual-camera triangulation. The PnP problem of finding the pose from image coordinates of a single camera, lens distortion, and time misalignment between the two cameras were not addressed (Unmeasured).
• Noise was added equally to each axis. Actual triangulation noise is much larger along the camera's line of sight (Unmeasured).

6. Conclusion

• Coordinate systems are named, and transformations record "from where to where." The inverse of a rotation is its transpose, and the inverse of a homogeneous transformation uses a dedicated formula.
• Internal calculations are performed using rotation matrices or quaternions. Euler angles amplify noise by hundreds of times near a pitch of 90°.
• Accumulating rotations for a long time in float32 requires normalization. In float64, it remains at the 10⁻¹² level even after one million times.
• With 8 markers and a 5 mm point noise, the positional error on the table tennis table is a few millimeters. This error remains constant as a bias across all frames and cannot be removed with a filter.

A word on TT. The coordinates of the same ball vary depending on who is viewing it. When tilting the racket up and down, you must hold tight to quaternions instead of Euler angles!

References

All materials were accessed on 2026-10-18.

• Lynch, Park, Modern Robotics: Mechanics, Planning, and Control, Cambridge University Press 2017, open preprint (May 2017), Chapter 3 Rigid-Body Motions.
• ITTF, Statutes 2026, 2.1.1 and 2.2.2 (Table and Net Post Positions).
• Google DeepMind, competitive_robot_table_tennis, Coordinate System Description (README), CC-BY 4.0.