Flow Field Magnitude

easyPROOptical FlowMotionCV: Motion Estimation

Implement a function to compute the magnitude of a given 2D optical flow field at each pixel, which represents the speed of motion. The optical flow field is a 2D vector field where each vector $(u, v)$ at a pixel location represents the motion of that pixel in the $x$ and $y$ directions.

The concept of optical flow is crucial in Computer Vision as it helps in understanding the motion of objects in a scene. The magnitude of flow at each pixel is calculated using the formula $|\mathbf{v}| = \sqrt{u^2 + v^2}$ , where $(u, v)$ is the flow vector at that pixel.

Understand the given 2D optical flow field.
Calculate the magnitude at each pixel using the flow vector.

|\mathbf{v}| = \sqrt{u^2 + v^2}

This technique is widely used in traffic monitoring applications to measure velocity.

Example

Input

flow = [[(3, 4), (0, 0)],
       [(1, 0), (0, 1)]]

Output

[[5.0, 0.0], [1.0, 1.0]]

Reasoning

Input: flow is a $2 \times 2$ grid of pixels. Each pixel holds a flow vector $(u, v)$ : how far that pixel moved horizontally ( $u$ ) and vertically ( $v$ ) between frames.
Top-left $(3, 4)$ : the speed is the length of the vector, $\sqrt{3^2 + 4^2} = \sqrt{9 + 16} = \sqrt{25} = 5.0$ . This is the classic 3-4-5 right triangle.
Top-right $(0, 0)$ : the pixel did not move, so $\sqrt{0 + 0} = 0.0$ .
Bottom row $(1, 0)$ and $(0, 1)$ : one unit right and one unit down. Both give $\sqrt{1} = 1.0$ , so the direction differs but the speed is identical.
Output: [[5.0, 0.0], [1.0, 1.0]], a grid with the same $2 \times 2$ layout as the input, but each pixel now holds one non-negative number instead of a pair. Values are rounded to 2 decimal places, so a vector like $(1, 1)$ would give $\sqrt{2} \approx 1.41$ .
Notice that magnitude throws away direction: $(3, 4)$ , $(4, 3)$ and $(-3, -4)$ all map to $5.0$ .

Constraints

flow is a 2D array of (u, v) tuples
Return magnitude array rounded to 2 decimal places

More from CV: Motion Estimation

Hungarian Algorithm for MOThard Rolling Shutter Correctionhard Horn-Schunck Global Optical Flowmedium Intersection over Union (IoU) for Trackingmedium Bilinear Flow Warpinghard

Concept primerPREVIEW

Flow Field Magnitude: Background and Solution Strategy

Background Knowledge

Optical flow represents the apparent motion of objects between consecutive frames in a video sequence. At each pixel, optical flow is represented as a 2D velocity vector $(u, v)$ , where $u$ is the horizontal (x-direction) component and $v$ is the vertical (y-direction) component of motion. These components are typically computed using algorithms like Lucas-Kanade or deep learning methods, and they indicate how many pixels an object has moved in each direction between frames.

The magnitude of this flow vector is a scalar value that represents the total speed of motion at that pixel, regardless of direction. It's computed using the Euclidean distance formula: $|$ \mathbf{v} $| = \sqrt{u^2 + v^2}$ . This magnitude is particularly useful because it provides a single, direction-independent measure of motion intensity. Pixels with high magnitude values indicate rapid motion (moving objects), while low magnitude values indicate static or slowly moving regions.

Flow magnitude visualization is a fundamental preprocessing step in many computer vision applications. It helps identify moving objects in surveillance systems, detect motion boundaries where objects transition from moving to stationary, and measure velocity in real-world applications like traffic monitoring. The magnitude field can be visualized as a grayscale or heatmap image where brightness corresponds to motion speed, making it intuitive for human interpretation and further processing.

Algorithm/Approach

The solution follows a straightforward element-wise computation pattern:

Input: A 2D optical flow field represented as two arrays (or a single array with shape [height, width, 2]), containing $u$ and $v$ components
Processing: For each pixel position, apply the magnitude formula independently
Output: A 2D magnitude field with shape [height, width] containing scalar values

This is a vectorizable operation, meaning you can compute all magnitudes simultaneously rather than iterating pixel-by-pixel, which significantly improves performance in most programming languages and frameworks.

Step-by-Step Strategy

PRO

Continue the full explanation

You're reading the free preview. Unlock the complete walkthrough, the code editor, test runner and reference solution with Premium.

PRO

Editor locked

The code editor is locked for Pro problems. It is only available for free problems. Please upgrade to gain access to the code editor for all problems.

solution.py

Python 3.13

Test results