Teoria delle ondicelle 2/ Compressione di segnali e immagini a.a. 2006/2007 JPEG.

Presentazione sul tema: "Teoria delle ondicelle 2/ Compressione di segnali e immagini a.a. 2006/2007 JPEG."— Transcript della presentazione:

1 Teoria delle ondicelle 2/ Compressione di segnali e immagini a.a. 2006/2007 JPEG

2 function y = im2jpeg(x,quality) % y = im2jpeg(x,quality) comprime una immagine x usando lo schema % di JPEG: dct 8x8, quantizzazione, codifica di Huffman. % quality è uno scalare con il quale si modifica la tabella di % quantizzazione rispetto alla qualità con cui si vuole codificare % y è una variabile di tipo struct con i seguenti campi % y.size = dimensione di x % y.numblocks = numero di blocchi 8*8 % y.quality = fattore di qualità (in percentuale) % y.huffman = output della funzione mat2huff error(nargchk(1,2,nargin)); % controllo delle variabili di input if ndims(x)~= 2 | ~isreal(x) | ~isnumeric(x) | ~isa(x,'uint8') error('la variabile di input deve essere una immagine uint8 ') end if nargin < 2, quality = 1;, end

3 % tabella di quantizzazione m = [16 11 10 16 24 40 51 61; 12 12 14 19 26 58 60 55; 14 13 16 24 40 57 69 56; 14 17 22 29 51 87 80 62; 18 22 37 56 68 109 103 77; 24 35 55 64 81 104 113 92; 49 64 78 87 103 121 120 101; 72 92 95 98 112 100 103 99] * quality; % tabella per l'ordinamento a zig zag order = [1 9 2 3 10 17 25 18 11 4 5 12 19 26 33 41 34 27 20 13... 6 7 14 21 28 35 42 49 57 50 43 36 29 22 15 8 16 23 30... 37 44 51 58 59 52 45 38 31 24 32 39 46 53 60 61 54 47... 40 48 55 62 63 56 64];

4 [xm,xn] = size(x); % determina la dimensione della immagine di input x = double(x) - 128; % sottrae 128 ai valori della immagine di input t = dctmtx(8); % determina la matrice 8x8 per il calcolo della DCT y = blkproc(x,[8 8],'P1*x*P2',t,t'); % calcolo della DCT di x su blocchi % Bi di dimensione 8x8 usando la % seguente formula t*Bi*t' y = blkproc(y,[8 8],'round(x./P1)',m); % quantizza i coefficienti della % DCT di ogni blocco secondo % la tabella m y = im2col(y,[8 8],'distinct'); % trasforma ogni blocco 8x8 in un vettore % colonna, y è ora una matrice di % dimensione 64*numero_di_blocchi xb = size(y,2); % calcola il numero dei blocchi y = y(order,:); % ordina gli elementi di ogni blocco secondo % lo schema a zig zag in order

5 eob = max(x(:)) + 1; % definisce il simbolo di fine blocco r = zeros(numel(y)+size(y,2),1); count = 0; for j = 1:xb % per ogni blocco: i = max(find(y(:,j))); % trova l'ultimo elemento diverso da zero if isempty(i) i = 0; end p = count + 1; % tronca la sequenza eliminando gli zeri e % la aggiunge al vettore di output insieme q = p + i; % al simbolo di fine blocco r(p:q) = [y(1:i,j);eob]; count = count + i + 1; end r(count+1:end) = []; % elimina gli elementi di r non usati

6 % definisce la variabile di output y.size = uint16([xm xn]); y.numblocks = uint16(xb); y.quality = uint16(quality*100); y.huffman = mat2huff(r);

7 function x = jpeg2im(y) % x = jpeg2im(y) decodifica un' immagine codificata con la funzione % im2jpeg.m % % y è una variabile di tipo struct generata dalla funzione im2jpeg % x è una matrice corrispondente alla approssimazione della immagine % codificata in y error(nargchk(1,1,nargin)); % controllo della variabile di input

8 % tabella di quantizzazione m = [16 11 10 16 24 40 51 61; 12 12 14 19 26 58 60 55; 14 13 16 24 40 57 69 56; 14 17 22 29 51 87 80 62; 18 22 37 56 68 109 103 77; 24 35 55 64 81 104 113 92; 49 64 78 87 103 121 120 101; 72 92 95 98 112 100 103 99]; % tabella per l'ordinamento a zig zag order = [1 9 2 3 10 17 25 18 11 4 5 12 19 26 33 41 34 27 20 13... 6 7 14 21 28 35 42 49 57 50 43 36 29 22 15 8 16 23 30... 37 44 51 58 59 52 45 38 31 24 32 39 46 53 60 61 54 47... 40 48 55 62 63 56 64];

9 rev = order; % calcola l'ordinamento inverso % (da zig zag a lessicografico) for k = 1:length(order) rev(k) = find(order == k); end m = double(y.quality)/ 100 * m; % ricostruisce la tabella di % quantizzazione rispetto alla qualità % con cui si è effettuata la codifica xb = double(y.numblocks); % legge il numero di blocchi sz = double(y.size); % legge la dimensione della immagine da % decodificare xn = sz(2); % numero di colonne xm = sz(1); % numero di righe x = huff2mat1(y.huffman); % decodifica con l'algoritmo di Huffman eob = max(x(:)); % estrae il simbolo di fine blocco

10 z = zeros(64,xb); % definisce una matrice di zeri in cui ogni colonna % ha la dimensione di un blocco 8x8 stirato k = 1; % legge il vettore x e conserva gli elementi diversi % da zero in ogni colonna di z. for j = 1:xb % Ogni volta che trova un eob cambia blocco, % ovvero colonna di z for i = 1:64 if x(k) == eob k = k + 1; break; else z(i,j) = x(k); k = k + 1; end

11 z = z(rev,:); % ordina gli elementi di ogni colonna di z % secondo l'ordinamento lessicografico di % una matrice 8x8 x = col2im(z,[8 8],[xm xn],'distinct'); % genera una matrice di % dimensione xm*xn come % composizione di blocchi di % dimensione 8x8 i cui % elementi corrispondono ad % una colonna di z x = blkproc(x,[8 8],'x.*P1',m); % operazione inversa della % quantizzazione t = dctmtx(8); % determina la matrice 8x8 per % il calcolo della DCT x = blkproc(x,[8 8],'P1*x*P2',t',t); % per ogni blocco calcola la dct % inversa con l'operazione t'*Bi*t x = uint8(x + 128); % aggiunge 128 e trasforma in una % variabile uint8

12 % esempio di codifica e decodifica di una immagine usando le funzione % im2jpeg e jpeg2im I = zeros(16)+2; % immagine da codificare I(5:12,4:13) = 200; I = uint8(I); C1 = im2jpeg_ese(I); % codifica con im2jpeg Id = jpeg2im(C1); % decodifica con jpeg2im CR = imratio(I,C1); % calcola il rapporto di compressione disp('RAPPORTO DI COMPRESSIONE'), disp(CR), pause bpp = 8/CR % calcola il bpp % calcola il PSNR psnr = 10*log10(255^2/(mean2(abs(double(I)-double(Id)).^2))) figure, imshow(I,[]), title('immagine originale') figure, imshow(Id,[]), title('immagine decodificata')

13 function CR = imratio(I1,I2) % calcolo del rapporto di compressione CR = bytes(I1)/bytes(I2); %--------------------------------------- function b = bytes(I) % legge il numero di bytes della variabile b. Se b è di tipo struct, legge % i bytes occupati da ogni campo if ischar(I) % caso in cui I è il nome di un file info = dir(I);, b = info.bytes; elseif isstruct(I) % se I è una variabile di tipo struct, richiama ricorsivamente se stessa b = 0;, fields = fieldnames(I); for k = 1:length(fields) b = b + bytes(getfield(I,char(fields(k)))); end else % I non è una variabile di tipo struct info = whos('I');, b = info.bytes; end

14 % esempio di codifica e decodifica di una immagine usando le funzione % im2jpeg e jpeg2im I = imread('cameraman.tif'); % legge l'immagine da codificare C1 = im2jpeg(I); % codifica con im2jpeg Id = jpeg2im(C1); % decodifica con jpeg2im CR = imratio(I,C1); % calcola il rapporto di compressione disp('RAPPORTO DI COMPRESSIONE') disp(CR), pause bpp = 8/CR % calcola il bpp % calcola il PSNR psnr = 10*log10(255^2/(mean2(abs(double(I)-double(Id)).^2))) figure, imshow(I,[]), title('immagine originale') figure, imshow(Id,[]), title('immagine decodificata')

15 function [bpp,psnr] = curvaRDjpeg(nameim) % disegna la curva Rate Distortion per l'immagine nameim I = imread(nameim); % legge l'immagine da codificare for q = 1:15 C1 = im2jpeg(I,q); % codifica con im2jpeg Id = jpeg2im(C1); % decodifica con jpeg2im CR(q) = imratio(I,C1); % calcola il rapporto di compressione disp('qualita'), disp(q) disp('RAPPORTO DI COMPRESSIONE'), disp(CR(q)) bpp(q) = 8/CR(q) % calcola il bpp psnr(q) = 10*log10(255^2/(mean2(abs(double(I)-double(Id)).^2))) %PSNR pause figure, imshow(I,[]), title('immagine originale') figure, imshow(Id,[]), title(['immagine decodificata, qualita ',num2str(q)]) pause end figure, plot(bpp,psnr), title('Curva RD')