Crop Image

easyFREEBook OverviewImage ProcessingCV: Introduction to Computer Vision

Implement a function to extract a rectangular region from an image, given the top-left corner coordinates $(row, col)$ and the dimensions $(height, width)$ . This task involves image processing and region of interest extraction.

The concept of cropping an image is fundamental in computer vision, as it allows for focusing on specific parts of an image, reducing noise, and improving processing efficiency. In mathematical terms, the cropped image can be represented as a subset of the original image pixels, defined by the bounds $row \leq y < row + height$ and $col \leq x < col + width$ (the end bounds are excluded, like Python slicing).

To achieve this, consider the following steps:

Identify the top-left corner coordinates $(row, col)$ .
Determine the dimensions $(height, width)$ of the region to be extracted.
Extract the sub-image using the specified bounds.

\text{Cropped Image} = \{(x, y) | row \leq y < row + height, col \leq x < col + width\}

This technique is widely used in image editing and object detection applications.

Example

Input

crop([[1,2,3],[4,5,6],[7,8,9]], 0, 0, 2, 2)

Output

[[1,2],[4,5]]

Reasoning

Input: image is a $3 \times 3$ grid of pixel values, rows top to bottom: $(1,2,3)$ , $(4,5,6)$ , $(7,8,9)$ . row $=0$ and col $=0$ put the top-left corner of the crop at the very first pixel; height $=2$ and width $=2$ ask for a $2 \times 2$ window.
Row range: keep rows $y$ with $0 \le y < 0 + 2$ , so rows $0$ and $1$ . The upper bound is exclusive.
Column range: keep columns $x$ with $0 \le x < 0 + 2$ , so columns $0$ and $1$ . Column $2$ ( $3, 6, 9$ ) is dropped.
Output: the pixels at those rows and columns, still arranged row by row: $(1,2)$ from row $0$ and $(4,5)$ from row $1$ , giving [[1, 2], [4, 5]]. The result has exactly height rows of width values each.
Notice that the crop keeps each pixel's value and relative position. Only the coordinates shift: the corner $(row, col)$ becomes $(0, 0)$ . With row $=1$ , col $=1$ the same $2 \times 2$ window would land on the bottom-right, $(5,6)$ and $(8,9)$ .

Constraints

The crop region must be within image bounds
Return the cropped sub-image

Learn this in

Introduction to Computer VisionCV Study Plan

More from CV: Introduction to Computer Vision

Sparse Matrix Operations for Imagesmedium Multi-Scale Feature Pyramidhard Implement Prewitt Edge Detectorhard Connected Components Labelinghard K-Means Color Quantizationmedium

Concept primer

Background Knowledge

Image Representation and Indexing

In computer vision, digital images are typically represented as multi-dimensional arrays or matrices. A grayscale image is a 2D array where each element represents pixel intensity, while a color image is a 3D array with dimensions for height, width, and color channels (e.g., RGB). Understanding this array-based representation is fundamental because image operations—including cropping—are essentially array slicing operations. The key insight is that images use a coordinate system where the origin (0, 0) is typically at the top-left corner, with row indices increasing downward and column indices increasing rightward.

Region Extraction as a Preprocessing Step

Region extraction is a foundational preprocessing technique in computer vision pipelines. Cropping is the simplest form of region extraction—you're isolating a rectangular portion of an image defined by spatial boundaries. This operation is essential for many downstream tasks: focusing computational resources on regions of interest, removing irrelevant background information, and preparing data for further analysis. The ability to efficiently extract rectangular regions is a building block for more complex computer vision operations like object detection and image segmentation.

Coordinate Systems and Boundary Handling

When working with image cropping, you must carefully manage coordinate systems and boundary conditions. Given a top-left corner (row, col) and dimensions (height, width), you need to calculate the corresponding bottom-right corner and ensure all indices remain within valid image bounds. This involves understanding inclusive vs. exclusive indexing conventions used by your programming language or library, and handling edge cases where the specified region extends beyond the image boundaries.

Algorithm/Approach

The core approach to image cropping is direct array slicing:

Validate inputs: Ensure the specified region is within or partially overlaps the image bounds
Calculate boundaries: Determine the exact row and column ranges from the given top-left corner and dimensions
Extract the subarray: Use array indexing to isolate the rectangular region
Return the cropped image: Return the extracted subarray as a new image

This is fundamentally an O(n) operation where n is the number of pixels in the cropped region, since you must access and copy each pixel.

Step-by-Step Strategy

Parse and validate inputs

Verify that the top-left corner coordinates (row, col) are non-negative integers
Verify that dimensions (height, width) are positive integers
Check that the region doesn't extend beyond image boundaries (decide on your handling strategy: clipping, error-throwing, or padding)

Calculate boundary indices

Calculate row_end = row + height
Calculate col_end = col + width
Ensure these don't exceed image dimensions

Extract the region using array slicing

Use your language's array slicing syntax to extract rows from row to row_end and columns from col to col_end
Most languages use half-open intervals: [start, end) where start is inclusive and end is exclusive

Return the cropped subimage

The extracted region should maintain the original image format (same number of color channels if applicable)

Test edge cases

Cropping at image boundaries
Cropping the entire image
Cropping a single pixel
Regions that partially or completely exceed image bounds

Common Pitfalls

Off-by-one errors: Confusing inclusive vs. exclusive indexing when calculating row_end and col_end. If using half-open intervals [start, end), remember that end is not included.
Boundary violations: Attempting to access indices outside the image array without proper validation. Always check that row + height ≤ image_height and col + width ≤ image_width.
Incorrect dimension handling: Mixing up rows (height) with columns (width), or confusing the order of indexing in your language (row-major vs. column-major).
Channel preservation: If working with color images, ensure the cropping operation preserves all color channels. The slice should include the full channel dimension.
Data type mismatches: Ensure input coordinates are integers; floating-point coordinates will cause indexing errors.
Empty regions: Not handling cases where height or width is zero, which would result in an empty cropped image.

Time & Space Complexity

Time Complexity: $O(h \times w \times c)$ where $h$ is the cropped height, $w$ is the cropped width, and $c$ is the number of color channels. In the worst case (cropping the entire image), this is $O(n)$ where $n$ is the total number of pixels.

Space Complexity: $O(h \times w \times c)$ for storing the cropped image. If the operation creates a new array (as opposed to a view/reference), you must allocate memory proportional to the cropped region's size. Some implementations may use lazy evaluation or memory views to reduce this to $O(1)$ if only a reference is returned.

solution.py

Python 3.13

Test results