Added some more method of compression

Author: BryanYehuda

CompressionCheck.py

@@ -19,7 +19,7 @@ def SNR(original, compressed):
 
 def main():
     original = cv2.imread("raw.png")
-    compressed = cv2.imread("lossless.png", 1)
+    compressed = cv2.imread("lossy.png", 1)
     mse = np.mean((original - compressed) ** 2)
     snr = SNR(original, compressed)
     psnr = PSNR(original, compressed)

DCT.py

@@ -0,0 +1,56 @@
+import io
+import os
+from PIL import Image
+import numpy as np
+import matplotlib.pyplot as plt
+from scipy import fftpack
+from urllib.request import urlopen
+import IPython
+
+image_url='file:///D:/downloads/LossyComparison/raw.jpg'
+def get_image_from_url(image_url='http://i.imgur.com/8vuLtqi.png', size=(128, 128)):
+    file_descriptor = urlopen(image_url)
+    image_file = io.BytesIO(file_descriptor.read())
+    image = Image.open(image_file)
+    img_color = image.resize(size, 1)
+    img_grey = img_color.convert('L')
+    img = np.array(img_grey, dtype=float)
+    return img
+
+def get_2D_dct(img):
+    return fftpack.dct(fftpack.dct(img.T, norm='ortho').T, norm='ortho')
+
+def get_2d_idct(coefficients):
+    return fftpack.idct(fftpack.idct(coefficients.T, norm='ortho').T, norm='ortho')
+
+def get_reconstructed_image(raw):
+    img = raw.clip(0, 255)
+    img = img.astype('uint8')
+    img = Image.fromarray(img)
+    return img
+
+pixels = get_image_from_url(image_url=image_url, size=(256, 256))
+dct_size = pixels.shape[0]
+dct = get_2D_dct(pixels)
+reconstructed_images = []
+
+for ii in range(dct_size):
+    dct_copy = dct.copy()
+    dct_copy[ii:,:] = 0
+    dct_copy[:,ii:] = 0
+    
+    r_img = get_2d_idct(dct_copy);
+    reconstructed_image = get_reconstructed_image(r_img);
+    reconstructed_images.append(reconstructed_image);
+
+fig = plt.figure(figsize=(16, 16))
+for ii in range(64):
+    plt.subplot(8, 8, ii + 1)
+    plt.imshow(reconstructed_images[ii], cmap=plt.cm.gray)
+    plt.grid(False);
+    plt.xticks([]);
+    plt.yticks([]);
+    if ii == 63:
+        plt.imsave('hasilDCT.jpg', reconstructed_images[ii], cmap=plt.cm.gray);
+    
+plt.show();

Fractal.py

@@ -0,0 +1,187 @@
+import matplotlib.pyplot as plt
+import matplotlib.image as mpimg
+from scipy import ndimage
+from scipy import optimize
+import numpy as np
+import math
+
+# Manipulate channels
+
+def get_greyscale_image(img):
+    return np.mean(img[:,:,:2], 2)
+
+def extract_rgb(img):
+    return img[:,:,0], img[:,:,1], img[:,:,2]
+
+def assemble_rbg(img_r, img_g, img_b):
+    shape = (img_r.shape[0], img_r.shape[1], 1)
+    return np.concatenate((np.reshape(img_r, shape), np.reshape(img_g, shape), 
+        np.reshape(img_b, shape)), axis=2)
+
+# Transformations
+
+def reduce(img, factor):
+    result = np.zeros((img.shape[0] // factor, img.shape[1] // factor))
+    for i in range(result.shape[0]):
+        for j in range(result.shape[1]):
+            result[i,j] = np.mean(img[i*factor:(i+1)*factor,j*factor:(j+1)*factor])
+    return result
+
+def rotate(img, angle):
+    return ndimage.rotate(img, angle, reshape=False)
+
+def flip(img, direction):
+    return img[::direction,:]
+
+def apply_transformation(img, direction, angle, contrast=1.0, brightness=0.0):
+    return contrast*rotate(flip(img, direction), angle) + brightness
+
+# Contrast and brightness
+
+def find_contrast_and_brightness1(D, S):
+    # Fix the contrast and only fit the brightness
+    contrast = 0.75
+    brightness = (np.sum(D - contrast*S)) / D.size
+    return contrast, brightness 
+
+def find_contrast_and_brightness2(D, S):
+    # Fit the contrast and the brightness
+    A = np.concatenate((np.ones((S.size, 1)), np.reshape(S, (S.size, 1))), axis=1)
+    b = np.reshape(D, (D.size,))
+    x, _, _, _ = np.linalg.lstsq(A, b)
+    #x = optimize.lsq_linear(A, b, [(-np.inf, -2.0), (np.inf, 2.0)]).x
+    return x[1], x[0]
+
+# Compression for greyscale images
+
+def generate_all_transformed_blocks(img, source_size, destination_size, step):
+    factor = source_size // destination_size
+    transformed_blocks = []
+    for k in range((img.shape[0] - source_size) // step + 1):
+        for l in range((img.shape[1] - source_size) // step + 1):
+            # Extract the source block and reduce it to the shape of a destination block
+            S = reduce(img[k*step:k*step+source_size,l*step:l*step+source_size], factor)
+            # Generate all possible transformed blocks
+            for direction, angle in candidates:
+                transformed_blocks.append((k, l, direction, angle, apply_transformation(S, direction, angle)))
+    return transformed_blocks
+
+def compress(img, source_size, destination_size, step):
+    transformations = []
+    transformed_blocks = generate_all_transformed_blocks(img, source_size, destination_size, step)
+    i_count = img.shape[0] // destination_size
+    j_count = img.shape[1] // destination_size
+    for i in range(i_count):
+        transformations.append([])
+        for j in range(j_count):
+            print("{}/{} ; {}/{}".format(i, i_count, j, j_count))
+            transformations[i].append(None)
+            min_d = float('inf')
+            # Extract the destination block
+            D = img[i*destination_size:(i+1)*destination_size,j*destination_size:(j+1)*destination_size]
+            # Test all possible transformations and take the best one
+            for k, l, direction, angle, S in transformed_blocks:
+                contrast, brightness = find_contrast_and_brightness2(D, S)
+                S = contrast*S + brightness
+                d = np.sum(np.square(D - S))
+                if d < min_d:
+                    min_d = d
+                    transformations[i][j] = (k, l, direction, angle, contrast, brightness)
+    return transformations
+
+def decompress(transformations, source_size, destination_size, step, nb_iter=8):
+    factor = source_size // destination_size
+    height = len(transformations) * destination_size
+    width = len(transformations[0]) * destination_size
+    iterations = [np.random.randint(0, 256, (height, width))]
+    cur_img = np.zeros((height, width))
+    for i_iter in range(nb_iter):
+        print(i_iter)
+        for i in range(len(transformations)):
+            for j in range(len(transformations[i])):
+                # Apply transform
+                k, l, flip, angle, contrast, brightness = transformations[i][j]
+                S = reduce(iterations[-1][k*step:k*step+source_size,l*step:l*step+source_size], factor)
+                D = apply_transformation(S, flip, angle, contrast, brightness)
+                cur_img[i*destination_size:(i+1)*destination_size,j*destination_size:(j+1)*destination_size] = D
+        iterations.append(cur_img)
+        cur_img = np.zeros((height, width))
+    return iterations
+
+# Compression for color images
+
+def reduce_rgb(img, factor):
+    img_r, img_g, img_b = extract_rgb(img)
+    img_r = reduce(img_r, factor)
+    img_g = reduce(img_g, factor)
+    img_b = reduce(img_b, factor)
+    return assemble_rbg(img_r, img_g, img_b)
+
+def compress_rgb(img, source_size, destination_size, step):
+    img_r, img_g, img_b = extract_rgb(img)
+    return [compress(img_r, source_size, destination_size, step), \
+        compress(img_g, source_size, destination_size, step), \
+        compress(img_b, source_size, destination_size, step)]
+
+def decompress_rgb(transformations, source_size, destination_size, step, nb_iter=8):
+    img_r = decompress(transformations[0], source_size, destination_size, step, nb_iter)[-1]
+    img_g = decompress(transformations[1], source_size, destination_size, step, nb_iter)[-1]
+    img_b = decompress(transformations[2], source_size, destination_size, step, nb_iter)[-1]
+    return assemble_rbg(img_r, img_g, img_b)
+
+# Plot
+
+def plot_iterations(iterations, target=None):
+    # Configure plot
+    plt.figure()
+    nb_row = math.ceil(np.sqrt(len(iterations)))
+    nb_cols = nb_row
+    # Plot
+    for i, img in enumerate(iterations):
+        plt.subplot(nb_row, nb_cols, i+1)
+        plt.imshow(img, cmap='gray', vmin=0, vmax=255, interpolation='none')
+        if target is None:
+            plt.title(str(i))
+        else:
+            # Display the RMSE
+            plt.title(str(i) + ' (' + '{0:.2f}'.format(np.sqrt(np.mean(np.square(target - img)))) + ')')
+        frame = plt.gca()
+        frame.axes.get_xaxis().set_visible(False)
+        frame.axes.get_yaxis().set_visible(False)
+    plt.tight_layout()
+
+# Parameters
+
+directions = [1, -1]
+angles = [0, 90, 180, 270]
+candidates = [[direction, angle] for direction in directions for angle in angles]
+
+# Tests
+
+def test_greyscale():
+    img = mpimg.imread('raw.jpg')
+    img = get_greyscale_image(img)
+    img = reduce(img, 4)
+    plt.figure()
+    plt.imshow(img, cmap='gray', interpolation='none')
+    transformations = compress(img, 8, 4, 8)
+    iterations = decompress(transformations, 8, 4, 8)
+    plot_iterations(iterations, img)
+    plt.show()
+
+def test_rgb():
+    img = mpimg.imread('raw.jpg')
+    img = reduce_rgb(img, 8)
+    transformations = compress_rgb(img, 8, 4, 8)
+    retrieved_img = decompress_rgb(transformations, 8, 4, 8)
+    plt.figure()
+    plt.subplot(121)
+    plt.imshow(np.array(img).astype(np.uint8), interpolation='none')
+    plt.subplot(122)
+    plt.imshow(retrieved_img.astype(np.uint8), interpolation='none')
+    plt.show()
+    plt.imsave("hasilFractal.jpg",retrieved_img.astype(np.uint8))
+                    
+if __name__ == '__main__':
+    #test_greyscale()
+    test_rgb()

RLE.py

@@ -0,0 +1,47 @@
+import cv2 as cv
+import numpy as np
+
+image = cv.imread('raw.png',1)
+grayimg = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
+rows, cols = grayimg.shape
+image1 = grayimg.flatten() 
+
+for i in range(len(image1)):
+    if image1[i] >= 127:
+        image1[i] = 255
+    if image1[i] < 127:
+        image1[i] = 0
+
+data = []
+image3 = []
+count = 1
+
+for i in range(len(image1)-1):
+    if (count == 1):
+        image3.append(image1[i])
+    if image1[i] == image1[i+1]:
+        count = count + 1
+        if i == len(image1) - 2:
+            image3.append(image1[i])
+            data.append(count)
+    else:
+        data.append(count)
+        count = 1
+
+if(image1[len(image1)-1] != image1[-1]):
+    image3.append(image1[len(image1)-1])
+    data.append(1)
+
+#Compression ratio
+ys_rate = len(image3)/len(image1)*100
+print(str(ys_rate) + '%')
+
+rec_image = []
+for i in range(len(data)):
+    for j in range(data[i]):
+        rec_image.append(image3[i])
+
+rec_image = np.reshape(rec_image,(rows,cols))
+
+cv.imshow('rec_image',rec_image) 
+cv.waitKey(0)