%	LWP returns the local wavelet pattern histogram of an image.
%   The original code of LBP is used and updated to the LWP by Shiv Ram Dubey, IIIT Allahabad
%   This code can be used only for the academic and research purposes and can not be used for any commercial purposes.
%   Cite the paper 'Shiv Ram Dubey, Satish Kumar Singh, Rajat Kumar Singh, 
%	"Local Wavelet Pattern: A New Feature Descriptor for Image Retrieval in Medical CT Databases," 
%	IEEE Transactions on Image Processing, vol. 24, no. 12, pp. 5892-5903, 2015',
%		In case you are using this code.

function h11=LWP(path_image)
% path_image='datasets\tcia-ct\01\tcia_ct_colo_prone (1).jpg';
img=imread(path_image);
if length(size(img))==3
    img=rgb2gray(img);
end
%  J = lwp1(I,R,N,MAPPING,MODE) returns a LWP histogram of an intensity image I. 
%  Use mapping as 0 for (i.e. no mapping).
%  The only MODE we used is 'h' or 'hist' to get a histogram of mdLBP codes.
h11=lwp1(img,1,8,0,'h');
h11=h11/sum(h11);
end





function result = lwp1(varargin) % image,radius,neighbors,mapping,mode)

max_level=2; % Define the level of wavelet decomposition

error(nargchk(1,5,nargin));
image=varargin{1};
d_image=double(image);

if nargin==1
    spoints=[-1 -1; -1 0; -1 1; 0 -1; -0 1; 1 -1; 1 0; 1 1];
    neighbors=8;
    mapping=0;
    mode='h';
end

if (nargin == 2) && (length(varargin{2}) == 1)
    error('Input arguments');
end

if (nargin > 2) && (length(varargin{2}) == 1)
    radius=varargin{2};
    neighbors=varargin{3};
    
    spoints=zeros(neighbors,2);

    % Angle step.
    a = 2*pi/neighbors;
    
    for i = 1:neighbors
        spoints(i,1) = -radius*sin((i-1)*a);
        spoints(i,2) = radius*cos((i-1)*a);
    end
    
    if(nargin >= 4)
        mapping=varargin{4};
        if(isstruct(mapping) && mapping.samples ~= neighbors)
            error('Incompatible mapping');
        end
    else
        mapping=0;
    end
    
    if(nargin >= 5)
        mode=varargin{5};
    else
        mode='h';
    end
end

if (nargin > 1) && (length(varargin{2}) > 1)
    spoints=varargin{2};
    neighbors=size(spoints,1);
    
    if(nargin >= 3)
        mapping=varargin{3};
        if(isstruct(mapping) && mapping.samples ~= neighbors)
            error('Incompatible mapping');
        end
    else
        mapping=0;
    end
    
    if(nargin >= 4)
        mode=varargin{4};
    else
        mode='h';
    end   
end

% Determine the dimensions of the input image.
[ysize xsize] = size(image);



miny=min(spoints(:,1));
maxy=max(spoints(:,1));
minx=min(spoints(:,2));
maxx=max(spoints(:,2));

bsizey=ceil(max(maxy,0))-floor(min(miny,0))+1;
bsizex=ceil(max(maxx,0))-floor(min(minx,0))+1;

% Coordinates of origin (0,0) in the block
origy=1-floor(min(miny,0));
origx=1-floor(min(minx,0));

if(xsize < bsizex || ysize < bsizey)
  error('Too small input image. Should be at least (2*radius+1) x (2*radius+1)');
end

dx = xsize - bsizex;dy = ysize - bsizey;
C = image(origy:origy+dy,origx:origx+dx);d_C = double(C);

for i = 1:neighbors
  y = spoints(i,1)+origy;
  x = spoints(i,2)+origx;
  % Calculate floors, ceils and rounds for the x and y.
  fy = floor(y); cy = ceil(y); ry = round(y);
  fx = floor(x); cx = ceil(x); rx = round(x);
  % Check if interpolation is needed.
  if (abs(x - rx) < 1e-6) && (abs(y - ry) < 1e-6)
    % Interpolation is not needed, use original datatypes
    N(:,:,i) = image(ry:ry+dy,rx:rx+dx);
  else
    % Interpolation needed, use double type images 
    ty = y - fy;
    tx = x - fx;

    % Calculate the interpolation weights.
    w1 = (1 - tx) * (1 - ty);
    w2 =      tx  * (1 - ty);
    w3 = (1 - tx) *      ty ;
    w4 =      tx  *      ty ;
    % Compute interpolated pixel values
    N(:,:,i) = w1*d_image(fy:fy+dy,fx:fx+dx) + w2*d_image(fy:fy+dy,cx:cx+dx) + ...
        w3*d_image(cy:cy+dy,fx:fx+dx) + w4*d_image(cy:cy+dy,cx:cx+dx);
end  
end
N=double(N);
tmp=N;

for level=1:max_level
    nb_count=neighbors/(2.^level);
    for i=1:nb_count
        diff(:,:,i+nb_count)=((tmp(:,:,2*i-1)-tmp(:,:,2*i))/1.414) ...
                            > ((2.^(level/2))*d_C-(2.^(level/2-1))*255);
        tmp(:,:,i)=(tmp(:,:,2*i-1)+tmp(:,:,2*i))/1.414; 
    end
    if level==max_level
        for i=1:nb_count
            diff(:,:,i)=tmp(:,:,i) > (2.^(level/2))*d_C;
        end
    end
end

result=zeros(dy+1,dx+1);
for i=1:neighbors
    result=result+diff(:,:,i)*(2.^(i-1)); 
end
bins=2.^neighbors;
result=hist(result(:),0:(bins-1));
end
