Setelah bab ini berakhir, diharapkan pembaca mendapatkan pengetahuan mengenai hal-hal berikut dan
mampu mempraktikkannya.
- Pengantar operasi geometrik
- Penggeseran citra
- Pemutaran citra
- Interpolasi piksel
- Pemutaran citra berdasarkan sebarang koordinat
- Pemutaran citra secara utuh
- Pembesaran citra
- Pengecilan citra
- Pembesaran citra dengan skala vertikal dan horizontal
- Pencerminan citra
- Transformasi affine
- Efek ripple
- Efek twirl
- Transformasi spherical
- Transformasi bilinear
5.1 Pengantar Operasi Geometrik
Operasi geometrik dalam pengolahan citra digital adalah manipulasi yang dilakukan pada citra digital berdasarkan transformasi geometrik seperti translasi, rotasi, scaling, flipping, dan shear. Tujuannya adalah untuk mengubah ukuran, posisi, orientasi, dan bentuk citra digital. Operasi geometrik ini dapat dilakukan secara manual atau otomatis menggunakan algoritma komputer.
Operasi geometrik ini sangat penting dalam pengolahan citra digital karena memungkinkan pengguna untuk melakukan perubahan yang signifikan pada citra, seperti menghilangkan distorsi perspektif, meningkatkan kejelasan gambar, mengubah ukuran gambar, dan memperbaiki orientasi gambar. Contohnya, dalam aplikasi pengolahan citra medis, operasi geometrik dapat digunakan untuk meregistrasi gambar dari berbagai jenis pencitraan medis seperti MRI, CT scan, dan USG untuk memudahkan interpretasi dokter.
Secara umum, operasi geometrik dalam pengolahan citra digital digunakan untuk meningkatkan kualitas citra, memudahkan analisis citra, dan memfasilitasi pengolahan citra selanjutnya. Pada operasi seperti ini terdapat pemetaan geometrik, yang menyatakan hubungan pemetaan antara piksel pada citra masukan dan piksel pada citra keluaran. Secara prinsip, terdapat dua cara yang dapat dipakai. Pertama yaitu pemetaan ke depan dan kedua berupa pemetaan ke belakang. Perbedaan secara visual kedua cara tersebut diperlihatkan pada Gambar 5.1.
Gambar di atas menjelaskan bahwa pada cara pemetaan ke depan, posisi pada citra keluaran ditentukan dengan acuan pemrosesan pada citra masukan. Pada gambar tersebut terlihat bahwa kalau piksel keluaran berada pada posisi yang tidak tepat (tidak berupa bilangan bulat), penempatannya dapat berada pada salah satu dari empat kemungkinan. Dengan cara seperti ini, ada kemungkinan sebuah piksel pada citra keluaran tidak pernah diberi nilai atau malah diberi nilai lebih dari satu kali. Lubang yang ditimbulkan karena piksel tidak diberi nilai pada pemetaan ke depan dapat dilihat pada Gambar 5.5. Hal ini berbeda dengan pada pemetaan ke belakang. Pada pemetaan ke belakang, mengingat pemrosesan dimulai dari citra keluaran maka dipastikan bahwa semua piksel pada citra keluaran akan diberi nilai sekali saja berdasarkan piksel masukan.
Pada Gambar 5.1(a), piksel yang digunakan untuk menentukan piksel keluaran dapat ditentukan oleh salah satu piksel yang tercakup dalam kotak yang menggantung pada keempat piksel. Hal itu merupakan cara paling sederhana yang dapat dilakukan dan biasa dinamakan sebagai pemilihan berdasarkan tetangga terdekat. Cara lain yang dapat dilakukan adalah dengan memperhitungkan empat piksel yang dapat mewakilinya. Cara ini dikenal dengan sebutan interpolasi bilinear, yaitu linear di arah vertikal dan mendatar. Kedua cara ini akan dibahas saat membicarakan pemutaran citra (Subbab 5.3).
5.2 Menggeser Citra
Penggeseran citra ke arah horisontal atau vertikal dapat dilaksanakan dengan mudah. Rumus yang digunakan sebagai berikut:
Untuk penyederhanaan pembahasan, sx dan sy dianggap bertipe bilangan bulat. Contoh berikut menunjukkan program yang digunakan untuk melakukan penggeseran citra.
| Program : geser.m |
% GESER Melakukan operasi penggeseran citra.
F = imread('c:\Image\gedung.tif');
[tinggi, lebar] = size(F)
sx = 45; % Penggesaran arah horisontal
sy = 15; % Penggesaran arah vertikal
F2 = double(F);
G = zeros(size(F2));
for y=1 : tinggi
for x=1 : lebar
xlama = x - sx;
ylama = y - sy;
if (xlama>=1) && (xlama<=lebar) && ...
(ylama>=1) && (ylama<=tinggi)
G(y, x) = F2(ylama, xlama);
else
G(y, x) = 0;
end
end
end
G = uint8(G);
figure(1); imshow(G);
figure(2); imshow(F);
clear all;
Program di atas merupakan implementasi dari algoritma operasi geometrik translasi pada citra menggunakan bahasa pemrograman MATLAB.
Baris pertama membaca citra "gedung.tif" dari direktori "c:\Image" menggunakan fungsi "imread" dan menyimpannya ke dalam variabel "F".
Baris kedua dan ketiga mengambil ukuran citra "F" dan menyimpannya ke dalam variabel "tinggi" dan "lebar".
Baris keempat dan kelima mendefinisikan jumlah piksel penggeseran citra pada arah horizontal dan vertikal, yang disimpan dalam variabel "sx" dan "sy".
Baris keenam melakukan konversi tipe data citra dari "uint8" menjadi "double" dan disimpan dalam variabel "F2". Konversi ini dilakukan agar nilai piksel dapat dihitung dengan presisi yang lebih tinggi.
Baris ketujuh menginisialisasi citra hasil translasi, "G", dengan ukuran yang sama dengan citra asli, tetapi setiap nilai pikselnya diatur ke 0.
Baris ke-8 hingga ke-17 melakukan perulangan untuk setiap piksel pada citra "F". Pada setiap iterasi, piksel pada posisi (x, y) pada citra "F" akan dihitung ulang posisinya dengan menggeser koordinatnya sebesar "sx" pada sumbu horizontal dan "sy" pada sumbu vertikal. Koordinat yang baru dihitung ini disimpan dalam variabel "xlama" dan "ylama".
Baris ke-19 dan ke-20 mengecek apakah koordinat yang baru tersebut masih berada dalam jangkauan citra asli, dengan menggunakan operator logika "&&". Jika iya, maka nilai piksel pada koordinat yang baru tersebut diambil dari citra "F2" dan disimpan pada piksel yang bersesuaian pada citra hasil translasi "G". Jika koordinat yang baru tersebut berada di luar jangkauan citra asli, nilai piksel pada citra hasil translasi "G" menjadi 0.
Baris terakhir mengubah tipe data citra hasil translasi dari "double" menjadi "uint8" menggunakan fungsi "uint8" dan menampilkan citra hasil translasi menggunakan fungsi "imshow".
Perlu diingat bahwa program ini tidak melakukan interpolasi untuk mengisi celah yang muncul saat melakukan translasi, sehingga hasil translasi mungkin tidak optimal tergantung pada metode interpolasi yang digunakan.
Program : geserRGB.m
% GESER Melakukan operasi penggeseran citra.
F = imread('c:\Image\jalan sawah orang.jpg');
[tinggi, lebar, ch] = size(F)
sx = 75; % Penggesaran arah horisontal
sy = 35; % Penggesaran arah vertikal
F2 = double(F);
G = zeros(size(F2));
for z=1 : ch
for y=1 : tinggi
for x=1 : lebar
xlama = x - sx;
ylama = y - sy;
if (xlama>=1) && (xlama<=lebar) && ...
(ylama>=1) && (ylama<=tinggi)
G(y, x, z) = F2(ylama, xlama, z);
else
G(y, x, z) = 0;
end
end
end
end
G = uint8(G);
figure(1); imshow(G);
figure(2); imshow(F);
clear all;
Hasil:
5.3 Memutar Citra
Operasi geometrik memutar citra adalah salah satu teknik dalam pengolahan citra digital yang digunakan untuk memutar citra searah jarum jam atau berlawanan arah jarum jam tergantung pada kebutuhan.
Aplikasi dari operasi geometrik memutar citra dalam pengolahan citra digital cukup beragam, di antaranya:
- Pengolahan gambar medis: Teknik operasi geometrik memutar citra dapat digunakan untuk memperbaiki posisi gambar medis seperti X-ray, CT scan, atau MRI. Dalam aplikasi ini, citra medis mungkin tidak diambil dengan posisi yang tepat, sehingga operasi geometrik memutar citra dapat membantu mengoreksi posisi gambar.
- Pengolahan gambar arsitektur dan jaringan jalan: Dalam pengolahan gambar arsitektur dan jaringan jalan, teknik operasi geometrik memutar citra dapat digunakan untuk menyesuaikan posisi gambar agar sesuai dengan perspektif pandangan yang diinginkan.
- Augmented Reality: Dalam aplikasi augmented reality, teknik operasi geometrik memutar citra dapat digunakan untuk memutar citra objek agar sesuai dengan sudut pandang pengguna.
- Pengenalan karakter: Teknik operasi geometrik memutar citra juga dapat digunakan untuk membantu pengenalan karakter pada OCR (Optical Character Recognition) dengan menyesuaikan orientasi gambar karakter yang terdistorsi atau miring.
- Pemrosesan gambar artistik: Teknik operasi geometrik memutar citra juga dapat digunakan untuk tujuan pemrosesan gambar artistik, di mana memutar gambar dapat membantu menciptakan efek yang unik dan menarik pada gambar.
Itulah beberapa contoh aplikasi dari operasi geometrik memutar citra dalam pengolahan citra digital.
Suatu citra dapat diputar dengan sudut ๐ seiring arah jarum jam atau berlawanan arah jarum jam dengan pusat putaran pada koordinat (0,0). Gambar 5.3 menjelaskan bentuk pemutaran citra. Adapun rumus yang digunakan untuk memutar citra dengan sudut ๐ berlawanan arah jam berupa:
Berdasarkan Persamaan 5.3 dan 5.4, pemutaran citra dengan sudut ๐ searah jarum jam dapat dilakukan. Caranya, dengan menggunakan x dan y sebagai posisi baru dan xbaru justru sebagai posisi lama. Pada saat menghitung dengan rumus di atas, apabila posisi koordinat (ybaru ,xbaru) berada di luar area [1, lebar] dan [1, tinggi], intensitas yang digunakan berupa nol. Cara inilah yang merupakan contoh pemetaan ke belakang. Implementasinya dapat dilihat berikut ini.
| Program : rotasi.m |
% ROTASI Melakukan Operasi pemutaran citra.
% Versi 1
% Menggunakan pendekatan pemetaan ke belakang
F = imread('c:\Image\sungai.png');
[tinggi, lebar] = size(F);
sudut = 10; % Sudut pemutaran
rad = pi * sudut/180;
cosa = cos(rad);
sina = sin(rad);
F2 = double(F);
for y=1 : tinggi
for x=1 : lebar
x2 = round(x * cosa + y * sina);
y2 = round(y * cosa - x * sina);
if (x2>=1) && (x2<=lebar) && ...
(y2>=1) && (y2<=tinggi)
G(y, x) = F2(y2, x2);
else
G(y, x) = 0;
end
end
end
G = uint8(G);
figure(1); imshow(G);
figure(2); imshow(F);
clear all;
Program di atas adalah program untuk melakukan operasi rotasi pada citra menggunakan pendekatan pemetaan ke belakang. Berikut ini penjelasan lebih detail mengenai masing-masing bagian program:
- Membaca citra dan mendapatkan ukuran citra
F = imread('c:\Image\sungai.png');
[tinggi, lebar] = size(F);
Pada bagian ini, citra 'sungai.png' dibaca menggunakan fungsi imread dan disimpan dalam variabel F. Selanjutnya, ukuran citra (tinggi dan lebar) diperoleh dengan menggunakan fungsi size.
2. Mendefinisikan sudut pemutaran
sudut = 10; % Sudut pemutaran
Pada bagian ini, sudut pemutaran citra ditentukan. Dalam contoh ini, sudut pemutaran adalah 10 derajat.
3. Menghitung nilai cosine dan sine dari sudut pemutaran
rad = pi * sudut/180;
cosa = cos(rad);
sina = sin(rad);
Pada bagian ini, nilai cosine dan sine dari sudut pemutaran dihitung menggunakan fungsi cos dan sin dengan konversi sudut ke radian.
4. Melakukan operasi rotasi pada citra
F2 = double(F);
for y=1 : tinggi
for x=1 : lebar
x2 = round(x * cosa + y * sina);
y2 = round(y * cosa - x * sina);
if (x2>=1) && (x2<=lebar) && ...
(y2>=1) && (y2<=tinggi)
G(y, x) = F2(y2, x2);
else
G(y, x) = 0;
end
end
end
Pada bagian ini, operasi rotasi dilakukan dengan menggunakan pendekatan pemetaan ke belakang. Untuk setiap pixel pada citra awal, koordinat baru (x2, y2) pada citra yang diputar dihitung menggunakan rumus:
x2 = round(x * cos(sudut) + y * sin(sudut))
y2 = round(y * cos(sudut) - x * sin(sudut))
Selanjutnya, nilai piksel pada koordinat (y2, x2) pada citra yang diputar disalin ke koordinat (y, x) pada citra hasil. Jika koordinat (y2, x2) berada di luar ukuran citra yang diputar, nilai piksel pada koordinat (y, x) pada citra hasil diisi dengan nilai 0.
5. Menampilkan citra hasil rotasi
G = uint8(G);
figure(1); imshow(G);
Pada bagian ini, citra hasil rotasi ditampilkan menggunakan fungsi imshow.
6. Menampilkan citra asli
figure(2); imshow(F);
Pada bagian ini, citra asli ditampilkan untuk membandingkan hasil rotasi dengan citra asli.
7. Membersihkan variabel dari memori
clear all;Contoh hasil pemutaran dapat dilihat pada Gambar 5.4.
Program : rotasiRGB.m
% ROTASI Melakukan Operasi pemutaran citra.
% Versi 1
% Menggunakan pendekatan pemetaan ke belakang
F = imread('c:\Image\jalan sawah orang.jpg');
[tinggi, lebar, ch] = size(F);
sudut = 10; % Sudut pemutaran
rad = pi * sudut/180;
cosa = cos(rad);
sina = sin(rad);
F2 = double(F);
for z=1 : ch
for y=1 : tinggi
for x=1 : lebar
x2 = round(x * cosa + y * sina);
y2 = round(y * cosa - x * sina);
if (x2>=1) && (x2<=lebar) && ...
(y2>=1) && (y2<=tinggi)
G(y, x, z) = F2(y2, x2, z);
else
G(y, x, z) = 0;
end
end
end
end
G = uint8(G);
figure(1); imshow(G);
figure(2); imshow(F);
clear all;
Hasil:
Apa yang terjadi kalau dilaksanakan pemetaan ke depan dengan menggunakan rumus pada Persamaan 5.3 dan 5.4? Sebagaimana telah dijelaskan di depan (Subbab 5.1), cara seperti itu dapat menimbulkan lubang pada citra hasil. Artinya, akan ada piksel yang tidak terisi dengan piksel dari citra masukan. Untuk
melihat efek ini, cobalah jalankan program berikut.
| Program : rotasi2.m |
% ROTASI2 Melakukan operasi pemutaran citra.
% Versi 2
% Menggunakan pemetaan ke depan
F = imread('c:\Image\gedung.tif');
[tinggi, lebar] = size(F);
sudut = 5; % Sudut pemutaran
rad = pi * sudut/180;
cosa = cos(rad);
sina = sin(rad);
F2 = double(F);
G=zeros(tinggi, lebar);
for y=1 : tinggi
for x=1 : lebar
x2 = round(x * cosa - y * sina);
y2 = round(y * cosa + x * sina);
if (x2>=1) && (x2<=lebar) && ...
(y2>=1) && (y2<=tinggi)
G(y2, x2) = F2(y, x);
end
end
end
G = uint8(G);
figure(1); imshow(G);
figure(2); imshow(F);
clear all;
Hasilnya bisa dilihat pada gambar berikut.
Perhatikan pada Gambar 5.5(b). Titik-titik hitam pada citra adalah efek lubang yang memerlukan penanganan lebih lanjut untuk menghilangkannya.
Program : rotasi2RGB.m
% ROTASI2 Melakukan operasi pemutaran citra.
% Versi 2
% Menggunakan pemetaan ke depan
F = imread('c:\Image\jalan sawah orang.jpg');
[tinggi, lebar, ch] = size(F);
sudut = 5; % Sudut pemutaran
rad = pi * sudut/180;
cosa = cos(rad);
sina = sin(rad);
F2 = double(F);
G=zeros(tinggi, lebar);
for z=1 : ch
for y=1 : tinggi
for x=1 : lebar
x2 = round(x * cosa - y * sina);
y2 = round(y * cosa + x * sina);
if (x2>=1) && (x2<=lebar) && ...
(y2>=1) && (y2<=tinggi)
G(y2, x2, z) = F2(y, x, z);
end
end
end
end
G = uint8(G);
figure(1); imshow(G);
figure(2); imshow(F);
clear all;
Hasil:
5.4 Interpolasi Piksel
Interpolasi piksel pada pengolahan citra digital adalah teknik untuk menghitung nilai piksel baru di antara piksel yang sudah ada dalam citra digital. Teknik ini sangat penting dalam pengolahan citra digital karena seringkali informasi gambar yang diperlukan tidak tersedia dalam resolusi yang cukup atau terdapat piksel yang hilang dalam citra.
Teknik interpolasi piksel memperkirakan nilai piksel baru dengan menggunakan teknik matematika tertentu yang didasarkan pada piksel yang sudah ada di sekitarnya. Teknik interpolasi yang umum digunakan dalam pengolahan citra digital antara lain adalah nearest neighbor, linear, spline, dan Lanczos.
Teknik nearest neighbor memilih nilai piksel terdekat dari piksel yang akan diinterpolasi, sedangkan teknik linear memperkirakan nilai piksel di antara dua piksel dengan menggunakan garis lurus. Teknik spline dan Lanczos menggunakan fungsi matematika tertentu untuk menghitung nilai piksel baru dengan lebih akurat dan menghasilkan gambar yang lebih halus.
Interpolasi piksel pada pengolahan citra digital memiliki banyak aplikasi, seperti meningkatkan resolusi gambar, memperhalus gambar, mengurangi efek aliasing, dan memperbaiki citra yang rusak atau terkorupsi.
Hasil pemutaran citra menggunakan rotasi.m menimbulkan efek bergerigi pada objek citra. Hal itu diakibatkan oleh penggunaan nilai intensitas didasarkan pada piksel tetangga terdekat, yang dilakukan melalui:
Penggunaan fungsi round (pembulatan ke atas) merupakan upaya untuk menggunakan intensitas piksel terdekat. Alternatif lain dilakukan dengan menggunakan floor (pembulatan ke bawah). Gambar berikut menunjukkan keadaan tersebut ketika hasil pada Gambar 5.4 (b) diperbesar.
memberikan citra terlihat tidak mulus
Keadaan seperti itu dapat diperhalus melalui interpolasi piksel. Idenya seperti berikut. Misalnya, hasil perhitungan menghasilkan:
xlama = 47,09
ylama = 59,85
Pada contoh di depan, piksel yang digunakan berposisi (60, 47) dengan melakukan pembulatan ke atas. Namun, sesungguhnya bisa saja piksel yang digunakan adalah yang berada pada posisi (59, 47) jika dilakukan pembulatan ke bawah. Hal yang perlu diketahui, kemungkinan yang terjadi dapat melibatkan
empat buah piksel. Gambar 5.7 menunjukkan keadaan ini. Oleh karena itu, nilai intensitas yang digunakan dapat melibatkan keempat piksel tersebut. Jika ukuran piksel, yaitu di bawah ukuran kepekaan mata pemandang, spek zig-zag tidak akan terlihat. Namun, bila pemutran citra terjadi berulang secara serial, cacat gerigi akan membesar.
Perhatikan bahwa f(pโ. qโ) mempunyai empat piksel terdekat berupa f(p,q), f(p,q+1), f(p+1,q), dan f(p+1,q+1). Pratt (2001) menunjukkan cara menghitung nilai intensitas yang digunakan untuk suatu piksel berdasarkan empat piksel. Rumusnya sebagai berikut:
Dalam hal ini, a dan b dihitung melalui:
Rumus dalam Persamaan 5.5 itulah yang disebut sebagai bilinear interpolation.
Selain bilinear interpolation, sebenarnya terdapat beberapa cara untuk melakukan interpolasi. Dua cara lain yang populer yaitu bicubic interpolation, yang menggunakan 16 piksel tetangga untuk memperoleh interpolasi intensitas piksel dan bikuadratik yang melibatkan 9 piksel terdekat.
Contoh program yang menggunakan interpolasi bilinear untuk mendapatkan intensitas piksel dapat dilihat di bawah ini.
| Program : rotasi3.m |
% ROTASI3 Melakukan operasi pemutaran citra.
% Versi 3 - menggunakan bilinear interpolation
F = imread('c:\Image\gedung.tif');
[tinggi, lebar] = size(F);
sudut = 15; % Sudut pemutaran
rad = pi * sudut/180;
cosa = cos(rad);
sina = sin(rad);
F2 = double(F);
for y=1 : tinggi
for x=1 : lebar
x2 = x * cosa + y * sina;
y2 = y * cosa - x * sina;
if (x2>=1) && (x2<=lebar) && ...
(y2>=1) && (y2<=tinggi)
% Lakukan interpolasi bilinear
p = floor(y2);
q = floor(x2);
a = y2-p;
b = x2-q;
if (x2 == lebar) || (y2 == tinggi)
G(y, x) = F(floor(y2), floor(x2));
else
intensitas = (1-a) * ((1-b) * F(p,q) + ...
b * F(p, q+1)) + ...
a *((1-b)* F(p+1, q) + ...
b * F(p+1, q+1));
G(y, x) = intensitas;
end
else
G(y, x) = 0;
end
end
end
G = uint8(G);
figure(1); imshow(G);
figure(2); imshow(F);
clear all;
Program di atas merupakan contoh implementasi operasi pemutaran citra dengan interpolasi bilinear pada citra digital. Program ini menggunakan citra "gedung.tif" sebagai citra input.
Pertama-tama, program membaca citra "gedung.tif" menggunakan fungsi imread dan menyimpan ukuran citra tersebut dalam variabel tinggi dan lebar. Kemudian, program menentukan nilai sudut rotasi yang diinginkan dalam derajat, dan mengonversinya ke dalam radian.
Selanjutnya, program melakukan operasi pemutaran citra dengan menggunakan metode interpolasi bilinear. Proses pemutaran citra dilakukan pada setiap piksel pada citra asli. Untuk setiap piksel pada citra hasil rotasi, program menghitung koordinat piksel asli yang sesuai pada citra asli menggunakan persamaan transformasi geometrik.
Kemudian, program melakukan interpolasi bilinear pada citra asli untuk menghitung intensitas piksel pada citra hasil rotasi. Untuk melakukan interpolasi bilinear, program menggunakan 4 piksel terdekat pada citra asli yang membentuk kotak di sekitar titik yang ingin diinterpolasi, dan menggunakan jarak antara titik yang ingin diinterpolasi dengan 4 piksel terdekat tersebut untuk menghitung bobot masing-masing piksel.
Setelah proses rotasi dan interpolasi bilinear selesai dilakukan pada semua piksel, citra hasil rotasi disimpan dalam variabel G dan ditampilkan menggunakan fungsi imshow. Citra asli juga ditampilkan untuk membandingkan hasil rotasi dengan citra asli. Akhirnya, program membersihkan workspace dengan perintah clear all.
Hasil:
Program : rotasi3RGB.m
% ROTASI3 Melakukan operasi pemutaran citra.
% Versi 3 - menggunakan bilinear interpolation
F = imread('c:\Image\jalan sawah orang.jpg');
[tinggi, lebar, ch] = size(F);
sudut = 15; % Sudut pemutaran
rad = pi * sudut/180;
cosa = cos(rad);
sina = sin(rad);
F2 = double(F);
G=zeros(tinggi, lebar, ch);
for z=1 : ch
for y=1 : tinggi
for x=1 : lebar
x2 = x * cosa + y * sina;
y2 = y * cosa - x * sina;
if (x2>=1) && (x2<=lebar) && ...
(y2>=1) && (y2<=tinggi)
% Lakukan interpolasi bilinear
p = floor(y2);
q = floor(x2);
a = y2-p;
b = x2-q;
if (x2 == lebar) || (y2 == tinggi)
G(y, x, z) = F2(floor(y2), floor(x2), z);
else
intensitas = (1-a) * ((1-b) * F2(p,q,z) + ...
b * F2(p, q+1,z)) + ...
a *((1-b)* F2(p+1, q,z) + ...
b * F2(p+1, q+1,z));
G(y, x, z) = intensitas;
end
else
G(y, x, z) = 0;
end
end
end
end
G = uint8(G);
figure(1); imshow(G);
figure(2); imshow(F);
clear all;
Hasil:
Gambar 5.8 memperlihatkan perbedaan hasil antara pemutaran citra yang menggunakan pendekatan interpolasi bilinear dan yang tidak.
Berikut ini gambar lain hasil dengan interpolasi (bawah) dan tanpa interpolasi (atas):
Terlihat bahwa hasil yang menggunakan interpolasi bilinear lebih halus. Namun, tentu saja, kehalusan tersebut harus dibayar dengan waktu komputasi yang lebih lama.
5.5 Memutar Berdasarkan Sebarang Koordinat
Operasi pemutaran citra dapat dilakukan dengan pusat di mana saja; tidak harus dari (0, 0). Gambar 5.9 memperlihatkan keadaan ini.
Rumus untuk melakukan pemutaran berlawanan arah jarum jam sebesar ๐ yang diperlihatkan pada Gambar 5.9 diperoleh melalui pemodifikasian Persamaan 5.3 dan 5.4:
Untuk kepentingan pemutaran citra sejauh ๐ searah jarum jam, intensitas piksel (y, x) dapat diperoleh melalui intensitas pada piksel (ybaru, xbaru) yang tertera pada Persamaan 5.8 dan 5.9. Implementasi program dapat dilihat pada contoh berikut.
| Program : rotasi4.m |
% ROTASI4 Melakukan operasi pemutaran citra.
% Versi 4 - pusat putaran pada pusat citra
F = imread('c:\Image\gedung.tif');
Ukuran = size(F);
tinggi = Ukuran(1);
lebar = Ukuran(2);
sudut = 5; % Sudut pemutaran
rad = pi * sudut/180;
cosa = cos(rad);
sina = sin(rad);
F2 = double(F);
m = floor(tinggi / 2);
n = floor(lebar / 2);
for y=1 : tinggi
for x=1 : lebar
x2 = (x-n) * cosa + (y-m) * sina + n;
y2 = (y-m) * cosa - (x-n) * sina + m;
if (x2>=1) && (x2<=lebar) && ...
(y2>=1) && (y2<=tinggi)
% Lakukan interpolasi bilinear
p = floor(y2);
q = floor(x2);
a = y2-p;
b = x2-q;
if (x2==lebar) || (y2 == tinggi)
G(y, x) = F(y2, x2);
else
intensitas = (1-a) * ((1-b) * F(p,q) + ...
b * F(p, q+1)) + ...
a *((1-b)* F(p+1, q) + ...
b * F(p+1, q+1));
G(y, x) = intensitas;
end
else
G(y, x) = 0;
end
end
end
G = uint8(G);
figure(1); imshow(G);
figure(2); imshow(F);
clear all;
Program ROTASI4 adalah program untuk melakukan operasi pemutaran citra dengan menggunakan pusat putaran pada pusat citra. Program ini menggunakan pendekatan bilinear interpolation untuk menghasilkan citra yang diputar dengan lebih halus. Berikut adalah penjelasan dari setiap bagian program tersebut:
- Mengambil citra F dari direktori 'c:\Image\gedung.tif'.
- Mendapatkan ukuran citra F dan menyimpan lebar dan tingginya pada variabel lebar dan tinggi.
- Menentukan sudut putaran yang diinginkan dengan menyimpan nilainya pada variabel sudut.
- Menghitung nilai radian dari sudut putaran dengan menggunakan rumus pi * sudut/180, dan menyimpan nilai cos(rad) dan sin(rad) pada variabel cosa dan sina.
- Mengubah tipe data citra F menjadi tipe data double dan menyimpannya pada variabel F2.
- Menghitung koordinat pusat citra dengan cara membagi tinggi dan lebar citra dengan 2, lalu dibulatkan ke bawah menggunakan fungsi floor() dan disimpan pada variabel m dan n.
- Melakukan perulangan pada setiap piksel pada citra F.
- Menghitung koordinat baru x2 dan y2 pada citra hasil pemutaran dengan menggunakan rumus x2 = (x-n) * cosa + (y-m) * sina + n dan y2 = (y-m) * cosa - (x-n) * sina + m.
- Melakukan pengecekan apakah koordinat x2 dan y2 berada dalam batas citra F. Jika koordinat berada dalam batas citra F, maka dilakukan interpolasi bilinear untuk mendapatkan nilai intensitas piksel pada koordinat (y2, x2).
- Jika koordinat x2 atau y2 berada di tepi citra, maka nilai intensitas pada koordinat (y2, x2) akan diambil langsung dari citra F.
- Hasil interpolasi bilinear disimpan pada variabel G(y, x).
- Citra hasil putaran yang disimpan pada variabel G diubah tipe datanya menjadi uint8 dan ditampilkan menggunakan fungsi imshow().
- Citra asli F juga ditampilkan menggunakan fungsi imshow().
- Menjaga agar workspace tetap bersih dengan menggunakan perintah clear all().
Contoh di atas menggunakan interpolasi bilinear. Hasilnya dapat dilihat pada Gambar 5.10.
Program : rotasi4RGB.m
% ROTASI4 Melakukan operasi pemutaran citra.
% Versi 4 - pusat putaran pada pusat citra
F = imread('c:\Image\jalan sawah orang.jpg');
Ukuran = size(F);
tinggi = Ukuran(1);
lebar = Ukuran(2);
ch = Ukuran(3);
sudut = 5; % Sudut pemutaran
rad = pi * sudut/180;
cosa = cos(rad);
sina = sin(rad);
F2 = double(F);
m = floor(tinggi / 2);
n = floor(lebar / 2);
F2 = double(F);
G=zeros(tinggi, lebar, ch);
for z=1 : ch
for y=1 : tinggi
for x=1 : lebar
x2 = (x-n) * cosa + (y-m) * sina + n;
y2 = (y-m) * cosa - (x-n) * sina + m;
if (x2>=1) && (x2<=lebar) && ...
(y2>=1) && (y2<=tinggi)
% Lakukan interpolasi bilinear
p = floor(y2);
q = floor(x2);
a = y2-p;
b = x2-q;
if (x2==lebar) || (y2 == tinggi)
G(y, x, z) = F2(y2, x2, z);
else
intensitas = (1-a) * ((1-b) * F2(p,q,z) + ...
b * F2(p, q+1,z)) + ...
a *((1-b)* F2(p+1, q,z) + ...
b * F2(p+1, q+1,z));
G(y, x, z) = intensitas;
end
else
G(y, x, z) = 0;
end
end
end
end
G = uint8(G);
figure(1); imshow(G);
figure(2); imshow(F);
clear all;
Hasil:
5.6 Memutar Citra Secara Utuh
Pada seluruh contoh yang telah diberikan, ada bagian gambar yang hilang ketika pemutaran dilaksanakan. Namun, adakalanya dihendaki agar pemutaran citra tidak membuat ada bagian citra asli hilang. Untuk keperluan ini, ukuran citra hasil pemutaran harus diubah sesuai dengan sudut putaran. Dalam hal ini, Persamaan 5.8 dan 5.9 digunakan untuk menentukan keempat pojok gambar semula. Adapun lebar dan tinggi gambar hasil pemutaran dengan menghitung nilai terkecil dan terbesar dari koordinat keempat pojok hasil pemutaran. Untuk lebih jelasnya, lihat Gambar 5.11.
Implementasi pemutaran citra secara utuh diperlihatkan pada program rotasi5.m.
| Program : rotasi5.m |
% ROTASI5 Melakukan operasi pemutaran citra.
% Versi 5
% Memutar dengan hasil utuh
F = imread('c:\Image\gedung.tif');
Ukuran = size(F);
tinggi = Ukuran(1);
lebar = Ukuran(2);
sudut = 45; % Sudut pemutaran
rad = pi * sudut/180;
cosa = cos(rad);
sina = sin(rad);
x11 = 1; y11 = 1;
x12 = lebar; y12 = 1;
x13 = lebar; y13 = tinggi;
x14 = 1; y14 = tinggi;
m = floor(tinggi/2);
n = floor(lebar/2);
% Menentukan pojok
x21 = ((x11-n) * cosa + (y11-m) * sina + n);
y21 = ((y11-m) * cosa - (x11-n) * sina + m);
x22 = ((x12-n) * cosa + (y12-m) * sina + n);
y22 = ((y12-m) * cosa - (x12-n) * sina + m);
x23 = ((x13-n) * cosa + (y13-m) * sina + n);
y23 = ((y13-m) * cosa - (x13-n) * sina + m);
x24 = ((x14-n) * cosa + (y14-m) * sina + n);
y24 = ((y14-m) * cosa - (x14-n) * sina + m);
ymin = min([y21 y22 y23 y24]);
xmin = min([x21 x22 x23 x24]);
ymak = max([y21 y22 y23 y24]);
xmak = max([x21 x22 x23 x24]);
lebar_baru = xmak - xmin + 1;
tinggi_baru = ymak - ymin + 1;
tambahan_y = floor((tinggi_baru-tinggi)/2);
tambahan_x = floor((lebar_baru-lebar)/2);
F2=zeros(floor(tinggi_baru), floor(lebar_baru));
for y=1 : tinggi
for x=1 : lebar
F2(y+tambahan_y, x+tambahan_x) = F(y, x);
end
end
figure(1);
imshow( uint8(F2));
% Putar citra
m = floor(tinggi_baru/2);
n = floor(lebar_baru/2);
for y=1 : tinggi_baru
for x=1 : lebar_baru
x2 = round((x-n) * cosa + (y-m) * sina + n);
y2 = round((y-m) * cosa - (x-n) * sina + m);
if (x2>=1) && (x2<=lebar_baru) && ...
(y2>=1) && (y2<=tinggi_baru)
G(y, x) = F2(y2,x2);
else
G(y,x) = 0;
end
end
end
figure(2);
G = uint8(G);
imshow(G);
clear all;
Program di atas merupakan program untuk melakukan operasi pemutaran citra dengan sudut yang ditentukan. Program ini merupakan versi ke-5, yang memutar citra dengan hasil utuh. Berikut ini adalah penjelasan lebih detail mengenai program tersebut:
- Pertama-tama, program membaca citra 'gedung.tif' yang berada di direktori 'c:\Image', dan menentukan ukuran citra tersebut. Variabel 'tinggi' dan 'lebar' diisi dengan ukuran citra tersebut.
- Selanjutnya, program menentukan sudut pemutaran yang akan dilakukan, yang dalam program ini ditentukan dengan variabel 'sudut'. Variabel ini diubah menjadi radian dengan dikalikan dengan nilai pi dan dibagi dengan 180.
- Kemudian, program menghitung nilai cosinus dan sinus dari sudut tersebut, yang disimpan dalam variabel 'cosa' dan 'sina'.
- Program kemudian menentukan titik pusat citra dengan cara menghitung nilai tengah dari 'tinggi' dan 'lebar', dan dibulatkan ke bawah menggunakan fungsi 'floor'. Variabel 'm' dan 'n' diisi dengan nilai tersebut.
- Selanjutnya, program menentukan posisi setiap pojok citra setelah dilakukan pemutaran dengan mengalikan koordinat x dan y awal dengan matriks rotasi. Posisi baru kemudian disimpan dalam variabel 'x21', 'y21', 'x22', 'y22', 'x23', 'y23', 'x24', dan 'y24'.
- Program kemudian menentukan nilai batas koordinat baru citra setelah dilakukan pemutaran. Koordinat minimal dihitung dengan mencari nilai minimum dari koordinat x dan y baru, sedangkan koordinat maksimal dihitung dengan mencari nilai maksimum dari koordinat x dan y baru. Variabel 'xmin', 'xmax', 'ymin', dan 'ymax' diisi dengan nilai tersebut.
- Program kemudian membuat citra kosong baru dengan ukuran sesuai dengan nilai koordinat minimal dan maksimal yang telah dihitung sebelumnya, dan menyimpan citra asli pada posisi yang benar di citra baru. Citra baru ini disimpan dalam variabel 'F2'.
- Selanjutnya, program melakukan iterasi pada setiap piksel citra baru dan memutar posisi setiap piksel tersebut dengan matriks rotasi. Posisi baru tersebut kemudian digunakan untuk mengisi nilai piksel pada citra hasil putaran 'G'.
- Jika posisi piksel baru masih berada di dalam batas citra asli, maka nilai piksel pada posisi baru diambil dari citra asli yang telah diputar sebelumnya. Jika posisi piksel baru berada di luar batas citra asli, maka nilai piksel pada posisi tersebut diisi dengan nol.
- Setelah selesai, citra hasil putaran ditampilkan pada Figure 2 menggunakan fungsi 'imshow'.
- Akhirnya, semua variabel yang digunakan dalam program dihapus dari memori menggunakan fungsi 'clear all'.
x11 = 1; y11 = 1; x12 = lebar; y12 = 1; x13 = lebar; y13 = tinggi; x14 = 1; y14 = tinggi;
Baris kode ini mendefinisikan koordinat pojok gambar asli sebelum dilakukan pemutaran. Posisi x11 dan y11 adalah pojok kiri atas gambar, sedangkan posisi x12 dan y12 adalah pojok kanan atas gambar. Posisi x13 dan y13 adalah pojok kanan bawah gambar, dan posisi x14 dan y14 adalah pojok kiri bawah gambar.
Hasil pemutaran gambar dengan menggunakan rotasi5.m ditunjukkan pada Gambar 5.12.
Program : rotasi5RGB.m
% ROTASI5 Melakukan operasi pemutaran citra.
% Versi 5
% Memutar dengan hasil utuh
F = imread('c:\Image\jalan sawah orang.jpg');
Ukuran = size(F);
tinggi = Ukuran(1);
lebar = Ukuran(2);
ch = Ukuran(3);
sudut = 45; % Sudut pemutaran
rad = pi * sudut/180;
cosa = cos(rad);
sina = sin(rad);
x11 = 1; y11 = 1;
x12 = lebar; y12 = 1;
x13 = lebar; y13 = tinggi;
x14 = 1; y14 = tinggi;
m = floor(tinggi/2);
n = floor(lebar/2);
% Menentukan pojok
x21 = ((x11-n) * cosa + (y11-m) * sina + n);
y21 = ((y11-m) * cosa - (x11-n) * sina + m);
x22 = ((x12-n) * cosa + (y12-m) * sina + n);
y22 = ((y12-m) * cosa - (x12-n) * sina + m);
x23 = ((x13-n) * cosa + (y13-m) * sina + n);
y23 = ((y13-m) * cosa - (x13-n) * sina + m);
x24 = ((x14-n) * cosa + (y14-m) * sina + n);
y24 = ((y14-m) * cosa - (x14-n) * sina + m);
ymin = min([y21 y22 y23 y24]);
xmin = min([x21 x22 x23 x24]);
ymak = max([y21 y22 y23 y24]);
xmak = max([x21 x22 x23 x24]);
lebar_baru = xmak - xmin + 1;
tinggi_baru = ymak - ymin + 1;
tambahan_y = floor((tinggi_baru-tinggi)/2);
tambahan_x = floor((lebar_baru-lebar)/2);
F2=zeros(floor(tinggi_baru), floor(lebar_baru), ch);
%F2 = double(F);
%G=zeros(tinggi, lebar, ch);
for z=1 : ch
for y=1 : tinggi
for x=1 : lebar
F2(y+tambahan_y, x+tambahan_x, z) = F(y, x, z);
end
end
end
figure(1);
imshow( uint8(F2));
% Putar citra
m = floor(tinggi_baru/2);
n = floor(lebar_baru/2);
for z=1 : ch
for y=1 : tinggi_baru
for x=1 : lebar_baru
x2 = round((x-n) * cosa + (y-m) * sina + n);
y2 = round((y-m) * cosa - (x-n) * sina + m);
if (x2>=1) && (x2<=lebar_baru) && ...
(y2>=1) && (y2<=tinggi_baru)
G(y, x, z) = F2(y2,x2,z);
else
G(y,x,z) = 0;
end
end
end
end
figure(2);
G = uint8(G);
imshow(G);
clear all;
Hasil:
5.7 Memperbesar Citra
Suatu citra dapat diperbesar dengan membuat setiap piksel menjadi beberapa piksel. Gambar 5.13 memberikan contoh cara memperbesar citra.
Pada contoh di atas pembesaran pada arah vertikal dan horizontal sebesar 2 kali. Berikut adalah fungsi yang memperlihatkan cara perbesaran tersebut.
| Program : perbesar.m |
function G = perbesar(berkas, sy, sx)
% PERBESAR Melakukan operasi pembesaran citra.
% Masukan: berkas = nama berkas image
% sy : skala pembesaran pada sumbu Y
% sx : skala pembesaran pada sumbu X
%
% Versi 1
F = imread(berkas);
F = rgb2gray(F);
Ukuran = size(F);
tinggi = Ukuran(1);
lebar = Ukuran(2);
figure(2);
imshow(F);
tinggi_baru = tinggi * sy;
lebar_baru = lebar * sx;
F2 = double(F);
for y=1 : tinggi_baru
y2 = ((y-1) / sy) + 1;
for x=1 : lebar_baru
x2 = ((x-1) / sx) + 1;
G(y, x) = F(floor(y2), floor(x2));
end
end
G = uint8(G);
Program di atas merupakan sebuah fungsi MATLAB bernama "perbesar", yang digunakan untuk melakukan operasi pembesaran pada citra grayscale. Fungsi ini memiliki tiga parameter masukan, yaitu nama berkas gambar, skala pembesaran pada sumbu Y, dan skala pembesaran pada sumbu X.
Pertama-tama, fungsi membaca gambar menggunakan perintah imread dan kemudian mengubah gambar ke mode grayscale menggunakan fungsi rgb2gray. Ukuran gambar awal diambil menggunakan perintah size dan disimpan dalam variabel Ukuran. Variabel tinggi dan lebar kemudian diisi dengan Ukuran(1) dan Ukuran(2) masing-masing.
Selanjutnya, gambar awal ditampilkan menggunakan perintah imshow dan disimpan ke dalam variabel F2 sebagai tipe data double. Variabel tinggi_baru dan lebar_baru dihitung dengan mengalikan tinggi dan lebar gambar awal dengan skala pembesaran pada sumbu Y dan sumbu X.
Untuk setiap piksel pada gambar hasil, fungsi melakukan transformasi balik pada koordinat (x,y) pada gambar awal untuk menentukan posisi piksel pada gambar hasil. Posisi pada gambar awal dihitung dengan membagi posisi pada gambar hasil dengan skala pembesaran pada sumbu Y dan sumbu X.
Nilai piksel pada gambar hasil diisi dengan nilai piksel pada posisi yang sesuai pada gambar awal. Untuk memperoleh nilai piksel yang tepat pada gambar awal, nilai x2 dan y2 dibulatkan ke bawah menggunakan perintah floor.
Terakhir, gambar hasil dikonversi menjadi tipe data uint8 dan disimpan ke dalam variabel G sebelum fungsi mengembalikan variabel G sebagai output.
Perlu diketahui, tinggi dan lebar citra keluaran dihitung berdasarkan
tinggi_baru = tinggi * sy;
lebar_baru = lebar * sx;Kemudian,
y2 = ((y-1) / sy) + 1;digunakan untuk memperoleh nilai y2 yang berkisar antara 1 sampai dengan lebar citra asli. Hal yang serupa dilakukan untuk x2 yang dilaksanakan melalui
x2 = ((x-1) / sx) + 1;Berdasar fungsi perbesar di atas, dapat diberikan perintah seperti berikut:
Hasilnya dapat dilihat pada Gambar 5.14.
Program : perbesarRGB.m
function G = perbesar(berkas, sy, sx)
% PERBESAR Melakukan operasi pembesaran citra.
% Masukan: berkas = nama berkas image
% sy : skala pembesaran pada sumbu Y
% sx : skala pembesaran pada sumbu X
%
% Versi 1
F = imread(berkas);
Ukuran = size(F);
tinggi = Ukuran(1);
lebar = Ukuran(2);
ch = Ukuran(3);
figure(1);
imshow(F);
tinggi_baru = tinggi * sy;
lebar_baru = lebar * sx;
F2 = double(F);
for z=1 : ch
for y=1 : tinggi_baru
y2 = ((y-1) / sy) + 1;
for x=1 : lebar_baru
x2 = ((x-1) / sx) + 1;
G(y, x, z) = F(floor(y2), floor(x2), z);
end
end
end
G = uint8(G);
Hasilnya:
Untuk memperhalus hasil perbesaran citra, interpolasi piksel perlu dilakukan. Contoh dapat dilihat pada kode berikut.
| Program : perbesar2.m |
function G = perbesar2(berkas, sy, sx)
% PERBESAR2 Melakukan operasi pembesaran citra
% dengan interpolasi.
% Masukan: berkas = nama berkas image
% sy : skala pembesaran pada sumbu Y
% sx : skala pembesaran pada sumbu X
%
% Versi 2
F = imread(berkas);
F = rgb2gray(F);
Ukuran = size(F);
tinggi = Ukuran(1);
lebar = Ukuran(2);
tinggi_baru = round(tinggi * sy);
lebar_baru = round(lebar * sx);
figure(2);
imshow(F);
F2 = double(F);
for y=1 : tinggi_baru
y2 = (y-1) / sy + 1;
for x=1 : lebar_baru
x2 = (x-1) / sx + 1;
% Lakukan interpolasi bilinear
p = floor(y2);
q = floor(x2);
a = y2-p;
b = x2-q;
if (floor(x2)==lebar) || (floor(y2) == tinggi)
G(y, x) = F(floor(y2), floor(x2));
else
intensitas = (1-a) * ((1-b) * F(p,q) + ...
b * F(p, q+1)) + ...
a *((1-b)* F(p+1, q) + ...
b * F(p+1, q+1));
G(y, x) = intensitas;
end
end
end
G = uint8(G);
Penghalusan citra keluaran dilakukan melalui interpolasi bilinear, seperti yang telah dibahas di Subbab 5.4.
Untuk melihat hasil interpolasi pada pembesaran citra, dapat diberikan perintah seperti berikut:
Hasilnya dapat dilihat pada Gambar 5.15.
Program : perbesar2RGB.m
function G = perbesar2(berkas, sy, sx)
% PERBESAR2 Melakukan operasi pembesaran citra
% dengan interpolasi.
% Masukan: berkas = nama berkas image
% sy : skala pembesaran pada sumbu Y
% sx : skala pembesaran pada sumbu X
%
% Versi 2
F = imread(berkas);
Ukuran = size(F);
tinggi = Ukuran(1);
lebar = Ukuran(2);
ch = Ukuran(3);
figure(1);
imshow(F);
tinggi_baru = round(tinggi * sy);
lebar_baru = round(lebar * sx);
F2 = double(F);
for z=1 : ch
for y=1 : tinggi_baru
y2 = (y-1) / sy + 1;
for x=1 : lebar_baru
x2 = (x-1) / sx + 1;
% Lakukan interpolasi bilinear
p = floor(y2);
q = floor(x2);
a = y2-p;
b = x2-q;
if (floor(x2)==lebar) || (floor(y2) == tinggi)
G(y, x, z) = F(floor(y2), floor(x2), z);
else
intensitas = (1-a) * ((1-b) * F(p,q,z) + ...
b * F(p, q+1, z)) + ...
a *((1-b)* F(p+1, q, z) + ...
b * F(p+1, q+1, z));
G(y, x, z) = intensitas;
end
end
end
end
G = uint8(G);
Hasilnya:
5.8 Memperkecil Citra
Bagaimana kalau ingin memperkecil citra? Secara prinsip, pengecilan citra berarti mengurangi jumlah piksel. Algoritma yang digunakan untuk mewujudkan perbesar.m maupun perbesar2.m dapat digunakan untuk keperluan ini dengan m berupa bilangan pecahan seperti 1/2, ยผ, 1/8, dan seterusnya. Contoh:
Pada perintah bagian atas, Hasilnya ditunjukkan pada Gambar 5.17.
5.9 Perbesaran dengan Skala Vertikal dan Horizontal Berbeda
Fungsi perbesar dan perbesar2 dapat digunakan untuk melakukan perbesaran/pengecilan dengan skala horizontal dan vertikal yang berbeda. Sebagai contoh, dapat diberikan perintah seperti berikut:
Pada perintah bagian bawah, Hasilnya ditunjukkan pada Gambar 5.17.
2,5 kali pada arah horizontal
5.10 Pencerminan Citra
Pencerminan citra atau flip image merupakan operasi transformasi geometri pada citra digital yang menghasilkan citra baru dengan mengubah arah sudut pandang citra dari aslinya. Pencerminan citra dapat dilakukan secara horizontal, yaitu dengan merefleksikan citra terhadap sumbu vertikal, atau secara vertikal, yaitu dengan merefleksikan citra terhadap sumbu horizontal.
Pada proses pencerminan citra, setiap piksel pada citra asli akan dipindahkan ke posisi yang baru pada citra hasil pencerminan. Piksel yang semula berada di sisi kiri citra akan dipindahkan ke sisi kanan citra, dan sebaliknya. Begitu pula dengan piksel yang berada di sisi atas dan bawah citra.
Pencerminan citra sering digunakan dalam berbagai aplikasi pengolahan citra, seperti pengenalan pola, deteksi wajah, dan perbaikan citra. Salah satu keuntungan dari pencerminan citra adalah dapat memperbaiki citra yang terbalik tanpa perlu merekam ulang citra tersebut.
Pencerminan yang umum dilakukan berupa pencerminan secara vertikal dan pencerminan secara horizontal. Pencerminan secara horizontal dilakukan dengan menukarkan dua piksel yang berseberangan kiri-kanan, sebagaimana diperlihatkan pada Gambar 5.18. Algoritma untuk menangani pencerminan secara horizontal diperlihatkan Algoritma 5.1.
Implementasinya ditunjukkan pada program berikut.
| Program : cerminh.m |
function G = cerminh(F)
% CERMINH Berfungsi untuk mencerminkan citra
% secara horizontal
% Masukan: F = Citra berskala keabuan
F = rgb2gray(F);
[tinggi, lebar] = size(F);
imshow(F)
for y=1 : tinggi
for x=1 : lebar
x2 = lebar - x + 1;
y2 = y;
G(y, x) = F(y2, x2);
end
endProgram di atas merupakan sebuah fungsi MATLAB yang digunakan untuk melakukan pencerminan citra secara horizontal. Fungsi ini mengambil sebuah citra berskala keabuan sebagai masukan dan menghasilkan citra baru yang dicerminkan secara horizontal.
Pada awal fungsi, citra masukan F diubah menjadi citra berskala keabuan menggunakan fungsi "rgb2gray". Kemudian, ukuran citra diambil menggunakan fungsi "size" dan disimpan dalam variabel tinggi dan lebar.
Setelah itu, dilakukan perulangan untuk setiap piksel pada citra masukan F. Setiap piksel pada citra tersebut diambil dan diproses untuk dicerminkan secara horizontal. Koordinat x pada piksel tersebut diubah dengan mencari selisih lebar citra dengan posisi piksel tersebut (lebar - x + 1) sehingga piksel tersebut dicerminkan secara horizontal. Koordinat y pada piksel tetap sama.
Setiap piksel pada citra hasil cerminkan disimpan pada variabel G yang memiliki ukuran yang sama dengan citra masukan. Pada akhir program, citra hasil cerminkan ditampilkan menggunakan fungsi "imshow" dan dihasilkan sebagai keluaran fungsi.
Program : cerminhRGB.m
function G = cerminh(F)
% CERMINH Berfungsi untuk mencerminkan citra
% secara horizontal
% Masukan: F = Citra berskala keabuan
[tinggi, lebar, ch] = size(F);
imshow(F)
for z=1 : ch
for y=1 : tinggi
for x=1 : lebar
x2 = lebar - x + 1;
y2 = y;
G(y, x, z) = F(y2, x2, z);
end
end
end
Contoh pemakaian fungsi cerminh:
Contoh pencerminan gambar secara horizontal ditunjukkan pada Gambar 5.19.
Pencerminan secara vertikal dilakukan dengan menukarkan dua piksel yang berseberangan atas-bawah, sebagaimana diperlihatkan pada Gambar 5.20. Algoritma untuk menangani pencerminan secara horizontal diperlihatkan Algoritma 5.2.
Implementasinya ditunjukkan pada program berikut.
| Program : cerminv.m |
function G = cerminv(F)
% CERMINV Berfungsi untuk mencerminkan citra
% secara vertikal
% Masukan: F = Citra berskala keabuan
F = rgb2gray(F);
[tinggi, lebar] = size(F);
imshow(F)
for y=1 : tinggi
for x=1 : lebar
x2 = x;
y2 = tinggi - y + 1;
G(y, x) = F(y2, x2);
end
end
G = uint8(G);
Program di atas adalah fungsi cerminv yang digunakan untuk melakukan pencerminan citra secara vertikal.
Pada awal fungsi, citra F diubah menjadi citra berskala keabuan menggunakan fungsi rgb2gray. Kemudian, tinggi dan lebar citra diambil menggunakan fungsi size dan disimpan dalam variabel tinggi dan lebar.
Selanjutnya, dilakukan perulangan pada setiap pixel citra, dimana pada setiap perulangan nilai variabel x2 dihitung dengan cara x2 = x dan nilai variabel y2 dihitung dengan cara y2 = tinggi - y + 1. Variabel x2 dan y2 merepresentasikan koordinat pixel pada citra hasil pencerminan yang merupakan pencerminan citra asli pada sumbu vertikal. Kemudian nilai piksel pada citra hasil pencerminan G ditentukan dengan mengambil nilai piksel pada koordinat (y2,x2) pada citra asli F.
Akhirnya, citra hasil pencerminan G dikonversi menjadi citra dengan tipe data uint8 menggunakan fungsi uint8 dan dijadikan output dari fungsi cerminv.
Program : cerminvRGB.m
function G = cerminv(F)
% CERMINV Berfungsi untuk mencerminkan citra
% secara vertikal
% Masukan: F = Citra berskala keabuan
[tinggi, lebar, ch] = size(F);
imshow(F)
for z=1 : ch
for y=1 : tinggi
for x=1 : lebar
x2 = x;
y2 = tinggi - y + 1;
G(y, x, z) = F(y2, x2, z);
end
end
end
G = uint8(G);
Contoh pemakaian fungsi cerminv:
Contoh pencerminan gambar secara vertikal ditunjukkan pada Gambar 5.21.
| Di beberapa software, pencerminan secara horizontal justru dinamakan vertical flip. |
5.11 Transformasi Affine
Transformasi affine adalah teknik yang digunakan dalam pengolahan citra digital untuk melakukan transformasi linier pada citra. Transformasi affine melibatkan penggunaan matriks transformasi linier untuk memetakan satu set titik pada citra asli ke posisi baru pada citra hasil transformasi.
Transformasi affine dapat mencakup rotasi, translasi, pengskalaan, dan shear. Rotasi dilakukan dengan memutar citra sekitar titik tertentu, translasi memindahkan citra ke posisi baru, pengskalaan mengubah ukuran citra, dan shear memutar citra sepanjang satu sumbu.
Dalam pengolahan citra digital, transformasi affine digunakan untuk berbagai tujuan, seperti mengoreksi distorsi citra, melakukan peregangan citra, mengubah orientasi citra, atau memindahkan objek di dalam citra. Transformasi affine juga digunakan dalam teknik seperti segmentasi citra, pengenalan objek, dan perbaikan citra.
Transformasi affine adalah transformasi linear yang menyertakan penskalaan, pemutaran, penggeseran, dan shearing (pembengkokan). Transformasi affine dapat dinyatakan dengan persamaan seperti berikut:
Persamaan di atas dapat ditulis pula menjadi seperti berikut:
Berdasarkan persamaan di atas, terlihat bahwa transformasi affine memiliki enam derajat kebebasan: dua untuk translasi (tx dan ty) dan empat buah untuk rotasi, penskalaan, stretching, dan shearing (a11, a12, a21, dan a22).
Tabel 5.1 menunjukkan koefisien yang digunakan dalam matriks di depan untuk menyatakan operasi dasar penskalaan, rotasi, translasi, dan pembengkokan. Tentu saja, keenam koefisien tersebut dapat diatur secara bebas untuk mendapatkan transformasi affine. Untuk melakukan penggabungan dua operasi
dasar, koefisien yang sama dari dua jenis transformasi dapat dikalikan. Contoh dapat dilihat pada Gambar 5.22.
penyekalaan, dan affine
Fungsi berikut berguna untuk mewujudkan transformasi affine.
| Program : taffine.m |
function G = taffine(F, a11, a12, a21, a22, tx, ty)
% TAFFINE Digunakan untuk melakukan transformasi affine.
% Masukan: F = Citra berskala keabuan
% a11, a12, a21, a22, tx, ty = mengatur
% transformasi affine
[tinggi, lebar] = size(F);
for y=1 : tinggi
for x=1 : lebar
x2 = a11 * x + a12 * y + tx;
y2 = a21 * x + a22 * y + ty;
if (x2>=1) && (x2<=lebar) && ...
(y2>=1) && (y2<=tinggi)
% Lakukan interpolasi bilinear
p = floor(y2);
q = floor(x2);
a = y2-p;
b = x2-q;
if (floor(x2)==lebar) || ...
(floor(y2) == tinggi)
G(y, x) = F(floor(y2), floor(x2));
else
intensitas = (1-a)*((1-b)*F(p,q) + ...
b * F(p, q+1)) + ...
a *((1-b)* F(p+1, q) + ...
b * F(p+1, q+1));
G(y, x) = intensitas;
end
else
G(y, x) = 0;
end
end
end
G = uint8(G);
Program di atas adalah sebuah fungsi transformasi affine yang digunakan untuk melakukan transformasi affine pada citra berskala keabuan F. Transformasi affine dilakukan dengan memasukkan nilai koefisien a11, a12, a21, a22, tx, dan ty sebagai input.
Setiap piksel pada citra F diproses pada looping for y=1:tinggi dan x=1:lebar. Piksel ini akan ditransformasikan menjadi posisi baru x2 dan y2 pada citra G. Posisi baru ini dihitung menggunakan persamaan transformasi affine.
Setelah posisi piksel baru diperoleh, program akan memeriksa apakah posisi piksel baru berada di dalam batas citra G. Jika berada di dalam batas citra G, program akan melakukan interpolasi bilinear untuk menentukan nilai intensitas piksel baru pada posisi (x2, y2) di citra G. Jika posisi piksel baru berada di luar batas citra G, maka nilai intensitas piksel tersebut akan diatur menjadi 0.
Setelah proses transformasi affine selesai dilakukan pada setiap piksel, citra hasil transformasi affine G akan dikembalikan dalam format citra berskala keabuan dengan menggunakan perintah G = uint8(G).
Contoh penggunaan fungsi taffine untuk melakukan pembengkokan:
Gambar diatas (kiri) merupakan citra asli dan (kanan) merupakan citra hasil
Contoh berikut digunakan untuk memutar gambar:
>> rad = 10 * pi / 180;
>> G = taffine(F,cos(rad),sin(rad), ...
-sin(rad),cos(rad),0,0);
>> imshow(G) 
Contoh penggabungan rotasi dan translasi:
Contoh penggabungan rotasi, penskalaan, dan translasi:
Perlu diketahui, angka seperti 2 di depan cos(rad) menyatakan bahwa hasilnya adalah kebalikannya, yaitu ยฝ kalinya.
5.12 Efek Ripple
Efek ripple (riak) adalah aplikasi transformasi citra yang membuat gambar terlihat bergelombang. Efek riak dapaat dibuat baik pada arah x maupun y. Transformasinya seperti berikut:
Dalam hal ini, ax dan ay menyatakan amplitudo riak gelombang sinus, sedangkan Tx dan Ty menyatakan periode gelombang sinus. Implementasi efek gelombang dapat dilihat di bawah ini.
| Program : ripple.m |
function G = ripple(F, ax, ay, tx, ty)
% RIPPLE Berfungsi untuk melakukan transformasi 'ripple'.
F = rgb2gray(F);
%imshow(F)
dimensi = size(F);
tinggi = dimensi(1);
lebar = dimensi(2);
for y=1 : tinggi
for x=1 : lebar
x2 = x + ax * sin(2 * pi * y / tx);
y2 = y + ay * sin(2 * pi * x / ty);
if (x2>=1) && (x2<=lebar) && ...
(y2>=1) && (y2<=tinggi)
% Lakukan interpolasi bilinear
p = floor(y2);
q = floor(x2);
a = y2-p;
b = x2-q;
if (floor(x2)==lebar) || ...
(floor(y2) == tinggi)
G(y, x) = F(floor(y2), floor(x2));
else
intensitas = (1-a)*((1-b)*F(p,q) + ...
b * F(p, q+1)) + ...
a *((1-b)* F(p+1, q) + ...
b * F(p+1, q+1));
G(y, x) = intensitas;
end
else
G(y, x) = 0;
end
end
end
G = uint8(G);Program di atas merupakan implementasi dari transformasi 'ripple' pada citra berskala keabuan. Transformasi 'ripple' menghasilkan efek bergelombang pada citra dengan memanipulasi posisi piksel pada citra menggunakan fungsi sinusoidal.
Berikut adalah penjelasan tiap bagian program:
- Program menerima masukan citra F dan parameter ax, ay, tx, dan ty.
- Citra F diubah menjadi citra grayscale dengan fungsi rgb2gray() karena transformasi 'ripple' hanya digunakan untuk citra grayscale.
- Variabel dimensi menyimpan ukuran citra F (tinggi dan lebar).
- Variabel tinggi dan lebar menyimpan tinggi dan lebar citra F.
- Program melakukan perulangan pada setiap piksel pada citra F.
- Posisi piksel pada citra F diubah menjadi posisi baru x2 dan y2 dengan menggunakan fungsi sinusoidal.
- Jika posisi piksel baru masih berada di dalam citra, program melakukan interpolasi bilinear untuk mencari intensitas piksel baru. Jika piksel baru berada di tepi citra, program menggunakan intensitas piksel tepi terdekat.
- Jika posisi piksel baru berada di luar citra, program memberi nilai intensitas 0.
- Hasil akhir transformasi disimpan pada citra G dan dikembalikan oleh program.
Contoh penggunaan fungsi ripple:
Pada contoh di atas, amplitude gelombang sinus yang digunakan berupa 10 dan 15, sedangkan periode yang digunakan 120 dan 250. Contoh hasil perintah di atas ditunjukkan pada Gambar 5.23.
Beberapa contoh yang lain dapat dilihat pada Gambar 5.24.
.
.
.
5.13 Efek Twirl
Transformasi twirl adalah suatu teknik dalam pengolahan citra digital untuk memutar dan memutarbalikkan piksel-piksel citra. Transformasi ini membuat suatu efek berpusar atau berputar-putar pada citra. Secara matematis, transformasi ini melibatkan pemetaan piksel-piksel citra ke titik-titik tertentu di sekitar pusat yang berputar.
Transformasi twirl (olak atau puntiran) dilakukan dengan memutar citra berdasarkan titik pusat citra, tetapi tidak bersifat linear. Salah satu varian bentuk transformasinya, yang diadaptasi dari Burger & Burge (2008), sebagai berikut:
dengan
Contoh berikut menggunakan rmaks sebesar ยฝ diagonal citra dan alpha sebesar 43 derajat.
| Program : twirl.m |
function G = twirl(F)
% TWIRL Berfungsi untuk melakukan transformasi 'twirl'
F = rgb2gray(F);
dimensi = size(F);
tinggi = dimensi(1);
lebar = dimensi(2);
xc = round(lebar / 2);
yc = round(tinggi / 2);
alpha = 43 * pi / 180;
rmaks = 0.5 * sqrt(xc^2 + yc ^ 2); % 1/2 diagonal citra
for y=1 : tinggi
for x=1 : lebar
r = sqrt((x-xc)^2+(y-yc)^2);
beta = atan2(y-yc, x-xc) + ...
alpha * (rmaks - r) / rmaks;
x2 = xc + r * cos(beta);
y2 = yc + r * sin(beta);
if (x2>=1) && (x2<=lebar) && ...
(y2>=1) && (y2<=tinggi)
% Lakukan interpolasi bilinear
p = floor(y2);
q = floor(x2);
a = y2-p;
b = x2-q;
if (floor(x2)==lebar) || ...
(floor(y2) == tinggi)
G(y, x) = F(floor(y2), floor(x2));
else
intensitas = (1-a)*((1-b)*F(p,q) + ...
b * F(p, q+1)) + ...
a *((1-b)* F(p+1, q) + ...
b * F(p+1, q+1));
G(y, x) = intensitas;
end
else
G(y, x) = 0;
end
end
end
G = uint8(G);Program di atas adalah implementasi dari transformasi twirl pada pengolahan citra digital. Transformasi twirl ini digunakan untuk memutar gambar pada titik tengah gambar, di mana bagian-bagian luar gambar akan berputar lebih banyak daripada bagian dalam gambar.
Program ini menerima citra masukan dalam format grayscale atau RGB, dan akan mengembalikan citra keluaran dalam format uint8. Program ini bekerja dengan cara sebagai berikut:
- Mengubah citra masukan menjadi grayscale jika citra masukan dalam format RGB.
- Menentukan dimensi citra masukan, tinggi dan lebar, serta titik tengah citra (xc,yc).
- Menentukan parameter alpha, yaitu besarnya sudut putaran maksimum yang diterapkan pada bagian terluar gambar, dan besarnya radius maksimum (rmaks) dari putaran tersebut.
- Untuk setiap piksel di citra masukan, program akan menghitung jarak r dari piksel tersebut ke titik tengah citra. Kemudian, program akan menghitung sudut beta dengan menggunakan fungsi atan2 yang menghitung nilai arctan dari dua variabel y/x. Nilai sudut beta dihitung dengan menambahkan alpha kali selisih antara rmaks dan r, lalu dibagi dengan rmaks.
- Setelah nilai beta dan r diketahui, program akan menghitung koordinat baru (x2,y2) dari piksel tersebut setelah dilakukan transformasi. Koordinat baru dihitung dengan menggunakan rumus koordinat titik akhir setelah rotasi terhadap titik pusat, yaitu: x2 = xc + r * cos(beta) dan y2 = yc + r * sin(beta).
- Program melakukan interpolasi bilinear untuk mendapatkan intensitas piksel pada koordinat baru (x2,y2).
- Program mengembalikan citra keluaran dalam format uint8.
Dengan menggunakan program di atas, pengguna dapat melakukan transformasi twirl pada citra digital dengan mengubah parameter alpha dan rmaks sesuai kebutuhan.
Contoh penggunaan fungsi twirl:
Hasil ditunjukkan pada Gambar 5.25.
5.14 Transformasi Spherical
Transformasi Spherical adalah salah satu teknik transformasi dalam pengolahan citra digital yang digunakan untuk memanipulasi bentuk citra. Transformasi ini mengubah setiap piksel pada citra dari koordinat kartesian menjadi koordinat bola yang dikelilingi oleh sebuah bola, sehingga menghasilkan efek distorsi pada gambar seperti efek fisheye pada foto.
Transformasi spherical memberikan efek bulatan (bola), seperti melihat gambar menggunakan lensa pembesar. Bagian tengah terlihat membesar. Hal seperti itu diperoleh dengan menggunakan transformasi seperti berikut.
Perlu diketahui, ๐ disebut indeks refraksi atau indeks pantulan. Implementasi transformasi spherical dapat dilihat pada program berikut.
| Program : spheri.m |
function G = spheri(F, rho)
% SPHERI Berfungsi untuk melakukan transformasi 'spherical'
F = rgb2gray(F);
dimensi = size(F);
tinggi = dimensi(1);
lebar = dimensi(2);
xc = round(lebar / 2);
yc = round(tinggi / 2);
rmaks = xc; % 1/2 lebar gambar
for y=1 : tinggi
for x=1 : lebar
r = sqrt((x-xc)^2+(y-yc)^2);
z = sqrt(rmaks^2-r^2);
bx = (1 - 1/rho) * asin((x-xc)/...
sqrt((x-xc)^2+z^2));
by = (1 - 1/rho) * asin((y-yc)/...
sqrt((y-yc)^2+z^2));
if r <= rmaks
x2 = x - z * tan(bx);
y2 = y - z * tan(by);
else
x2 = x;
y2 = y;
end
if (x2>=1) && (x2<=lebar) && ...
(y2>=1) && (y2<=tinggi)
% Lakukan interpolasi bilinear
p = floor(y2);
q = floor(x2);
a = y2-p;
b = x2-q;
if (floor(x2)==lebar) || ...
(floor(y2) == tinggi)
G(y, x) = F(floor(y2), floor(x2));
else
intensitas = (1-a)*((1-b)*F(p,q) + ...
b * F(p, q+1)) + ...
a *((1-b)* F(p+1, q) + ...
b * F(p+1, q+1));
G(y, x) = intensitas;
end
else
G(y, x) = 0;
end
end
end
G = uint8(G);Pemakaian skrip di atas dapat dilihat pada contoh berikut:
Hasil ditunjukkan pada Gambar 5.26.
5.15 Transformasi bilinear
Transformasi bilinear mempunyai fungsi pemetaan seperti berikut:
Transformasi ini termasuk dalam transformasi nonlinear mengingat terdapat pencampuran xy. Implementasi dalam bentuk program dapat dilihat berikut ini.
| Program : tbilin.m |
function G = tbilin(F, a1, a2, a3, a4, b1, b2, b3, b4)
% Fungsi untuk melakukan transformasi bilinear
F = rgb2gray(F);
dimensi = size(F);
tinggi = dimensi(1);
lebar = dimensi(2);
for y=1 : tinggi
for x=1 : lebar
x2 = a1 * x + a2 * y + a3 * x * y + a4;
y2 = b1 * x + b2 * y + b3 * x * y + b4;
if (x2>=1) && (x2<=lebar) && ...
(y2>=1) && (y2<=tinggi)
% Lakukan interpolasi bilinear
p = floor(y2);
q = floor(x2);
a = y2-p;
b = x2-q;
if (floor(x2)==lebar) || ...
(floor(y2) == tinggi)
G(y, x) = F(floor(y2), floor(x2));
else
intensitas = (1-a)*((1-b)*F(p,q) + ...
b * F(p, q+1)) + ...
a *((1-b)* F(p+1, q) + ...
b * F(p+1, q+1));
G(y, x) = intensitas;
end
else
G(y, x) = 0;
end
end
end
G = uint8(G);
Contoh pemanggilan fungsi tbilin seperti berikut:
Hasilnya dapat dilihat pada Gambar 5.27.
