Python CV Course Week 2: Image Basics with NumPy and OpenCV

If you are following a computer vision learning path, python cv course week 2 image basics with numpy and opencv is where things start to feel practical. This is the point where images stop looking like mysterious files and start making sense as data. Once you understand that an image is really a structured NumPy array, many common OpenCV tasks become easier to reason about.

In this beginner-friendly guide, you will learn how images are stored in memory, how to load them safely with OpenCV, how to inspect their shape and data type with NumPy, and how to make simple pixel-level edits. You will also see how grayscale and color images differ, why OpenCV uses BGR ordering, and how to crop, resize, flip, display, and save results without getting tripped up by common mistakes.

The goal is not just to memorize functions. The goal is to build a mental model you can reuse throughout later lessons on drawing, transformations, filtering, and preprocessing.

What you will learn in Python CV Course Week 2 image basics with NumPy and OpenCV

• How digital images are represented as NumPy arrays
• How to install and import OpenCV and NumPy
• How to load an image correctly with cv2.imread()
• How to inspect shape, size, ndim, and dtype
• How grayscale and color images differ in OpenCV
• How to access and modify pixels using NumPy indexing
• How to crop, resize, flip, copy, brighten, and save images
• How to debug common beginner errors quickly

Setup checklist

Before working with images, make sure your Python environment is ready. A simple setup checklist helps avoid the most common beginner issues.

Install the required packages

pip install numpy opencv-python

If you are using Jupyter or another notebook environment, you may also want matplotlib for display:

pip install matplotlib

Import the libraries

import cv2
import numpy as np

Optional for notebooks:

import matplotlib.pyplot as plt

Prepare a test image

Place a sample image in your project folder, such as image.jpg. Beginners often save the file in a different folder than the script and then wonder why loading fails. Keep your file path simple at first.

How digital images work

At a practical level, an image in Python is usually stored as a NumPy array. That means each pixel is represented by numeric values, and the whole image becomes a grid of numbers.

Width, height, and channels

A grayscale image usually has one value per pixel. A color image usually has three values per pixel, one for each color channel.

• Height: number of rows
• Width: number of columns
• Channels: number of values stored per pixel

A grayscale image may have shape (height, width). A color image may have shape (height, width, 3).

What pixel values mean

Most beginner OpenCV images use the data type uint8. That means each channel value is an integer from 0 to 255.

• 0 means very dark or no intensity
• 255 means maximum intensity
• Values in between represent intermediate brightness

For a grayscale image, one number defines pixel brightness. For a color image, three numbers define the color.

Why image arrays matter in computer vision

Many computer vision operations are just array operations. Cropping means slicing an array. Brightness adjustment means adding to array values. Masking means selecting pixels based on conditions. If you are comfortable with NumPy arrays, you will learn OpenCV much faster.

Reading images with OpenCV

The standard function for loading an image is cv2.imread().

img = cv2.imread('image.jpg')

If the file loads correctly, img becomes a NumPy array. If not, OpenCV usually returns None.

Load in grayscale

gray = cv2.imread('image.jpg', cv2.IMREAD_GRAYSCALE)

This gives you a single-channel image instead of a color one.

Verify that the image loaded correctly

img = cv2.imread('image.jpg')

if img is None:
    print('Error: image not loaded')
else:
    print('Image loaded successfully')

This check is important. Do not assume image loading always works.

Common file path mistakes

• The filename is misspelled
• The script is running from a different working directory
• The path uses the wrong slashes for your system
• The file extension is wrong
• The image file is missing or corrupted

A practical beginner tip: use a direct relative path in the same folder first. Once that works, move on to more complex folder structures.

Inspecting image properties with NumPy

Once an image is loaded, inspect it immediately. This simple habit saves a lot of debugging time.

img = cv2.imread('image.jpg')

print('Shape:', img.shape)
print('Size:', img.size)
print('Dimensions:', img.ndim)
print('Data type:', img.dtype)
print('Min value:', img.min())
print('Max value:', img.max())

What these properties tell you

• shape: image dimensions and channels
• size: total number of values in the array
• ndim: number of axes in the array
• dtype: underlying numeric type, often uint8
• min() and max(): smallest and largest pixel values

Example outputs might look like this:

Shape: (720, 1280, 3)
Size: 2764800
Dimensions: 3
Data type: uint8
Min value: 0
Max value: 255

This tells you the image is 720 pixels high, 1280 pixels wide, and has 3 color channels.

Understanding grayscale, BGR, and color channels in OpenCV

One of the biggest surprises for beginners is that OpenCV loads color images in BGR order, not RGB.

Grayscale images

A grayscale image stores one value per pixel. Its array often has shape like (height, width).

gray = cv2.imread('image.jpg', cv2.IMREAD_GRAYSCALE)
print(gray.shape)

Color images in OpenCV

OpenCV stores color pixels as [Blue, Green, Red], not [Red, Green, Blue].

img = cv2.imread('image.jpg')
print(img[0, 0])

The result might be something like [120 200 45], meaning blue 120, green 200, red 45.

Why BGR matters

If you display an OpenCV image with a library expecting RGB, the colors can look wrong. A common fix is converting the image before display.

rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

This is especially useful in notebooks when using matplotlib.

Accessing and changing pixels with NumPy indexing

This is where image basics become hands-on. Since an image is an array, you can access values using familiar indexing.

Read a single pixel

pixel = img[100, 200]
print(pixel)

For a color image, this returns a BGR triplet.

Read a single channel value

blue_value = img[100, 200, 0]
green_value = img[100, 200, 1]
red_value = img[100, 200, 2]

Modify one pixel

img[100, 200] = [0, 0, 255]

That sets the pixel to red in OpenCV’s BGR format.

Modify rows, columns, and regions

img[0:50, :] = 0            # top band to black
img[:, 0:50] = 255          # left band to white
img[100:200, 150:300] = [0, 255, 0]  # rectangle to green

These examples show why array slicing is so useful in computer vision.

Basic image operations for beginners

You do not need advanced computer vision to start doing useful work. A few simple operations teach the most important concepts.

Crop a region of interest

crop = img[100:300, 200:400]

The first slice is rows, which correspond to height. The second slice is columns, which correspond to width. This order confuses many beginners at first.

Resize an image

resized = cv2.resize(img, (640, 480))

In cv2.resize(), the target size is passed as (width, height), which is different from NumPy’s (rows, columns) style. Keep that distinction in mind.

Copy an image

img_copy = img.copy()

Use copy() when you want to preserve the original. If you assign with img2 = img, both variables point to the same data.

Flip an image

horizontal = cv2.flip(img, 1)
vertical = cv2.flip(img, 0)
both = cv2.flip(img, -1)

Simple brightness adjustment

Directly adding values to a uint8 image can produce unexpected wraparound behavior if you are not careful. A safer beginner-friendly option is OpenCV arithmetic.

bright = cv2.add(img, 50)

For darkening:

dark = cv2.subtract(img, 50)

Split color channels

b, g, r = cv2.split(img)

This can help you inspect how much each channel contributes to the final image.

Displaying and saving results

Seeing output is part of the feedback loop. OpenCV offers a desktop window display, while notebooks usually work better with matplotlib.

Display with OpenCV

cv2.imshow('Image', img)
cv2.waitKey(0)
cv2.destroyAllWindows()

Important notes:

• waitKey(0) waits until a key is pressed
• Without waitKey(), the window may appear and close immediately
• destroyAllWindows() cleans up the display windows

Notebook-friendly display

rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
plt.imshow(rgb)
plt.axis('off')
plt.show()

For grayscale:

plt.imshow(gray, cmap='gray')
plt.axis('off')
plt.show()

Save an image

cv2.imwrite('output.jpg', img)

Always check that your output path is valid and that you have write permission.

Comparison table: common Week 2 image basics tasks

Pros and cons of learning image basics this way

Pros

• Builds a strong foundation for later computer vision topics
• Makes OpenCV functions easier to understand
• Teaches practical NumPy indexing skills
• Helps you debug image issues faster
• Turns image processing into understandable array manipulation

Cons

• OpenCV’s BGR format can confuse beginners
• Array index order feels unintuitive at first
• Desktop display with cv2.imshow() can behave differently across environments
• Simple pixel edits can be slow if done one pixel at a time in Python loops
• Beginners may mix up width-height order between NumPy and OpenCV functions

Common beginner errors and how to debug them quickly

cv2.imread() returns None

This usually means the path is wrong. Print the path, check the file location, and confirm the filename and extension. Start with a simple image in the same folder as your script.

Colors look strange in matplotlib

You are probably displaying a BGR image as RGB. Convert first:

rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

Crop does not match the expected area

Remember the indexing order is img[y1:y2, x1:x2], not img[x1:x2, y1:y2].

Edits changed the original image unexpectedly

You may have created a reference instead of a copy. Use:

img_copy = img.copy()

Brightness changes produce odd values

Use cv2.add() and cv2.subtract() instead of plain arithmetic until you are comfortable with image data types.

cv2.imshow() does not work in your environment

This is common in notebooks, remote servers, or restricted systems. Use matplotlib instead.

Practice exercises

If you want this lesson to stick, do not stop at reading the code. Try these short tasks yourself.

1. Inspect several images

Load three different images and print their shape, dtype, min(), and max(). Compare grayscale and color versions.

2. Convert color formats

Load a color image, convert it from BGR to RGB for display, and also create a grayscale version.

3. Crop a region of interest

Select a meaningful part of the image, such as a face, object, or corner, and save it as a new file.

4. Modify selected pixels

Draw a colored square by assigning values to a small rectangular region. Then try changing only one channel.

5. Compare resize results

Resize the same image to different dimensions and inspect how the array shape changes.

FAQ

What does an image look like as a NumPy array in OpenCV?

An image is a NumPy array of numeric pixel values. A grayscale image is usually a 2D array with shape (height, width). A color image is usually a 3D array with shape (height, width, 3).

Why does OpenCV use BGR instead of RGB?

OpenCV historically uses BGR channel order in many of its default image operations. You do not need to know the full historical reason to work effectively with it, but you do need to remember that OpenCV color images are typically stored as blue, green, red.

How do I check an image’s shape and data type in Python?

Use NumPy-style properties:

print(img.shape)
print(img.dtype)

You can also inspect img.ndim and img.size.

What is the difference between grayscale and color images in OpenCV?

A grayscale image stores one intensity value per pixel. A color image stores three channel values per pixel, typically in BGR order in OpenCV. Grayscale images use less memory and are common in preprocessing pipelines.

How can beginners edit pixel values using NumPy and OpenCV?

Use array indexing. For example:

img[50, 100] = [255, 0, 0]
img[100:150, 200:250] = [0, 255, 0]

This changes one pixel or a region directly.

Why is cv2.imread returning None and how do I fix it?

The most common cause is an incorrect file path. Make sure the file exists, the extension is correct, and your script is running in the folder you expect. Printing the current working directory can help.

How do I crop and resize an image with NumPy and OpenCV?

Crop with slicing:

crop = img[y1:y2, x1:x2]

Resize with OpenCV:

resized = cv2.resize(img, (width, height))

Is this Python CV course Week 2 image basics with NumPy and OpenCV lesson suitable for beginners?

Yes. This topic is ideal for beginners because it introduces the core ideas behind image data without requiring advanced math. If you know basic Python variables, functions, and indexing, you can start practicing right away.

Next steps in the course

Once you are comfortable with image basics, the next lessons in a typical computer vision course become much easier. You will be ready for drawing shapes and text, geometric transformations, color conversions, thresholding, filtering, and more structured preprocessing workflows.

That is why python cv course week 2 image basics with numpy and opencv for beginners is such an important lesson. It gives you the vocabulary and mental model behind nearly every image-processing task you will do later.

Conclusion

Week 2 is where computer vision starts to become concrete. Images are not magic objects. They are arrays with dimensions, data types, and values you can inspect and change. By learning how to load images safely, inspect their properties, understand channels, and edit regions with NumPy indexing, you build a foundation that supports every later OpenCV topic.

If you practice just a few operations repeatedly, such as loading, checking shape, cropping, converting color, and saving output, you will gain confidence quickly. Keep your experiments small, print properties often, and treat every image as data you can understand. That mindset will serve you throughout the rest of your computer vision journey.