4
Transformasi Citra
4.1
Introduksi
|
Seperti
yang telah didiskusikan pada bab sebelumnya bahwa divais-divais pengakuisisi
citra menangkap citra dalam domain spasial dan dapat dimanipulasi dalam domain
spasial atau piksel untuk kepentingan peningkatan visual. Tetapi, dalam
operasi-operasi pemrosesan citra tertentu, akan lebih effisien bila citra
diproses dalam domain yang berbeda. Misalnya, filter digital lebih mudah
dirancang dan diinterpretasi jika diadopsi domain transformasi Fourier. Aspek
menarik lainnya dalam menggunakan suatu representasi citra dalam domain
frekuensi adalah fakta bahwa akan lebih effisien untuk mendekorelasi citra
dalam domain frekuensi dibandingkan dalam domain spasial. Hal ini juga akan
dibuktikan dalam bidang kompressi citra dan video. Begitu juga dalam
identifikasi dan klasifikasi citra akan lebih effisien bila dilakukan dalam
domain frekuensi. Hal ini dikarenakan pengurangan dimensi sehingga memperingan
beban komputasi.
Perlu diketahui bahwa domain
Fourier atau domain frekuensi bukanlah satu-satunya domain alternatif untuk
merepresentasikan suatu citra. Sembarang transformasi orthogonal dapat dipakai
untuk merepresentasikan citra. Jenis domain yang dipilih tergantung dari
applikasi yang diinginkan. Juga, transformasi yang diinginkan harus linier dan
invertible sehingga citra dapat dikembalikan ke domain spasial dari domain
transformasi.
Tujuan penggunaan suatu
transformasi orthogonal dalam merepresentasikan citra dalam suatu domain yang
baru adalah untuk memperoleh kompressi data dengan derajat yang tinggi tanpa
harus mengorbankan kualitas visual. Oleh karena itu, pada bab ini akan
dipelajari dan dieksplorasi transformasi orthogonal dan uniter. Transformasi
KLT, DCT, dan lainnya akan dibahas secara detil untuk memberikan pemahaman yang
cukup tentang pentingnya domain frekuensi dalam pemrosesan cirtra digital.
4.2
Transformasi Uniter
|
Untuk suatu citra berukuran NxN
Gambar 4.1 Grafik-alir sinyal atas suatu algoritma FFT 8-titik desimasi dalam waktu: (a) DFT 8-titik dalam suku-suku dua DFT 4-titik; (b) DFT 4-titik dalam suku-suku dua DFT 2-titik; (c) DFT 8-titik seutuhnya
Gambar 4.2 Grafik-alir sinyal suatu DCT 8-titik menggunakan algoritma desimasi dalam frekuensi
Gambar 4.3 Grafik-alir untuk menghitung IDCT (inverse discrete cosine transform) 8-titik
FastDCTCitra.m
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
% FastDCTCitra.m
% menghitung DCT N x N atas suatu citra masukan
% menggunakan algoritma FFT
A = imread('kameraman.tif');
x = double(A(:,:));% mengubah menjadi double
%{
% untuk citra yang dipotong
Height = 256; Width = 256;
A = imread(’lena.png’);
x = double(A(59:58+Height,331:330+Width,1));
%}
figure,imshow(x,[]), title('Citra asli')
% menghitung DCT 2D atas suatu citra dalam blok-blok piksel 8 x 8
% dengan memanggil fungsi MATLAB blkproc
% FastDCT menghitung DCT 2D atas suatu blok 8 x 8
% Y akan berukuran sama dengan citra x
Y = blkproc(x,[8 8],@FastDCT);
figure,imshow(uint8(Y)),title('DCT atas citra')
% sekarang menghitung DCT 2D invers dengan memanggil kembali
% fungsi MATLAB blkproc dengan FastIDCT, yang
% menghitung DCT 2D invers
z = blkproc(Y,[8 8],@FastIDCT);
figure,imshow(uint8(z)),title('DCT invers atas hasil DCT')
|
FastDCT.m
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
|
function y = FastDCT(x)
% y = FastDCT(x)
% menghitung DCT atas blok x berukuran N x N
% menggunakan algoritma FFT desimasi dalam waktu
% x adalah suatu matriks N x N dan y adalah DCT atas x
% N diasumsikan bertipe 2ˆm, m
adalah suatu integer positif
N = size(x,1);
x1 = zeros(N,N);
y = zeros(N,N);
% mendapatkan x1 dari x: x1(n) = x(2n), 0 <= n <= N/2;
% x1(N-1-n)= x(2n+1), 0<= n <= N/2
x1(:,1:N/2) = x(:,1:2:N);
% menghitung DFT atas setiap baris x1: X1(k) = sum(x1(n)*WNˆnk);
for m = 1:N
x1(m,:) = fft(x1(m,:));
end
% mengalikan DFT dengan alpha(k) dan W2Nˆ(k/2)
dan mengambil bagian riil
% alpha(0) = 1/sqrt(N) dan alpha(2:N) = sqrt(2/N);
% W2N = exp(-i*2*pi/(2*N))
% fungsi kompleks akan lebih cepat bila digunakan 1i
% daripada i
% dimana i = sqrt(-1).
a(1) = 1/sqrt(N);
a(2:N) = sqrt(2/N);
W2N = exp(-1i*2*pi/(2*N));
for m = 1:N
y(m,1:N) = real(a.*W2N
.^((0:N-1)/2).*x1(m,1:N));
end
% Sekrang menghitung DCT pada tiap kolom, yang sama seperti
% menghitung DCT y’ sepanjang baris
y = y';
x1(:,1:N/2) = y(:,1:2:N);
x1(:,N+1-(1:N/2))= y(:,2:2:N);
for m = 1:N
x1(m,:) = fft(x1(m,:));
end
% Lagi, kalikan DFT dengan alpha(k) dan W2Nˆ(k/2)
for m = 1:N
y(m,1:N) = real(a.*W2N
.^((0:N-1)/2).*x1(m,1:N));
end
% transposisi y untuk mendapatkan DCT dengan urutan yang sama dengan
% blok x masukan
y = y';
|
FastIDCT.m
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
|
function y = FastIDCT(x)
% y = FastIDCT(x)
% menghitung IDCT atas suatu blok N x N
% menggunakan algoritma desimasi dalam waktu IFFT
% N harus dalam N = 2ˆm, dimana
% m adalah suatu integer positif
N = size(x,1);
x3 = zeros(N,N);
% mengalikan x dengan a(k)*W2Nˆ(-k/2)
& menghitung IDFT atas tiap baris
W = exp(1i*pi/(2*N));
a(1) = 1/sqrt(N);
a(2:N) = sqrt(2/N);
for m = 1:N
x(m,1:N) = a.*x(m,1:N).*W .^(0:N-1);
x3(m,:) = ifft(x(m,:));
end
% mengalikan ifft(x) dengan N karena ifft menyertakan faktor 1/N
x3 = x3 * N;
% menata-ulang runtun keluaran untuk mendapatkan keluaran yang benar
y(:,1:2:N) = x3(:,1:N/2);
y(:,2:2:N)= x3(:,N:-1:N/2+1);
y = real(y);
%
% mengalikan y dengan a(k)*W2Nˆ(-k/2)
& menghitung IDFT atas tiap kolom
% yang sama dengan menghitung IDFT atas baris y'
y = y';
for m = 1:N
x3(m,1:N) = a.*y(m,1:N).*W .^(0:N-1);
x3(m,:) = ifft(x3(m,:));
end
x3 = x3 * N;
% menata-ulang runtun keluaran untuk mendapatkan keluaran yang benar
%
y(:,1:2:N) = x3(:,1:N/2);
y(:,2:2:N)= x3(:,N:-1:N/2+1);
% meskipun y seharusnya riil, bagian imajiner
% dari y akan nol dan y akan tampil sebagai kompleks.
% jadi, ambil bagian riil dari y' untuk mendapatkan IDCT yang
sebenarnya
% ingat untuk mentransposisi y dalam menghitung IDCT
% sepanjang kolom.
y = real(y');
|
Gambar 4.4 Transformasi DCT menggunakan algoritma FFT: (a) Citra asli; (b) Koefisien-koefisien DCT 8-titik; (c) Hasil IDCT 8-titik atas (b).
Contoh4_3.m
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
% Contoh4_3.m
% Menghitung citra-citra basis
% pada transformasi-transformasi uniter 2D
% yang ditampilkan sebagai citra.
%
% transformasi-transformasi yang diijinkan = ’DCT’, ’DST’,
% ’Hartley’, ’Haar’, ’Hadamard’, dan ’Slant’
%
N = 8; % N x N adalah
ukuran transformasi uniter
% Hanya N = 8 yang diijinkan untuk transformasi Haar
TransformType = 'Slant';
% compute the basis images by calling the
% fungsi CitraBasis
[y,T] = CitraBasis(N,TransformType); % T adalah Nˆ2 x Nˆ2
% citra-citra basis
%
X = ones(192,192) * 16; % jadikan setiap submatriks N x N menjadi X
for k = 0:N-1
rIndx = k*24 + 1;
for l = 0:N-1
cIndx = l*24 +1;
MaxT =
max(max(T(k*N+1:k*N+N,l*N+1:l*N+N)));
MinT =
min(min(T(k*N+1:k*N+N,l*N+1:l*N+N)));
% dinormalisasi menjadi 0-255
% untuk kepentingan ditampilkan
if k == 0
t1 = T(k*N+1:k*N+N,l*N+1:l*N+N)/MaxT*255;
else
t1 = (T(k*N+1:k*N+N,l*N+1:l*N+N)-MinT)/(MaxT-MinT)*255;
end
T1 = imresize(t1,[16 16],'bicubic'); %
ekspansi matriks
% menjadi 2N x 2N
X(rIndx+3:rIndx+18,cIndx+3:cIndx+18) = T1;
end
end
figure,imshow(X,[]),title([ ' Citra basis ' num2str(N) 'x' num2str(N)
' untuk
' TransformType]);
|
Gambar 4.5 Citra-citra basis untuk beberapa transformasi uniter: (a) DCT; (b) DST; (c) Hartley; (d) Haar; (e) Hadamard; (f) Slant
CitraBasis.m
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
|
function [y,T] = CitraBasis(N,Type)
% Mengembalikan nilai balik berupa koefisien-koefisien transformasi N
x N
% dan citra-citra basis Nˆ2 x Nˆ2 untuk
% suatu transformasi uniter 2D N x N
%
% Masukan:
% N x N = ukuran transformasi
% Untuk transformasi Haar, hanya N = 8 yang diijinkan
% Type = tipe transformasi uniter
% Transformasi-transformasi yang diijinkan adalah:
% DCT, DST, Hartley, Haar, Hadamard, dan Slant
%
y = zeros(N,N);
T = zeros(N*N,N*N);
switch Type
case 'DCT'
for k = 0:N-1
y(k+1,:) = cos((2*(0:N-1)+1)*pi*k/(2*N));
end
y(1,:) = y(1,:)/sqrt(N);
y(2:N,:) = y(2:N,:) * sqrt(2/N);
case 'DST'
for k = 0:N-1
y(k+1,:) = sin(((0:N-1)+1)*pi*(k+1)/(N+1));
end
y = y*sqrt(2/(N+1));
case 'Hartley'
for k = 0:N-1
y(k+1,:) = cos((0:N-1)*2*pi*k/N) +
sin((0:N-1)*2*pi*k/N);
end
y = y*sqrt(1/N);
case 'Haar'
sq2 = sqrt(2);
y = [1 1 1 1 1 1 1 1; 1 1 1 1 -1 -1 -1
-1;...
sq2 sq2 -sq2 -sq2 0 0 0 0; 0 0 0 0 sq2 sq2
-sq2 -sq2;...
2 -2 0 0 0 0 0 0; 0 0 2 -2 0 0 0 0;...
0 0 0 0 2 -2 0 0; 0 0 0 0 0 0 2 -2];
y = y/sqrt(8);
case 'Hadamard'
y = [1 1; 1 -1];
y = y/sqrt(2);
n = 2;
while n < N
n = 2*n;
y = [y y; y -y];
y = y/sqrt(2);
end
case 'Slant'
a8 = sqrt(16/21);
b8 = sqrt(5/21);
s4 = [1 1 1 1; 3/sqrt(5) 1/sqrt(5)
-1/sqrt(5) -3/sqrt(5);...
1 -1 -1 1; 1/sqrt(5) -3/sqrt(5) 3/sqrt(5)
-1/sqrt(5)];
s4 = s4/2;
h1 = [1 0 0 0 1 0 0 0];
h2 = [a8 b8 0 0 -a8 b8 0 0];
h3 = [0 0 1 0 0 0 1 0];
h4 = [0 0 0 1 0 0 0 1];
h5 = [0 1 0 0 0 -1 0 0];
h6 = [-b8 a8 0 0 b8 a8 0 0];
h7 = [0 0 1 0 0 0 -1 0];
h8 = [0 0 0 1 0 0 0 -1];
y = [h1;h2;h3;h4;h5;h6;h7;h8]*[s4
zeros(4,4);...
zeros(4,4) s4]/sqrt(2);
end
%
y1 = zeros(N,N);
if ~strcmpi(Type,'hadamard')
y1 = y'; % Transposisi matriks transformasi kecuali Hadamard
else
y1 = y;
end
for k = 0:N-1
rInd = k*N + 1;
for l = 0:N-1
cInd = l*N + 1;
T(rInd:rInd+N-1,cInd:cInd+N-1) = y1(:,k+1)
* y1(:,l+1)';
end
end
|
Contoh
4-4:
Baca suatu citra dan ekspansi citra tersebut dalam suku-suku citra-citra basis
DCT dan tampilkan bagaimana kualitas citra terperbaiki dengan jumlah penggunaan
citra basis yang berbeda. Juga, tampilkan MSE (mean square error) dalam merekonstruksi citra menggunakan
citra-citra basis dari 1 sampai N x N. Diasumsikan N = 8.
Solusi:
Seperti contoh sebelumnya, pertama-tama dihitung 64 citra-citra basis berukuran
8 x 8, yang berkaitan dengan DCT 8 x 8. Setelah citra kameraman.tif
dibaca, DCT 2D atas setiap blok 8 x 8 dihitung. Setelah citra direkonstruksi
menggunakan citra-citra basis, kemudian MSE antara citra terekonstruksi dan
citra asli dihitung. Untuk memperlihatkan perbedaan kualitas visualisasi citra
terekonstruksi, digunakan 1 dan 13 citra-citra basis dalam rekonstruksi.
Gambar 4.6a menampilkan citra
terekonstruksi hanya dari 1 citra basis. Karena basis pertama proporsional
dengan nilai rata-rata atas suatu blok piksel (lihat Gambar 4.5a), maka tidak
mengagetkan bila citra pada Gambar 4.6a tampak tersekat blok demi blok akibat
operasi perata-rataan yang dilakukan oleh citra basis pertama. Ketika 13
citra-citra basis (8 citra-citra basis pada baris pertama dan 5 citra-citra
basis pertama pada baris kedua pada Gambar 4.5a) dilibatkan dalam
merekonstruksi, kualitas citra terekonstruksi tampak jauh lebih baik. Ketika
semua 64 citra basis digunakan, maka rekonstruksi menjadi sempurna dan MSE
menjadi 0. Gambar 4.6c merupakan hasil rekonstruksi yang menggunakan 64
citra-citra basis yang ada. MSE akibat rekonstruksi parsial ditampilkan pada
Gambar 4.6d, dimana dapat diperhatikan bahwa MSE berkurang secara drastis
seiring dengan penambahan jumlah citra basis yang digunakan dalam rekonstruksi.
Kode MATLAB yang diperlukan diberikan berikut ini.
Gambar 4.6 Rekonstruksi citra menggunakan citra-citra basis DCT 8 x 8
Contoh4_4.m
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
|
% Contoh4_4.m
% Ekspansi suatu citra masukan dalam suku-suku
% citra-citra basis
% transformasi uniter 2D
%
N = 8;
TransformType = 'DCT';% opsi-opsi: ’DCT’, ’DST’, ’Hartley’, ’Haar’,
% ’Hadamard’ dan ’Slant’
%
% kalkulasi kernel transformasi 1D dan citra-citra basis
% dengan memanggil fungsi CitraBasis
[y,T] = CitraBasis(N,TransformType);
% membaca citra masukan
A = imread('kameraman.tif');
Height = 256;
Width = 256;
x = A(59:58+Height,331:330+Width,1);% memotong citra masukan
%{
% citra alternatif yang dibaca
A = imread(’kameraman.tif’);
%[Height,Width,Depth] = size(A);
x = A(:,:,1);
%}
clear A
%
x1 = zeros(N,N);% array N x N dari koefisien-koefisien transformasi
x2 = zeros(size(x)); % citra terekonstruksi
mse = zeros(N,N); % mse akibat penggunaan citra basis 1 sampai N
% ekspansi citra masukan dalam suku-suku citra-citra basis dan
% kalkulasi mse akibat penggunaan 1 sampai N*N citra-citra basis dalam
% rekonstruksi
for m = 0:N-1 % ambil setiap citra basis
sepanjang baris
mInd = m*N + 1;
for n = 0:N-1 % ambil setiap citra basis
sepanjang kolom
nInd = n*N + 1;
for r = 1:N:Height % ambil N baris pada satu
waktu
for c = 1:N:Width % ambil N kolom pada satu
waktu
x1 = y*double( x(r:r+N-1,c:c+N-1))*y';
sum1 = x2(r:r+N-1,c:c+N-1);% akumulasi
citra
x2(r:r+N-1,c:c+N-1) = sum1 +...
x1(m+1,n+1) *
T(mInd:mInd+N-1,nInd:nInd+N-1);
end
end
% menampilkan citra terekonstruksi dengan 1
dan 13 citra basis
if (m == 0 && n == 0) || (m == 1
&& n == 4)
figure,imshow(x2,[])
title(['jumlah citra basis yang digunakan =
' num2str(m*N+n+1)])
end
mse(m+1,n+1) = (std2(double(x) - x2)) ^2;
end
end
%
figure,imshow(x2,[])
title('Rekonstruksi menggunakan semua citra basis')
%
figure,plot(0:N^2-1,[mse(1,:) mse(2,:) mse(3,:) mse(4,:) mse(5,:)
mse(6,:) mse(7,:) mse(8,:)],'k:','LineWidth',2)
xlabel([' Jumlah citra-citra basis ' TransformType ' yang digunakan'])
ylabel('MSE'), title([ 'Transformasi ' TransformType ' 2D ' ]);
|
4.3
Transformasi Karhunen-Lo
|
Tujuan mengkompressi suatu citra adalah untuk memperoleh setinggi mungkin kompressi dan serendah mungkin distorsi yang terjadi. Karena itulah dibutuhkan mentransformasi citra dari domain piksel ke domain lain. Ingat bahwa idea dasar di balik pencapaian kompressi yang tinggi adalah bagaimana mendekorelasi piksel-piksel, yang lebih effisien dilakukan pada domain transformasi. Salah satu transformasi yang optimal dikenal dengan transformasi Karhunen-Lo
Contoh4_5.m
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
|
% Contoh 4_5.m
% Transformasi Karhunen-Loeve atas suatu citra
%
N = 8; % N x N adalah ukuran transformasi
%{
A = imread(’lena.png’);
[Height,Width,Depth] = size(A);
f = double(A(:,:,1));
%}
A = imread('cameraman.tif');
Height = 256;
Width = 256;
f = double(A(59:58+Height,331:330+Width,1));% citra dipotong
%
b = zeros(N,N);
R = zeros(N,N);
Meanfc = zeros(1,N);% vektor rerata di sepanjang kolom
Meanfr = zeros(1,N);% vektor rerata di sepanjang baris
% % menghitung N-vektor rerata di sepanjang dimensi kolom dan baris
for n = 1:N:Width
for k = 1:N
Meanfc(k) = Meanfc(k) + sum(f(:,n+k-1));
Meanfr(k) = Meanfr(k) + sum(f(n+k-1,:),2);
end
end
Meanfc = floor(Meanfc/(Height*Width/N));
Meanfr = floor(Meanfr/(Height*Width/N));
% menghitung matriks kovariansi N x N dari N-vektor
% di sepanjang dimensi kolom
for m = 1:Height
for n = 1:N:Width
b =
(f(m,n:n+N-1)-Meanfc)'*(f(m,n:n+N-1)-Meanfc);
R = R + b;
end
end
R = R/max(R(:));
[EVc,Evalc] = eig(R);% matriks eigen R
% menata-ulang matriks kovariansi dengan nilai-nilai eigen berurut
menurun
%
EVc = EVc(:,N:-1:1);
EVc = EVc(N:-1:1,:);
%
% menghitung matriks kovariansi N x N dari N-vektor
% di sepanjang dimensi baris
R(:,:) = 0;
for n = 1:Width
for m = 1:N:Height
b =
(f(m:m+N-1,n)-Meanfr')*(f(m:m+N-1,n)-Meanfr')';
R = R + b;
end
end
R = R/max(R(:));
[EVr,Evalr] = eig(R);% matriks eigen R
% menata-ulang matriks kovariansi dengan nilai-nilai eigen berurut
menurun
%
EVr = EVr(:,N:-1:1);
EVr = EVr(N:-1:1,:);
%
% menghitung citra-citra basis dan menampilkannya
X = ones(192,192) * 16; % setiap submatriks N x N ke X
T2 = zeros(N*N,N*N);
for k = 0:N-1
rIndx = k*24 + 1;
rInd = k*N + 1;
for l = 0:N-1
cIndx = l*24 +1;
cInd = l*N +1;
y = EVr(:,k+1) * EVc(:,l+1)';
T = y;
T2(rInd:rInd+N-1,cInd:cInd+N-1) = y;
if k == 0
T = T/max(T(:))*255;
else
T =
(T-min(T(:)))/(max(T(:))-min(T(:)))*255;
end
T1 = imresize(T,[16 16],'bicubic'); %
ekspansi matriks
% menjadi 2N x 2N
X(rIndx+3:rIndx+18,cIndx+3:cIndx+18) = T1;
end
end
figure,imshow(X,[]),title([' citra-citra basis KLT ' num2str(N) 'x'
num2str(N) ])
%
% menghitung mse akibat pembatasan jumlah basis
x1 = zeros(N,N);
x2 = zeros(Height,Width);
mse = zeros(N,N);
for m = 0:N-1 % ambil setiap basis sepanjang
baris
mInd = m*N + 1;
for n = 0:N-1 % ambil setiap basis sepanjang
kolom
nInd = n*N + 1;
for r = 1:N:Height % ambil N baris satu waktu
for c =
1:N:Width % ambil N kolom satu waktu
x1 = EVr'*double( f(r:r+N-1,c:c+N-1))*EVc;
sum1 = x2(r:r+N-1,c:c+N-1);
x2(r:r+N-1,c:c+N-1) = sum1 +...
x1(m+1,n+1) *
T2(mInd:mInd+N-1,nInd:nInd+N-1);
end
end
if(m == 0 && n == 0) || (m == 1
&& n == 4)
figure,imshow(x2,[])
title(['Jumlah basis yang digunakan =
' num2str(m*N+n+1)])
end
mse(m+1,n+1) = (std2(double(f) - x2))^2;
end
end
figure,imshow(x2,[])
%
figure,plot(0:N^2-1, [mse(1,:) mse(2,:) mse(3,:) mse(4,:) mse(5,:)
mse(6,:) mse(7,:) mse(8,:)],'k:','LineWidth',2)
xlabel(' # citra basis yang digunakan')
ylabel('MSE')
title('MSE Vs citra-citra basis KLT')
|
Gambar 4.7 Rekonstruksi citra menggunakan citra-citra basis KL 8 x 8
No comments:
Post a Comment