Simple Binary Thresholding

easyFREEImage SegmentationComputer Vision 2

Implement a binary thresholding technique to segment a 2D grayscale image based on a given threshold $T$ . This process involves categorizing each pixel into one of two classes, creating a binary image. The concept of image segmentation is crucial in computer vision, as it enables the separation of objects or regions of interest from the rest of the image, which is vital for various applications. Each output pixel depends only on the input pixel at the same position $(x, y)$ , and the result has the same dimensions as the input:

f(x, y) = \begin{cases} 1 & \text{if } I(x, y) > T \\ 0 & \text{if } I(x, y) \leq T \end{cases}

This technique is widely used in medical imaging applications.

Example

Input

image = [[100, 150, 200], [50, 120, 180]]
T = 120

Output

[[0, 1, 1], [0, 0, 1]]

Reasoning

image is a $2 \times 3$ grid of grayscale intensities (2 rows, 3 columns), and T $= 120$ is the cut-off between the two classes.
Each pixel is judged on its own against the rule $f(x, y) = 1$ when $I(x, y) > T$ , otherwise $0$ . Neighbouring pixels play no part.
Row 1: $100 \le 120 \Rightarrow 0$ , $150 > 120 \Rightarrow 1$ , $200 > 120 \Rightarrow 1$ , giving [0, 1, 1].
Row 2: $50 \le 120 \Rightarrow 0$ , $120 \le 120 \Rightarrow 0$ , $180 > 120 \Rightarrow 1$ , giving [0, 0, 1].
The result [[0, 1, 1], [0, 0, 1]] keeps the $2 \times 3$ shape, but every intensity has collapsed to a class label: $1$ marks the bright foreground, $0$ the darker background.
Notice the middle pixel of row 2: it equals $T$ exactly, and the comparison is strict, so it lands in class $0$ . With $T = 119$ it would flip to $1$ .

Constraints

image is a 2D list of non-negative numbers
T is a numeric threshold
Return a 2D binary list (0 or 1)

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

Image segmentation is a fundamental concept in computer vision that involves dividing an image into its constituent parts or objects. The goal is to simplify the representation of an image into something that is more meaningful and easier to analyze. Binary thresholding is the simplest form of image segmentation, where the image is divided into two parts: the foreground (objects of interest) and the background. This is achieved by applying a threshold to the pixel values of the image.

In a grayscale image, each pixel is represented by a single value that indicates its intensity, ranging from 0 (black) to 255 (white). By applying a threshold $T$ , we can create a binary image where pixels with values greater than $T$ are considered part of the foreground (and set to 1), and pixels with values less than or equal to $T$ are considered part of the background (and set to 0). This can be represented mathematically as:

\text{Binary Image}(x, y) = \begin{cases} 1 & \text{if } \text{Grayscale Image}(x, y) > T \\ 0 & \text{if } \text{Grayscale Image}(x, y) \leq T \end{cases}

The choice of threshold $T$ is crucial and depends on the specific application and the characteristics of the image. In some cases, a fixed threshold may be used, while in other cases, the threshold may be determined dynamically based on the image content.

Algorithm/Approach

The general approach to solving this problem involves iterating over each pixel in the grayscale image and applying the thresholding rule to determine the corresponding pixel value in the binary image. This can be achieved using a simple iterative algorithm that scans the image pixel by pixel.

Step-by-Step Strategy

To implement the solution, follow these steps:

Load the grayscale image and store it in a 2D array or matrix.
Initialize an empty 2D array or matrix to store the binary image.
Iterate over each pixel in the grayscale image, and for each pixel:
Compare the pixel value to the threshold $T$ .
If the pixel value is greater than $T$ , set the corresponding pixel in the binary image to 1.
If the pixel value is less than or equal to $T$ , set the corresponding pixel in the binary image to 0.
Return the binary image.

Common Pitfalls

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

Forgetting to handle the boundary cases (e.g., when the pixel value is exactly equal to the threshold).
Using an incorrect data type to store the binary image (e.g., using a floating-point type instead of an integer type).
Not checking for errors when loading the input image.

Time & Space Complexity

The time complexity of this solution is $O(m \cdot n)$ , where $m$ and $n$ are the dimensions of the input image, since we need to iterate over each pixel in the image. The space complexity is also $O(m \cdot n)$ , since we need to store the binary image, which has the same dimensions as the input image.

solution.py

Python 3.13

Test results