семестр 2 / лабы / lab7

import os
import skimage
import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import minimize
from threading import Thread
import time

#Создание класса-наследника класса Thread с возвращением элементов
class ThreadRV(Thread):

    def __init__(self, group=None, target=None, name=None,
        args=(), kwargs={}, Verbose=None):
        Thread.__init__(self, group, target, name, args, kwargs)
        self._return = None

    def run(self):
        if self._target is not None:
            self._return = self._target(*self._args, ** self._kwargs)

    def result(self):
        return self._return

#Функция вызова потоков
def thrd_call(trg, argnt1, argnt2, a):
    thread1 = ThreadRV(target=trg, args =argnt1)
    thread2 = ThreadRV(target=trg, args =argnt2)
    thread1.start()
    thread2.start()
    if a == False:
        thread2.join()
        thread1.join()
    elif a == True:
        thread1.join()
        thread2.join()
        return (thread1.result(), thread2.result())

#Функция считывания названий файлов
def f_name(s):
    lt = os.listdir(s)
    return lt

#Функция создания списков изображений
def img_read(ls, path):
    array = []
    for i in ls:
        array.append(np.array(skimage.io.imread(f'{path}/{i}')))
    return array

#Функция «спрямления» изображений
def img_flatten(ls):
	for i in ls:
		i.shape = (len(i)*len(i[0])*3)
		i = i.T

#Функция нормирования параметров
def norm(arr,mn,st):
	for i in range(len(arr)):
		arr[i] = (arr[i] - mn[i])/st[i]

#Функция денормирования
def denorm(arr,mn,st):
    for i in range(len(arr)):
        arr[i] = arr[i]*st[i] + mn[i]

#Функция вывода изображений на экран
def img_out(img, number,tlt):
    plt.figure(number)
    plt.title(tlt)
    plt.imshow(np.reshape(img,(64,64,3)))

#Очистка окна консоли
os.system('cls')

#Запуск таймера
t1 = time.perf_counter_ns()

#Создание списков названий файлов в папках
trees_list, no_trees_list = thrd_call(f_name,\
    ("Trees",), ("NoTrees",), True)

#Создание списков изображений в папке
trees_img_list, no_trees_img_list = thrd_call(img_read,\
    (trees_list, "Trees"), (no_trees_list, "NoTrees"), True)

#Размер одного несжатого изображения
img_size = trees_img_list[0].size
print(f'Size of one image:  {img_size} bytes.')

#Размер всего набора несжатых изображений
img_all_size = img_size*len(trees_img_list) +\
img_size*len(no_trees_img_list)
print(f'Size of all images: {img_all_size/(1024*1024):.4f} \
mebibytes.')

#Максимальный размер сжатого изображения
storage_size = 620*1024
img_cmprs_size = int(storage_size/(len(trees_img_list)+len(no_trees_list))+1)
print(f'Size of one compressed image:  {img_cmprs_size} bytes.')

#Максимальное количество параметров
max_par = img_cmprs_size
print(f'Maximum ammount of parameters: {max_par}.\n')

#Создание массива параметров
	#«Спрямление» массивов изображений
thrd_call(img_flatten, (trees_img_list,),
	(no_trees_img_list,), False)
	#Объединение массивов в массив параметров
X = np.vstack((np.array(trees_img_list[0:len(trees_img_list)+1]),
	np.array(no_trees_img_list[0:len(no_trees_img_list)+1])))
X = X.astype('float64')

#Среднее нормирование
mean = np.mean(X.T, axis=1)
std = np.std(X.T, axis=1)
thrd_call(norm,\
(X.T[0:int(len(X.T)/2)],mean[0:int(len(mean)/2)],std[0:int(len(std)/2)]),
(X.T[int(len(X.T)/2):],mean[int(len(mean)/2):],std[int(len(std)/2):]),\
False)

##Создание матрицы собственных векторов для ковариационной матрицы
p = os.path.isfile('U_matrix.npy')
if p == True:
    ##Создание матрицы преобразований
    U = np.load('U_matrix.npy')
elif p == False:
    ##Создание ковариционной матрицы
    sigma = np.cov(X.T,bias=True)
    ##Создание матрицы преобразований
    U, S, Vh = np.linalg.svd(sigma)
    np.save('U_matrix.npy', U[::, :max_par:])
    del sigma, S, Vh

#Компрессия изображений
X_cmprs = X@U
img_trees_cmprs = X_cmprs[0]
img_notrees_cmprs = X_cmprs[int(len(X_cmprs)/2)]
print(f'Size of one matrix-compressed image with trees:    \
{img_trees_cmprs.size} bytes.\n\
Size of one matrix-compressed image without trees: \
{img_notrees_cmprs.size} bytes.')

#Декомпрессия изображений
X_uncmprs = X_cmprs@U.T
    #Денормирование
thrd_call(denorm,\
(X_uncmprs.T[0:int(len(X_uncmprs.T)/2)],mean[0:int(len(mean)/2)],\
std[0:int(len(std)/2)]),
(X_uncmprs.T[int(len(X_uncmprs.T)/2):],mean[int(len(mean)/2):],\
std[int(len(std)/2):]),\
False)
X_uncmprs = X_uncmprs.astype('int16')
img_trees = X_uncmprs[0]
img_notrees = X_uncmprs[int(len(X_uncmprs)/2)]

#Вывод необходимых изображений на экран
img_arr = [trees_img_list[0],img_trees,\
no_trees_img_list[0],img_notrees]
number_arr = [1,2,3,4]
title_arr = ['Исходное изображение','Декомпрессованное изображение',\
'Исходное изображение','Декомпрессованное изображение']
for i in range(4):
    img_out(img_arr[i],number_arr[i],title_arr[i])

#Вывод времени выполнения программы
print(f'\nTotal program execution time: \
{(time.perf_counter_ns()-t1)/10**9:.5f} seconds.')

plt.show()