Added codex folder with exercise 3 (incomplete)

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

Quantization/quantize_matrix.m

@@ -1,5 +1,5 @@
 function quantized_matrix = quantize_matrix(matrix, new_bytesize)
-    quantized_matrix = zeros(size(matrix,1),size(matrix,2),'uint8');
+    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);

Transformation/haar_reverse.m

@@ -8,13 +8,13 @@
 end
 
 function haar_matrix = revert_haar(matrix)
-    haar_matrix = zeros(size(matrix,1),size(matrix,2));
+    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) = matrix(row,col) + matrix(row,col + half_col);
-            haar_matrix(row,i+1) = matrix(row,col) - matrix(row,col + 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

Transformation/haar_reverse_multilevel.m

@@ -1,5 +1,5 @@
 function haar_matrix = haar_reverse_multilevel(original_matrix, n_transforms)
-    haar_matrix = original_matrix;
+    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);

Transformation/haar_reverse_multilevel2.m

@@ -12,13 +12,13 @@
 end
 
 function haar_matrix = haar_pass(matrix)
-    haar_matrix = zeros(size(matrix,1),size(matrix,2));
+    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;
-            c = (double(matrix(row,col)) - double(matrix(row,col+1)))/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

Transformation/haar_transform.m

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

Transformation/haar_transform_multilevel.m

@@ -55,4 +55,4 @@
 %function dequantization = dequantize(pixel, delta)
     % Operation avg*Pixel+avg changed to:
 %    dequantization=  delta*(double(pixel) + 0.5);
-%end
+%end