ソフトウェアエンジニアの技術ブログ：Software engineer tech blog

Gradients -> edges
1. smoothing derivatives to suppress noise and compute gradient.
2. threshold to find regions of “significant” gradient
3. thin to get localized edge pixels

The canny edge detector

% for your eyes only
pkg load image;

frizzy = imread('frizzy.png');
froomer = imread('froomer.png');
imshow(frizzy);
imshow(froomer);

frizzy_gray = rgb2gray(frizzy);
froomer_gray = rgb2gray(froomer);

frizzy_edges = edge(frizzy_gray, 'canny');
froomer_edges = edge(froomer_gray, 'canny');
imshow(frizzy_edges);
imshow(froomer_edges);

imshow(frizzy_edges & froomer_edges);

f(x)
d/dx*f(x)

Finite differences responding to noise
Increasing noise

Solution: smooth first
f, h, h*f, α/αx*(h*f)
where is the edge?

for sigma = 1:3:10
	h = fspecial('gaussian', fsize, sigma);
	out = imfilter(im, h);
	imshow(out);
	pause;
end

Differential operators – when applied to the image returns some derivatives.
Model these “operators” as masks/kernels that compute the image gradient function.

Discrete gradient
For discrete data, we can approximate using finite differences.

pkg load image;

function result = select_gdir(gmag, gdir, mag_min, angle_low, angle_high)
	result = gmag >= mag_min
endfunction

img = double(imread('octagon.png'))/255.;
imshow(img);

[gx gx] = imgradientxy(img, 'sobel');
imshow((gy + 4) / 8);

[gmag gdir] = imgradient(gx, gy);
imshow(gmag / (4 * sqrt(2)));

my_grad = select_gdir(gmag, gdir, 1, 30, 60);

Origin of Edges
-surface normal discontinuity
-depth discontinuity
-surface color discontinuity
-illumination discontinuity

Edges seem to occur “change boundaries” that are related to shape or illumination.
A stripe on a sign is not such a boundary.

Edge Detection
Basic idea: look for a neighborhood with strong signs of change.

Problems:
– neighborhood size
– how to detect change

intensity function (along horizontal scanline)

first derivative
-edges correspond to extrema of derivative

Scene
Template(mask)

Detected template
Correlation map

pkg load image;

function [yIndex xIndex] = find_template_2D(template, img)

endfunction

tablet = imread('tablet.png');
imshow(tablet);
glyph = tablet(75:165, 150:185);
imshow(plyph);

[y x] = find_template_2D(glyph, tablet);
disp([y x]);

Signal
Filter
Normalized cross-correlation

Matlab cross-correlation doc
onion = rgb2gray(imread(‘onion.png’));
peppers = rgb2gray(imread(‘peppers.png’));
imshowpair(peppers, onion,’montage’)

Matlab cross-correlation doc
c = normxcorr2(onion,peppers);
figure, surf(c), shading flat;

pkg load image;
function index = find_template_1D(t, s)

endfunction

s = [-1 0 0 1 1 1 0 -1 -1 0 1 0 0 -1];
t = [1 1 0];

disp('Signal:'), disp([1:size(s, 2); s]);
disp('Template:'), disp([1:size(t, 2); t]);

index = find_template_1D(t, s);
disp('Index:'), disp(index);

10 15 20
23 90 27
33 31 30
sor-> 10 15 20 23 27 30 31 33 90
replace
10 15 20
23 27 27
33 31 30
Median filter is smooth nicer

pkg load image;

img = imread('moon.png');
imshow(img);

%% Add salt & pepper noise
noisy_img = imnoise(img, 'salt & pepper', 0.02);
imshow(noisy_img);

median_filtered = medfilt2(noisy_img);
imshow(median_filtered);

division is a linear operation?
true becase (x + y)/z = x/z + y/z

Boundary Issues
full, same, valid

Boundary issues
methods:
clip filter(black):imfilter(f,g,0)
wrap around(f,g,’circular’)
copy edge(f,g,’replicate’)
reflect across edge(f,g,’symmetric’)

pkg load image;

img = imread('fall-leaves.png');
imshow(img);

filter_size = 21;
filter_sigma = 3;
filter = fspecial('gaussian', filter_size, filter_sigma);

smoothed = imfilter(img, filter, 0);

The reflection method of handling boundary conditions in filtering is good because
the created imagery has the same statistic as the original image

An operator H is linear if two properties hold(f1 and f2 are some functions, a is a constant):

Additivity(things sum):
-H(f1 + f2) = H(f1) + H(f2)(looks like distributive law)

Multiplicative scaling(Homogeneity of degree 1)
(constant scales):
-H(a*f1) = a*H(f1)

Because it is sums ans multiplies, the “filtering” operation we were doing are linear:

An impulse function…
it’s just a value of 1 at a single location

An impulse response
-if I have unknown system and I put in an impulse, the response is called the impulse response
-so if the black box is linear you can describe H by h(x)

Assuming center coordinate is “reference point”.

kernel is size MxM, and our image was NxN.
filter whole image is M*M*N*N

Correlation vs Convolution(flip in both dimensions, bottom to top, right to left)

Shift invariant:
linear & shift invariant

Associative
(f*g)*h = f*(g*h)
Identity:
unit impulse e = […,0,0,1,0,0,…] f*e = f
Differentiation: α/αx(f*g) = αf/αx*g