The First Step

0 The First Step

For this first step, we will introduce the basic functionality provided by the
library, and then we will read and write pixel values. For these tutorials
I will use 'nano' as a text editor, though you may use whichever text editor
you are most comfortable with. These examples can be run from the terminal,
and from the desktop.

First navigate to your home directory and create and edit a new file called
basics.py, this will be our template for the remaining tutorial.

cd ~
sudo nano basics.py

Next we need to import the custom tutorial python module. So at the top of the
file:

import imgproc
from imgproc import *

Now, we will load the webcam, and create a viewer window to display images. If
you do not have a webcam, skip that line.

# open a webcam to take pictures
camera = Camera(160, 120)
# Open a viewer window to display images
viewer = Viewer(160, 120, "The first step")

Next we will take a picture and display it in the viewer window, if you are not
using a webcam, you can load bitmap (.bmp) images by suppling the path to the
constructor img = Image("./path/bitmapfile.bmp") or
in C, you can use the function
imgFromBitmap("./path/bitmapfile.bmp") to create a new Image
from the source file.

# take a picture from the camera
img = camera.grabImage()
# for those without a webcam
img = Image("/path/to/image.bmp")
# display the image in the viewer
viewer.displayImage(img)

Now we have taken an image and displayed it in the viewer, we want to do
something with it. The format of the image we take from the camera uses the
colour model RGB, with 8 bits per colour channel. This gives us a range of
values between 0 and 255 (inclusive) for each channel of each pixel. What we
are going to do is iterate over every pixel in turn and set their colour to the
pixels dominant channel. Here is the operation in psuedo-code:

ITERATE over every column in the image
ITERATE over every row in every column
GET the pixel at this row and column
SET Red to the pixel's red intensity
SET Green to the pixel's green intensity
SET Blue to the pixel's blue intensity
IF Red > Green AND Red > Blue THEN
SET pixel's red to 255
SET pixel's green to 0
SET pixel's blue to 0
ELSE IF Green > Red AND Green > Blue THEN
SET pixel's green to 255
SET pixel's red to 0
SET pixel's blue to 0
ELSE
SET pixel's blue to 255
SET pixel's red to 0
SET pixel's green to 0
END
END
END

This code translates quite well into Python, for the iteration we can use a
for loop. We need to iterate over the width and height of the
image, which we can access as an element of our Image object
with img.width and img.height

for x in range(0, img.width):
for y in range(0, img.height):

Now we need to get the value of the pixel at the given position. To do this
we treat the Image as a Python array, and we index it with a tuple of the
x and y position of the pixel. The returned value
is a tuple itself, made up of the red, green and blue intensities

# Get the value at the xth column and yth row, place the intensities into variables
red, green, blue = img[x, y]

Now we can test the red, green and blue values against each other as they are
simply integers. To set the value of the pixel, we against index img as an
array, and provide a tuple of the new red, green and blue values.

To finish up, we need to display the image again so that we can see the
changes, call displayImage() again, and then use
delay() to delay for a number of milliseconds before exiting.

# display the image again
viewer.displayImage(img)
# delay for 5000 milliseconds to give us time to see the changes, then exit
waitTime(5000)

Now we have reached the end of the script. To run the script exit nano, or
your text editor, open a terminal and type.

sudo python basics.py

The script should open an image from the webcam, and then a few seconds later
change to a primary coloured image, marking the dominant colour at each pixel.
This script has the basic operations used to operate on each pixel in an image.
You will find on the Raspberry Pi that the per pixel operations takes a few
seconds to complete. This is mainly due to overhead from the Python
interpreter, which causes the large number of pixel accesses to be quite slow.

Below is a full Python listing of this tutorials code, as well as a faster
commented C implementation.

1 Code Listing

1.1 Python Code

import imgproc
from imgproc import *
# open a webcam to take pictures
camera = Camera(160, 120)
# Open a viewer window to display images
viewer = Viewer(160, 120, "The first step")
# take a picture from the camera
img = camera.grabImage()
# display the image in the viewer
viewer.displayImage(img)
# iterate over each pixel in the image
for x in range(0, img.width):
for y in range(0, img.height):
# Get the value at the xth column and yth row, place the intensities into variables
red, green, blue = img[x, y]
# test to find which colour is dominant
if red > green and red > blue:
# Red is dominant, so set the pixel to completely red
img[x, y] = 255, 0, 0
elif green > red and green > blue:
img[x, y] = 0, 255, 0
else:
# if red or green isn't dominant, blue must be
img[x, y] = 0, 0, 255
# display the image again
viewer.displayImage(img)
# delay for 5000 milliseconds to give us time to see the changes, then exit
waitTime(5000)
# end of the script