Scribd
Upload
20 views28 pages

Computer Vision Udacity

The document outlines a computer vision course from Udacity, covering topics such as image representation, filtering techniques, edge detection, and stereo correspondence. It includes code snippets for image processing tasks like blending images, applying Gaussian filters, and using the Hough transform. Additionally, it discusses methods for finding templates in images and computing disparity values between stereo images.

Uploaded by

mraza17
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
20 views28 pages

Computer Vision Udacity

The document outlines a computer vision course from Udacity, covering topics such as image representation, filtering techniques, edge detection, and stereo correspondence. It includes code snippets for image processing tasks like blending images, applying Gaussian filters, and using the Hough transform. Additionally, it discusses methods for finding templates in images and computing disparity values between stereo images.

Uploaded by

mraza17
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 28

Computer Vision Course Udacity

2A-L1 Image as functions


% Load and display an image
img = imread('dolphin.png');
imshow(img);
disp(size(img));
disp(class(img));

disp(img(101:103,201:203));
81 77 77
81 78 76
82 79 77
% Color planes
img = imread('fruit.png');
imshow(img);

disp(size(img));

% TODO: Select a color plane, display it, inspect values from a


row

im_red = img(:,:,1);
imshow(im_red);
% Blend two images
function output = blend(a, b, alpha)
% TODO: Your code here; finally assign: output =
<something>:
output = alpha * a + (1-alpha) * b ;
endfunction

% Test code:
dolphin = imread('dolphin.png');
bicycle = imread('bicycle.png');

result = blend(dolphin, bicycle, 0.75);


imshow(result); % note: will result in an error if blend()
returns empty or incorrect value
2A-L2 Filtering

% Apply a Gaussian filter to remove noise


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

% TODO: Add noise to the image

noise_sigma = 25;
noise = randn(size(img)).* noise_sigma;
noisy_img = img + noise;
imshow(img);

% TODO: Now apply a Gaussian filter to smooth out the noise

filter_size = 11;
filter_sigma = 2;
pkg load image;
filter = fspecial('gaussian', filter_size, filter_sigma);
smoothed = imfilter(noisy_img,filter);
imshow(smoothed);

% Note: You may need to pkg load image;


% Explore edge options
pkg load image;

%% Load an image
img = imread('fall-leaves.png'); % also available:
peppers.png, mandrill.png
imshow(img);

%% TODO: Create a Gaussian filter


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

%% TODO: Apply it, specifying an edge parameter (try


different parameters)

smoothed = imfilter(img,filter,'replicate');
imshow(smoothed);

smoothed = imfilter(img,filter,0);
imshow(smoothed);

smoothed = imfilter(img,filter,'circular');
imshow(smoothed);
Median filtering
Some convolution related laws introduced in the last lecture.

2A-L4 Filters as Templates


pkg load image; % AFTER function definition
function index = find_template_1D(t, s)
c = normxcorr2(t,s);
[maxvalue index] = max(c);

index = index - size(t,2) + 1;


endfunction

% Test code:
s = [-1 0 0 1 1 1 0 -1 -1 0 1 0 0 -1];
t = [0 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);

2ndfunction 2d version
pkg load image; % should always be before using it in code
function [yIndex xIndex] = find_template_2D(template, img)
c = normxcorr2(template,img);
[yraw xraw] = find(c == max(c(:))); % this will compute the
image wise maximum
yIndex = yraw - size(template,1) + 1;
xIndex = xraw - size(template,2) + 1;
% disp('correlation:'), disp([1:size(img, 2); img]);
endfunction

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

[y x] = find_template_2D(glyph, tablet);
disp([y x]); % should be the top-left corner of template in
tablet
colormap(‘gray’),imagesc(glyph);
hold on;
plot(x,y,’r+’,’markersize’,16);
hold off;

xy gradient of image
Differentiation is linear operation. All linear operations lets us
allow to use (Associate, Commutative and Distributive )
properties.
% Gradient Direction
pkg load image;
function result = select_gdir(gmag, gdir, mag_min,
angle_low, angle_high)
% TODO Find and return pixels that fall within the desired
mag, angle range
result = gmag >= mag_min & gdir >= angle_low & gdir <=
angle_high;
endfunction

%% Load and convert image to double type, range [0, 1] for


convenience
img = double(imread('octagon.png')) / 255.;
imshow(img); % assumes [0, 1] range for double images
%% Compute x, y gradients
[gx gy] = imgradientxy(img, 'sobel'); % Note: gx, gy are not
normalized
%gx = (gx+4)/8;
%gy = (gy+4)/8;
%% Obtain gradient magnitude and direction
[gmag gdir] = imgradient(gx, gy);
imshow(gmag / (4 * sqrt(2))); % mag = sqrt(gx^2 + gy^2), so
[0, (4 * sqrt(2))]
imshow((gdir + 180.0) / 360.0); % angle in degrees [-180, 180]
%% Find pixels with desired gradient direction
my_grad = select_gdir(gmag, gdir, 1, 30, 60); % 45 +/- 15
imshow(my_grad); % NOTE: enable after you've
implemented select_gdir
2A-L6 Edge Detector: 2D operators
Edge Function Matlab
% For Your Eyes Only
pkg load image;
frizzy = imread('frizzy.png');
froomer = imread('froomer.png');
imshow(frizzy);
imshow(froomer);
% TODO: Find edges in frizzy and froomer images
friz = rgb2gray(frizzy);
froom = rgb2gray(froomer);
frizzy_edge = edge(friz,'canny');
froomer_edge = edge(froom,'canny');
imshow(frizzy_edge);
imshow(froomer_edge);
% TODO: Display common edge pixels
imshow(frizzy_edge & froomer_edge); % common edge
pixels are obtained by doing and of the two images.
2B-L1 Hough transform lin
A line in the image space(x,y) corresponds to a point in
Hough space(b,m). and a point in image space(x,y)
corresponds to a line in Hough space (b,m). This is duality.

Point in image space is now sinusoid segment in hough space


x cos θ+ y sin θ=d
Hough transform theory presented with all displacement
vectors towards center of object. No major coding example
demonstrated.

2C-L1 Fourier Transform


3B-L3 Stereo correspondence

% TODO: Match two strips to compute disparity values


function disparity = match_strips(strip_left, strip_right, b)
% For each non-overlapping patch/block of width b in the left strip,
% find the best matching position (along X-axis) in the right strip.
% Return a vector of disparities (left X-position - right X-position).
% Note: Only consider whole blocks that fit within image bounds.

endfunction

% Find best match for a patch in a given strip (SSD)


% Note: You may use this or roll your own
function best_x = find_best_match(patch, strip)
min_diff = Inf;
best_x = 0; % column index (x value) of topleft corner; haven't found it yet
for x = 1:(size(strip)(2) - size(patch)(2))
other_patch = strip(:, x:(x + size(patch)(2) - 1));
diff = sumsq((patch - other_patch)(:));
if diff < min_diff
min_diff = diff;
best_x = x;
endif
endfor
endfunction

pkg load image;

% Test code:

%% Load images
left = imread('flowers-left.png');
right = imread('flowers-right.png');
figure, imshow(left);
figure, imshow(right);

%% Convert to grayscale, double, [0, 1] range for easier computation


left_gray = double(rgb2gray(left)) / 255.0;
right_gray = double(rgb2gray(right)) / 255.0;

%% Define strip row (y) and square block size (b)


y = 120;
b = 100;

%% Extract strip from left image


strip_left = left_gray(y:(y + b - 1), :);
figure, imshow(strip_left);

%% Extract strip from right image


strip_right = right_gray(y:(y + b - 1), :);
figure, imshow(strip_right);

%% Now match these two strips to compute disparity values


disparity = match_strips(strip_left, strip_right, b);
disp(disparity);
figure, plot(disparity);

Coherent Stereo on 2D grid


4A-L2 Finding Corners
6B-L3 Hierarchical LK

You might also like