Implementacion Del Lempel Ziv en Matlab

1

Objetivos:

Empleando el software matemático Matlab implementar el algoritmo de

compresión y descompresión de datos: Lempel Ziv.

Comprobar el funcionamiento del algoritmo Lempel Ziv, basado en las

secuencias codificadas y decodificadas y así verificar que Lempel Ziv es un

algoritmo de compresión sin perdida de información

Ideado por Jacob Ziv y Abraham Lempel, y publicado en el IEEE (Instituto de

Ingenieros Eléctricos y Electrónicos) Transactions on Information Theory, vol. IT-23, Nº

3 de Mayo de 1977, si bien ya había sido presentado anteriormente en el IEEE

International Symposium on Information Theory celebrado en Ronneby, Suecia, en

Junio de 1976.

La mayoría de los métodos de compresión se basan en un

análisis inicial del texto para identificar cadenas repetidas

para armar un diccionario de equivalencias, asignando

códigos breves a estas cadenas. En una segunda etapa, se

convierte el texto utilizando los códigos equivalentes para

las cadenas repetidas. Esto requiere dos etapas, una de

análisis y una segunda de conversión y también requiere

que el diccionario se encuentre junto con el texto codificado,

incrementando el tamaño del archivo de salida.

Lempel Ziv (LZ) es un algoritmo que elimina la redundancia en la codificación y la

redundancia en la secuencia de aparición, y cuya principal característica, es su

sencillez de implementación y velocidad de ejecución. Es un algoritmo de compresión

los-sless, es decir, que los datos recuperados tras la compresión y descompresión son

exactamente los datos de partida.

La clave del método LZ reside en que es posible crear, de

manera automática y en una única pasada un diccionario

de cadenas que se encuentren dentro del texto a

comprimir mientras al mismo tiempo se procede a su

codificación. Dicho diccionario no es transmitido con el

texto comprimido, puesto que el descompresor puede

reconstruirlo usando la misma lógica con que lo hace el

compresor y, si está codificado correctamente, tendrá

exactamente las mismas cadenas que el diccionario del compresor tenía.

2

Porque este paquete computacional presenta varias ventajas que se describen

brevemente a continuación.

Permite codificación rápida y fácil en un lenguaje de muy alto nivel.

No hay que preocuparse por las estructuras de datos, en particular, los arreglos

no tienen que ser declarados antes de usarse.

La interfaz interactiva permite rápida experimentación y depuración mas

efectiva (permite la ejecución controlada de un programa o un código, para

seguir cada instrucción ejecutada).

Los archivos de Matlab son completamente portátiles en diferentes plataformas

(Linux, Apple, Windows).

A continuación se detallará los pasos para hacer uso de Lempel Ziv en Matlab:

1.) Clic en el icono de Matlab, anclado en el Escritorio del ordenador

2.) Clic en el cuadro File (Archivo), se escoge la opción Open

3.) A continuación la ventana despliega una serie de opciones de apertura de

carpetas o archivos, se escoge el correcto, en nuestro caso Lempel Ziv, ya que

esta es la carpeta que contiene el desarrollo del código fuente, la interfaz

gráfica, etc.

http://www.alegsa.com.ar/Dic/codigo.php

3

4.) Clic en el nombre de archivo: Lempelziv, Tipo MATLAB M-file (debido a que

este contiene toda la informacion del algoritmo).

5.) Una vez que nos encontramos en el archivo ‘‘.m’’, se prosigue a hacer correr el

programa, dando clic en el botón Run.

6.) A continuación se despliega la interfaz gráfica donde el usuario puede hacer

uso del programa de una forma más fácil.

7.) Como se puede observar se puede ingresar el texto en la cuadro de texto

denominado: Texto.

4

8.) A continuacion se aplasta el botón: Binario, el mismo que transformará a

lenguaje binario el texto ingresado, posteriormente eso se visualizará en la

parte posterior de la gráfica, ya que ese será el cuadro que se procederá a

comprimir con Lempel Ziv.

9.) Para poder comprimir la secuencia damos clic en el botón Comprimir, a

continuacion se muestra el progreso de la compresión.

10.) Al finalizar el cuadro inferior muestra la secuencia comprimida:

Secuencia que se procederá

a comprimir con Lempel Ziv

Secuencia Comprimida

Radio de Descompresión

5

Se observa que el programa también muestra el radio de compresión:

El radio de compresión, que se utiliza con frecuencia, es lo contrario al

factor de compresión (núm. de bits sin compresión/ núm. De bits con

compresión) y se lo expresa como porcentaje.

Por último, la ganancia de compresión, que también se expresa como

porcentaje, equivale a 1 menos el radio de compresión.

11.) Para descomprimir, se hace clic en el botón: Descomprimir, y la secuencia que

se comprimió al principio se observa que salió al final de la descompresión.

12.) Si se desea ingresar un nuevo texto se hace clic en el botón Limpiar y este

borrará todo el historial existente en los cuadros de texto, luego se procede a

realizar los pasos anteriores.

13.) Para salir del programa se cierra todas las ventanas,

Secuencia

Descomprimida

Limpiar

6

DIAGRAMA DE FLUJO DEL ALGORITMO DE LEMPEL ZIV

COMPRESOR:

INICIO

ingr=get(handles.edit1,'string'); ta=size(ingr); ingr='' tline = fgetl(fid);

~ischar(tline

)

i=1:length(tline)

ingr=cat(2,ingr,dec2bin(tline(i)));

fclose(fid); set(handles.edit1,'String',ingr)

SI NO

ingr=get(handles.edit1,'string'); ta=size(ingr); buf=[num2str(0) num2str(0) num2str(0) num2str(0) num2str(0) num2str(0)

num2str(0) num2str(0) num2str(0) ingr(1) ingr(2) ingr(3) ingr(4) ingr(5)

ingr(6) ingr(7) ingr(8) ingr(9)]; a=0; c=0; x=c/ta(2); t=0; cod=[]; h=waitbar(0,'Comprimiendo...');

l=1

c<ta(2)

SI NO

Texto en binario

7

l=1;

l<=9

bufpr(l)=buf(9+l); l=l+1;

SI NO

FIN

proc=[]; sproc=[]; n=1;

n<9

proc=[proc buf(9+n)]; sproc=[sproc buf(n)]; k=0; while (n+k)<=18 d=1; while (d+k)<=(n+k)

sproc(d)=buf(d+k); d=d+1; end if sproc==proc; if (k+1)>=9 else if t==0 codtemp=[num2str(k)

num2str(n) bufpr(n+1)]; k=18; a=a+1; else codtemp=[num2str(k)

num2str(n-1) bufpr(n)]; k=18; a=a+1; end end end k=k+1; end n=n+1; end if a==0 codtemp=[num2str(8)

num2str(0) bufpr(1)]; end

8

cod=[cod codtemp]; a=0; b=1;

b<=18

if b<=(17-

(str2num(codtemp(2)))) buf(b)=buf(b+(str2num(codte

mp(2))+1)); else if (b-9+c)<=ta(2) buf(b)=ingr(b-9+c); else buf(b)='~'; t=1; end end b=b+1; end

FIN

9

DESCOMPRESOR:

INICIO

cod=get(handles.edit2,'string'); ta=size(cod); buf=[num2str(0) num2str(0) num2str(0)

num2str(0) num2str(0) num2str(0) num2str(0)

num2str(0) num2str(0)]; c=0; deco=[]; x=c/ta(2); h=waitbar(0,'Descomprimiendo...');

copro=[cod(c+1) cod(c+2) cod(c+3)]; k=0;

SI NO (c+3)<=ta(2)

SI k<(str2num(copro(2))

)

a=str2num(copro(1))+1; b=buf(a); d=1;

d<9

buf(d)=buf(d+1); d=d+1;

buf(9)=b; k=k+1;

d=1;

NO

NO SI

10

d<9

buf(d)=buf(d+1); d=d+1;

buf(9)=copro(3); t=9-

(str2num(copro(2))+1); d=1; decotemp=buf(t+1); decotemp(d)=buf(t+1);

t<9

decotemp(d)=buf(t+1); d=d+1; t=t+1;

c=c+3; x=c/ta(2); waitbar(x) deco=[deco decotemp];

x=1; waitbar(x,h,'Completado') close(h) l=size(deco); por=(ta(2)/l(2))*100; set(handles.edit4,'string',deco) set(handles.text4,'Visible','on') set(handles.edit3,'string',por) axes1=patch([0 1 1 0],[100 100 0 0],[0.5 0.5

0.5]); axes1=patch([0 1 1 0],[por por 0 0],'g'); axis([0, 1, 0, 100]) axis off

FIN

11

Con sus respectivos comentarios

function varargout = Lempelziv(varargin)

% LEMPELZIV M-file for Lempelziv.fig

% LEMPELZIV, by itself, creates a new LEMPELZIV or raises the existing

% singleton*.

%

% H = LEMPELZIV returns the handle to a new LEMPELZIV or the handle to

% the existing singleton*.

%

% LEMPELZIV('CALLBACK',hObject,eventData,handles,...) calls the local

% function named CALLBACK in LEMPELZIV.M with the given input arguments.

%

% LEMPELZIV('Property','Value',...) creates a new LEMPELZIV or raises the

% existing singleton*. Starting from the left, property value pairs are

% applied to the GUI before Lempelziv_OpeningFcn gets called. An

% unrecognized property name or invalid value makes property application

% stop. All inputs are passed to Lempelziv_OpeningFcn via varargin.

%

% *See GUI Options on GUIDE's Tools menu. Choose "GUI allows only one

% instance to run (singleton)".

%

% See also: GUIDE, GUIDATA, GUIHANDLES

% Edit the above text to modify the response to help Lempelziv

% Last Modified by GUIDE v2.5 23-Apr-2012 23:14:09

% Begin initialization code - DO NOT EDIT

gui_Singleton = 1;

gui_State = struct('gui_Name', mfilename, ...

'gui_Singleton', gui_Singleton, ...

'gui_OpeningFcn', @Lempelziv_OpeningFcn, ...

'gui_OutputFcn', @Lempelziv_OutputFcn, ...

'gui_LayoutFcn', [] , ...

'gui_Callback', []);

if nargin && ischar(varargin{1})

gui_State.gui_Callback = str2func(varargin{1});

end

if nargout

[varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:});

else

gui_mainfcn(gui_State, varargin{:});

end

% End initialization code - DO NOT EDIT

% --- Executes just before Lempelziv is made visible.

function Lempelziv_OpeningFcn(hObject, eventdata, handles, varargin)

% This function has no output args, see OutputFcn.

% hObject handle to figure

% eventdata reserved - to be defined in a future version of MATLAB

% handles structure with handles and user data (see GUIDATA)

% varargin command line arguments to Lempelziv (see VARARGIN)

% Choose default command line output for Lempelziv

handles.output = hObject;

% Update handles structure

guidata(hObject, handles);

% Cambia El Icono de la esquina (cei).

javaFrame = get(hObject,'JavaFrame');

javaFrame.setFigureIcon(javax.swing.ImageIcon('icon.JPG'));

12

%C EvIta que se muestren los ejes del axis.

axis off

axes1=patch([0 1 1 0],[100 100 0 0],[0.5 0.5 0.5]);

% UIWAIT makes Lempelziv wait for user response (see UIRESUME)

% uiwait(handles.figure1);

% --- Outputs from this function are returned to the command line.

function varargout = Lempelziv_OutputFcn(hObject, eventdata, handles)

% varargout cell array for returning output args (see VARARGOUT);

% hObject handle to figure



% Get default command line output from handles structure

varargout{1} = handles.output;

function edit1_Callback(hObject, eventdata, handles)

% hObject handle to edit1 (see GCBO)



% Hints: get(hObject,'String') returns contents of edit1 as text

% str2double(get(hObject,'String')) returns contents of edit1 as a

double

% --- Executes during object creation, after setting all properties.

function edit1_CreateFcn(hObject, eventdata, handles)



% handles empty - handles not created until after all CreateFcns called

% Hint: edit controls usually have a white background on Windows.

% See ISPC and COMPUTER.

if ispc && isequal(get(hObject,'BackgroundColor'),

get(0,'defaultUicontrolBackgroundColor'))

set(hObject,'BackgroundColor','white');

end







double











end

13

% --- Executes on button press in pushbutton1.

function pushbutton1_Callback(hObject, eventdata, handles)

try

ingr=get(handles.edit1,'string');

ta=size(ingr);

buf=[num2str(0) num2str(0) num2str(0) num2str(0) num2str(0) num2str(0)

num2str(0) num2str(0) num2str(0) ingr(1) ingr(2) ingr(3) ingr(4) ingr(5)

ingr(6) ingr(7) ingr(8) ingr(9)];

a=0;

c=0;

x=c/ta(2);

t=0;

cod=[];

h=waitbar(0,'Comprimiendo...');

% Inicio del proceso de compresion, se realiza hasta que se haya procesado

todo lo ingresado.

while c<ta(2)

% Separa en un vector la sección sin procesar del bufer.

l=1;

while l<=9

bufpr(l)=buf(9+l);

l=l+1;

end

% ---------------------------------------.

% Declaracion de las variables a usarse en los proximos ciclos

% (enceración).

proc=[];

sproc=[];

n=1;

% ---- Proceso que va incrementando el tamaño de los vectores a compararse

% para encontrar la secuencias repetidas mas largas dentro del buffer, n

% tamaño del vector.

while n<9

% Acumuladores, va generando un vector de tamaño variable

% tanto de la parte a procesarse como de la procesada con el fin de

% tener vectores de igual tamaño que se puedan comparar y así buscar

% la máxima longitud de repeticion posible (8), permite automatizar el

% proceso dado que si no existen repeticiones la maxima longitud es 1 y

% el programa lo detecta, n es el tamaño del vector que se genera.

proc=[proc buf(9+n)];

sproc=[sproc buf(n)];

k=0;

% proceso de comparación, k controla la posición en la que se ubica el

% vector sin procesar de longitud y posicón variable, lo que permite

% comparar secuencias en la sección total del bufer con la sección

% procesada de posición fija con vector auxiliar de longitud variable

% que permite la comparación.

while (n+k)<=18

% aquí se modifica el vector que se comparará con el de la sección

% a procesar, se forma automáticamente dicho vector dependiendo de

% la posición de inicio y del tamaño del mismo, lo que permite

% buscar repeticiones de cualquier longitud hasta 8 en cualquier

% parte del bufer, ya que con k se va realizando el desplazamiento.

d=1;

while (d+k)<=(n+k)

sproc(d)=buf(d+k);

d=d+1;

end

14

% aquí se realiza la verificación de repeticiones, comparando los

% vectores del mismo tamaño procesado y sin procesar, el ultimo

% siendo un vector fijo desde la posición 9 y el otro móvil a

% traves de todo el bufer hasta la posición 9, puesto que si va mas

% allá en la sección sin procesar habra fallos en la descompresión.

if sproc==proc;

% la estructura que tiene (comparación de algo de lo cual lo que

% vale es el caso contrario) es resultado de un intento de lograr

% el objetivo del programa de un efoque previo diferente del cual

% se recicló esta sección modificandola lo menos posible.

% este if verifica que la posición del vector movil no esté dentro

% de la sección sin procesar

if (k+1)>=9

else

% este if evita que si la longitud de la secuencia ingresada no

% coincide exactamente con los desplazamientos progresivos de

% la misma en el bufer provoque que los últimos espacios se

% llenen con ceros alterando el código generado.

if t==0

codtemp=[num2str(k) num2str(n) bufpr(n+1)];

k=18;

a=a+1;

else

% en el caso que la rescuencia restante ingresada no

% complete el bufer se genera un código específico basado

% en alteraciones provocadas mas abajo que garantizan que

% sea correcto.

codtemp=[num2str(k) num2str(n-1) bufpr(n)];

% si el programa se encuentra en la sección que genera el código

% con una longitud de repetición cualquiera encuentra coincidencia

% no hay necesidad de buscar mas coincidencias de la mima longitud,

% k=18 provocará que se detenga la búsqueda y que se proceda a

% realizar lo mismo con una longitud mayor.

k=18;

% variable acumuladora que permitirá detectar si ha habido

% coincidencias en la generación de código, para que si no es así

% se genere un código específico para dicho caso.

a=a+1;

end

end

end

k=k+1;

end

n=n+1;

end

% aqui se genera el codigo (80(contenido de la posición 9 del bufer)) que

% sería el correcto en el caso que no haya habido una sola coincidencia.

if a==0

codtemp=[num2str(8) num2str(0) bufpr(1)];

end

% se acumula el codigo tempporal(de cada ves que se pocesa

% el bufer).

cod=[cod codtemp];

a=0;

b=1;

t=0;

% modificación del estado de la barra de progreso

waitbar(x)

% acumulador que permite saber cuántos caracteres se han procesado

c=c+(str2num(codtemp(2))+1);

15

x=c/ta(2);

% desplazador de la secuencia ingresada a traves ddel bufer dependiendo del

% código generado en la últim configuracion del bufer.

while b<=18

if b<=(17-(str2num(codtemp(2))))

buf(b)=buf(b+(str2num(codtemp(2))+1));

else

if (b-9+c)<=ta(2)

buf(b)=ingr(b-9+c);

else

% en el caso que la longitud restante sea insuficiente se rellena

% con ~ evitando llenado automatico de ceros que provoca un codigo

% erroneo.

buf(b)='~';

% la variable que detecta este estado cambia para permitir realizar

% los procesos pertinentes.

t=1;

end

end

b=b+1;

end

end

x=1;

% reconfiguración y cierre de la barra y creación de ratio de compreción y

% su respectivo gráfico, para el mismo existen secciones de código también

% en las secciones de iniciación de la ventana arriba.

waitbar(x,h,'Completado')

close(h)

set(handles.edit2,'string',cod)

y=size(cod);

por=(y(2)/ta(2))*100;

set(handles.text4,'Visible','on')

set(handles.edit3,'string',por)

axes1=patch([0 1 1 0],[100 100 0 0],[0.5 0.5 0.5]);

axes1=patch([0 1 1 0],[por por 0 0],'g');

axis([0, 1, 0, 100]);

axis off

catch

% debido a la configuración del programa este solo funciona si la

% secuencia ingresada es de al menos 9 caracteres, si esto no es así se

genera un error, debido a ello se usa

% un try catch para aprovechar esta coondición e informar al usuario q

% la secuencia es muy pequeña al generarse dicho error.

msgbox('La secuencia a comprimir es muy pequeña')

end

% hObject handle to pushbutton1 (see GCBO)





try

% adquisicion de datos, creacion de bufer, declaracion de variables e

% inicio de barra de espera.

cod=get(handles.edit2,'string');

ta=size(cod);

buf=[num2str(0) num2str(0) num2str(0) num2str(0) num2str(0) num2str(0)

num2str(0) num2str(0) num2str(0)];

c=0;

deco=[];

16

x=c/ta(2);

h=waitbar(0,'Descomprimiendo...');

% --- Descompresor.

% controla que se procese el código de 3 en 3 hasta que se procese todo el

% codigo.

while (c+3)<=ta(2)

% crea un vector con los 3 digitos del codigo a procesarse en ese

instante.

copro=[cod(c+1) cod(c+2) cod(c+3)];

k=0;

% se realizan la interpolaciones del código las veces que lo indica el

% digito 2 del codigo q se esta procesando a ese inatante.

while k<(str2num(copro(2)))

a=str2num(copro(1))+1;

b=buf(a);

d=1;

while d<9

buf(d)=buf(d+1);

d=d+1;

end

buf(9)=b;

k=k+1;

end

% Realiza la última iteración que no está contemplada en el número 2 del

% código y coloca el dígito apropiado al final de la misma.

d=1;

while d<9

buf(d)=buf(d+1);

d=d+1;

end

buf(9)=copro(3);

% crea una variable que permite conocer cuántos dígitos del nuevo estado

% del bufer son correspondientes a la secuencia original y vuelca los

% mismos a un vector sobreescribible que se acumulará en otro vector que

% guarda la secuencia total (decotemp y deco respectivamente).

t=9-(str2num(copro(2))+1);

d=1;

decotemp=buf(t+1);

decotemp(d)=buf(t+1);

while t<9

decotemp(d)=buf(t+1);

d=d+1;

t=t+1;

end

% acumula la longitud que se va procesando para controlar el avance del

% proceso y evitar bucle infinito

c=c+3;

x=c/ta(2);

waitbar(x)

deco=[deco decotemp];

end

% crea las mismas condiciones finales que en el compresor: actualización de

% la barra, obtención del radio de compresión y su respectivo gráfico.

x=1;


close(h)

l=size(deco);

por=(ta(2)/l(2))*100;

set(handles.edit4,'string',deco)

17

set(handles.text4,'Visible','on')

set(handles.edit3,'string',por)

axes1=patch([0 1 1 0],[100 100 0 0],[0.5 0.5 0.5]);

axes1=patch([0 1 1 0],[por por 0 0],'g');

axis([0, 1, 0, 100])

axis off

catch

% para el descompresor la condición que genera un error es que exista

% un 9 en la posición que indica la posicion menos 1 de inicio de la

% repetición, puesto que el bufer es de long 9, dicho numero

% representaría una posición 10 inexistente.

msgbox('El código ingresado no es válido o está corrupto')

close(h)

end




% --- Executes on mouse press over figure background.

function figure1_ButtonDownFcn(hObject, eventdata, handles)

% hObject handle to figure1 (see GCBO)



% --- Executes on mouse press over figure background, over a disabled or

% --- inactive control, or over an axes background.

function figure1_WindowButtonDownFcn(hObject, eventdata, handles)





function figure1_CreateFcn(hObject, eventdata, handles)




% --- Executes during object deletion, before destroying properties.

function figure1_DeleteFcn(hObject, eventdata, handles)




% --- Executes on key press with focus on figure1 and none of its controls.

function figure1_KeyPressFcn(hObject, eventdata, handles)


% eventdata structure with the following fields (see FIGURE)

% Key: name of the key that was pressed, in lower case

% Character: character interpretation of the key(s) that was pressed

% Modifier: name(s) of the modifier key(s) (i.e., control, shift) pressed




% setea a las condiciones iniciales todos los elementos.

set(handles.edit1,'string','SECUENCIA EN BINARIO')

set(handles.edit2,'string','CÓDIGO')

set(handles.edit4,'string','SECUENCIA DECODIFICADA')

set(handles.edit3,'string','')

set(handles.edit7,'string','')

axes1=patch([0 1 1 0],[100 100 0 0],[0.5 0.5 0.5]);

18










double











end







double











end







double



19









end



fid=fopen('texto.txt');

ingr='';

while 1

tline = fgetl(fid);

if ~ischar(tline), break, end

for i=1:length(tline)

ingr=cat(2,ingr,(tline(i)));

end

end

fclose(fid);

ingr2=char(ingr);

set(handles.edit7,'String',ingr2)

handles.ingr=ingr;

guidata(hObject,handles);






dat=get(handles.edit7,'string')

binar=dec2bin(dat)

ta=size(binar)

a=1

g=[]

x=a/ta(1);

h=waitbar(0,'Convirtiendo a binario...');

while a<=ta(1)

c=binar(a,:)

g=cat(2,g,c)

a=a+1

x=a/ta(1);

waitbar(x)

end

x=1;


close(h)

set(handles.edit1,'string',g)




20

Se concluyó que el algoritmo de Lempel Ziv es un eficaz algoritmo de

compresión, aunque en la vida práctica es bastante utilizado para comprimir

archivos de imágenes, por medio de la implementación del algoritmo en un

software pudimos constatar que también puede comprimir archivos de texto.

Se concluyó que al armar el diccionario sobre la marcha se evita hacer dos

pasadas sobre el texto, una analizando y la otra codificando y dado que la regla

de armado del diccionario es tan simple, el descompresor puede reconstruirlo a

partir del texto comprimido mientras lo lee, evitando así incluir el diccionario

dentro del texto comprimido.

Por medio de la implementación del código en un software computacional se

concluyó que el algoritmo de Lempel Ziv es bastante eficiente para comprimir

archivos de texto en especial texto en binario, especialmente en cadenas largas

de texto, y cuando existen bucles largos de repetición ya sean estos de ceros o

unos.

Por medio del programa se concluyó que en muchos casos el resultado

comprimido posee un alto porcentaje de compresión respecto de la información

original, dicho de otra manera, los resultados comprimidos ocupan un menor

número de bits respecto a los números de bits que ocupan los de la información

no comprimida.

Por medio del programa computacional se constató que el algoritmo de

compresión de Lempel Ziv es sin pérdidas, ya que al descomprimir el archivo

volvemos a tener el archivo original que se tenía antes de la compresión.

Se recomienda utilizar el programa siguiendo el correspondiente manual

incorporado, de esta manera se facilitará el uso del mismo para el usuario.

Es recomendable usar el programa implementado para comprimir cadenas de

textos largos ya que de esta manera se observará una mejor tasa de

compresión respecto a la cadena original, además el algoritmo funciona de

mejor manera.

No se recomienda utilizar el programa con cadenas de texto demasiado cortas,

ya que el programa no comprimirá debido a que el propio algoritmo de Lempel

Ziv está básicamente diseñado para secuencias largas.

Se recomienda utilizar el algoritmo de compresión Lempel Ziv para comprimir

imágenes, pero como se pudo constatar también puede comprimir otros tipos

de información como texto por ejemplo.

21

Se sugiere observar detenidamente todos los parámetros indicados en la

ventana principal del programa implementado, de esta manera se podrá

constatar, comprender y comprobar de mejor manera el proceso de

compresión realizado.

Para ingresar nuevas cadenas de texto al compresor se recomienda utilizar el

botón “Limpiar”, de esta forma se reiniciaran todos los parámetros en la

ventana principal y se podrá ingresar una nueva secuencia de texto para que

sea comprimida.

BIBLIOGRAFÍA

http://ocw.udl.cat/enginyeria-i-arquitectura/codificacio-i-transport-de-la-infomacio/Contenidos/2/CompSinPerd.pdf

http://www.programacion.com/articulo/introduccion_a_la_compresion_de_datos:_lempel-ziv-_gzip_186/4

http://es.kioskea.net/contents/video/compress.php3 http://www.mathworks.com/matlabcentral/fileexchange/29345-exemple-of-lempel-ziv-

coding Paquete Computacional Matlab R2009a





http://es.kioskea.net/contents/video/compress.php3

http://www.mathworks.com/matlabcentral/fileexchange/29345-exemple-of-lempel-ziv-coding

http://www.mathworks.com/matlabcentral/fileexchange/29345-exemple-of-lempel-ziv-coding

22

INDICE

Pág

PORTADA I

IMPLEMENTACION DEL ALGORITMO DE LEMPEL ZIV EN MATLAB 1

OBJETIVOS 1

INTRODUCCIÓN 1

MANUAL DE USUARIO DEL PROGRAMA 2

DIAGRAMA DE FLUJO DEL ALGORITMO DE LEMPEL ZIV 6

DIAGRAMA DE FLUJO DEL COMPRESOR 6

DIAGRAMA DE FLUJO DEL DESCOMPRESOR 9

CODIGO FUENTE DEL ALGORITMO DE LEMPEL ZIV APLICADO EN MATLAB 11

CONCLUSIONES 20

RECOMENDACIONES y SUGERENCIAS 20

BIBLIOGRAFÍA 21

Implementacion Del Lempel Ziv en Matlab

Documents

Transcript of Implementacion Del Lempel Ziv en Matlab