I did this codes but its not working,can anyone figure out whats wrong?

T = imread('tanker.jpg');

imag = T;

[m, n] = size(imag);

m

n

 figure, imshow(imag)

 I2 = zeros(floor(m/2),floor(n/2));
 % Initializing the new image by setting it to zero. 
 %Floor function round each element of variable to the nearest integer less than or equal to that element.
for row = 1 : floor(m/2)
for col = 1 : floor(n/2)
     img50 = imresize(imag, 0.5)
end
end
figure, imshow(img50, [])

[Meghana Dinesh]

What is your requirement?

[Meesha Lini Eesan]

To subsample the image to be half of the original image size

Answer 1

[Konstantinos Sofos]

Hi,

Resize an image using imresize

If you have the Image processing toolbox installed then you could use imresize

    I = imread('tanker.jpg');
    J = imresize(I, 0.5);
    figure, imshow(I), figure, imshow(J)

Resize an image with bilinear interpolation without imresize

Before I start with any code, I'm going to refer you to Richard Alan Peters' II digital image processing lecture. It has a great illustration as well as pseudocode on how to do bilinear interpolation that is MATLAB friendly. To be self-contained, I'm going to include his slide here so we can follow along and code it:

Let's write a routine that will do this for us. This function will take in an image (that is read in through imread ) which can be either colour or grayscale, as well as an array of two elements - The image you want to resize and the output dimensions in a two-element array of the final resized image you want. The first element of this array will be the rows and the second element of this array will be the columns. We will simply go through this algorithm and calculate the output pixel colours / grayscale values using this pseudocode:

    function [out] = bilinearInterpolation(im, out_dims)

        %// Get some necessary variables first
        in_rows = size(im,1);
        in_cols = size(im,2);
        out_rows = out_dims(1);
        out_cols = out_dims(2);

        %// Let S_R = R / R'        
        S_R = in_rows / out_rows;
        %// Let S_C = C / C'
        S_C = in_cols / out_cols;

        %// Define grid of co-ordinates in our image
        %// Generate (x,y) pairs for each point in our image
        [cf, rf] = meshgrid(1 : out_cols, 1 : out_rows);

        %// Let r_f = r'*S_R for r = 1,...,R'
        %// Let c_f = c'*S_C for c = 1,...,C'
        rf = rf * S_R;
        cf = cf * S_C;

        %// Let r = floor(rf) and c = floor(cf)
        r = floor(rf);
        c = floor(cf);

        %// Any values out of range, cap
        r(r < 1) = 1;
        c(c < 1) = 1;
        r(r > in_rows - 1) = in_rows - 1;
        c(c > in_cols - 1) = in_cols - 1;

        %// Let delta_R = rf - r and delta_C = cf - c
        delta_R = rf - r;
        delta_C = cf - c;

        %// Final line of algorithm
        %// Get column major indices for each point we wish
        %// to access
        in1_ind = sub2ind([in_rows, in_cols], r, c);
        in2_ind = sub2ind([in_rows, in_cols], r+1,c);
        in3_ind = sub2ind([in_rows, in_cols], r, c+1);
        in4_ind = sub2ind([in_rows, in_cols], r+1, c+1);       

        %// Now interpolate
        %// Go through each channel for the case of colour
        %// Create output image that is the same class as input
        out = zeros(out_rows, out_cols, size(im, 3));
        out = cast(out, class(im));

        for idx = 1 : size(im, 3)
            chan = double(im(:,:,idx)); %// Get i'th channel
            %// Interpolate the channel
            tmp = chan(in1_ind).*(1 - delta_R).*(1 - delta_C) + ...
                           chan(in2_ind).*(delta_R).*(1 - delta_C) + ...
                           chan(in3_ind).*(1 - delta_R).*(delta_C) + ...
                           chan(in4_ind).*(delta_R).*(delta_C);
            out(:,:,idx) = cast(tmp, class(im));
        end

As an example to show this works, let's use the onion.png image that is part of MATLAB's system path. The original dimensions of this image are 135 x 198. Let's interpolate this image by making it larger, going to 270 x 396 which is twice the size of the original image:

    im = imread('onion.png');
    out = bilinearInterpolation(im, [270 396]);
    figure;
    imshow(im);
    figure;
    imshow(out);

The above code will interpolate the image by increasing each dimension by twice as much, then show a figure with the original image and another figure with the scaled up image. This is what I get for both:

Answer 2

[Image Analyst]

Try this:

T = imread('tanker.jpg');
smallT = T(1:2:end, 1:2:end, :);  % Extract every second pixel.