hi,..i m doing work on image forgery,,,i have to firstly decompose the image into overlapping blocks and after that apply the feature extraction can you tell how it can be done???

can you help me how it can be implemented???suggest me the proper source code for it.....the answer you have given to me is ok.. but not exactly....

[Walter Roberson]

This appears to be referencing http://www.mathworks.co.uk/matlabcentral/answers/59412-hello-i-m-new-to-matlab-plz-help-me-how-can-we-divide-an-image-into-overlapping-blocks

If the answer there was not exactly okay, it is not clear why you Accepted it.

What difference do you observe between what the previous Answer does and what you need done?

[Image Analyst]

We did get what you were trying to say - we just don't know how this is different than your first question. I've posted a couple of demos below. It's not clear to me why the image needs to be divided up into blocks. That is not necessary for most image analysis methods. Please tell us. Secondly, feature extraction is not just one thing, like a call to regionprops(). Different images have different features and need different algorithms to extract those specific features. It's impossible to give you code that is so general it works for everything. You haven't even shared an image with us yet (try http://snag.gy) so how can we give advice on how to measure anything in it? If you want, run my image segmentation tutorial in my File Exchange for an example of one kind of feature extraction (based on intensity thresholding).

Answer 1

[Image Analyst]

Here's a blockproc demo:

% Demo of blockproc in two different ways.
% One uses an anonymous function to return a block of pixels
% the same size as the sliding window block.
% The other uses a custom written function to return a
% single value for each sliding window position.
function blockproc_demo()
try
  clc; % Clear the command window.
  close all; % Close all figures (except those of imtool.)
  workspace; % Make sure the workspace panel is showing.
  fontSize = 20;

  % Change the current folder to the folder of this m-file.
  if(~isdeployed)
    cd(fileparts(which(mfilename)));
  end

  % Read in standard MATLAB demo image.
  grayImage = imread('cameraman.tif');
  [rows columns numberOfColorChannels] = size(grayImage);
  % Display the original image.
  subplot(2, 2, 1);
  imshow(grayImage, []);
  caption = sprintf('Original Image\n%d by %d pixels', ...
  rows, columns);
  title(caption, 'FontSize', fontSize);
  % Enlarge figure to full screen.
  set(gcf, 'Position', get(0,'Screensize'));
  set(gcf, 'name','Image Analysis Demo', 'numbertitle','off')

  % Block process the image.
  windowSize = 3;
  % Each 3x3 block will get replaced by one value.
  % Output image will be smaller by a factor of windowSize.
  myFilterHandle = @myFilter;
  blockyImage = blockproc(grayImage,[windowSize windowSize], myFilterHandle);
  [rowsP columnsP numberOfColorChannelsP] = size(blockyImage);

  % Display the processed image.
  % It is smaller, but the display routine imshow() replicates
  % the image so that it looks bigger than it really is.
  subplot(2, 2, 2);
  imshow(blockyImage, []);
  caption = sprintf('Image Processed in %d by %d Blocks\n%d by %d pixels\nCustom Box Filter', ...
  windowSize, windowSize, rowsP, columnsP);
  title(caption, 'FontSize', fontSize);

  % Now let's do it an alternate way where we use an anonymous function.
  % We'll take the standard deviation in the blocks.
  windowSize = 8;
  myFilterHandle2 = @(block_struct) ...
  std2(block_struct.data) * ones(size(block_struct.data));
  blockyImageSD = blockproc(grayImage, [windowSize windowSize], myFilterHandle2);
  [rowsSD columnsSD numberOfColorChannelsSD] = size(blockyImageSD);
  subplot(2, 2, 4);
  imshow(blockyImageSD, []);
  caption = sprintf('Image Processed in %d by %d Blocks\n%d by %d pixels\nAnonymous Standard Deviation Filter', ...
  windowSize, windowSize, rowsSD, columnsSD);
  title(caption, 'FontSize', fontSize);

  % Note: the image size of blockyImageSD is 256x256, NOT smaller.
  % That's because we're returning an 8x8 array instead of a scalar.

  uiwait(msgbox('Done with demo'));
  catch ME
    errorMessage = sprintf('Error in blockproc_demo():\n\nError Message:\n%s', ME.message);
    uiwait(warndlg(errorMessage));
  end
  return;

% Takes one 3x3 block of image data and multiplies it
% element by element by the kernel and
% returns a single value.
function singleValue = myFilter(blockStruct)
  try
    % Assign default value.
    % Will be used near sides of image (due to boundary effects),
    % or in the case of errors, etc.
    singleValue = 0;

    % Create a 2D filter.
    kernel = [0 0.2 0; 0.2 0.2 0.2; 0 0.2 0];
    % kernel = ones(blockStruct.blockSize); % Box filter.

    % Make sure filter size matches image block size.
    if any(blockStruct.blockSize ~= size(kernel))
      % If any of the dimensions don't match.
      % You'll get here near the edges,
      % if the image is not a multiple of the block size.
      % warndlg('block size does not match kernel size');
      return;
    end
    % Size matches if we get here, so we're okay.

    % Extract our block out of the structure.
    array3x3 = blockStruct.data;

    % Do the filtering. Multiply by kernel and sum.
    singleValue = sum(sum(double(array3x3) .* kernel));

  catch ME
    % Some kind of problem...
    errorMessage = sprintf('Error in myFilter():\n\nError Message:\n%s', ME.message);
    % uiwait(warndlg(errorMessage));
    fprintf(1, '%s\n', errorMessage);
  end
  return;

Answer 2

[Image Analyst]

Here's a demo for splitting an image into non-overlapping blocks:

% Demo to divide a color image up into blocks.
clc;    % Clear the command window.
close all;  % Close all figures (except those of imtool.)
workspace;  % Make sure the workspace panel is showing.
fontSize = 20;

% Read in a standard MATLAB color demo image.
folder = fullfile(matlabroot, '\toolbox\images\imdemos');
baseFileName = 'peppers.png';
% Get the full filename, with path prepended.
fullFileName = fullfile(folder, baseFileName);
if ~exist(fullFileName, 'file')
  % Didn't find it there.  Check the search path for it.
  fullFileName = baseFileName; % No path this time.
  if ~exist(fullFileName, 'file')
    % Still didn't find it.  Alert user.
    errorMessage = sprintf('Error: %s does not exist.', fullFileName);
    uiwait(warndlg(errorMessage));
    return;
  end
end
% Read the image from disk.
rgbImage = imread(fullFileName);

% Test code if you want to try it with a gray scale image.
% Uncomment line below if you want to see how it works with a gray scale image.
% rgbImage = rgb2gray(rgbImage);

% Display image full screen.
imshow(rgbImage);
% Enlarge figure to full screen.
set(gcf, 'units','normalized','outerposition',[0 0 1 1]);
drawnow;
% Get the dimensions of the image.  numberOfColorBands should be = 3.
[rows columns numberOfColorBands] = size(rgbImage)

%==========================================================================
% The first way to divide an image up into blocks is by using mat2cell().
blockSizeR = 150; % Rows in block.
blockSizeC = 100; % Columns in block.

% Figure out the size of each block in rows. 
% Most will be blockSizeR but there may be a remainder amount of less than that.
wholeBlockRows = floor(rows / blockSizeR);
blockVectorR = [blockSizeR * ones(1, wholeBlockRows), rem(rows, blockSizeR)];
% Figure out the size of each block in columns. 
wholeBlockCols = floor(columns / blockSizeC);
blockVectorC = [blockSizeC * ones(1, wholeBlockCols), rem(columns, blockSizeC)];

% Create the cell array, ca.  
% Each cell (except for the remainder cells at the end of the image)
% in the array contains a blockSizeR by blockSizeC by 3 color array.
% This line is where the image is actually divided up into blocks.
if numberOfColorBands > 1
  % It's a color image.
  ca = mat2cell(rgbImage, blockVectorR, blockVectorC, numberOfColorBands);
else
  ca = mat2cell(rgbImage, blockVectorR, blockVectorC);
end

% Now display all the blocks.
plotIndex = 1;
numPlotsR = size(ca, 1);
numPlotsC = size(ca, 2);
for r = 1 : numPlotsR
  for c = 1 : numPlotsC
    fprintf('plotindex = %d,   c=%d, r=%d\n', plotIndex, c, r);
    % Specify the location for display of the image.
    subplot(numPlotsR, numPlotsC, plotIndex);
    % Extract the numerical array out of the cell
    % just for tutorial purposes.
    rgbBlock = ca{r,c};
    imshow(rgbBlock); % Could call imshow(ca{r,c}) if you wanted to.
    [rowsB columnsB numberOfColorBandsB] = size(rgbBlock);
    % Make the caption the block number.
    caption = sprintf('Block #%d of %d\n%d rows by %d columns', ...
      plotIndex, numPlotsR*numPlotsC, rowsB, columnsB);
    title(caption);
    drawnow;
    % Increment the subplot to the next location.
    plotIndex = plotIndex + 1;
  end
end

% Display the original image in the upper left.
subplot(4, 6, 1);
imshow(rgbImage);
title('Original Image');

%==============================================================================
% Another way to split the image up into blocks is to use indexing.
% Read in a standard MATLAB gray scale demo image.
folder = fullfile(matlabroot, '\toolbox\images\imdemos');
baseFileName = 'cameraman.tif';
fullFileName = fullfile(folder, baseFileName);
% Get the full filename, with path prepended.
fullFileName = fullfile(folder, baseFileName);
if ~exist(fullFileName, 'file')
  % Didn't find it there.  Check the search path for it.
  fullFileName = baseFileName; % No path this time.
  if ~exist(fullFileName, 'file')
    % Still didn't find it.  Alert user.
    errorMessage = sprintf('Error: %s does not exist.', fullFileName);
    uiwait(warndlg(errorMessage));
    return;
  end
end
grayImage = imread(fullFileName);
% Get the dimensions of the image.  numberOfColorBands should be = 1.
[rows columns numberOfColorBands] = size(grayImage);
% Display the original gray scale image.
figure;
subplot(2, 2, 1);
imshow(grayImage, []);
title('Original Grayscale Image', 'FontSize', fontSize);
% Enlarge figure to full screen.
set(gcf, 'units','normalized','outerposition',[0 0 1 1]);

% Divide the image up into 4 blocks.
% Let's assume we know the block size and that all blocks will be the same size.
blockSizeR = 128; % Rows in block.
blockSizeC = 128; % Columns in block.
% Figure out the size of each block. 
wholeBlockRows = floor(rows / blockSizeR);
wholeBlockCols = floor(columns / blockSizeC);
% Preallocate a 3D image
image3d = zeros(wholeBlockRows, wholeBlockCols, 3);
% Now scan though, getting each block and putting it as a slice of a 3D array.
sliceNumber = 1;
for row = 1 : blockSizeR : rows
  for col = 1 : blockSizeC : columns
    % Let's be a little explicit here in our variables
    % to make it easier to see what's going on.
    row1 = row;
    row2 = row1 + blockSizeR - 1;
    col1 = col;
    col2 = col1 + blockSizeC - 1;
    % Extract out the block into a single subimage.
    oneBlock = grayImage(row1:row2, col1:col2);
    % Specify the location for display of the image.
    subplot(2, 2, sliceNumber);
    imshow(oneBlock);
    % Make the caption the block number.
    caption = sprintf('Block #%d of 4', sliceNumber);
    title(caption);
    drawnow;
    % Assign this slice to the image we just extracted.
    image3D(:, :, sliceNumber) = oneBlock;
    sliceNumber = sliceNumber + 1;
  end
end
% Now image3D is a 3D image where each slice, 
% or plane, is one quadrant of the original 2D image.

msgbox('Done with demo!  Check out the two figures.');