How to do operation in {CELL}??

Assume i have 8x8 blocks of image. Here my code:

[L L]=size(img);
L2=C/8;
imgblk=cell(L2,L2);
for i=1:L2
for j=1:L2
imgblk{i,j}=img( (i-1)*4+1:i*4 , (j-1)*4+1:j*4);
end
end

Now, how to apply coding below into imgblk{i,j} since imgblk{i,j} is in 'cell'??

A (i,j)  = [Ʃ(fi,j - fi,j+1 ) - Ʃ(fi,j-1 - fi,j )] 
and
B (i,j)  = [Ʃ(fi,j - fi,j+1 ) - Ʃ(fi,j+1 - fi,j+2 )]

Also, how to do in horizontal first, then vertical? Thanks for those who help me =)

[Image Analyst]

What is "fi" and what is the sum over?

[Walter Roberson]

fi,j is f subscript i,j . But that doesn't tell us what f is or what the sum is over.

[troy]

Sorry.Actually we denote the luminance value in the image f of size MxN or LxL, at the particular location (i,j) with f(i,j), i and j being the row and column index, respectively.

Calculation sum is for every pixel f(i,j) in the odd-numbered rows of the image two variables :A (i,j) and B (i,j)

In my case i denote f(i,j)=I2(i,j)

I have done the code.But get error.

I2 = imread('.....');
I2 = rgb2gray (I2);
N=8;
[L L]=size(img);
L2=C/8;
imgblk=cell(L2,L2);

for i=1:L2
for j=1:L2
imgblk{i,j}=img( (i-1)*4+1:i*4 , (j-1)*4+1:j*4);
A (i,j)  = abs(sum(I2(i,j) - I2(i,j+1) ) - sum(I2(i,j-1) - I2(i,j) ))
B (i,j)  = abs(sum(I2(i,j) - I2(i,j+1) ) - sum(I2(i,j+1) - I2(i,j+2) ))
end
end

and i got this error

>>Undefined function or method 'minus' for input arguments of type 'cell'.

Actually A (i,j) = [Ʃ(f(i,j) - f(i,j+1) ) - Ʃ(f(i,j-1) - f(i,j) )] and B (i,j) = [Ʃ(f(i,j) - f(i,j+1) ) - Ʃ(f(i,j+1) - f(i,j+2) )] .

where i€ (i, i+2, i+4) and i is odd-numbered row.

Answer 1

[Image Analyst]

I don't understand this code at all. Some questions

1. What is C?
2. What is L2 for?
3. What is imgblk intended to be used for? Why is it necessary? Why are you messing around with cells anyway?
4. Do you know that sum(I2(i,j) - I2(i,j+1)) will clip to zero if I2 is uint8? Cast them to double before subtracting to avoid that.
5. What are A and B supposed to represent?

[troy]

1) sorry.actually C is actually L. I forgot to change it to L.

2) My image size is 512. L2 =512/8=64. i can't explain well what is L2 for because i get this coding from another people.

3) imgblk is access 8x8 block pixel. So i can get 64x64 cell boundary and apply formula A and B across the boundary of two adjacent 8x8 blocks of compressed image. I need to find activity around block boundary, that is why i use cell. Is that false?

4) I think i want to apply formula A and B into unit8 inside the cell. Is that possible? I already done with double and i cant get 8x8 blocks if i apply. I want to use sum(I2(i,j) - I2(i,j+1)) inside the 8x8 actually and I dont know how to do that.

5) A and B is formula to measure activity inside the block boundary and I want to apply inside 8x8 units.

If U dont mind, U can search on google about topic "BLOCKING EFFECT REDUCTION IN LOW BITRATE VIDEO ON A MOBILE PLATFORM". Thats what exactly i want to do and may be can help u understand what I want on my coding. Here

Every image have pixels. I want to divide it to 8x8 blocks and apply A and B inside 8x8 units.

Sorry for the late reply and cant answer well what u ask.

[Image Analyst]

You never ever use imgblk so you might as well get rid of it. You create it but never end up using it.

If you want a blockproc demo, let me know, and I can give you a couple of them.

Also, I don't have time to read a paper and explain it to you. I hope you understand http://matlab.wikia.com/wiki/FAQ#Can_you_program_up_the_algorithm_in_this_article_for_me_and_explain_it_to_me.3F. Giving you the blockproc demo is probably all I have time for, and I might not even be able to get to that today.

[troy]

Its ok. I know everyone have their works. I have tried blockproc before and could't understand it. But I will try to understand blockproc if ypu give me blokproc demo. I hope you will read the paper someday. I have tried to do this almost 1 year but get like nothing.lol

1 more thing. Why are you said that I can't use the imgblk?

Thanks.

[Image Analyst]

I didn't say you can't use it. I said you don't use it.

Here's the first blockproc demo:

% Demo code to divide the image up into 16 pixel by 16 pixel blocks
% and replace each pixel in the block by the median, mean, or standard
% deviation of all the gray levels of the pixels in the block.
%
clc;
clearvars;
close all;
workspace;
fontSize = 16;

% Read in a standard MATLAB gray scale demo image.
folder = fullfile(matlabroot, '\toolbox\images\imdemos');
if ~exist(folder, 'dir')
  % If that folder does not exist, don't use a folder
  % and hope it can find the image on the search path.
  folder = [];
end
baseFileName = 'cameraman.tif';
fullFileName = fullfile(folder, baseFileName);
grayImage = imread(fullFileName);
% Get the dimensions of the image.  numberOfColorBands should be = 1.
[rows, columns, numberOfColorBands] = size(grayImage)
% Display the original gray scale image.
subplot(2, 2, 1);
imshow(grayImage, []);
title('Original Grayscale Image', 'FontSize', fontSize);

% Enlarge figure to full screen.
set(gcf, 'Position', get(0,'Screensize')); 
set(gcf,'name','Image Analysis Demo','numbertitle','off') 

% Define the function that we will apply to each block.
% First in this demo we will take the median gray value in the block
% and create an equal size block where all pixels have the median value.
% Image will be the same size since we are using ones() and so for each block
% there will be a block of 8 by 8 output pixels.
medianFilterFunction = @(theBlockStructure) median(theBlockStructure.data(:)) * ones(size(theBlockStructure.data), class(theBlockStructure.data));

% Block process the image to replace every pixel in the 
% 8 pixel by 8 pixel block by the median of the pixels in the block.
blockSize = [8 8];
% Quirk: must cast grayImage to single or double for it to work with median().
% blockyImage8 = blockproc(grayImage, blockSize, medianFilterFunction); % Doesn't work.
blockyImage8 = blockproc(single(grayImage), blockSize, medianFilterFunction); % Works.
[rows, columns] = size(blockyImage8);

% Display the block median image.
subplot(2, 2, 2);
imshow(blockyImage8, []);
caption = sprintf('Block Median Image\n32 blocks. Input block size = 8, output block size = 8\n%d rows by %d columns', rows, columns);
title(caption, 'FontSize', fontSize);

% Block process the image to replace every pixel in the 
% 4 pixel by 4 pixel block by the mean of the pixels in the block.
% The image is 256 pixels across which will give 256/4 = 64 blocks.
% Note that the size of the output block (2 by 2) does not need to be the size of the input block!
% Image will be the 128 x 128 since we are using ones(2, 2) and so for each of the 64 blocks across
% there will be a block of 2 by 2 output pixels, giving an output size of 64*2 = 128.
% We will still have 64 blocks across but each block will only be 2 output pixels across,
% even though we moved in steps of 4 pixels across the input image.
meanFilterFunction = @(theBlockStructure) mean2(theBlockStructure.data(:)) * ones(2,2, class(theBlockStructure.data));
blockSize = [4 4];
blockyImage64 = blockproc(grayImage, blockSize, meanFilterFunction);
[rows, columns] = size(blockyImage64);

% Display the block mean image.
subplot(2, 2, 3);
imshow(blockyImage64, []);
caption = sprintf('Block Mean Image\n64 blocks. Input block size = 4, output block size = 2\n%d rows by %d columns', rows, columns);
title(caption, 'FontSize', fontSize);

% Block process the image to replace every pixel in the 
% 8 pixel by 8 pixel block by the standard deviation
% of the pixels in the block.
% Image will be smaller since we are not using ones() and so for each block
% there will be just one output pixel, not a block of 8 by 8 output pixels.
blockSize = [8 8];
StDevFilterFunction = @(theBlockStructure) std(double(theBlockStructure.data(:)));
blockyImageSD = blockproc(grayImage, blockSize, StDevFilterFunction);
[rows, columns] = size(blockyImageSD);

% Display the block standard deviation filtered image.
subplot(2, 2, 4);
imshow(blockyImageSD, []);
title('Standard Deviation Filtered Image', 'FontSize', fontSize);
caption = sprintf('Block Standard Deviation Filtered Image\n32 blocks. Input block size = 8, output block size = 1\n%d rows by %d columns', rows, columns);
title(caption, 'FontSize', fontSize);

Here's the second 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;

[troy]

thanks..I will try to understand it.