Merge pull request #1 from yolanda93/iuya

Merge between master and iuya branch

Author: iuya

Codec/codec.m

@@ -0,0 +1,98 @@
+% Part 3. Implementation of a codec
+% 1. Load image/lena_gray_512.tif
+% Use the double haar transform.
+lena_haar = haar_transform_multilevel(lena_gray_512,2);
+% Let's see the histogram for each sub-band
+% First we divide the matrix into submatrices
+% We have 3x3 sub-bands
+sub11 = lena_haar(1:128,1:128);
+sub12 = lena_haar(1:128,129:256);
+sub13 = lena_haar(129:256,1:128);
+sub14 = lena_haar(129:256,129:256);
+sub21 = lena_haar(1:256,257:512);
+sub22 = lena_haar(257:512,1:256);
+sub23 = lena_haar(257:512,257:512);
+figure
+subplot(4,4,1)
+imshow(sub11,[0,255])
+subplot(4,4,2)
+imshow(sub12,[0,255])
+subplot(4,4,5)
+imshow(sub13,[0,255])
+subplot(4,4,6)
+imshow(sub14,[0,255])
+% Now for the bigger subbands we are going to use bigger subplots
+subplot(4,4,[3:4 7:8])
+imshow(sub21,[0,255])
+subplot(4,4,[9:10 13:14])
+imshow(sub22,[0,255])
+subplot(4,4,[11:12 15:16])
+imshow(sub23,[0,255])
+
+% We are going to use the same subplot distribution to show the histogram
+% of each sub image
+% Since imhist only uses values from 0 to 1,
+% we need to move everything 256 values up (to make the negative numbers)
+% possitive and then divide by 512 to obtain values from 0 to 1.
+% In this scale, the old 0 is at 0.5, -255 at 0 and 255 at 1.
+figure
+subplot(4,4,1)
+imhist((sub11+255)./512)
+subplot(4,4,2)
+imhist((sub12+255)./512)
+subplot(4,4,5)
+imhist((sub13+255)./512)
+subplot(4,4,6)
+imhist((sub14+255)./512)
+% Now for the bigger subbands we are going to use bigger subplots
+subplot(4,4,[3:4 7:8])
+imhist((sub21+255)./512)
+subplot(4,4,[9:10 13:14])
+imhist((sub22+255)./512)
+subplot(4,4,[11:12 15:16])
+imhist((sub23+255)./512)
+
+% After looking at the distribution of data, we should use a non-uniform
+% scalar quantizer and with a smaller quantization step around 0, but since
+% we only have a uniform scalar quantizer, we will use that.
+% No Quantization for the ll part of the image (sub 11)
+
+
+
+% Need to count all the appearances of each number
+entropies = zeros(7,8);
+for i= 7:-1:1
+    q_sub11 = quantize_matrix(sub11,8);
+    q_sub12 = quantize_matrix(sub12,i);
+    q_sub13 = quantize_matrix(sub13,i);
+    q_sub14 = quantize_matrix(sub14,i);
+    q_sub21 = quantize_matrix(sub21,i);
+    q_sub22 = quantize_matrix(sub22,i);
+    q_sub23 = quantize_matrix(sub23,i);
+    e_sub11 = shannonEntropy(q_sub11);
+    e_sub12 = shannonEntropy(q_sub12);
+    e_sub13 = shannonEntropy(q_sub13);
+    e_sub14 = shannonEntropy(q_sub14);
+    e_sub21 = shannonEntropy(q_sub21);
+    e_sub22 = shannonEntropy(q_sub22);
+    e_sub23 = shannonEntropy(q_sub23);
+    q_lena = quantize_matrix(lena_haar,i);
+    q_lena(1:128,1:128) = q_sub11;
+    e_lena = shannonEntropy(q_lena);
+    dict = huffmanDict(q_lena);
+    sizeMap = containers.Map('KeyType','double', 'ValueType','any');
+    for row = 1:size(dict,1)
+        keyCell = dict(row,1);
+        valueCell = dict(row,2);
+        code = valueCell{1};
+        key = keyCell{1};
+        sizeMap(key) = size(code,2);
+    end
+    %SizeMap holds the lengths of all the symbols
+    % TODO subtitute the symbols by their length and add all the elements
+    % of the matrix, then divide by the nuelem of the matrix
+    entropies(i,:) = [e_sub11, e_sub12, e_sub13, e_sub14, e_sub21, e_sub22, e_sub23, e_lena];
+end 
+entropies
+
+

Codec/huffmanDict.m

@@ -0,0 +1,7 @@
+function dict = huffmanDict(matrix)
+    a = unique(matrix);
+    count = numel(matrix);
+    out = [a,histc(matrix(:),a)/count];
+    p = out(:,2);
+    dict = huffmandict(a,p);
+end

Codec/shannonEntropy.m

@@ -0,0 +1,8 @@
+function bitsPerSymbol = shannonEntropy(matrix)
+    a = unique(matrix);
+    count = numel(matrix);
+    out = [a,histc(matrix(:),a)/count];
+    p = out(:,2);
+    H = sum(-(p(p>0).*(log2(p(p>0))))); % Shannon entropy formula
+    bitsPerSymbol = H;
+end

Documents/TD2016.pdf

@@ -0,0 +1,20 @@
+% dequantize_matrix:
+% Uniformly proyects a matrix with a number of levels (2^old_bytesize)
+% into a new matrix with a number of levels (2^new_bytesize)
+%  
+% Correct behaviour only when: 
+%   new_bytesize >= old_bytesize
+function dequantized_matrix = dequantize_matrix(matrix, old_bytesize, new_bytesize)
+    delta = 2^(new_bytesize-old_bytesize);
+    dequantized_matrix = zeros(size(matrix,1),size(matrix,2),'uint8');
+    for row = 1:size(matrix,1)
+        for col = 1:size(matrix,2)
+            dequantized_matrix(row,col) = dequantize(matrix(row,col), delta);
+        end
+    end
+end
+
+function dequantization = dequantize(pixel, delta)
+    % Operation avg*Pixel+avg changed to:
+    dequantization = delta*(double(pixel) + 0.5);
+end

Quantization/dequantization.m

@@ -0,0 +1,13 @@
+function quantized_matrix = quantize_matrix(matrix, new_bytesize)
+    quantized_matrix = zeros(size(matrix,1),size(matrix,2),'double');
+    for row = 1:size(matrix,1)
+        for col = 1:size(matrix,2)
+            quantized_matrix(row,col) = quantize(matrix(row,col), new_bytesize);
+        end
+    end
+end
+
+function quantization = quantize(pixel, new_bytesize)
+    dif_levels = 2^(8-new_bytesize);
+    quantization=floor(double(pixel)/dif_levels);
+end

Quantization/dequantize_matrix.m

@@ -0,0 +1,21 @@
+% haar_reverse:
+% Given an input haar_transform image of 256 levels, undo the transform.
+function haar_matrix = haar_reverse(original_matrix)
+    temp_matrix = transpose(original_matrix);
+    temp_matrix = revert_haar(temp_matrix);
+    temp_matrix = transpose(temp_matrix);
+    haar_matrix = revert_haar(temp_matrix);
+end
+
+function haar_matrix = revert_haar(matrix)
+    haar_matrix = zeros(size(matrix,1),size(matrix,2),'double');
+    half_col = size(matrix,2)/2;
+    for row = 1:size(matrix,1)
+        i = 1;
+        for col = 1:half_col
+            haar_matrix(row,i) = double(matrix(row,col)) + matrix(row,col + half_col);
+            haar_matrix(row,i+1) = double(matrix(row,col)) - matrix(row,col + half_col);
+            i = i + 2;
+        end
+    end
+end

Quantization/quantization.m

@@ -0,0 +1,8 @@
+function haar_matrix = haar_reverse_multilevel(original_matrix, n_transforms)
+    haar_matrix = double(original_matrix);
+    for i = n_transforms-1:-1:0
+        rows = 1:(size(haar_matrix,1)/2^i);
+        columns = 1:(size(haar_matrix,1)/2^i);
+        haar_matrix(rows,columns) = haar_reverse(haar_matrix(rows,columns));
+    end
+end

Quantization/quantization2.m

@@ -0,0 +1,26 @@
+% haar_transform:
+% Given an input greyscale image of 256 levels, apply the harr transform
+% to it.
+% Will apply the transform first to the rows and then to the columns
+% Parameteres:
+%   matrix: the image to be transformed
+function haar_matrix = haar_transform(original_matrix)
+    temp_matrix = haar_pass(original_matrix);
+    temp_matrix = transpose(temp_matrix);
+    temp_matrix = haar_pass(temp_matrix);
+    haar_matrix = transpose(temp_matrix);
+end
+
+function haar_matrix = haar_pass(matrix)
+    haar_matrix = zeros(size(matrix,1),size(matrix,2),'double');
+    half_col = size(matrix,2)/2;
+    for row = 1:size(matrix,1)
+        i = 1;
+        for col = 1:2:size(matrix,2)
+            haar_matrix(row,i) = (double(matrix(row,col)) + double(matrix(row,col+1)))/2.0;
+            c = (double(matrix(row,col)) - double(matrix(row,col+1)))/2.0;
+            haar_matrix(row,i+half_col) = c ;
+            i = i + 1;
+        end
+    end
+end

Quantization/quantize_matrix.m

@@ -0,0 +1,8 @@
+function haar_matrix = haar_transform_multilevel(original_matrix, n_transforms)
+    haar_matrix = double(original_matrix);
+    for i = 1:n_transforms
+        rows = 1:size(haar_matrix,1)/i;
+        columns = 1:size(haar_matrix,1)/i;
+        haar_matrix(rows,columns) = haar_transform(haar_matrix(rows,columns));
+    end
+end

Test-images/cameraman.tif

@@ -0,0 +1,58 @@
+% figure 1
+%for i = 1:8
+%    temp = quantize_matrix(lena_gray_512,i);
+%    subplot(2,4,i,'replace')
+%    imshow(temp,[0,2^(i)-1]);
+%end
+
+%figure 2
+%for i = 1:8
+%    temp = quantize_matrix(lena_gray_512,i);
+%    temp2 = dequantize_matrix(temp,i,8);
+%    subplot(2,4,i,'replace')
+%    imshow(temp2);
+%end
+
+%zeros(8,N,M)
+
+%for j = 1:8
+%    output=zeros(256,1);
+%    delta = 2^(8-j);
+%    for i = 0:255
+%        output(i+1,1) = dequantize(quantize(i,j),delta);
+%    end
+%    subplot(2,4,j,'replace')
+%    plot(0:255,output(:,1));
+%    axis([0,255,0,255])
+%end
+
+%for j = 1:8
+%    output=zeros(256,1);
+%    for i = 0:255
+%        output(i+1,1) = quantize(i,j);
+%    end
+%    subplot(2,4,j,'replace')
+%    plot(0:255,output(:,1));
+%    axis([0,255,0,2^(j)])
+%end
+
+%results = zeros(8,1);
+%for i = 1:8
+%    temp = dequantize_matrix(quantize_matrix(lena_gray_512,i),i,8);
+%    D = abs(lena_gray_512-temp).^2;
+%    MSE = sum(D(:))/numel(lena_gray_512);
+%    results(i,1) = MSE;
+%end
+%plot(1:8,results);
+
+
+   
+%function quantization = quantize(pixel, new_bytesize)
+%    dif_levels = 2^(8-new_bytesize);
+%    quantization=floor(double(pixel)/double(dif_levels));
+%end
+
+%function dequantization = dequantize(pixel, delta)
+    % Operation avg*Pixel+avg changed to:
+%    dequantization=  delta*(double(pixel) + 0.5);
+%end