| function [VW, sptHist] = LMdenseVisualWords(D, HOMEIMAGES, VWparam) | |
| % | |
| % Compute dense visual words and spatial pyramid histogram. | |
| % | |
| % The SIFT grid + visual words will be defined by the parameters VWparam: | |
| % VWparam.imagesize = 256; % normalized image size (images will be scaled so that the maximal axis has this dimension before computing the sift features) | |
| % VWparam.grid_spacing = 1; % distance between grid centers | |
| % VWparam.patch_size = 16; % size of patch from which to compute SIFT descriptor (it has to be a factor of 4) | |
| % VWparam.NumVisualWords = 200; % number of visual words | |
| % VWparam.Mw = 2; % number of spatial scales for spatial pyramid histogram | |
| % | |
| % Run demoVisualWords.m to see an example of how it works. | |
| % | |
| % The SIFT descriptor at each location has 128 dimensions and is vector quantized. | |
| % | |
| % This function can be called as: | |
| % | |
| % [VW, sptHist] = LMdenseVisualWords(img, HOMEIMAGES, param); | |
| % [VW, sptHist] = LMdenseVisualWords(D(n), HOMEIMAGES, param); | |
| % [VW, sptHist] = LMdenseVisualWords(filename, HOMEIMAGES, param); | |
| % | |
| % | |
| % Antonio Torralba, 2008 | |
| if nargin==4 | |
| precomputed = 1; | |
| % get list of folders and create non-existing ones | |
| %listoffolders = {D(:).annotation.folder}; | |
| else | |
| precomputed = 0; | |
| HOMESIFT = ''; | |
| end | |
| if nargin<3 | |
| % Default parameters | |
| VWparam.grid_spacing = 1; % distance between grid centers | |
| VWparam.patch_size = 16; % size of patch from which to compute SIFT descriptor (it has to be a factor of 4) | |
| end | |
| Nfeatures = 128; | |
| if isstruct(D) | |
| % [gist, param] = LMdenseVisualWords(D, HOMEIMAGES, param); | |
| Nscenes = length(D); | |
| typeD = 1; | |
| end | |
| if iscell(D) | |
| % [gist, param] = LMdenseVisualWords(filename, HOMEIMAGES, param); | |
| Nscenes = length(D); | |
| typeD = 2; | |
| end | |
| if isnumeric(D) | |
| % [gist, param] = LMdenseVisualWords(img, HOMEIMAGES, param); | |
| Nscenes = size(D,4); | |
| typeD = 3; | |
| end | |
| if Nscenes >1 | |
| fig = figure; | |
| end | |
| % Loop: Compute visual words for all scenes | |
| if isfield(VWparam, 'imagesize') | |
| n = VWparam.imagesize-VWparam.patch_size+2; m = n; | |
| else | |
| % read one image to check size. This will only work if all the images | |
| % have the same size | |
| switch typeD | |
| case 1 | |
| img = LMimread(D, 1, HOMEIMAGES); | |
| case 2 | |
| img = imread(fullfile(HOMEIMAGES, D{1})); | |
| case 3 | |
| img = D(:,:,:,1); | |
| end | |
| n = size(img,1)-VWparam.patch_size+2; | |
| m = size(img,2)-VWparam.patch_size+2; | |
| end | |
| VW = zeros([n m Nscenes], 'uint16'); | |
| sptHist = zeros([VWparam.NumVisualWords*((4^VWparam.Mw-1)/3) Nscenes], 'single'); | |
| for n = 1:Nscenes | |
| g = []; | |
| todo = 1; | |
| % otherwise compute gist | |
| if todo==1 | |
| disp([n Nscenes]) | |
| % load image | |
| try | |
| switch typeD | |
| case 1 | |
| img = LMimread(D, n, HOMEIMAGES); | |
| case 2 | |
| img = imread(fullfile(HOMEIMAGES, D{n})); | |
| case 3 | |
| img = D(:,:,:,n); | |
| end | |
| catch | |
| disp(D(n).annotation.folder) | |
| disp(D(n).annotation.filename) | |
| rethrow(lasterror) | |
| end | |
| % Reshape image to standard format | |
| if isfield(VWparam, 'imagesize') | |
| img = imresizecrop(img, VWparam.imagesize, 'bilinear'); | |
| end | |
| %M = max(size(img,1), size(img,2)); | |
| %if M~=VWparam.imagesize | |
| % img = imresize(img, VWparam.imagesize/M, 'bilinear'); | |
| %end | |
| % get SIFT descriptors | |
| sift = single(LMdenseSift(img, HOMEIMAGES, VWparam)); | |
| [nrows ncols nf] = size(sift); | |
| sift = reshape(sift, [size(sift,1)*size(sift,2) Nfeatures]); | |
| % vector quantization | |
| [fitd, w] = min(distMat(single(VWparam.visualwordcenters), sift)); | |
| VW(:,:,n) = uint16(reshape(w, [nrows ncols])); | |
| % Compute spatial histogram | |
| sptHist(:,n) = spatialHistogram(VW(:,:,n), VWparam.Mw, VWparam.NumVisualWords); | |
| if Nscenes >1 | |
| figure(fig); | |
| subplot(121) | |
| imshow(uint8(img)) | |
| subplot(122) | |
| imagesc(VW(:,:,n)) | |
| axis('equal') | |
| axis('off') | |
| end | |
| end | |
| drawnow | |
| end | |
| % | |
| % function [sift_arr, grid_x, grid_y] = dense_sift(I, SIFTparam) | |
| % % Svetlana Lazebnick | |
| % % Antonio Torralba: modified using convolutions to speed up the | |
| % % computations. | |
| % | |
| % grid_spacing = SIFTparam.grid_spacing; | |
| % patch_size = SIFTparam.patch_size; | |
| % | |
| % I = double(I); | |
| % I = mean(I,3); | |
| % I = I /max(I(:)); | |
| % | |
| % % parameters | |
| % num_angles = 8; | |
| % num_bins = 4; | |
| % num_samples = num_bins * num_bins; | |
| % alpha = 9; %% parameter for attenuation of angles (must be odd) | |
| % | |
| % if nargin < 5 | |
| % sigma_edge = 1; | |
| % end | |
| % | |
| % angle_step = 2 * pi / num_angles; | |
| % angles = 0:angle_step:2*pi; | |
| % angles(num_angles+1) = []; % bin centers | |
| % | |
| % [hgt wid] = size(I); | |
| % | |
| % [G_X,G_Y]=gen_dgauss(sigma_edge); | |
| % | |
| % % add boundary: | |
| % I = [I(2:-1:1,:,:); I; I(end:-1:end-1,:,:)]; | |
| % I = [I(:,2:-1:1,:) I I(:,end:-1:end-1,:)]; | |
| % | |
| % I = I-mean(I(:)); | |
| % I_X = filter2(G_X, I, 'same'); % vertical edges | |
| % I_Y = filter2(G_Y, I, 'same'); % horizontal edges | |
| % | |
| % I_X = I_X(3:end-2,3:end-2,:); | |
| % I_Y = I_Y(3:end-2,3:end-2,:); | |
| % | |
| % I_mag = sqrt(I_X.^2 + I_Y.^2); % gradient magnitude | |
| % I_theta = atan2(I_Y,I_X); | |
| % I_theta(find(isnan(I_theta))) = 0; % necessary???? | |
| % | |
| % % grid | |
| % grid_x = patch_size/2:grid_spacing:wid-patch_size/2+1; | |
| % grid_y = patch_size/2:grid_spacing:hgt-patch_size/2+1; | |
| % | |
| % % make orientation images | |
| % I_orientation = zeros([hgt, wid, num_angles], 'single'); | |
| % | |
| % % for each histogram angle | |
| % cosI = cos(I_theta); | |
| % sinI = sin(I_theta); | |
| % for a=1:num_angles | |
| % % compute each orientation channel | |
| % tmp = (cosI*cos(angles(a))+sinI*sin(angles(a))).^alpha; | |
| % tmp = tmp .* (tmp > 0); | |
| % | |
| % % weight by magnitude | |
| % I_orientation(:,:,a) = tmp .* I_mag; | |
| % end | |
| % | |
| % % Convolution formulation: | |
| % weight_kernel = zeros(patch_size,patch_size); | |
| % r = patch_size/2; | |
| % cx = r - 0.5; | |
| % sample_res = patch_size/num_bins; | |
| % weight_x = abs((1:patch_size) - cx)/sample_res; | |
| % weight_x = (1 - weight_x) .* (weight_x <= 1); | |
| % | |
| % for a = 1:num_angles | |
| % %I_orientation(:,:,a) = conv2(I_orientation(:,:,a), weight_kernel, 'same'); | |
| % I_orientation(:,:,a) = conv2(weight_x, weight_x', I_orientation(:,:,a), 'same'); | |
| % end | |
| % | |
| % % Sample SIFT bins at valid locations (without boundary artifacts) | |
| % % find coordinates of sample points (bin centers) | |
| % [sample_x, sample_y] = meshgrid(linspace(1,patch_size+1,num_bins+1)); | |
| % sample_x = sample_x(1:num_bins,1:num_bins); sample_x = sample_x(:)-patch_size/2; | |
| % sample_y = sample_y(1:num_bins,1:num_bins); sample_y = sample_y(:)-patch_size/2; | |
| % | |
| % sift_arr = zeros([length(grid_y) length(grid_x) num_angles*num_bins*num_bins], 'single'); | |
| % b = 0; | |
| % for n = 1:num_bins*num_bins | |
| % sift_arr(:,:,b+1:b+num_angles) = I_orientation(grid_y+sample_y(n), grid_x+sample_x(n), :); | |
| % b = b+num_angles; | |
| % end | |
| % clear I_orientation | |
| % | |
| % | |
| % % Outputs: | |
| % [grid_x,grid_y] = meshgrid(grid_x, grid_y); | |
| % [nrows, ncols, cols] = size(sift_arr); | |
| % | |
| % % normalize SIFT descriptors | |
| % | |
| % %sift_arr = reshape(sift_arr, [nrows*ncols num_angles*num_bins*num_bins]); | |
| % %sift_arr = normalize_sift(sift_arr); | |
| % %sift_arr = reshape(sift_arr, [nrows ncols num_angles*num_bins*num_bins]); | |
| % | |
| % | |
| % ct = .1; | |
| % sift_arr = sift_arr + ct; | |
| % tmp = sqrt(sum(sift_arr.^2, 3)); | |
| % sift_arr = sift_arr ./ repmat(tmp, [1 1 size(sift_arr,3)]); | |
| % | |
| % function [GX,GY]=gen_dgauss(sigma) | |
| % | |
| % % laplacian of size sigma | |
| % %f_wid = 4 * floor(sigma); | |
| % %G = normpdf(-f_wid:f_wid,0,sigma); | |
| % %G = G' * G; | |
| % G = gen_gauss(sigma); | |
| % [GX,GY] = gradient(G); | |
| % | |
| % GX = GX * 2 ./ sum(sum(abs(GX))); | |
| % GY = GY * 2 ./ sum(sum(abs(GY))); | |
| % | |
| % | |
| % function G=gen_gauss(sigma) | |
| % | |
| % if all(size(sigma)==[1, 1]) | |
| % % isotropic gaussian | |
| % f_wid = 4 * ceil(sigma) + 1; | |
| % G = fspecial('gaussian', f_wid, sigma); | |
| % % G = normpdf(-f_wid:f_wid,0,sigma); | |
| % % G = G' * G; | |
| % else | |
| % % anisotropic gaussian | |
| % f_wid_x = 2 * ceil(sigma(1)) + 1; | |
| % f_wid_y = 2 * ceil(sigma(2)) + 1; | |
| % G_x = normpdf(-f_wid_x:f_wid_x,0,sigma(1)); | |
| % G_y = normpdf(-f_wid_y:f_wid_y,0,sigma(2)); | |
| % G = G_y' * G_x; | |
| % end | |
| function D=distMat(P1, P2) | |
| % | |
| % Euclidian distances between vectors | |
| if nargin == 2 | |
| X1=repmat(single(sum(P1.^2,2)),[1 size(P2,1)]); | |
| X2=repmat(single(sum(P2.^2,2)),[1 size(P1,1)]); | |
| R=P1*P2'; | |
| D=X1+X2'-2*R; | |
| else | |
| % each vector is one column | |
| X1=repmat(sum(P1.^2,1),[size(P1,2) 1]); | |
| R=P1'*P1; | |
| D=X1+X1'-2*R; | |
| D = sqrt(D); | |
| end | |
| function h = spatialHistogram(W, Mw, Nwords) | |
| % Mw = number of spatial windows for computing histograms | |
| coef = 1./[2^(Mw-1) 2.^(Mw-(1:(Mw-1)))]; | |
| h = []; | |
| for M = 1:Mw | |
| lx = round(linspace(1, size(W,2)-1, 2^(M-1)+1)); | |
| ly = round(linspace(1, size(W,1)-1, 2^(M-1)+1)); | |
| for x = 1:2^(M-1) | |
| for y = 1:2^(M-1) | |
| ww = W(ly(y)+1:ly(y+1), lx(x)+1:lx(x+1)); | |
| hh = hist(ww(:), 1:Nwords); | |
| h = [h coef(M)*hh]; | |
| end | |
| end | |
| end | |
| % store words | |
| h = h /sum(h); | |