Building upon our understanding of image fundamentals like pixels and color channels (such as $RGB$ ), we now turn to actually creating simple images from scratch. Generating images programmatically, even basic ones, is a foundational step in synthetic data creation for computer vision. Instead of relying solely on existing photographs, we can define rules and procedures to construct new visual data.

One straightforward approach is to generate images containing basic geometric shapes or repeating patterns. Think of this like drawing on digital graph paper where you decide the color of each square (pixel).

Drawing Basic Shapes

To create an image with a shape, you typically start with a blank digital canvas, essentially a grid of pixels initialized to a background color (like black or white). Then, you define the parameters of your shape and determine which pixels fall within its boundaries. These pixels are then assigned the desired foreground color.

Rectangles: A rectangle is defined by its position (e.g., the coordinates of its top-left corner) and its dimensions (width and height). Pixels whose coordinates $(x, y)$ fall within the range $x_{start} \le x < x_{start} + width$ and $y_{start} \le y < y_{start} + height$ are colored in.
Circles: A circle is defined by its center coordinates $(cx, cy)$ and its radius $r$ . Pixels whose distance from the center is less than or equal to the radius (i.e., satisfying $\sqrt{(x-cx)^2 + (y-cy)^2} \le r$ ) are colored.
Lines: A line can be defined by its start and end points $(x_1, y_1)$ and $(x_2, y_2)$ . Algorithms like Bresenham's line algorithm are efficient ways to determine which pixels lie closest to the ideal mathematical line between these points.

For each shape, you specify its parameters (position, size, radius) and its color. The software then modifies the pixel values in the image array accordingly.

Generating Patterns

Besides individual shapes, you can create images with repeating patterns by applying a simple rule to each pixel based on its coordinates.

Checkerboards: A classic example is the checkerboard. You can iterate through each pixel $(x, y)$ . If $(x // \text{square\_size} + y // \text{square\_size})$ is even, color the pixel white; otherwise, color it black. This creates alternating colored squares of a specified size.
Grids: You can draw horizontal and vertical lines at regular intervals to create a grid pattern. This involves coloring pixels where $x$ is a multiple of the grid spacing or $y$ is a multiple of the grid spacing.
Stripes: Simple horizontal or vertical stripes can be made by changing color based only on the $x$ or $y$ coordinate modulo some stripe width.

These methods rely on mathematical or logical rules applied directly to pixel coordinates to determine their color.

A Visual Example

Imagine creating a very small image, perhaps 10x10 pixels. We could decide to draw a simple blue square shape within it on a light gray background. Programmatically, we would create a 10x10 grid of pixels, initially all light gray. Then, we'd specify the square's top-left corner (e.g., at coordinates (3,3)) and its size (e.g., 4x4 pixels). The pixels from $(3,3)$ to $(6,6)$ would then be set to blue.

A 10x10 pixel image generated programmatically. The light gray pixels (#e9ecef) represent the background (value 1), and the blue pixels (#4263eb) form a simple square shape (value 2).

Underlying Mechanism and Tools

At its core, generating these images involves manipulating a multi-dimensional array (often using libraries like NumPy in Python) where each element corresponds to a pixel's color. For an $RGB$ image of size Width $\times$ Height, this might be an array of shape (Height, Width, 3), where the last dimension holds the Red, Green, and Blue values for each pixel.

While you can manipulate these pixel arrays directly, many image processing libraries (such as Pillow or Scikit-image, which we'll touch upon in Chapter 6) provide higher-level functions like draw_rectangle, draw_circle, or draw_line. These functions abstract away the pixel-by-pixel calculations, making it much easier to place shapes and patterns onto your digital canvas.

Generating these simple geometric images serves as an important starting point. It demonstrates direct control over image creation and forms the basis for generating more complex scenes, potentially combining multiple shapes, varying colors, and adding other elements, which are valuable for training and testing computer vision models.