1. pip install sewar
2. from numpy.random import randint
3. from numpy.random import rand
4. import numpy as np
5. from PIL import Image
6. import cv2
7. import os
8. import random
9. from skimage import metrics
10. import argparse
11. from sewar.full_ref import mse
12. import pandas as pd
13. import glob
14. import time
15. from google.colab import drive
16. drive.mount('/content/drive')
17. !unzip "/content/drive/My Drive/zbiór_danych/tiny-imagenet-200-gray.zip"
18.  
19. def fitness(x, path):
20.     im_pil = Image.open(path)
21.     im_pil.save("picture.jpeg", qtables = {0: list(map(int, x))} )
22.     im_pil2 = Image.open("picture.jpeg")
23.  
24.     imageA = np.array(im_pil)
25.     if(len(imageA.shape)==3):
26.         imageA = imageA[:, :, ::-1]
27.         grayA = cv2.cvtColor(imageA, cv2.COLOR_BGR2GRAY)
28.     else:
29.         grayA = imageA
30.  
31.     imageB = np.array(im_pil2)
32.     if(len(imageB.shape)==3):
33.         imageB = imageB[:, :, ::-1]
34.         grayB = cv2.cvtColor(imageB, cv2.COLOR_BGR2GRAY)
35.     else:
36.         grayB = imageB
37.    
38.     score = mse(grayA,grayB)
39.     compression = os.path.getsize("picture.jpeg")/os.path.getsize(path)
40.     return score + 30 * compression
41.  
42. def decode(bounds, n_bits, bitstring):
43.     decoded = list()
44.     largest = 2**n_bits
45.     for i in range(len(bounds)):
46.         start, end = i * n_bits, (i * n_bits)+n_bits
47.         substring = bitstring[start:end]
48.         chars = ''.join([str(s) for s in substring])
49.         integer = int(chars, 2)
50.         value = bounds[i][0] + int((integer/largest) * (bounds[i][1] - bounds[i][0]))
51.         decoded.append(value)
52.     return decoded
53.  
54. def selection_ranking(pop, scores, k):
55.     pop = [y for _,y in sorted(zip(scores,pop),key=lambda x: x[0])]
56.     pop[0:k] = pop[len(pop)-k:len(pop)]  
57.     return pop
58.  
59. def crossover(p1, p2, r_cross):
60.     c1, c2 = p1.copy(), p2.copy()
61.     if rand() < r_cross:
62.         pt = randint(1, len(p1)-2)
63.         c1 = p1[:pt] + p2[pt:]
64.         c2 = p2[:pt] + p1[pt:]
65.     return [c1, c2]
66.  
67. def mutation(bitstring, r_mut):
68.     for i in range(len(bitstring)):
69.         if rand() < r_mut:
70.             bitstring[i] = 1 - bitstring[i]
71.      
72. def genetic_algorithm(fitness, bounds, n_bits, n_iter, n_pop, r_cross, r_mut, start_value, path):
73.     new_x = [int(example * 2**n_bits / bounds[0][1]) for example in start_value]
74.     newList = list()
75.     for j in new_x:
76.         newList.extend([int(x) for x in bin(j)[2:].zfill(n_bits)])
77.     pop = [newList for _ in range(n_pop)]
78.     best, best_eval = pop[0], fitness(decode(bounds, n_bits, pop[0]),path)
79.     for gen in range(n_iter):
80.         decoded = [decode(bounds, n_bits, p) for p in pop]
81.         scores = [fitness(d,path) for d in decoded]
82.         for i in range(n_pop):
83.             if scores[i] < best_eval:
84.                 best, best_eval = pop[i], scores[i]
85.                 print(">%d, new best f(%s) = %f" % (gen,  decoded[i], scores[i]))
86.         selected = selection_ranking(pop, scores, 5)
87.         children = list()
88.         for i in range(0, n_pop, 2):
89.             p1, p2 = selected[i], selected[i+1]
90.             for c in crossover(p1, p2, r_cross):
91.                 mutation(c, r_mut)
92.                 children.append(c)
93.         pop = children
94.     return [best, best_eval]
95.  
96. def data_preparation(path, quality):
97.     im_pil = Image.open(path)
98.     im_pil.save("picture.jpeg", quality = quality)
99.     im_pil2 = Image.open("picture.jpeg")
100.     imageA = np.array(im_pil)
101.     if(len(imageA.shape)==3):
102.         imageA = imageA[:, :, ::-1]
103.         grayA = cv2.cvtColor(imageA, cv2.COLOR_BGR2GRAY)
104.     else:
105.         grayA = imageA
106.  
107.     imageB = np.array(im_pil2)
108.     if(len(imageB.shape)==3):
109.         imageB = imageB[:, :, ::-1]
110.         grayB = cv2.cvtColor(imageB, cv2.COLOR_BGR2GRAY)
111.     else:
112.         grayB = imageB
113.    
114.     (score_structural_similarity, diff) = metrics.structural_similarity(grayA, grayB, full=True)
115.     compression = os.path.getsize("picture.jpeg")/os.path.getsize(path)
116.     score_mse = mse(grayA,grayB)
117.     return [score_structural_similarity,compression,score_mse, im_pil2.quantization[0]]
118.  
119. def test(x, path):
120.     qtable = list(map(int, x))
121.     array = {0: qtable}
122.     im_pil = Image.open(path)
123.     im_pil.save("picture.jpeg", qtables = array)
124.     im_pil2 = Image.open("picture.jpeg")
125.  
126.     imageA = np.array(im_pil)
127.     if(len(imageA.shape)==3):
128.         imageA = imageA[:, :, ::-1]
129.         grayA = cv2.cvtColor(imageA, cv2.COLOR_BGR2GRAY)
130.     else:
131.         grayA = imageA
132.  
133.     imageB = np.array(im_pil2)
134.     if(len(imageB.shape)==3):
135.         imageB = imageB[:, :, ::-1]
136.         grayB = cv2.cvtColor(imageB, cv2.COLOR_BGR2GRAY)
137.     else:
138.         grayB = imageB
139.  
140.     (score_structural_similarity, diff) = metrics.structural_similarity(grayA, grayB, full=True)
141.     score_mse = mse(grayA,grayB)                            
142.     compression = os.path.getsize("picture.jpeg")/os.path.getsize(path)
143.    
144.     return [score_structural_similarity,compression,score_mse]
145.  
146. arr = os.listdir("tiny-imagenet-200-gray/")
147. arr.sort()
148.  
149. index = 0
150.  
151. quality_list = [70,80,85,90]
152. index_quality = -1
153.  
154. if os.path.exists('/content/drive/My Drive/zbiór_danych/quantization_tables_gray.csv'):
155.     df = pd.read_csv('/content/drive/My Drive/zbiór_danych/quantization_tables_gray.csv',index_col=[0])
156.     print(df)
157.     index = arr.index(df.iloc[-1]["name"])
158.     index_quality = quality_list.index(df.iloc[-1]["quality"])
159.     if df.iloc[-1]["quality"] == 90:
160.       index = index + 1
161.       index_quality = -1
162. else:
163.     df = pd.DataFrame(columns=['name','quantization table','quality', 'mse', 'compression'])
164.  
165. start_flag = True
166. print('Index: ' + str(index))
167.  
168.    
169. for name in arr[index:]:
170.     quality_list = [70,80,85,90]
171.     if start_flag:
172.       quality_list = quality_list[index_quality + 1:]
173.     for quality in quality_list:
174.         tic = time.perf_counter()
175.         start_flag = False
176.         print('Quality:'+str(quality))
177.         path = "tiny-imagenet-200-gray/"+name
178.         score_structural_similarity_original,compression_original,score_mse_original, quantization = data_preparation(path, quality)
179.         print('Score structural similarity original: ' + str(score_structural_similarity_original))
180.         print('Compression original: ' + str(compression_original))
181.         print('Score mse original: ' + str(score_mse_original))
182.         flag = False
183.         decoded = []
184.         while flag == False:
185.             best, score = genetic_algorithm(fitness, bounds, n_bits, n_iter, n_pop, r_cross, r_mut, "ranking", 0.001, 1, quantization,path)
186.             print('Done!')
187.             decoded = decode(bounds, n_bits, best)
188.             print('f(%s) = %f' % (decoded, score))
189.             score_structural_similarity, compression, score_mse = test(decoded,path)    
190.             print('Score structural similarity: ' + str(score_structural_similarity))
191.             print('Compression: ' + str(compression))
192.             print('Score mse:' + str(score_mse))
193.             if (score_mse < score_mse_original and compression < compression_original):
194.                 flag = True
195.                 df.loc[len(df.index)] = [name, decoded, quality, score_mse, compression]
196.                 df.to_csv('/content/drive/My Drive/zbiór_danych/quantization_tables_gray.csv')  
197.         toc = time.perf_counter()
198.         print(f"Processed in {toc - tic:0.4f} seconds")