Gradient Magnitude and Direction

easyFREEEdge DetectionEdgesCV: Feature Detection and Matching

Implement a function to compute the gradient magnitude and direction from given horizontal and vertical gradient components, a crucial step in edge detection algorithms. This process is essential in image processing to identify and analyze the boundaries of objects within an image.

The gradient of an image is a measure of how the intensity of the image changes in different directions, which can be represented by its horizontal ( $G_x$ ) and vertical ( $G_y$ ) components. The magnitude of the gradient indicates the strength of the edge, while the direction indicates the orientation of the edge.

Here are the steps to compute the gradient magnitude and direction:

Compute the magnitude using the given $G_x$ and $G_y$ components.
Calculate the direction using the arctan2 function.

\text{magnitude} = \sqrt{G_x^2 + G_y^2}

\text{direction} = \arctan2(G_y, G_x)

This technique is widely used in computer vision applications, such as object recognition and image segmentation.

Example

Input

image = [[100, 100, 100],
        [100, 150, 100],
        [100, 100, 100]]

Output

Gx = [[0, 0, 0],
     [50, 0, -50],
     [0, 0, 0]]
Gy = [[0, 50, 0],
     [0, 0, 0],
     [0, -50, 0]]

Reasoning

Image gradient formulas (central difference):

$G_x[i,j] = \frac{I[i,j+1] - I[i,j-1]}{2}$ $G_y[i,j] = \frac{I[i+1,j] - I[i-1,j]}{2}$

Computing $G_x$ (horizontal gradient) at position $(1,1)$ : $G_x = \frac{I[1,2] - I[1,0]}{2} = \frac{100 - 100}{2} = 0$

Computing $G_y$ (vertical gradient) at position $(1,1)$ : $G_y = \frac{I[2,1] - I[0,1]}{2} = \frac{100 - 100}{2} = 0$

At position $(1,0)$ - left edge of center row: $G_x = \frac{I[1,1] - I[1,-1]}{2} = \frac{150 - 100}{2} = 25$ (using boundary handling)

Gradient magnitude and direction: $|\nabla I| = \sqrt{G_x^2 + G_y^2}$ $\theta = \arctan2(G_y, G_x)$

For the bright center pixel $(150)$ , gradients point outward in all directions, indicating edges around the bright spot.

Constraints

gx and gy are gradient images (2D arrays) of the same size
Return tuple of (magnitude, direction) where both are 2D arrays
Magnitude rounded to 2 decimal places
Direction in degrees [0, 360), rounded to 2 decimal places

Learn this in

Feature Detection and MatchingCV Study Plan

More from CV: Feature Detection and Matching

Circle Hough Transformhard Canny Edge Detection Pipelinehard Hamming Distance Matcherhard Simple BRIEF Descriptormedium Point to Hough Spaceeasy

Concept primer

You want to (1) compute gradient magnitude from $G_x, G_y$ , and (2) compute gradient direction in degrees in $[0, 360)$ . Here is the background and how to think about the implementation.

1. Background Knowledge (concepts & theory)

In edge detection, an image gradient at a pixel is a 2D vector formed by the horizontal derivative $G_x$ and vertical derivative $G_y$ . Intuitively, this vector points in the direction of the greatest increase in intensity, and its length tells you how strong that change is. Large gradients indicate likely edges; small gradients correspond to flat or smooth regions.

Mathematically, you can think of $(G_x, G_y)$ as a vector in the 2D plane. The magnitude of this vector is given by the Euclidean norm:

\text{magnitude} = \sqrt{G_x^2 + G_y^2}

and the direction (angle) is the orientation of this vector:

\text{direction} = \arctan2(G_y, G_x)

The $\text{atan2}$ function is crucial because it considers the signs of both $G_x$ and $G_y$ to determine the correct quadrant of the angle. In many vision tasks (like Canny), the direction is often converted from radians to degrees and normalized to a specific range, here $[0, 360)$ .

2. Algorithm / General Approach

Given scalar values $G_x$ and $G_y$ (for a single pixel or for each pixel in an array):

Treat $(G_x, G_y)$ as a 2D vector.
Compute its length using the Pythagorean theorem.
Compute its angle using atan2(G_y, G_x) (in radians).
Convert this angle to degrees.
Map the angle into the range $[0, 360)$ (since atan2 typically returns $(-$ \pi $,$ \pi $]$ or $[-180, 180)$ in degrees).

This pattern is a direct application of basic vector math and trigonometry.

3. Step-by-Step Strategy (implementation breakdown)

Assume you have gx and gy as inputs (scalars or arrays):

Compute magnitude

mag = math.sqrt(gx * gx + gy * gy)

or, for arrays (NumPy-style):

mag = np.sqrt(gx**2 + gy**2)

Compute direction in radians using atan2

angle_rad = math.atan2(gy, gx)

atan2(y, x) returns an angle in radians in the range $(-$ \pi $,$ \pi $]$ .

Convert radians to degrees

angle_deg = angle_rad * 180.0 / math.pi

Normalize to [0, 360)

A common pattern is:

if angle_deg < 0:
angle_deg += 360.0

For arrays:

angle_deg = (angle_deg + 360.0) % 360.0

Return or store results

Output: magnitude and direction_in_degrees for each input pair $(G_x, G_y)$ .

4. Common Pitfalls

Using atan instead of atan2: atan(gy/gx) cannot distinguish quadrants and fails when $G_x = 0$ . Always use atan2(gy, gx).
Angle range not adjusted: atan2 can give negative angles (e.g., $-90^\circ$ ), but the problem explicitly wants $[0, 360)$ . Remember to shift or modulo.
Integer division / truncation: In languages where / can be integer division, ensure you use floating-point math when converting radians to degrees.
Precision / overflow:
For very large gx and gy, squaring can overflow in some languages/types. For typical image gradients (e.g., from Sobel filters), this usually isn’t an issue, but be aware of data types (use float/double).
If gx and gy are both zero, magnitude is zero and direction is mathematically undefined; most implementations just return any angle (often 0) since the pixel is not an edge.

5. Time & Space Complexity

If you process a single pair $(G_x, G_y)$ :

Time complexity:
$O(1)$ : a constant number of arithmetic operations and a couple of transcendental calls (sqrt, atan2).

If you process an image of size $H \times W$ :

Time complexity:
$O(H \cdot W)$ , since you do constant work per pixel.
Space complexity:
If you store magnitude and direction images:
$O(H \cdot W)$ additional space (two arrays of same size as input).
If you compute in-place or stream results, extra space can be reduced to $O(1)$ beyond output storage.

solution.py

Python 3.13

Test results