How can I divide a 1424*2144 image into a 32*32 blocks?

Need to divide an image into 32 by 32 blocks and then need to calculate the mean and variance of each block.

[John D'Errico]

Of course, you cannot divide the image as desired, since 1424 is not divisible by 32. There will be one row of blocks at one end that will all be 16x32. Or you will need to pad the image.

Answer 1

[Mikael Erkkilä]

So at first you determine the number of blocks per dimension. Then you go through the image in a loop. This could look like this:

 A=ones(1424,2144); % your image
 for i=1:size(A,1)/32 % loop from 1 to Nr of blocks in x-dimension
   for j=1:size(A,2)/32 % loop from 1 to Nr of blocks in y-dimension
      AVG(i,j)=mean(mean(A(i:i+32,j:j+32))); % compute the mean of the block
   end
 end

Note that with A(i:i+32,j:j+32) you get a 32x32 matrix from the image starting at point (i,j)

[Prachi Sharma]

Hey I used this code of yours.I am first converting any image into an image of 512*512 and then dividing it into 32*32 blocks.Then it calculates the mean but I am unable to calculate standard deviation for every particular block.I tried calculating standard deviation but it is giving errors.Can you please tell me whats wrong in it?

function [AVG,snd]=readims(b)

a=imresize(b,[512 512]);

   for i=1:size(a,1)/32 % loop from 1 to Nr of blocks in x-dimension
     for j=1:size(a,2)/32 % loop from 1 to Nr of blocks in y-dimension
        AVG(i,j)=mean(mean(a(i:i+32,j:j+32))); % compute the mean of the block
        snd(i,j)=(std(a(i:i+32,j:j+32)));% to calculate standard deviation
     end
   end

[José-Luis]

If you have the image processing toolbox, this is much easier to do with blokproc(), like others have already suggested.

[Prachi Sharma]

I tried using blockproc() but since I am new to matlab I can not use it properly.

[Image Analyst]

Attached are some demos.

[Prachi Sharma]

Hey I am finally able to write code using blockproc. I have written the code below. But how do I find the gradient of the image and then show its figure-

Here is the code-

function stds(b)

a=imresize(b,[512 512]);

myfun = @(block_struct)... uint8(std2(block_struct.data)*ones(size(block_struct.data)));

I2 = blockproc(a,[32 32],myfun);

figure;

imshow(a);

figure;

imshow(I2,[]);

Answer 2

[Walter Roberson]

If those are to be non-overlapping blocks, then you cannot do that, as the height 1424 is not divisible by 32.

Anyhow, you should be looking at blockproc()

Answer 3

[Matt J]

Assuming you made a mistake with the dimensions and that they're supposed to divide evenly into 32x32 blocks, then you should use SEPBLOCKFUN ( Download ) from the File Exchange.

   result = sepblockfun(A,[32,32],'mean');

This will be more efficient than blockproc, since it takes advantage of the separable properties of mean().

[Matt J]

it calculates the mean but I am unable to calculate standard deviation for every particular block

As mentioned at the link I gave you, sepblockfun can be used to get both means and standard deviations of blocks in just a few lines, and again much more efficiently than blockproc:

   a_means=sepblockfun(a,[32,32],@mean); 

   a_stds=sqrt( sepblockfun(a.^2,[32,32],'mean') - a_means.^2 );

[Prachi Sharma]

I tried using this but it gives error.I even tried downloading sepblock,the error still persists.

[Prachi Sharma]

function [AVG,a_stds]=readims(b)

a=imresize(b,[512 512]);

   for i=1:size(a,1)/32 % loop from 1 to Nr of blocks in x-dimension
     for j=1:size(a,2)/32 % loop from 1 to Nr of blocks in y-dimension
        AVG(i,j)=mean(mean(a(i:i+32,j:j+32))); % compute the mean of the block
     a_stds=sqrt( sepblockfun(a.^2,[32,32],'mean') - a_means.^2 );
     end
   end

It gives the following error-

 Undefined function 'sepblockfun' for input arguments of type 'uint8'.

Error in nidhims (line 7)
   a_stds=sqrt( sepblockfun(b.^2,[32,32],'mean') - a_means.^2 );

>> [r,s]=nidhims(I)
Undefined function 'sepblockfun' for input arguments of type 'uint8'.

Error in nidhims (line 7)
   a_stds=sqrt( sepblockfun(a.^2,[32,32],'mean') - a_means.^2 );

>>

[Matt J]

1. You shouldn't be using loops. The entire operation is done with just the two lines I gave you
2. You have to download sepblockfun AND put it somewhere that Matlab can see it. The error message clearly shows that it cannot.

[Prachi Sharma]

It is giving me values in like g(:,:,1),then g(:,:,2) then g(:,:,3) and also complex values for standard deviation so is it right or not?

[Matt J]

What do you get when you do this?

 >> a=reshape( 1:16, 4,4); a_means=sepblockfun(a,[2,2], 'mean')

[Prachi Sharma]

>> u=dev(q)

a_means =

      3.5000   11.5000
      5.5000   13.5000

u =

       1     5     9    13
       2     6    10    14
       3     7    11    15
       4     8    12    16

[Matt J]

It is working. If you have imaginary parts, I suspect they will be very small values from floating point errors - the argument to sqrt is slightly negative in places where it is supposed to be zero. You can just throw them away.

[Prachi Sharma]

Yeah I guess and it is giving me values for 3D right?

[Matt J]

If you gave it 3D input, then it should give you 3D output.

[Prachi Sharma]

qimage=328x525x3 uint8 these are the dimensions of input

and the following are the dimensions of the output

mean=16x16x3 double

std=16x16x3 complex double

It is in this form.Also that mean(:,:,1),mean(:,:,2) and mean(:,:,3) is for 3D right?

[Matt J]

Yes, it is taking the 32x32 block means in all 3 slices and mean(:,:,n) etc... signifies the n-th slice of "mean" for n=1,2,3.

[Prachi Sharma]

Standard deviation shouldn't be negative in my code's case.

[Matt J]

No, it should not be negative in any case, but again, be mindful of small floating point junk that is really supposed to be zero.

[Prachi Sharma]

The code is giving somewhat these kind of values for mean and standard deviation. Mean seems fine. standard deviation Doesn't feel right. s(:,:,1) =

Columns 1 through 8

   36.8232   65.3936  168.2119  217.9844  226.4990  227.0186  218.5986  220.1426
   33.9766   35.4727   62.6602  117.6250  169.1582  204.8369  222.0039  223.5576
   35.0264   35.5117   36.8799   38.8975   54.8672   68.2178  103.9268  116.0986
   37.8535   37.8994   38.9521   39.2480   39.2744   40.3682   40.7695   42.2002
   39.4990   39.6787   40.7666   41.8594   41.9883   42.4023   42.9873   43.5078
   45.1768   50.7979   62.4551   95.7666   84.9072   49.2676   45.5020   45.9463
   75.9414   84.1895   93.4805  106.7529   78.3408   52.4023   50.8818   51.0791
   69.2178   81.2949   95.2246   78.9775  111.6729   92.9980   60.9727   57.4355
   94.7432  119.9492  138.4629  138.4482  105.5059   76.1484   80.5010   80.5391
   85.6074   83.3936   96.2617   88.4316   84.7939   83.6699   79.9453   75.3545
   75.8535   77.4297   79.8193   82.8105   88.2197   91.8643  101.6094  102.9609
   91.3506   95.5371  103.9150  112.8857  117.3125  120.1475  121.4287  121.8047
   97.3047  100.2012  105.8203  111.1338  115.3564  119.8662  124.7607  129.7559
   56.8408   62.6738   70.5039   76.9268   83.7188   90.8291  103.4629  121.7910
   39.3975   43.3203   47.6689   52.2275   55.8574   62.6689   76.4238   98.9365
   28.8770   32.7529   37.2305   45.0059   54.5625   68.5244   89.7598  109.9170

Columns 9 through 16

Standard deviation values t(:,:,1) =

   1.0e+02 *

Columns 1 through 4

   0.0000 + 0.3318i   0.0000 + 0.6341i   0.0000 + 1.6745i   0.0000 + 2.1740i
   0.0000 + 0.2999i   0.0000 + 0.3168i   0.0000 + 0.6059i   0.0000 + 1.1654i
   0.0000 + 0.3117i   0.0000 + 0.3172i   0.0000 + 0.3324i   0.0000 + 0.3547i
   0.0000 + 0.3432i   0.0000 + 0.3437i   0.0000 + 0.3553i   0.0000 + 0.3585i
   0.0000 + 0.3613i   0.0000 + 0.3632i   0.0000 + 0.3751i   0.0000 + 0.3869i
   0.0000 + 0.4226i   0.0000 + 0.4822i   0.0000 + 0.6038i   0.0000 + 0.9443i
   0.0000 + 0.7424i   0.0000 + 0.8266i   0.0000 + 0.9211i   0.0000 + 1.0555i
   0.0000 + 0.6735i   0.0000 + 0.7971i   0.0000 + 0.9388i   0.0000 + 0.7735i
   0.0000 + 0.9339i   0.0000 + 1.1888i   0.0000 + 1.3754i   0.0000 + 1.3752i
   0.0000 + 0.8410i   0.0000 + 0.8185i   0.0000 + 0.9493i   0.0000 + 0.8698i
   0.0000 + 0.7415i   0.0000 + 0.7577i   0.0000 + 0.7821i   0.0000 + 0.8126i
   0.0000 + 0.8994i   0.0000 + 0.9419i   0.0000 + 1.0268i   0.0000 + 1.1175i
   0.0000 + 0.9599i   0.0000 + 0.9892i   0.0000 + 1.0461i   0.0000 + 1.0998i
   0.0000 + 0.5455i   0.0000 + 0.6061i   0.0000 + 0.6867i   0.0000 + 0.7525i
   0.0000 + 0.3602i   0.0000 + 0.4027i   0.0000 + 0.4491i   0.0000 + 0.4973i
   0.0000 + 0.2406i   0.0000 + 0.2860i   0.0000 + 0.3363i   0.0000 + 0.4208i

[Matt J]

I think I know why. Convert the input from uint8 to double first. Otherwise a.^2 will overflow. In any case, you can attach the "a" matrix in a .mat file so that we can try it.

[Prachi Sharma]

It worked this time.The values of standard deviation are not complex anymore after I changed the input to double.But I do have a concern,you can look at the code and output below and you can see it is giving output in 3d.What if I just need it 2D?

function[nmeans,nstds]=npra(b)

i=im2double(b);

a=imresize(i,[512 512]);

nmeans=sepblockfun(a,[32,32],@mean);

     nstds=sqrt(sepblockfun(a.^2,[32,32],'mean')-nmeans.^2);
  end

The output is something like this-

t(:,:,3) =

    Columns 1 through 12

      0.7938    0.7555    0.7372    0.7633    0.7751    0.7682    0.8241    0.8209    0.7872    0.7657    0.7750    0.7355
      0.5951    0.6326    0.5999    0.5704    0.6036    0.6203    0.6198    0.6311    0.5521    0.5366    0.7564    0.7762
      0.4144    0.4883    0.4637    0.5418    0.6465    0.6177    0.5946    0.6060    0.5786    0.5743    0.7065    0.7865
      0.4498    0.4735    0.4318    0.5096    0.5445    0.5421    0.4111    0.3732    0.4212    0.4241    0.5181    0.7821

[Prachi Sharma]

Also you can check the type of output I want.I first tried solving this problem with the code I wrote below.It gives the output as you can see below.For the code you helped me with using sepblockfun,I need the similar output.

Here is the code I tried first-

function AVG=blok(b)

a=imresize(b,[512 512]);

scale=512/32;

for i=1:scale

      for j=1:scale

          block2=a((i-1)*32+1:i*32,(j-1)*32+1:j*32);
          AVG(i,j)=mean(mean(a(i:i+32,j:j+32)));

      end
  end

The output I get for this goes like this-

>> ymean=blok(a)

ymean=

    Columns 1 through 12

    235.6400  235.7971  235.9541  236.1038  236.2259  236.3710  236.5096  236.5721  236.6134  236.6713  236.5014  235.7971
    234.4298  234.6520  234.8714  235.0799  235.2571  235.4444  235.6593  235.7824  235.8365  235.8935  235.7236  235.0174
    233.1524  233.4564  233.7576  234.0487  234.2810  234.4784  234.7089  234.8724  234.9513  235.0110  234.8411  234.1313
    231.8815  232.2746  232.6575  233.0129  233.3104  233.5225  233.7438  233.9054  233.9761  234.0331  233.8531  233.1405
    230.4757  230.9633  231.4197  231.8246  232.1938  232.4509  232.6860  232.8650  232.9376  233.0028  232.8044  232.0725
    229.1093  229.6795  230.1910  230.6382  231.0478  231.3416  231.5840  231.7833  231.8714  231.9504  231.7594  231.0119
    227.8255  228.4536  229.0083  229.4913  229.9366  230.2571  230.4803  230.6703  230.7640  230.8540  230.6667  229.9118
    226.2498  226.9486  227.5785  228.1442  228.6685  229.0496  229.2663  229.4389  229.5418  229.6437  229.4729  228.7309

[Matt J]

In other words, you now want mean and standard deviation over 32x32x3 blocks? Just give the blocksize [32,32,3] or [32,32,inf] to sepblockfun instead, rather than just [32,32].

Answer 4

[Image Analyst]

See the FAQ: http://matlab.wikia.com/wiki/FAQ#How_do_I_split_an_image_into_non-overlapping_blocks.3F

Answer 5

[Image Analyst]

See attached demos for blockproc(). Adapt as needed.

[Prachi Sharma]

@Imageanalyst...I am studying and trying to understand blockproc along with distinct block processing for further understanding from the files you have attached.

Answer 6

[Image Analyst]

Why not just use conv2() or imfilter() to compute the mean in a moving window, then subsample? For variance, you can use stdfilt() and then subsample, then square it to get the variance.

[Matt J]

The amount you end up discarding is considerable. You keep only 1/N^2 of the computations for NxN tiling. I suppose the waste may not matter as much in a parallelized/GPU implementation.

[Prachi Sharma]

@MattJ...Trying to apply what you suggested in this part below-

In other words, you now want mean and standard deviation over 32x32x3 blocks? Just give the blocksize [32,32,3] or [32,32,inf] to sepblockfun instead, rather than just [32,32].

[Prachi Sharma]

@ImageAnalyst and @MattJ....In between I have tried coding it with a little bit different technique.It is working.Still trying to do with the approaches of blockproc and sepblockfun as you guys suggested.

This is my code-

 function [AVG,nstd]=readim(b)

    a=imresize(b,[512 512]);

    scale=512/32;

    for i=1:scale

        for j=1:scale
            block2=a((i-1)*32+1:i*32,(j-1)*32+1:j*32);
            AVG(i,j)=mean(mean(a(i:i+32,j:j+32)));
            nstd(i,j)=std2(a(i:i+32,j:j+32));

        end
    end