ESCUELA POLITÉCNICA NACIONAL

Introducción a la Multimedia

InformeIntegrantes:

Mena Byron Naranjo José Luis Oyana Christian

Tema: Codificador y Decodificar JPEGObjetivos:

Implementar un codificador y decodificar JPEG que realice todo el algoritmo de compresión para imágenes JPEG.

Determinar las ventajas y desventajas que nos muestra este tipo de algoritmos.

Visualizar la calidad de compresión que nos brinda dicho algoritmo y advertir los pros i los contras que se generan al usar dicho proceso de compresión.

Marco teórico:

Joint Photographic Experts Group

JPEG

Foto de una flor comprimida gradualmente con

el formato JPEG.

Extensión de

archivo

.jpeg, .jpg, .jpe

.jfif, .jfi, .jif (contenedores)

Tipo de MIME image/jpeg

Type code JPEG

Uniform Type

Identifierpublic.jpeg

ESCUELA POLITÉCNICA NACIONAL

Introducción a la Multimedia

Número mágico ff d8

Tipo de formatoGráficos con compresión

con pérdida

JPEG (del inglés Joint Photographic Experts Group, Grupo Conjunto de Expertos en Fotografía), es el nombre de un comité de expertos que creó un estándar de compresión y codificación de archivos de imágenes fijas. Este comité fue integrado desde sus inicios por la fusión de varias agrupaciones en un intento de compartir y desarrollar su experiencia en la digitalización de imágenes. La ISO, tres años antes (abril de 1983), había iniciado sus investigaciones en el área.

Además de ser un método de compresión, es a menudo considerado como un formato de archivo. JPEG/Exif es el formato de imagen más común utilizado por las cámaras fotográficas digitales y otros dispositivos de captura de imagen, junto con JPG/JFIF, que también es otro formato para el almacenamiento y la transmisión de imágenes fotográficas en la World Wide Web. Estas variaciones de formatos a menudo no se distinguen, y se llaman JPEG. Los archivos de este tipo se suelen nombrar con la extensión .jpg.

Compresión del JPEG

Comparativa de calidad entre la imagen original, comprimida en JPG (con pérdida) y comprimida en WebP (con pérdida).

El formato JPEG utiliza habitualmente un algoritmo de compresión con pérdida para reducir el tamaño de los archivos de imágenes. Esto significa que al descomprimir o visualizar la imagen no se obtiene exactamente la misma imagen de la que se partía antes de la compresión. Existen también tres variantes del estándar JPEG que comprimen la imagen sin pérdida de datos: JPEG2000, JPEG-LS y Lossless JPEG.

El algoritmo de compresión JPEG se basa en dos defectos visuales del ojo humano, uno es el hecho de que es mucho más sensible al cambio en la luminancia que en la crominancia, es decir, capta más claramente los cambios de brillo que de color. El otro es que nota con más facilidad

ESCUELA POLITÉCNICA NACIONAL

Introducción a la Multimedia

pequeños cambios de brillo en zonas homogéneas que en zonas donde la variación es grande, por ejemplo en los bordes de los cuerpos de los objetos.

Una de las características del JPEG es la flexibilidad a la hora de ajustar el grado de compresión. Un grado de compresión muy alto generará un archivo de pequeño tamaño, a costa de una pérdida significativa de calidad. Con una tasa de compresión baja se obtiene una calidad de imagen muy parecida a la del original, pero con un tamaño de archivo mayor.

La pérdida de calidad cuando se realizan sucesivas compresiones es acumulativa. Esto significa que si se comprime una imagen y se descomprime, se perderá calidad de imagen, pero si se vuelve a comprimir una imagen ya comprimida se obtendrá una pérdida todavía mayor. Cada sucesiva compresión causará pérdidas adicionales de calidad. La compresión con pérdida no es conveniente en imágenes o gráficos que tengan textos, líneas o bordes muy definidos, pero sí para archivos que contengan grandes áreas de colores sólidos.

Codificación

Muchas de las opciones del estándar JPEG se usan poco. Esto es una descripción breve de uno de los muchos métodos usados comúnmente para comprimir imágenes cuando se aplican a una imagen de entrada con 24 bits por pixel (ocho por cada rojo, verde, y azul, o también dicho "8 bits por canal"). Esta opción particular es un método de compresión con pérdida.

Transformación del espacio de color

Esquema del modelo RGB.

ESCUELA POLITÉCNICA NACIONAL

Introducción a la Multimedia

Esquema del modelo YUV.

Comienza convirtiendo la imagen desde su modelo de color RGB a otro llamado YUV ó YCbCr. Este espacio de color es similar al que usan los sistemas de color para televisión PAL y NTSC, pero es mucho más parecido al sistema de televisión MAC.

Este espacio de color (YUV) tiene tres componentes:

La componente Y, o luminancia (información de brillo), es decir, la imagen en escala de grises.

Las componentes U o Cb y V o Cr, respectivamente diferencia del azul (relativiza la imagen entre azul y rojo) y diferencia del rojo (relativiza la imagen entre verde y rojo); ambas señales son conocidas como crominancia (información de color).

El resultado es una imagen en la que la luminancia está separada de la crominancia.

Las ecuaciones que realizan este cambio de base de RGB a YUV son las siguientes:

Y = 0.257 * R + 0.504 * G + 0.098 * B + 16Cb = U = -0.148 * R - 0.291 * G + 0.439 * B + 128Cr = V = 0.439 * R - 0.368 * G - 0.071 * B + 128

Las ecuaciones para el cambio inverso se pueden obtener despejando de las anteriores y se obtienen las siguientes:

B = 1.164 * (Y - 16) + 2.018 * (U - 128)G = 1.164 * (Y - 16) - 0.813 * (V - 128) - 0.391 * (U - 128)R = 1.164 * (Y - 16) + 1.596 * (V - 128)

NOTA: Estas ecuaciones están en continua investigación, por lo que se pueden encontrar en libros y en la red otras ecuaciones distintas pero con coeficientes muy parecidos.

ESCUELA POLITÉCNICA NACIONAL

Introducción a la Multimedia

Si se analiza el primer trío de ecuaciones veremos que las tres componentes toman como valor mínimo el 16. El canal de luminancia (canal Y) tiene como valor máximo el 235, mientras que los canales de crominancia el 240, todos estos valores caben en un byte haciendo redondeo al entero más próximo. Durante esta fase no hay pérdida significativa de información, aunque el redondeo introduce un pequeño margen de error imperceptible para el ojo humano.

Submuestreo

Ligera explicación visual sobre el submuestreo, la imagen de arriba a la izquierda es la original, las otras sufren unos submuestreos de color salvajes que dan idea de los efectos de esta técnica. Ampliar para mejor visualización.

El algoritmo JPEG, transforma la imagen en cuadrados de 8×8 y luego almacena cada uno de estos como una combinación lineal o suma de los 64 recuadros que forman esta imagen, esto permite eliminar detalles de forma selectiva, por ejemplo, si una casilla tiene un valor muy próximo a 0, puede ser eliminada sin que afecte mucho a la calidad.

Una opción que se puede aplicar al guardar la imagen, es reducir la información del color respecto a la de brillo (debido al defecto en el ojo humano comentado anteriormente). Hay varios métodos: si este paso no se

ESCUELA POLITÉCNICA NACIONAL

Introducción a la Multimedia

aplica, la imagen sigue en su espacio de color YUV, (este submuestreo se entiende como 4:4:4), con lo que la imagen no sufre pérdidas. Puede reducirse la información cromática a la mitad, 4:2:2 (reducir en un factor de 2 en dirección horizontal), con lo que el color tiene la mitad de resolución (en horizontal), y el brillo sigue intacto. Otro método, muy usado, es reducir el color a la cuarta parte, 4:2:0, en el que el color se reduce en un factor de 2 en ambas direcciones, horizontal y vertical. Si la imagen de partida estaba en escala de grises (blanco y negro), puede eliminarse por completo la información de color, quedando como 4:0:0.

Algunos programas que permiten el guardado de imágenes en JPEG (como el que usa GIMP) se refieren a estos métodos con 1×1,1×1,1×1 para YUV 4:4:4 (no perder color), 2×1,1×2,1×1 para YUV 4:2:2 y 2×2,1×1,1×1 para el último método, YUV 4:2:0.

Las técnicas algorítmicas usadas para este paso (para su reconstrucción exactamente) suelen ser interpolación bilineal, vecino más próximo, convolución cúbica, Bezier, b-spline y Catmun-Roll.rh

Transformación discreta de coseno o DCT

Cada componente de la imagen se divide en pequeños bloques de 8×8 píxeles, que se procesan de forma casi independiente, lo que disminuye notablemente el tiempo de cálculo. De esto resulta la típica formación cuadriculada, que se vuelve visible en las imágenes guardadas con alta compresión. Si la imagen sufrió un submuestreo del color, los colores quedarían en la imagen final en bloques de 8×16 y 16×16 píxeles, según fuese 4:2:2 o 4:2:0.

Después, cada pequeño bloque se convierte al dominio de la frecuencia a través de la transformación discreta de coseno, abreviadamente llamada DCT.

Un ejemplo de uno de esos pequeños bloques de 8×8 inicial es este:

El siguiente proceso es restarles 128 para que queden números entorno al 0, entre -128 y 127.

ESCUELA POLITÉCNICA NACIONAL

Introducción a la Multimedia

Se procede a la transformación por DCT de la matriz, y el redondeo de cada elemento al número entero más cercano.

Nótese que el elemento más grande de toda la matriz aparece en la esquina superior izquierda, este es el coeficiente DC.

Cuantificación digital

"Antes de", en un bloquecillo 8×8 (ampliación ×16).

ESCUELA POLITÉCNICA NACIONAL

Introducción a la Multimedia

"Después de", en un bloquecillo 8×8, se notan errores respecto a la primera imagen, como en la esquina inferior izquierda, que está más clara.

El ojo humano es muy bueno detectando pequeños cambios de brillo en áreas relativamente grandes, pero no cuando el brillo cambia rápidamente en pequeñas áreas (variación de alta frecuencia). Aprovechando este defecto, se puede eliminar las altas frecuencias, sin pérdida excesiva de calidad visual. Esto se realiza dividiendo cada componente en el dominio de la frecuencia por una constante para ese componente, y redondeándolo a su número entero más cercano. Este es el proceso en el que se pierde la mayor parte de la información (y calidad) cuando una imagen es procesada por este algoritmo. El resultado de esto es que los componentes de las altas frecuencias, tienden a igualarse a cero, mientras que muchos de los demás, se convierten en números positivos y negativos pequeños.

Una matriz de cuantificación típica es la matriz de Losheller que se usa opcionalmente en el estándar JPEG:

Dividiendo cada coeficiente de la matriz de la imagen transformada entre cada coeficiente de la matriz de cuantificación, se obtiene esta matriz, ya cuantificada:

Por ejemplo, cuantificando el primer elemento, el coeficiente DC, sería así:

ESCUELA POLITÉCNICA NACIONAL

Introducción a la Multimedia

Codificación entrópica

La codificación entrópica es una forma especial de la compresión sin pérdida de datos. Para ello se toman los elementos de la matriz siguiendo una forma de zig-zag, poniendo grupos con frecuencias similares juntos, e insertando ceros de codificación, y usando la codificación Huffman para lo que queda. También se puede usar la codificación aritmética, superior a la de Huffman, pero que rara vez se usa, ya que está cubierta por patentes, esta compresión produce archivos un 5% menores, pero a costa de un mayor tiempo de codificación y decodificación, esta pequeña ganancia, puede emplearse también en aplicar un menor grado de compresión a la imagen, y obtener más calidad para un tamaño parecido.

En la matriz anterior, la secuencia en zig-zag, es esta:−26, −3, 0, −3, −2, −6, 2, −4, 1 −4, 1, 1, 5, 1, 2, −1, 1, −1, 2, 0, 0, 0, 0, 0, −1, −1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0

JPEG tiene un código Huffman para cortar la cadena anterior en el punto en el que el resto de coeficientes sean ceros, y así, ahorrar espacio:−26, −3, 0, −3, −2, −6, 2, −4, 1 −4, 1, 1, 5, 1, 2, −1, 1, −1, 2, 0, 0, 0, 0, 0, −1, −1, EOB

Ruido producido por la compresión

Tras la compresión, suelen quedar a veces bloques como estos, en este caso en un trozo de una imagen ampliado.

El resultado tras la compresión, puede variar, en función de la agresividad de los divisores de la matriz de cuantización, a mayor valor de esos divisores, más coeficientes se convierten en ceros, y más se comprime la imagen. Pero mayores compresiones producen mayor ruido en la imagen, empeorando su calidad. Una imagen con una fuerte compresión (1%-15%) puede tener un tamaño de archivo mucho menor, pero tendrá tantas imperfecciones que no será interesante, una compresión muy baja (98%-100%) producirá una imagen de muy alta calidad, pero, tendrá un tamaño tan grande que quizás interese más un formato sin pérdida como PNG.

ESCUELA POLITÉCNICA NACIONAL

Introducción a la Multimedia

La mayoría de personas que naveguen por Internet estarán familiarizadas con estas imperfecciones, son el resultado de lograr una buena compresión; para evitarlos, se tendrá que reducir el nivel de compresión o aplicar compresión sin pérdida, produciendo mayores ficheros después.

Decodificación

El proceso de decodificación es similar al seguido hasta ahora, sólo que de forma inversa. En este caso, al haber perdido información, los valores finales no coincidirán con los iniciales.

Se coge la información de la matriz, se decodifica, y se pone cada valor en su casilla correspondiente. Después se multiplica cada uno de estos valores por el valor correspondiente de la matriz de cuantización usada, como muchos valores son ceros, sólo se recuperan ( y de forma aproximada) los valores de la esquina superior izquierda.

Después se deshace la transformación DCT:

Errores producidos por una compresión excesiva: Antes de y después de.

ESCUELA POLITÉCNICA NACIONAL

Introducción a la Multimedia

Y finalmente se suma 128 a cada entrada:

Para comparar las diferencias entre el bloque original y el comprimido, se halla la diferencia entre ambas matrices, la media de sus valores absolutos, da una ligera idea de la calidad perdida:

Se puede observar que las mayores diferencias están cerca de la mancha, y por la parte inferior, entre la esquina izquierda y el centro, notándose más esta última, ya que corre una mancha clara que antes estaba más hacia la esquina. La media de los valores absolutos de las restas es 4.8125, aunque en algunas zonas es mayor.

ESCUELA POLITÉCNICA NACIONAL

Introducción a la Multimedia

Implementación Practica en Matlab::

Algoritmo del Codificador:

% Begin initialization code - DO NOT EDITgui_Singleton = 1;gui_State = struct('gui_Name', mfilename, ... 'gui_Singleton', gui_Singleton, ... 'gui_OpeningFcn', @CodificadorJPEG_OpeningFcn, ... 'gui_OutputFcn', @CodificadorJPEG_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 CodificadorJPEG is made visible.function CodificadorJPEG_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 CodificadorJPEG (see VARARGIN) % Choose default command line output for CodificadorJPEG

ESCUELA POLITÉCNICA NACIONAL

Introducción a la Multimedia

handles.output = hObject; % Update handles structureguidata(hObject, handles); % UIWAIT makes CodificadorJPEG wait for user response (see UIRESUME)% uiwait(handles.figure1); % --- Outputs from this function are returned to the command line.function varargout = CodificadorJPEG_OutputFcn(hObject, eventdata, handles) % varargout cell array for returning output args (see VARARGOUT);% hObject handle to figure% eventdata reserved - to be defined in a future version of MATLAB% handles structure with handles and user data (see GUIDATA) % Get default command line output from handles structurevarargout{1} = handles.output; % --- Executes on button press in btnAbrir.function btnAbrir_Callback(hObject, eventdata, handles) %Pedimos que ingrese el nombre de la imagen a procesar con su extensión.[nombreImagen,ruta] = uigetfile('*.jpg','Seleccione la Imagen');if nombreImagen==0 returnend%Leemos la imagen y almacenamos su contenido en una matriz.imagen_RGB = imread(fullfile(ruta,nombreImagen));%axes(handles.imagenOriginal);imshow(imagen_RGB);axis off;handles.imagen = imagen_RGB;guidata(hObject,handles); % --- Executes on button press in btnCodificar.function btnCodificar_Callback(hObject, eventdata, handles) %Leemos la imagen original que se encuentra en la variable imagen imagenRGB = handles.imagen; %Obtenemos el tamaño de la imagen. [largo ancho planos]=size(imagenRGB); %Convertimos de RGB a YCbCr. imagenYCbCr=rgb2ycbcr(imagenRGB); %Separamos la la luminancia y las crominancias de la imagen convertida YCbCr. %Luminancia

ESCUELA POLITÉCNICA NACIONAL

Introducción a la Multimedia

Y = imagenYCbCr(:,:,1); %Primera Crominancia Cb = imagenYCbCr(:,:,2); %Segunda Crominancia Cr = imagenYCbCr(:,:,3); %========================================================================== %Realizamos el submuestreo de las crominancias %Para Cb Cb_sub = imresize(Cb,0.5,'nearest'); %Para Cr Cr_sub = imresize(Cr,0.5,'nearest'); %========================================================================== %Restamos 128 Y_128=Y; Cb_sub_128=Cb_sub; Cr_sub_128=Cr_sub; %Cálculo de las DCT de las tres matrices Y_128_dct = blkproc(Y_128,[8 8],@dct2); Cb_sub_128_dct = blkproc(Cb_sub_128,[8 8],@dct2); Cr_sub_128_dct = blkproc(Cr_sub_128,[8 8],@dct2); %Matrices del estandar JPEG para cuantificar las luminancias y las %Luminancias Q_luminancias=[16 11 10 16 124 140 151 161 12 12 14 19 126 158 160 155 14 13 16 24 140 157 169 156 14 17 22 29 151 187 180 162 18 22 37 56 168 109 103 177 24 35 55 64 181 104 113 192 49 64 78 87 103 121 120 101 72 92 95 98 112 100 103 199]; %Crominancias Q_crominancias=[17 18 24 47 99 99 99 99 18 21 26 66 99 99 99 99 24 26 56 99 99 99 99 99 47 66 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99]; %Funcion para cuantificar las luminancias y las crominancias

ESCUELA POLITÉCNICA NACIONAL

Introducción a la Multimedia

funcLuminancias = @(x) x./Q_luminancias; funcCrominancias = @(x) x./Q_crominancias; %%Cálculo de las DCT cuantificadas de las tres matrices Y_128_dct_q = blkproc(Y_128_dct, [8 8],funcLuminancias); Cb_sub_128_dct_q = blkproc(Cb_sub_128_dct, [8 8],funcCrominancias); Cr_sub_128_dct_q = blkproc(Cr_sub_128_dct, [8 8],funcCrominancias); %Aproximamos los valores de cada una de las matrices Y_128_dct_q_r = round(Y_128_dct_q); Cb_sub_128_dct_q_r = round(Cb_sub_128_dct_q); Cr_sub_128_dct_q_r = round(Cr_sub_128_dct_q); %Llamamos a la funcion zigzag funcionZigzag=@zigzag; Y_zz = blkproc(Y_128_dct_q_r, [8 8], funcionZigzag); CB_zz = blkproc(Cb_sub_128_dct_q_r, [8 8], funcionZigzag); CR_zz = blkproc(Cr_sub_128_dct_q_r , [8 8], funcionZigzag); %Guardar el imagen codificada en un archivo binario [name,path]=uiputfile('*.pro','Guardar Imagen Codificada'); if name==0 return end pathCompleto = [path , name]; escribirArchivo(pathCompleto,largo,ancho,Y_zz,CB_zz,CR_zz) %Funcion para leer en zigzag de los bloques de 8x8 de cada matrizfunction [A]=zigzag(X) f=1; c=1; contador = 1; operacion = 1; valorColumna = size(X,2); parte1 = 0; for k=1:(valorColumna*valorColumna) if parte1 == 1 A(1,contador) = X(f,c); contador = contador + 1; if operacion == 3 f = f+1; if f > valorColumna

ESCUELA POLITÉCNICA NACIONAL

Introducción a la Multimedia

operacion = 4; f = valorColumna; c = c+1; else c = c-1; end elseif operacion ==4 c = c+1; if c > valorColumna operacion = 3; c = valorColumna; f = f+1; else f = f-1; end end else A(1,contador) = X(f,c); contador = contador + 1; if c==valorColumna operacion = 3; parte1 = 1; divColum = valorColumna/2; multColum = round(divColum)*2; if multColum == valorColumna f =f+1; c=c-1; else f= f+1; end end if operacion ==1 f = f-1; if f == 0 operacion = 2; f=1; end c = c+1; elseif operacion ==2 f = f+1; c = c-1; if c ==0 operacion = 1;

ESCUELA POLITÉCNICA NACIONAL

Introducción a la Multimedia

c=1; end end end endreturn %Funcion para obtener el archivo obtenido de la lectura del zigzag function escribirArchivo(pathCompleto,filas,columnas,datosSerializadosY,datosSerializadosCb,datosSerializadosCr) fid = fopen(pathCompleto,'w+'); PIXELESY = filas; PIXELESX = columnas; cabecera = [PIXELESY;PIXELESX]; fwrite(fid,cabecera,'uint16'); for i=1:numel(datosSerializadosY) fwrite(fid,datosSerializadosY(i),'int8'); end for i=1:numel(datosSerializadosCb) fwrite(fid,datosSerializadosCb(i),'int8'); end for i=1:numel(datosSerializadosCr) fwrite(fid,datosSerializadosCr(i),'int8'); end fclose(fid)

Algoritmo del Decodificador:% Begin initialization code - DO NOT EDITgui_Singleton = 1;gui_State = struct('gui_Name', mfilename, ... 'gui_Singleton', gui_Singleton, ... 'gui_OpeningFcn', @DecodifcadorJPEG_OpeningFcn, ... 'gui_OutputFcn', @DecodifcadorJPEG_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{:});

ESCUELA POLITÉCNICA NACIONAL

Introducción a la Multimedia

else gui_mainfcn(gui_State, varargin{:});end% End initialization code - DO NOT EDIT % --- Executes just before DecodifcadorJPEG is made visible.function DecodifcadorJPEG_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 DecodifcadorJPEG (see VARARGIN) % Choose default command line output for DecodifcadorJPEGhandles.output = hObject; % Update handles structureguidata(hObject, handles); % UIWAIT makes DecodifcadorJPEG wait for user response (see UIRESUME)% uiwait(handles.figure1); % --- Outputs from this function are returned to the command line.function varargout = DecodifcadorJPEG_OutputFcn(hObject, eventdata, handles) % varargout cell array for returning output args (see VARARGOUT);% hObject handle to figure% eventdata reserved - to be defined in a future version of MATLAB% handles structure with handles and user data (see GUIDATA) % Get default command line output from handles structurevarargout{1} = handles.output; % --- Executes on button press in btnDecodificar.function btnDecodificar_Callback(hObject, eventdata, handles) [nombreArchivo,ubicacion] = uigetfile('*.pro','Seleccione el Archivo'); if nombreArchivo==0 return end ruta=[ubicacion,nombreArchivo]; [largo_imagen,ancho_imagen,Y_zz_cod,CB_zz_cod,CR_zz_cod] = leerArchivo(ruta); %Transforma la matriz fila en una matriz cuadrada func_inv_zigzag = @invzigzag;

ESCUELA POLITÉCNICA NACIONAL

Introducción a la Multimedia

Y_128_dct_q = blkproc(Y_zz_cod, [1 64], func_inv_zigzag); Cb_sub_128_dct_q = blkproc(CB_zz_cod, [1 64],func_inv_zigzag); Cr_sub_128_dct_q = blkproc(CR_zz_cod, [1 64], func_inv_zigzag); %Matrices del estandar JPEG para cuantificar las luminancias y las %Luminancias Q_luminancias=[16 11 10 16 124 140 151 161 12 12 14 19 126 158 160 155 14 13 16 24 140 157 169 156 14 17 22 29 151 187 180 162 18 22 37 56 168 109 103 177 24 35 55 64 181 104 113 192 49 64 78 87 103 121 120 101 72 92 95 98 112 100 103 199]; %Crominancias Q_crominancias=[17 18 24 47 99 99 99 99 18 21 26 66 99 99 99 99 24 26 56 99 99 99 99 99 47 66 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99]; %Funciones para decuantizar las matrices funcDeLuminancia = @(x) x.*Q_luminancias; funcDeCrominancia = @(x) x.*Q_crominancias; %Decuantización de la luminacia y crominancias Y_128_dct= blkproc(Y_128_dct_q, [8 8],funcDeLuminancia); Cb_sub_128_dct = blkproc(Cb_sub_128_dct_q, [8 8],funcDeCrominancia); Cr_sub_128_dct = blkproc(Cr_sub_128_dct_q, [8 8],funcDeCrominancia); %Aplicamos la DCT inversa Y_128 = blkproc(Y_128_dct , [8 8], @idct2); Cb_sub_128 = blkproc(Cb_sub_128_dct, [8 8], @idct2); Cr_sub_128 = blkproc(Cr_sub_128_dct, [8 8], @idct2); %Sumamos 128 Y_idct=Y_128; Cb_sub=Cb_sub_128; Cr_sub=Cr_sub_128; %Escogemos los valores que corresponde a la imagen Y = Y_idct(1:largo_imagen,1:ancho_imagen); Cb_sub = Cb_sub(1:(round(largo_imagen/2)),1:(round(ancho_imagen/2))); Cr_sub = Cr_sub(1:(round(largo_imagen/2)),1:(round(ancho_imagen/2))); %Sobremuestreo de las matrices de crominancias Cb_sobre = imresize(Cb_sub,2,'box');

ESCUELA POLITÉCNICA NACIONAL

Introducción a la Multimedia

Cr_sobre = imresize(Cr_sub,2,'box'); %Nueva Imagen en YCbCr Cb = imresize(Cb_sobre, size(Y)); Cr = imresize(Cr_sobre, size(Y)); %Concatenamos las planos YCbCr para formar nuestra imagen nuevaImg = cat(3,Y,Cb,Cr); %Convertimos nuestra imagen al tipo unit8 nuevaImg_uint8 = uint8(nuevaImg); %Cambiamos de YCbCr a RGB RGB = ycbcr2rgb(nuevaImg_uint8); %Muestra la figura en RGB %axes(handles.imagenDecodificada); imshow(RGB); function [A]=invzigzag(X) %Guarda en forma de zig-zag los valores de las matrices f=1;c=1;cont = 1;operacion = 1;maxColum = size(X,2);part1 = 0;for k=1:(maxColum) if part1 == 1 A(f,c) = X(1,cont); cont = cont + 1; if operacion == 3 f = f+1; if f > sqrt(maxColum) operacion = 4; f = sqrt(maxColum); c = c+1; else c = c-1; end elseif operacion ==4 c = c+1; if c > sqrt(maxColum) operacion = 3; c = sqrt(maxColum); f = f+1;

ESCUELA POLITÉCNICA NACIONAL

Introducción a la Multimedia

else f = f-1; end end else A(f,c) = X(1,cont); cont = cont + 1; if c==sqrt(maxColum) operacion = 3; part1 = 1; divColum = sqrt(maxColum)/2; multColum = round(divColum)*2; if multColum == sqrt(maxColum) f =f+1; c=c-1; else f= f+1; end end if operacion ==1 f = f-1; if f == 0 operacion = 2; f=1; end c = c+1; elseif operacion ==2 f = f+1; c = c-1; if c ==0 operacion = 1; c=1; end end endend return function [AlturaImg,AnchoImg,Img_CodifY_zigzag_linea,Img_CodifCB_zigzag_linea,Img_CodifCR_zigzag_linea] = leerArchivo(ruta) fid = fopen(ruta,'r');

ESCUELA POLITÉCNICA NACIONAL

Introducción a la Multimedia

%Guarda la altura y el ancho de la imagenAlturaImg = fread(fid,1,'uint16'); AnchoImg = fread(fid,1,'uint16'); AlturaImg_mult8_Y = ceil(AlturaImg/8)*8;AnchoImg_mult8_Y = ceil(AnchoImg/8)*8; AlturaImg_mult8_CbCr = ceil(round(AlturaImg/2)/8)*8;AnchoImg_mult8_CbCr = ceil(round(AnchoImg/2)/8)*8; i=1; j=1; lecturaColum=0; lecturaFil=0; while lecturaFil < AlturaImg_mult8_Y while lecturaColum < AnchoImg_mult8_Y for c=1:64 Img_CodifY_zigzag_linea_i(i,j)=fread(fid,1,'int8'); %#ok j=j+1; end lecturaColum=lecturaColum+8; end i=i+1; j=1; lecturaColum=0; lecturaFil=lecturaFil+8;endImg_CodifY_zigzag_linea = reshapeColum(Img_CodifY_zigzag_linea_i); i=1; j=1; lecturaColum=0; lecturaFil=0; while lecturaFil < AlturaImg_mult8_CbCr while lecturaColum < AnchoImg_mult8_CbCr for c=1:64 Img_CodifCB_zigzag_linea_i(i,j)=fread(fid,1,'int8'); %#ok j=j+1; end lecturaColum=lecturaColum+8; end i=i+1; j=1; lecturaColum=0; lecturaFil=lecturaFil+8;end Img_CodifCB_zigzag_linea =reshapeColum(Img_CodifCB_zigzag_linea_i);

ESCUELA POLITÉCNICA NACIONAL

Introducción a la Multimedia

i=1; j=1; lecturaColum=0; lecturaFil=0;while lecturaFil < AlturaImg_mult8_CbCr while lecturaColum < AnchoImg_mult8_CbCr for c=1:64 Img_CodifCR_zigzag_linea_i(i,j)=fread(fid,1,'int8'); %#ok j=j+1; end lecturaColum=lecturaColum+8; end i=i+1; j=1; lecturaColum=0; lecturaFil=lecturaFil+8;end Img_CodifCR_zigzag_linea =reshapeColum(Img_CodifCR_zigzag_linea_i); fclose(fid) function [A]=reshapeColum(B) i=1;m = size(B,1);columnas=1;tamanio=size(B,2);for i=1: size(B,1) colum = 1; while colum <= size(B,2) exep=1; for fila=1:m if colum <= size(B,2) A(fila,columnas) = B(i,colum); fila = fila + 1; colum = colum+1; end if colum > size(B,2) && numel(A)~=(ceil(numel(B)/m)*m) if exep == 1 if i < size(B,1) i = i+1; end colum = 1; exep = exep +1; end else if colum > tamanio return

ESCUELA POLITÉCNICA NACIONAL

Introducción a la Multimedia

end end end columnas = columnas+1; end i = i+1;end

Conclusiones:

Se concluye que el algoritmo de codificación JPEG es un algoritmo que nos permite comprimir una imagen y de mucho mas resultado o compresión cunado se trata de imagines con una variación no muy significante en crominancias y en luminancias, sin embargo, y a pesar de que la compresión no es muy grande nos permite guardar imágenes con grandes variaciones como por ejemplo la de paisajes, y el momento de descomprimir el resultado es muy bueno pues solo surgen cambios casi imperceptibles para el ojo humano.

SE concluye que una compresión de una imagen usando el algoritmo de compresión JPEG es muy usado cundo se tiene imágenes de alta fidelidad, pues gurda mucha información real de la imagen y las perdidas producidas son irrelevantes.

Se concluye que el algoritmo de compresión JPEG puede se r con perdidas y sin perdidas dependiendo de la forma de implementación del algoritmo.

Se concluye que una imagen JPEG ocupa mucho mas espacio de memoria que otros formatos debido ala gran cantidad de información de la imagen que se gurda. Se concluye que dependiendo de la forma de implementación del algoritmo JPEG el archivo de la imagen pude muchas veces expandirse o reducirse.

Bibliografía:http://es.wikipedia.org/wiki/Joint_Photographic_Experts_Groupwww.pensamientoscomputables.com/.../algoritmo-covimeo.com/41038308docs.gimp.org/es/gimp-tutorial-quickie-jpeg.html