Compresion

Compresion.py

from PIL import Image
import pywt
import numpy as np
import time
import matplotlib.pyplot as plt
import os

#clase que encapsula los procesos y la funcionalidad 
#necesaria para el proceso de compresion de imagenes.
class Compresion():

	#Constructor, recibe como parametro el nombre de la imagen
	#que se desea comprimir
	def __init__(self, imagen):
		self.imagen = imagen

	#filtro para convertir la imagen a procesar a escala de 
	#grises. (rutina propia)
	def filtroGrisesPromedio(self, imagen):
		x, y = imagen.size
		px = imagen.load()
		imagenGrises = Image.new('RGB',(x,y))
		for i in range(x):
			for j in range(y):
				pixeles = px[i,j]
				prom = sum(pixeles) / 3
				imagenGrises.putpixel((i,j),(prom,prom,prom))
		return imagenGrises

	#Metodo que genera una matriz numpy con los valores de
	#cada pixel de la imagen en escala de grises, matriz sobre la cual se
	#aplicara la transformada haar wavelet.
	def generarMatriz(self,imagen):
		x,y = imagen.size
		p = imagen.load()
		matriz = list()
		for j in range(y):
			fila = list()
			for i in range(x):
				fila.append(p[i,j][0])
			matriz.append(fila)
		n_array = np.array(matriz)
		return n_array

	#Metodo que recibe el arreglo y el valor umbral de compresion, aplica la transformada a la matriz
	#y umbraliza la matriz de detalle en base al valor, generando una nueva matriz, a la cual se le 
	#saca la transformada inversa para obtener la nueva matriz de valores grises sobre la cual construir la
	#nueva imagen.
	def wavelet(self, array, umbral):
		mu = -umbral
		#se crea el objeto de la funcion
		w = pywt.Wavelet('haar')
		#obtenemos los coheficientes al aplicar la transformada haar en el
		#array de valores de grises, nivel 2 para una capa
		coe = pywt.wavedec2(array, w, level=2)
		#se obtienen los coheficientes
		v1, v2, coheficientes = coe
		listaNva=list()
		for m in coheficientes:
			nva = np.where(((m<mu) | (m>umbral)), m, 0)
			listaNva.append(nva)
		fn = list()
		fn.append(v1)
		fn.append(v2)
		fn.append(tuple(listaNva))
		#fn es la lista de nuevos coheficientes
		#transformada inversa sobre los valores modificados
		t = pywt.waverec2(fn, 'haar')
		b = t.astype(int)
		return b

	#Metodo que genera la nueva imagen en base a la 
	#matriz generada por la transformada inversa
	def generaImagen(self, a, size, umbral):
		ancho,largo = size
		t = list()
		for e in a:
			fila = list()
			for valor in e:
				fila.append((int(valor),int(valor),int(valor)))
			t.append(fila)

		nueva = Image.new('RGB',(ancho,largo))
		for j in range(largo):
			for i in range(ancho):
				nueva.putpixel((i,j),t[j][i])
		nueva.save(str(umbral)+".png")
		return nueva

	#proceso que realiza la comparativa de resultados en pesos de la imagen
	#y prepara el archivo de datos para generacion de graficas
	def evaluacion(self, umbral):
		print "RESULTADOS"
		t_original = int(os.stat("test.png").st_size)
		t_gris = int(os.stat("gris.png").st_size)
		t_final = int(os.stat(str(umbral)+".png").st_size)
		porcentaje = ( t_final * 100 ) / float(t_original)
		print "Imagen compresa en un ", 100 - porcentaje, "%." 
		pf = 100 - porcentaje
		f = open ("data.txt", "a")
		f.write(str(umbral)+" "+str(pf)+"\n")
		f.close() 
	
	#Funcion que realiza todo el flujo de la operacion.
	def proceso(self, umbral):
		imagen = Image.open(self.imagen).convert('RGB')
		gris = self.filtroGrisesPromedio(imagen)
		gris.save("gris.png")
		array = self.generarMatriz(gris)
		inversa = self.wavelet(array, umbral)
		im = self.generaImagen(inversa, imagen.size, umbral)
		self.evaluacion(umbral)

#Funcion main, instanciar la clase del proceso y realizar
#la ejecucion.
def main():
	inicio = time.time()
	c = Compresion("test.png")
	contador = 0
	#Se itera para realizar la compresion con multiples valores
	#umbrales
	for i in range(1,31):
		c.proceso(i)
		contador += 1
	for i in range(30,301,10):
		c.proceso(i)
		contador += 1
	#Se genera la grafica del compresion/umbral
	os.system("gnuplot pcomp.gp")
	fin = time.time() - inicio
	print "tiempo total de ejecucion para ",contador,"imagenes: ",fin
	
	#Para generar el archivo de tiempos de ejecucion.
	f = open ("tiempos.txt", "a")
	#entero se modifica en base al tam de la imagen
	f.write(str(128)+" "+str(fin)+"\n")
	f.close() 

#inicio	
main()