kelly push (b9905013) · Commits · Elphel / image-compression

.DS_Store

(8 KiB)

File changed.

No diff preview for this file type.

View original file

View changed file

Compression_Rate_Kelly.ipynb

0 → 100644

+775 −0

File added.

Preview size limit exceeded, changes collapsed.

Encoding_decoding.ipynb

+38 −0

Original line number	Original line	Diff line number	Diff line
	%% Cell type:code id:14f74f21 tags:		%% Cell type:code id:14f74f21 tags:

	``` python		``` python
	import numpy as np		import numpy as np
	from matplotlib import pyplot as plt		from matplotlib import pyplot as plt
	from itertools import product		from itertools import product
	import os		import os
	import sys		import sys
	from PIL import Image		from PIL import Image
	from scipy.optimize import minimize,linprog		from scipy.optimize import minimize,linprog
	import time		import time
	import seaborn as sns		import seaborn as sns
	from sklearn.neighbors import KernelDensity		from sklearn.neighbors import KernelDensity
	import pandas as pd		import pandas as pd
	from collections import Counter		from collections import Counter
	import time		import time
	```		```

	%% Cell type:code id:c16af61f tags:		%% Cell type:code id:c16af61f tags:

	``` python		``` python
	def file_extractor(dirname="images"):		def file_extractor(dirname="images"):
	files = os.listdir(dirname)		files = os.listdir(dirname)
	scenes = []		scenes = []
	for file in files:		for file in files:
	scenes.append(os.path.join(dirname, file))		scenes.append(os.path.join(dirname, file))
	return scenes		return scenes

	def image_extractor(scenes):		def image_extractor(scenes):
	image_folder = []		image_folder = []
	for scene in scenes:		for scene in scenes:
	files = os.listdir(scene)		files = os.listdir(scene)
	for file in files:		for file in files:
	image_folder.append(os.path.join(scene, file))		image_folder.append(os.path.join(scene, file))
	images = []		images = []
	for folder in image_folder:		for folder in image_folder:
	ims = os.listdir(folder)		ims = os.listdir(folder)
	for im in ims:		for im in ims:
	if im[-4:] == ".jp4" or im[-7:] == "_6.tiff":		if im[-4:] == ".jp4" or im[-7:] == "_6.tiff":
	continue		continue
	else:		else:
	images.append(os.path.join(folder, im))		images.append(os.path.join(folder, im))
	return images #returns a list of file paths to .tiff files in the specified directory given in file_extractor		return images #returns a list of file paths to .tiff files in the specified directory given in file_extractor

	def im_distribution(images, num):		def im_distribution(images, num):
	"""		"""
	Function that extracts tiff files from specific cameras and returns a list of all		Function that extracts tiff files from specific cameras and returns a list of all
	the tiff files corresponding to that camera. i.e. all pictures labeled "_7.tiff" or otherwise		the tiff files corresponding to that camera. i.e. all pictures labeled "_7.tiff" or otherwise
	specified camera numbers.		specified camera numbers.

	Parameters:		Parameters:
	images (list): list of all tiff files, regardless of classification. This is NOT a list of directories but		images (list): list of all tiff files, regardless of classification. This is NOT a list of directories but
	of specific tiff files that can be opened right away. This is the list that we iterate through and		of specific tiff files that can be opened right away. This is the list that we iterate through and
	divide.		divide.

	num (str): a string designation for the camera number that we want to extract i.e. "14" for double digits		num (str): a string designation for the camera number that we want to extract i.e. "14" for double digits
	of "_1" for single digits.		of "_1" for single digits.

	Returns:		Returns:
	tiff (list): A list of tiff files that have the specified designation from num. They are the files extracted		tiff (list): A list of tiff files that have the specified designation from num. They are the files extracted
	from the 'images' list that correspond to the given num.		from the 'images' list that correspond to the given num.
	"""		"""
	tiff = []		tiff = []
	for im in images:		for im in images:
	if im[-7:-5] == num:		if im[-7:-5] == num:
	tiff.append(im)		tiff.append(im)
	return tiff		return tiff
	```		```

	%% Cell type:code id:aceba613 tags:		%% Cell type:code id:aceba613 tags:

	``` python		``` python
	def plot_hist(tiff_list):		def plot_hist(tiff_list):
	"""		"""
	This function is the leftovers from the first attempt to plot histograms.		This function is the leftovers from the first attempt to plot histograms.
	As it stands it needs some work in order to function again. We will		As it stands it needs some work in order to function again. We will
	fix this later. 1/25/22		fix this later. 1/25/22
	"""		"""

	image = tiff_list		image = tiff_list
	image = Image.open(image) #Open the image and read it as an Image object		image = Image.open(image) #Open the image and read it as an Image object
	image = np.array(image)[1:,:] #Convert to an array, leaving out the first row because the first row is just housekeeping data		image = np.array(image)[1:,:] #Convert to an array, leaving out the first row because the first row is just housekeeping data
	image = image.astype(int)		image = image.astype(int)
	A = np.array([[3,0,-1],[0,3,3],[1,-3,-4]]) # the matrix for system of equation		A = np.array([[3,0,-1],[0,3,3],[1,-3,-4]]) # the matrix for system of equation
	z0 = image[0:-2,0:-2] # get all the first pixel for the entire image		z0 = image[0:-2,0:-2] # get all the first pixel for the entire image
	z1 = image[0:-2,1:-1] # get all the second pixel for the entire image		z1 = image[0:-2,1:-1] # get all the second pixel for the entire image
	z2 = image[0:-2,2::] # get all the third pixel for the entire image		z2 = image[0:-2,2::] # get all the third pixel for the entire image
	z3 = image[1:-1,0:-2] # get all the forth pixel for the entire image		z3 = image[1:-1,0:-2] # get all the forth pixel for the entire image
	# calculate the out put of the system of equation		# calculate the out put of the system of equation
	y0 = np.ravel(-z0+z2-z3)		y0 = np.ravel(-z0+z2-z3)
	y1 = np.ravel(z0+z1+z2)		y1 = np.ravel(z0+z1+z2)
	y2 = np.ravel(-z0-z1-z2-z3)		y2 = np.ravel(-z0-z1-z2-z3)
	y = np.vstack((y0,y1,y2))		y = np.vstack((y0,y1,y2))
	# use numpy solver to solve the system of equations all at once		# use numpy solver to solve the system of equations all at once
	#predict = np.floor(np.linalg.solve(A,y)[-1])		#predict = np.floor(np.linalg.solve(A,y)[-1])
	predict = np.round(np.round((np.linalg.solve(A,y)[-1]),1))		predict = np.round(np.round((np.linalg.solve(A,y)[-1]),1))
	# flatten the neighbor pixlels and stack them together		# flatten the neighbor pixlels and stack them together
	z0 = np.ravel(z0)		z0 = np.ravel(z0)
	z1 = np.ravel(z1)		z1 = np.ravel(z1)
	z2 = np.ravel(z2)		z2 = np.ravel(z2)
	z3 = np.ravel(z3)		z3 = np.ravel(z3)
	neighbor = np.vstack((z0,z1,z2,z3)).T		neighbor = np.vstack((z0,z1,z2,z3)).T
	# calculate the difference		# calculate the difference
	diff = np.max(neighbor,axis = 1) - np.min(neighbor, axis=1)		diff = np.max(neighbor,axis = 1) - np.min(neighbor, axis=1)

	# flatten the image to a vector		# flatten the image to a vector
	image = np.ravel(image[1:-1,1:-1])		image = np.ravel(image[1:-1,1:-1])
	error = image-predict		error = image-predict

	return image, predict, diff, error, A		return image, predict, diff, error, A
	```		```

	%% Cell type:code id:6b965751 tags:		%% Cell type:code id:6b965751 tags:

	``` python		``` python
	class NodeTree(object):		class NodeTree(object):
	def __init__(self, left=None, right=None):		def __init__(self, left=None, right=None):
	self.left = left		self.left = left
	self.right = right		self.right = right

	def children(self):		def children(self):
	return self.left, self.right		return self.left, self.right

	def __str__(self):		def __str__(self):
	return self.left, self.right		return self.left, self.right


	def huffman_code_tree(node, binString=''):		def huffman_code_tree(node, binString=''):
	'''		'''
	Function to find Huffman Code		Function to find Huffman Code
	'''		'''
	if type(node) is str:		if type(node) is str:
	return {node: binString}		return {node: binString}
	(l, r) = node.children()		(l, r) = node.children()
	d = dict()		d = dict()
	d.update(huffman_code_tree(l, binString + '0'))		d.update(huffman_code_tree(l, binString + '0'))
	d.update(huffman_code_tree(r, binString + '1'))		d.update(huffman_code_tree(r, binString + '1'))
	return d		return d


	def make_tree(nodes):		def make_tree(nodes):
	'''		'''
	Function to make tree		Function to make tree
	:param nodes: Nodes		:param nodes: Nodes
	:return: Root of the tree		:return: Root of the tree
	'''		'''
	while len(nodes) > 1:		while len(nodes) > 1:
	(key1, c1) = nodes[-1]		(key1, c1) = nodes[-1]
	(key2, c2) = nodes[-2]		(key2, c2) = nodes[-2]
	nodes = nodes[:-2]		nodes = nodes[:-2]
	node = NodeTree(key1, key2)		node = NodeTree(key1, key2)
	nodes.append((node, c1 + c2))		nodes.append((node, c1 + c2))
	nodes = sorted(nodes, key=lambda x: x[1], reverse=True)		nodes = sorted(nodes, key=lambda x: x[1], reverse=True)
	return nodes[0][0]		return nodes[0][0]
	```		```

	%% Cell type:code id:b7561883 tags:		%% Cell type:code id:b7561883 tags:

	``` python		``` python
	def huffman(image):		def huffman(image):
	origin, predict, diff, error, A = plot_hist(image)		origin, predict, diff, error, A = plot_hist(image)

	image = Image.open(image)		image = Image.open(image)
	image = np.array(image)[1:,:] #Convert to an array, leaving out the first row because the first row is just housekeeping data		image = np.array(image)[1:,:] #Convert to an array, leaving out the first row because the first row is just housekeeping data
	image = image.astype(int)		image = image.astype(int)

	boundary = np.hstack((image[0,:],image[-1,:],image[1:-1,0],image[1:-1,-1]))		boundary = np.hstack((image[0,:],image[-1,:],image[1:-1,0],image[1:-1,-1]))
	boundary = boundary - image[0,0]		boundary = boundary - image[0,0]
	boundary[0] = image[0,0]		boundary[0] = image[0,0]

	string = [str(i) for i in boundary]		string = [str(i) for i in boundary]
	freq = dict(Counter(string))		freq = dict(Counter(string))
	freq = sorted(freq.items(), key=lambda x: x[1], reverse=True)		freq = sorted(freq.items(), key=lambda x: x[1], reverse=True)
	node = make_tree(freq)		node = make_tree(freq)
	encode1 = huffman_code_tree(node)		encode1 = huffman_code_tree(node)


	mask = diff <= 25		mask = diff <= 25
	string = [str(i) for i in error[mask].astype(int)]		string = [str(i) for i in error[mask].astype(int)]
	freq = dict(Counter(string))		freq = dict(Counter(string))
	freq = sorted(freq.items(), key=lambda x: x[1], reverse=True)		freq = sorted(freq.items(), key=lambda x: x[1], reverse=True)
	node = make_tree(freq)		node = make_tree(freq)
	encode2 = huffman_code_tree(node)		encode2 = huffman_code_tree(node)


	mask = diff > 25		mask = diff > 25
	new_error = error[mask]		new_error = error[mask]
	mask2 = diff[mask] <= 40		mask2 = diff[mask] <= 40
	string = [str(i) for i in new_error[mask2].astype(int)]		string = [str(i) for i in new_error[mask2].astype(int)]
	freq = dict(Counter(string))		freq = dict(Counter(string))
	freq = sorted(freq.items(), key=lambda x: x[1], reverse=True)		freq = sorted(freq.items(), key=lambda x: x[1], reverse=True)
	node = make_tree(freq)		node = make_tree(freq)
	encode3 = huffman_code_tree(node)		encode3 = huffman_code_tree(node)


	mask = diff > 40		mask = diff > 40
	new_error = error[mask]		new_error = error[mask]
	mask2 = diff[mask] <= 70		mask2 = diff[mask] <= 70
	string = [str(i) for i in new_error[mask2].astype(int)]		string = [str(i) for i in new_error[mask2].astype(int)]
	freq = dict(Counter(string))		freq = dict(Counter(string))
	freq = sorted(freq.items(), key=lambda x: x[1], reverse=True)		freq = sorted(freq.items(), key=lambda x: x[1], reverse=True)
	node = make_tree(freq)		node = make_tree(freq)
	encode4 = huffman_code_tree(node)		encode4 = huffman_code_tree(node)


	mask = diff > 70		mask = diff > 70
	string = [str(i) for i in error[mask].astype(int)]		string = [str(i) for i in error[mask].astype(int)]
	freq = dict(Counter(string))		freq = dict(Counter(string))
	freq = sorted(freq.items(), key=lambda x: x[1], reverse=True)		freq = sorted(freq.items(), key=lambda x: x[1], reverse=True)
	node = make_tree(freq)		node = make_tree(freq)
	encode5 = huffman_code_tree(node)		encode5 = huffman_code_tree(node)


	new_error = np.copy(image)		new_error = np.copy(image)
	new_error[1:-1,1:-1] = np.reshape(error,(510, 638))		new_error[1:-1,1:-1] = np.reshape(error,(510, 638))
	keep = new_error[0,0]		keep = new_error[0,0]
	new_error[0,:] = new_error[0,:] - keep		new_error[0,:] = new_error[0,:] - keep
	new_error[-1,:] = new_error[-1,:] - keep		new_error[-1,:] = new_error[-1,:] - keep
	new_error[1:-1,0] = new_error[1:-1,0] - keep		new_error[1:-1,0] = new_error[1:-1,0] - keep
	new_error[1:-1,-1] = new_error[1:-1,-1] - keep		new_error[1:-1,-1] = new_error[1:-1,-1] - keep
	new_error[0,0] = keep		new_error[0,0] = keep


	#new_error = np.ravel(new_error)		#new_error = np.ravel(new_error)

	bins = [25,40,70]		bins = [25,40,70]

	# return the huffman dictionary		# return the huffman dictionary
	return encode1, encode2, encode3, encode4, encode5, np.ravel(image), error, new_error, diff, boundary, bins, predict		return encode1, encode2, encode3, encode4, encode5, np.ravel(image), error, new_error, diff, boundary, bins, predict

	```		```

	%% Cell type:code id:2eb774d2 tags:		%% Cell type:code id:2eb774d2 tags:

	``` python		``` python
	def encoder(error, list_dic, diff, bound, bins):		def encoder(error, list_dic, diff, bound, bins):
	encoded = np.copy(error).astype(int).astype(str).astype(object)		encoded = np.copy(error).astype(int).astype(str).astype(object)

	diff = np.reshape(diff,(510,638))		diff = np.reshape(diff,(510,638))

	for i in range(encoded.shape[0]):		for i in range(encoded.shape[0]):
	for j in range(encoded.shape[1]):		for j in range(encoded.shape[1]):
	if i == 0 or i == encoded.shape[0]-1 or j == 0 or j == encoded.shape[1]-1:		if i == 0 or i == encoded.shape[0]-1 or j == 0 or j == encoded.shape[1]-1:
	encoded[i][j] = list_dic[0][encoded[i][j]]		encoded[i][j] = list_dic[0][encoded[i][j]]
	elif diff[i-1][j-1] <= bins[0]:		elif diff[i-1][j-1] <= bins[0]:
	encoded[i][j] = list_dic[1][encoded[i][j]]		encoded[i][j] = list_dic[1][encoded[i][j]]
	elif diff[i-1][j-1] <= bins[1] and diff[i-1][j-1] > bins[0]:		elif diff[i-1][j-1] <= bins[1] and diff[i-1][j-1] > bins[0]:
	encoded[i][j] = list_dic[2][encoded[i][j]]		encoded[i][j] = list_dic[2][encoded[i][j]]
	elif diff[i-1][j-1] <= bins[2] and diff[i-1][j-1] > bins[1]:		elif diff[i-1][j-1] <= bins[2] and diff[i-1][j-1] > bins[1]:
	encoded[i][j] = list_dic[3][encoded[i][j]]		encoded[i][j] = list_dic[3][encoded[i][j]]
	else:		else:
	encoded[i][j] = list_dic[4][encoded[i][j]]		encoded[i][j] = list_dic[4][encoded[i][j]]


	return encoded		return encoded
	```		```

	%% Cell type:code id:8eeb40d0 tags:		%% Cell type:code id:8eeb40d0 tags:

	``` python		``` python
	def decoder(A, encoded_matrix, list_dic, bins):		def decoder(A, encoded_matrix, list_dic, bins):
	"""		"""
	Function that accecpts the prediction matrix A for the linear system,		Function that accecpts the prediction matrix A for the linear system,
	the encoded matrix of error values, and the encoding dicitonary.		the encoded matrix of error values, and the encoding dicitonary.
	"""		"""

	the_keys0 = list(list_dic[0].keys())		the_keys0 = list(list_dic[0].keys())
	the_values0 = list(list_dic[0].values())		the_values0 = list(list_dic[0].values())

	the_keys1 = list(list_dic[1].keys())		the_keys1 = list(list_dic[1].keys())
	the_values1 = list(list_dic[1].values())		the_values1 = list(list_dic[1].values())

	the_keys2 = list(list_dic[2].keys())		the_keys2 = list(list_dic[2].keys())
	the_values2 = list(list_dic[2].values())		the_values2 = list(list_dic[2].values())

	the_keys3 = list(list_dic[3].keys())		the_keys3 = list(list_dic[3].keys())
	the_values3 = list(list_dic[3].values())		the_values3 = list(list_dic[3].values())

	the_keys4 = list(list_dic[4].keys())		the_keys4 = list(list_dic[4].keys())
	the_values4 = list(list_dic[4].values())		the_values4 = list(list_dic[4].values())

	error_matrix = np.zeros((512,640))		error_matrix = np.zeros((512,640))

	for i in range(error_matrix.shape[0]):		for i in range(error_matrix.shape[0]):
	for j in range(error_matrix.shape[1]):		for j in range(error_matrix.shape[1]):
	if i == 0 and j == 0:		if i == 0 and j == 0:
	error_matrix[i][j] = int(the_keys0[the_values0.index(encoded_matrix[i,j])])		error_matrix[i][j] = int(the_keys0[the_values0.index(encoded_matrix[i,j])])

	elif i == 0 or i == error_matrix.shape[0]-1 or j == 0 or j == error_matrix.shape[1]-1:		elif i == 0 or i == error_matrix.shape[0]-1 or j == 0 or j == error_matrix.shape[1]-1:
	error_matrix[i][j] = int(the_keys0[the_values0.index(encoded_matrix[i,j])]) + error_matrix[0][0]		error_matrix[i][j] = int(the_keys0[the_values0.index(encoded_matrix[i,j])]) + error_matrix[0][0]
	else:		else:
	z0 = error_matrix[i-1][j-1]		z0 = error_matrix[i-1][j-1]
	z1 = error_matrix[i-1][j]		z1 = error_matrix[i-1][j]
	z2 = error_matrix[i-1][j+1]		z2 = error_matrix[i-1][j+1]
	z3 = error_matrix[i][j-1]		z3 = error_matrix[i][j-1]
	y0 = int(-z0+z2-z3)		y0 = int(-z0+z2-z3)
	y1 = int(z0+z1+z2)		y1 = int(z0+z1+z2)
	y2 = int(-z0-z1-z2-z3)		y2 = int(-z0-z1-z2-z3)
	y = np.vstack((y0,y1,y2))		y = np.vstack((y0,y1,y2))
	difference = max(z0,z1,z2,z3) - min(z0,z1,z2,z3)		difference = max(z0,z1,z2,z3) - min(z0,z1,z2,z3)
	predict = np.round(np.round(np.linalg.solve(A,y)[-1][0],1))		predict = np.round(np.round(np.linalg.solve(A,y)[-1][0],1))

	if difference <= bins[0]:		if difference <= bins[0]:
	error_matrix[i][j] = int(the_keys1[the_values1.index(encoded_matrix[i,j])]) + int(predict)		error_matrix[i][j] = int(the_keys1[the_values1.index(encoded_matrix[i,j])]) + int(predict)
	elif difference <= bins[1] and difference > bins[0]:		elif difference <= bins[1] and difference > bins[0]:
	error_matrix[i][j] = int(the_keys2[the_values2.index(encoded_matrix[i,j])]) + int(predict)		error_matrix[i][j] = int(the_keys2[the_values2.index(encoded_matrix[i,j])]) + int(predict)
	elif difference <= bins[2] and difference > bins[1]:		elif difference <= bins[2] and difference > bins[1]:
	error_matrix[i][j] = int(the_keys3[the_values3.index(encoded_matrix[i,j])]) + int(predict)		error_matrix[i][j] = int(the_keys3[the_values3.index(encoded_matrix[i,j])]) + int(predict)
	else:		else:
	error_matrix[i][j] = int(the_keys4[the_values4.index(encoded_matrix[i,j])]) + int(predict)		error_matrix[i][j] = int(the_keys4[the_values4.index(encoded_matrix[i,j])]) + int(predict)


	return error_matrix.astype(int)		return error_matrix.astype(int)
	```		```

	%% Cell type:code id:3e0e9742 tags:		%% Cell type:code id:3e0e9742 tags:

	``` python		``` python
	scenes = file_extractor()		scenes = file_extractor()
	images = image_extractor(scenes)		images = image_extractor(scenes)
	encode1, encode2, encode3, encode4, encode5, image, error, new_error, diff, bound, bins, predict = huffman(images[0])		encode1, encode2, encode3, encode4, encode5, image, error, new_error, diff, bound, bins, predict = huffman(images[0])
	encoded_matrix = encoder(np.reshape(new_error,(512,640)), [encode1, encode2, encode3, encode4, encode5], diff, bound, bins)		encoded_matrix = encoder(np.reshape(new_error,(512,640)), [encode1, encode2, encode3, encode4, encode5], diff, bound, bins)
	list_dic = [encode1, encode2, encode3, encode4, encode5]		list_dic = [encode1, encode2, encode3, encode4, encode5]
	```		```

	%% Cell type:code id:ceb0b957 tags:		%% Cell type:code id:ceb0b957 tags:

	``` python		``` python
	reconstruct_image = decoder(A, encoded_matrix, list_dic, bins)		reconstruct_image = decoder(A, encoded_matrix, list_dic, bins)
	```		```

	%% Cell type:code id:60297ad0 tags:		%% Cell type:code id:60297ad0 tags:

	``` python		``` python
	np.allclose(image.reshape(512,640), reconstruct_image)		np.allclose(image.reshape(512,640), reconstruct_image)
	```		```

	%% Output		%% Output

	True		True

	%% Cell type:code id:f0948ab2 tags:		%% Cell type:code id:f0948ab2 tags:

	``` python		``` python
			for im in ims:
			if im[-4:] == ".jp4" or im[-7:] == "_6.tiff":
			continue
			else:
			images.append(os.path.join(folder, im))
	```		```

	%% Output		%% Output

	2		2

	%% Cell type:code id:7bc6e808 tags:		%% Cell type:code id:7bc6e808 tags:

	``` python		``` python
			scenes = file_extractor('im')
			for
			```

			%% Output

			---------------------------------------------------------------------------
			NotADirectoryError Traceback (most recent call last)
			/var/folders/z2/plvrsqjs023g1cmx7k19mhzr0000gn/T/ipykernel_3109/413509388.py in <module>
			1 scenes = file_extractor('im')
			----> 2 images = image_extractor(scenes)

			/var/folders/z2/plvrsqjs023g1cmx7k19mhzr0000gn/T/ipykernel_3109/3921095921.py in image_extractor(scenes)
			9 image_folder = []
			10 for scene in scenes:
			---> 11 files = os.listdir(scene)
			12 for file in files:
			13 image_folder.append(os.path.join(scene, file))
			NotADirectoryError: [Errno 20] Not a directory: 'im/1640840453_605947_0.tiff'

			%% Cell type:code id:4e6cad9c tags:

			``` python
			print(scenes)
			```

			%% Output

			['im/1640840453_605947_0.tiff', 'im/1640843156_846487_11.tiff', 'im/1628259417_495716_13.tiff', 'im/1640840448_738307_14.tiff', 'im/1628260288_519886_14.tiff', 'im/1640840458_606947_14.tiff']

			%% Cell type:code id:26bd3666 tags:

			``` python
	```		```

im/1628259417_495716_13.tiff

0 → 100644

+642 KiB

Loading image diff...

im/1628260288_519886_14.tiff

0 → 100644

+642 KiB

Loading image diff...

Admin message