2D Rotation Matrix

easyFREEGeometric TransformationsComputer Vision 2

Implement a 2D rotation transformation using a rotation matrix to rotate a list of 2D points by a given angle $\theta$ in degrees. The goal is to apply this transformation to each point and return the list of rotated points.

In geometric transformations, rotation is a fundamental concept that involves changing the orientation of an object in a 2D or 3D space. The rotation matrix is a mathematical representation of this transformation, which can be used to rotate points, vectors, and other geometric entities. The rotation matrix $R$ for a 2D rotation is given by:

\begin{bmatrix} \cos\theta & -\sin\theta \\ \sin\theta & \cos\theta \end{bmatrix}

To apply this transformation to a point $[x, y]$ , we can use the following steps:

Convert the angle from degrees to radians.
Compute the cosine and sine of the angle.
Apply the rotation matrix to the point using the formulas: $x' = x\cos\theta - y\sin\theta$ and $y' = x\sin\theta + y\cos\theta$ . The key formulas are:

x' = x\cos\theta - y\sin\theta

y' = x\sin\theta + y\cos\theta

This technique is widely used in computer vision and image processing applications.

Example

Input

theta = 90
points = [[1, 0], [0, 1]]

Output

[[0.0, 1.0], [-1.0, 0.0]]

Reasoning

Inputs: theta_deg is the angle in degrees ( $90^\circ$ ), and points holds two 2D points, $[1, 0]$ and $[0, 1]$ .
$90^\circ$ is $\frac{\pi}{2}$ radians, so $\cos\theta = 0$ and $\sin\theta = 1$ . The rotation matrix becomes $\begin{bmatrix} 0 & -1 \\ 1 & 0 \end{bmatrix}$ .
Point $[1, 0]$ : $x' = 1 \cdot 0 - 0 \cdot 1 = 0$ and $y' = 1 \cdot 1 + 0 \cdot 0 = 1$ , giving $[0.0, 1.0]$ . The $x$ -axis unit vector lands on the $y$ -axis.
Point $[0, 1]$ : $x' = 0 \cdot 0 - 1 \cdot 1 = -1$ and $y' = 0 \cdot 1 + 1 \cdot 0 = 0$ , giving $[-1.0, 0.0]$ .
Output: a list with one rotated $[x', y']$ pair per input point in input order, each coordinate rounded to 4 decimal places: [[0.0, 1.0], [-1.0, 0.0]].
Notice that a positive angle turns points counter-clockwise. In floating point, $\cos 90^\circ$ comes out near $6 \times 10^{-17}$ , not exactly 0, and rounding to 4 decimals turns it into a clean 0.0.

Constraints

theta is in degrees
points is a list of [x, y] pairs
Return list of [x', y'] pairs rounded to 4 decimal places
Use math.cos, math.sin, math.radians

Learn this in

Image FormationCV Study Plan

More from Computer Vision 2

1D Bilateral Filterhard Image Sharpening with Unsharp Maskmedium Gaussian Blurmedium Gaussian Kernel Generationeasy 2D Image Convolutioneasy

Concept primer

Background Knowledge

Geometric transformations are a fundamental concept in computer vision, allowing us to manipulate and analyze images and objects in 2D and 3D space. A rotation transformation is a type of geometric transformation that rotates an object or point around a fixed axis. In this problem, we're dealing with a 2D rotation transformation, which can be represented using a 2x2 rotation matrix $R$ . The rotation matrix $R$ is defined as:

$R = \begin{bmatrix} \cos\theta & -\sin\theta \\ \sin\theta & \cos\theta \end{bmatrix}$

where \theta is the angle of rotation in degrees. To apply the rotation transformation to a point [x, y], we can use the following equations:

$x' = x\cos\theta - y\sin\theta$ $y' = x\sin\theta + y\cos\theta$

These equations can be derived by multiplying the rotation matrix $R$ with the point $[x, y]$ represented as a column vector.

Background Knowledge: Trigonometry and Linear Algebra

To understand the rotation transformation, it's essential to have a basic understanding of trigonometry and linear algebra. The rotation matrix $R$ uses trigonometric functions such as $\cos\theta$ and $\sin\theta$ to represent the rotation. Additionally, the transformation equations involve matrix multiplication and vector operations, which are fundamental concepts in linear algebra. Familiarity with these concepts will help you understand how the rotation transformation works and how to implement it in code.

Background Knowledge: Coordinate Systems

It's also important to understand the coordinate system used in this problem. The points $[x, y]$ are represented in a 2D Cartesian coordinate system, where $x$ and $y$ are the horizontal and vertical coordinates, respectively. The rotation transformation rotates the points around the origin $(0, 0)$ of the coordinate system. Understanding the coordinate system and how the rotation transformation affects the points will help you visualize and implement the solution.

Algorithm/Approach

The general approach to solving this problem involves using the rotation matrix $R$ to apply the rotation transformation to each point $[x, y]$ . This can be done by multiplying the rotation matrix $R$ with the point $[x, y]$ represented as a column vector. Alternatively, you can use the transformation equations directly to compute the rotated coordinates $x'$ and $y'$ .

Step-by-Step Strategy

Here's a step-by-step breakdown of how to implement the solution:

Convert the angle $\theta$ from degrees to radians, as most programming languages use radians for trigonometric functions.
Define the rotation matrix $R$ using the converted angle $\theta$ .
Iterate over each point $[x, y]$ in the list of points.
For each point, apply the rotation transformation using the rotation matrix $R$ or the transformation equations.
Compute the rotated coordinates $x'$ and $y'$ and round them to 4 decimal places.
Store the rotated points in a new list and return it.

Common Pitfalls

Some common pitfalls to watch out for when implementing the solution include:

Forgetting to convert the angle $\theta$ from degrees to radians.
Using the wrong signs or order of operations in the transformation equations.
Failing to round the rotated coordinates to 4 decimal places.
Not handling edge cases, such as an empty list of points or an invalid angle $\theta$ .

Time & Space Complexity

The time complexity of the solution is $O(n)$ , where $n$ is the number of points in the list, since we need to iterate over each point to apply the rotation transformation. The space complexity is also $O(n)$ , as we need to store the rotated points in a new list. Note that the rotation matrix $R$ has a constant size of 2x2, so it does not affect the overall time or space complexity.

solution.py

Python 3.13

Test results