Why is my bilinear interpolation vastly different

I've been working on bilinear interpolation based on wiki example in matlab. I followed the example to the T, but when comparing the outputs from my function and the in-built matlab function, the results are vastly different and I can't figure out why or how that happens.

Using inbuilt matlab function:

Result of my function below:

function T = bilinear(X,h,w)
%pre-allocating the output size
T = uint8(zeros(h,w));
%padding the original image with 0 so i don't go out of bounds
X = padarray(X,[2,2],'both');
%calculating dimension ratios
hr = h/size(X,1);
wr = w/size(X,2);

for row = 3:h-3
    for col = 3:w-3
        %for calculating equivalent position on the original image
        o_row = ceil(row/hr);
        o_col = ceil(col/wr);
        %getting the intensity values from horizontal neighbors
        Q12=X(o_row+1,o_col-1);
        Q22=X(o_row+1,o_col+1);
        Q11=X(o_row-1,o_col-1);
        Q21=X(o_row-1,o_col+1);
        %calculating the relative positions to the enlarged image
        y2=round((o_row-1)*hr);
        y=round(o_row*hr);
        y1=round((o_row+1)*hr);
        x1=round((o_col-1)*wr);
        x=round(o_col*wr);
        x2=round((o_col+1)*wr);
        %interpolating on 2 first axis and the result between them
        R1=((x2-x)/(x2-x1))*Q11+((x-x1)/(x2-x1))*Q21;
        R2=((x2-x)/(x2-x1))*Q12+((x-x1)/(x2-x1))*Q22;
        P=round(((y2-y)/(y2-y1))*R1+((y-y1)/(y2-y1))*R2);
        T(row,col) = P;

        T = uint8(T);
        end    
    end
end

The arguments passed to the function are step4 = bilinear(Igray,1668,1836); (scale factor of 3).

You are finding the pixel nearest to the point you want to interpolate, then find 4 of this pixel’s neighbors and interpolate between them:

o_row = ceil(row/hr);
o_col = ceil(col/wr);
Q12=X(o_row+1,o_col-1);
Q22=X(o_row+1,o_col+1);
Q11=X(o_row-1,o_col-1);
Q21=X(o_row-1,o_col+1);

Instead, find the 4 pixels nearest the point you want to interpolate:

o_row = ceil(row/hr);
o_col = ceil(col/wr);
Q12=X(o_row,o_col-1);
Q22=X(o_row,o_col);
Q11=X(o_row-1,o_col-1);
Q21=X(o_row-1,o_col);

The same pixel’s coordinates then need to be used when computing distances. The easiest way to do that is to separate out the floating-point coordinates of the output pixel ((row,col)) in the input image (o_row,o_col), and the location of the nearest pixel in the input image (fo_row,fo_col). Then, the distances are simply d_row = o_row - fo_row and 1-d_row, etc.

This is how I would write this function:

function T = bilinear(X,h,w)
% Pre-allocating the output size
T = zeros(h,w,'uint8');            % Create the matrix in the right type, rather than cast !!
% Calculating dimension ratios 
hr = h/size(X,1);                  % Not with the padded sizes!!
wr = w/size(X,2);
% Padding the original image with 0 so I don't go out of bounds
pad = 2;
X = padarray(X,[pad,pad],'both');
% Loop
for col = 1:w                      % Looping over the row in the inner loop is faster!!
   for row = 1:h
      % For calculating equivalent position on the original image
      o_row = row/hr;
      o_col = col/wr;
      fo_row = floor(o_row);       % Code is simpler when using floor here !!
      fo_col = floor(o_col);
      % Getting the intensity values from horizontal neighbors
      Q11 = double(X(fo_row  +pad, fo_col  +pad));  % Indexing taking padding into account !!
      Q21 = double(X(fo_row+1+pad, fo_col  +pad));  % Casting to double might not be necessary, but MATLAB does weird things with integer computation !!
      Q12 = double(X(fo_row  +pad, fo_col+1+pad));
      Q22 = double(X(fo_row+1+pad, fo_col+1+pad));
      % Calculating the relative positions to the enlarged image
      d_row = o_row - fo_row;
      d_col = o_col - fo_col;
      % Interpolating on 2 first axis and the result between them
      R1 = (1-d_row)*Q11 + d_row*Q21;
      R2 = (1-d_row)*Q12 + d_row*Q22;
      T(row,col) = round((1-d_col)*R1 + d_col*R2);
   end
end
end