# Introduction to Image Processing¶

This numerical tour explores some basic image processing tasks.


In [2]:
using NtToolBox
using PyPlot


Several functions are implemented to load and display images.

path to the images

In [3]:
name = "NtToolBox/src/data/lena.png"
n = 256


We can display it. It is possible to zoom on it, extract pixels, etc.

In [5]:
imageplot(M[Int(n/2 - 25) : Int(n/2 + 25), Int(n/2 - 25) : Int(n/2 + 25)], "Zoom", [1, 2, 2]);


## Image Modification¶

An image is a 2D array, that can be modified as a matrix.

In [4]:
imageplot(-M, "-M", [1,2,1])
imageplot(M[end:-1:1,1:size(M, 2)], "Flipped", [1,2,2])

Out[4]:
PyObject <matplotlib.text.Text object at 0x000000001BED59E8>

Blurring is achieved by computing a convolution with a kernel.

Compute the low pass Gaussian kernel. Warning, the indexes need to be modulo $n$ in order to use FFTs.

In [5]:
sigma = 5
X = [0:n/2; -n/2:-2]'
Y = [0:n/2; -n/2:-2]
h = exp(-(X.^2 .+ Y.^2)/(2*(sigma)^2))
h = h/sum(h)
imageplot(fftshift(h))


Compute the periodic convolution ussing FFTs

In [6]:
Mh = conv2(Array{Float64, 2}(M), h)
Mh = Mh[1:255, 1:255] + Mh[257:511, 1:255] + Mh[1:255, 257:511] + Mh[257:511, 257:511];


Display

In [7]:
imageplot(M, "Image", [1, 2, 1])
imageplot(Mh, "Blurred", [1, 2, 2])

Out[7]:
PyObject <matplotlib.text.Text object at 0x000000001C3D5320>

Several differential and convolution operators are implemented.

In [8]:
(G_x, G_y) = Images.imgradients(M)
imageplot(G_x, "d/ dx", [1, 2, 1])
imageplot(G_y, "d/ dy", [1, 2, 2])

WARNING: the order of outputs has switched (grad1, grad2 = imgradients(img) rather than gradx, grady = imgradients). Silence this warning by providing a kernelfun, e.g., imgradients(img, KernelFactors.ando3).
in depwarn(::String, ::Symbol) at .\deprecated.jl:64
in execute_request(::ZMQ.Socket, ::IJulia.Msg) at C:\Users\Ayman\.julia\v0.5\IJulia\src\execute_request.jl:157
in eventloop(::ZMQ.Socket) at C:\Users\Ayman\.julia\v0.5\IJulia\src\eventloop.jl:8
in 
(::IJulia.##13#19)() at .\task.jl:360

Out[8]:
PyObject <matplotlib.text.Text object at 0x000000001DBAAEF0>

## Fourier Transform¶

The 2D Fourier transform can be used to perform low pass approximation and interpolation (by zero padding).

Compute and display the Fourier transform (display over a log scale). The function fftshift is useful to put the 0 low frequency in the middle. After fftshift, the zero frequency is located at position $(n/2+1,n/2+1)$.

In [9]:
Mf = plan_fft(M)
Mf*M
Lf = fftshift(log(abs(Mf*M) + 1e-1))
imageplot(M, "Image", [1, 2, 1])
imageplot(Lf, "Fourier transform", [1, 2, 2])

Out[9]:
PyObject <matplotlib.text.Text object at 0x000000001DC00208>

Exercise 1: To avoid boundary artifacts and estimate really the frequency content of the image (and not of the artifacts!), one needs to multiply M by a smooth windowing function h and compute fft2(M*h). Use a sine windowing function. Can you interpret the resulting filter ?

In [10]:
include("NtSolutions/introduction_3_image/exo1.jl")

Out[10]:
PyObject <matplotlib.text.Text object at 0x000000001DE049B0>

Exercise 2: Perform low pass filtering by removing the high frequencies of the spectrum. What do you oberve ?

In [11]:
include("NtSolutions/introduction_3_image/exo2.jl")

Out[11]:
PyObject <matplotlib.text.Text object at 0x000000001E0E8CC0>