Edge detection basics

Edge detection finds the places where brightness changes sharply, such as the outline of a shape or a lane line on a road. Edges are a compact summary of a picture, because they keep the outlines and drop the flat areas.

In this lesson you measure the change between neighbouring pixels and mark the places where it is large.

Subtract one pixel from the next. In a flat area the answer is near 0. At the border of a bright shape on a dark page it is large.

That difference is the gradient. Its size, ignoring whether it goes up or down, tells you how sharp the change is.

docker exec jupyter python3 -c "import numpy as np; from PIL import Image; a = np.array(Image.open('images/gradient.png')).astype(int); print(np.abs(np.diff(a, axis=1)).max(), np.abs(np.diff(a, axis=0)).max())"

The Run takes the differences along each row, then down each column, and prints the biggest of each. It prints 1 0.

The ramp rises by 1 grey level per pixel across and not at all down, so its largest step is 1. It changes all the way along, but never fast, so there is no edge.

row = [10, 10, 10, 200, 200]

for place in range(len(row) - 1):
    step = row[place + 1] - row[place]
    print("between", place, "and", place + 1, ":", abs(step))
# Change the 200 at the end of the row to 10 and press Run.
# How many edges are there now?

docker exec jupyter python3 -c "import numpy as np; a = np.array([10, 200], dtype=np.uint8); print((a[:1] - a[1:]).tolist(), (a[:1].astype(int) - a[1:]).tolist())"

A uint8 number cannot go below 0. NumPy wraps it round instead. The Run prints [66] [-190].

The first is 10 minus 200 in uint8: it wraps to 66, which is wrong. The second changes to ordinary integers first and gives the true -190. Always use astype(int) before you subtract pixels.

An edge can run in any direction, so look both ways. At each pixel, find the step to the pixel on its right and the step to the pixel below. Add their sizes.

That sum is the edge strength. A pixel whose strength is over a chosen limit is marked 1 in the edge map.

docker exec jupyter python3 -c "import numpy as np; from PIL import Image; a = np.array(Image.open('images/road.png')).astype(int); g = np.abs(np.diff(a, axis=1)); print(g.shape, int((g > 60).sum()), int(g.max()))"

The Run prints (240, 319) 1236 153. A picture 320 wide has 319 steps along a row, so the array is 240 by 319.

Of those, 1236 are bigger than 60, mostly the sides of the lane lines and the road. The biggest is 153. The small steps from noise stay under the limit and are dropped.

docker exec jupyter python3 steps/edges.py

The Canny method is what scikit-image offers. It blurs the picture first, measures the strength, keeps only the thin ridge of each edge, and drops the weak ones.

The Run finds 1326 edge pixels in a picture of 60000: a small share, because most of the page is flat. The blur is set by a number called sigma, so more sigma means fewer false edges and softer outlines.

In a notebook, run feature.canny(a, sigma=1) and then sigma=3 on road.png, and print int(edges.sum()) for each. Use from skimage import feature.

Which sigma finds more edge pixels, and which gives you cleaner lane lines?