def vec2display(vec):
image2display(imgVec2image(vec))
print(len(orth_basis.D[0]), len(orth_basis.D[1]))
print(len(centered_images[0].D))
print({
key: distance_squared(orth_basis, image)
for key, image in centered_images.items()
})
print('UNCLASIFIED')
raw_images_uncl = load_images('./unclassified', 10)
images_uncl = {
key: list2vec([el for row in image for el in row])
for key, image in raw_images_uncl.items()
}
centered_images_uncl = center_images(images_uncl, centroid)
dist = {
key: distance_squared(orth_basis, image)
for key, image in centered_images_uncl.items()
}
max = max(dist.values())
dist = {key: val * 100 / max for key, val in dist.items()}
print(dist)
print("Eigen Faces")
for i in range(10):
projection = project(orth_basis, centered_images_uncl[i]) + centroid
image2display(vec2image(projection, rowsCnt, colsCnt))
def find_threashold(fname, target_sparsity):
haar_image = to_haar2d(read_image(fname))
lo, hi = 0, 255
while lo <= hi:
th = (lo + hi) / 2
non_zero_frac = sparsity2d(suppress2d(haar_image, th))
if fabs(non_zero_frac - target_sparsity) <= 0.001:
return th
elif non_zero_frac < target_sparsity:
hi = th - 1
else:
lo = th + 1
return th if 0 < th else 0
def haar2d_compress_th(fname, threshold):
img = to_haar2d(read_image(fname))
print("Init sparcity: {:.2%}".format(sparsity2d(img)))
compressed_haar = suppress2d(img, threshold)
print("Apply th: {:4.2f} -> {:.2%}".format(threshold, sparsity2d(compressed_haar)))
return image_round(from_haar2d(compressed_haar))
def haar2d_compress_sp(fname, sparsity):
return haar2d_compress_th(fname, find_threashold(fname, sparsity))
if PRINT_FUNC_RUNS:
image2display(haar2d_compress_sp("flag.png", 0.03))
>>> from matutil import listlist2mat
>>> x = list2vec([1, 2, 3])
>>> M = listlist2mat([[1, 0], [0, 1], [0, 0]])
>>> project(M, x)
Vec({0, 1, 2},{0: 1, 1: 2, 2: 0})
>>> M = listlist2mat([[3/5, 0], [1/5, 2/3], [1/5, 1/3]])
>>> project(M, x)
Vec({0, 1, 2},{0: 0.96, 1: 1.8755555555555554, 2: 1.0977777777777777})
'''
return projected_representation(M, x) * M
## Task 11
face_0_project = project(orthonormal_basis, face_images[0])
face_5_project = project(orthonormal_basis, face_images[5])
# Have to translate vec to list of lists for image2display function
image2display(get_listlist_from_image_vec(face_0_project))
image2display(get_listlist_from_image_vec(face_5_project))
## Task 12
unclassified_0_project = project(orthonormal_basis, unclassified_images[0])
unclassified_1_project = project(orthonormal_basis, unclassified_images[1])
unclassified_6_project = project(orthonormal_basis, unclassified_images[6])
# Have to translate vec to list of lists for image2display function
image2display(get_listlist_from_image_vec(unclassified_0_project))
image2display(get_listlist_from_image_vec(unclassified_1_project))
image2display(get_listlist_from_image_vec(unclassified_6_project))
perpendicular = plen - x2
return math.sqrt(perpendicular * perpendicular)
e_t = eigenfaces_basis.transpose()
classified_distances = [
distance_squared(e_t, centered_image_vectors[x])
for x in centered_image_vectors
]
print(classified_distances)
unclassified = import_faces('singular_value_decomposition/unclassified', 10)
# for k in unclassified:
# vector = unclassified[k]
# centered = vector - centroid
# distance = distance_squared(e_t, centered)
# print(distance)
# image.image2display(vector2image(vector))
def project(M, x):
return M * projected_representation(M, x)
image.image2display(vector2image(project(e_t, unclassified[1])))
image.image2display(vector2image(project(e_t, unclassified[2])))
image.image2display(vector2image(project(e_t, unclassified[3])))
# non-face
image.image2display(vector2image(project(e_t, unclassified[0])))
assert (backward2d(forward2d([[1, 2, 3, 4]])) == [[4, 3, 2, 1]])
def import_flag():
loaded = image.file2image('special_bases/flag.png')
return image.color2gray(loaded)
def image_round(image):
return [[abs(round(p)) if p < 255 else 255 for p in row] for row in image]
loaded = import_flag()
image.image2display(loaded)
wavelet = forward2d(loaded)
listlistrep = backward2d(wavelet)
rounded = image_round(listlistrep)
image.image2display(rounded)
compressed = suppress2d(wavelet, 2)
suppressed = 2
while sparsity2d(compressed) > 0.02:
suppressed += 1
compressed = suppress2d(wavelet, suppressed)
listlistrep = backward2d(compressed)
rounded = image_round(listlistrep)
image.image2display(rounded)
def sparsity2d(D_dict):
return sum([sum([1 if abs(D_dict[kn][km]) != 0 else 0 for km in D_dict[kn]]) for kn in D_dict]) / len(D_dict) / len(list(D_dict.values())[0])
def listdict2dict(L_dict, i):
return dict((k, L_dict[k][i]) for k in L_dict)
def listdict2dictlist(listdict):
return [listdict2dict(listdict, i) for i in range(len(list(listdict.values())[0]))]
def backward2d(dictdict):
D_list = dict((k, backward(dictdict[k])) for k in dictdict)
L_dict = listdict2dictlist(D_list)
L_list = [backward(v) for v in L_dict]
return L_list
def image_round(image):
return [[min(255, abs(round(n))) for n in row] for row in image]
from image import file2image, color2gray, image2display
img = color2gray(file2image('Dali.png'))
# image2display(img)
wave_comp = forward2d(img)
wave_comp = suppress2d(wave_comp, 100)
print('sparsity is %f' % sparsity2d(wave_comp))
dump_img = image_round(backward2d(wave_comp))
image2display(dump_img)
