Anda di halaman 1dari 8

Pemrosesan Paralel Image Edge Detection dengan Algoritma Sobel

Radhwa Dhiya Razani, Mega Puspitasari, Muhammad Reza Pahlevi,


Astika Putri Roqimawati, Pandu Wicaksono
Department of Computer Science
Universitas Gadjah Mada
Abstract
In the development of technology which towards to digital and modern era, needed an application which can
accomplish various problems more efficiently. There are a lot of applications adjust edge detection method as a main
process for pattern recognition of image. So that, it can be said that edge detection of image considered important part
in computer image processing area.
In this paper explained about Sobel Operator which used for edge detection process; and it runs on Java
programming language This system gives access to user to choose an option whether the system will run in parallel or
run in serial. For parallel processing, is used Fork-Join Algorithm which utilizes multiple processors for breaking the
tasks into smaller parts, then distribute it to available processors. In the end of parallels execution, outputs are
reunited. However, for serial processing, the image as an input will be processed directly without breaking the task
first. After the process finish, the system will releases a new image. The result of this research is the level performance
of parallel processing is higher than serial processing (evidenced by comparison chart).
Keywords: Edge detection, image processing, Sobel operator, Fork-Join, parallel, serial

Abstrak
Dalam perkembangan teknologi yang menuju era digital dan modern, diperlukan sebuah aplikasi yang dapat
menyelesaikan berbagai permasalahan dengan lebih efisien. Sudah banyak aplikasi yang menerapkan metode edge
detection sebagai proses utama untuk pengenalan pola sebuah image. Jadi, dapat dikatakan bahwa edge detection
sebuah image dianggap penting pada computer image processing.
Dalam paper ini dijelaskan bahwa digunakan Sobel Operator untuk proses edge detection dan berjalan pada
bahasa pemograman Java. Sistem ini memberikan kebebasan kepada user untuk memilih apakah user akan
menjalakan operasi tersebut secara paralel atau secara sekuensial (serial). Untuk pemrosesan secara paralel,
digunakan algoritma Fork-Join dengan memanfaatkan multiple processor dengan cara memecah suatu pekerjaan
menjadi pekerjaan yang lebih kecil dan mendistribusikannya ke prosesor prosesor yang tersedia. Di akhir eksekusi,
keluaran yang didapat kembali disatukan. Pada pemrosesan secara serial, image yang dimasukkan langsung diproses
secara serial dan dihasilkan output berupa image baru. Diperoleh hasil bahwa performa pemrosesan secara paralel
lebih tinggi dibanding dengan pemrosesan secara serial (dibuktikan dengan sebuah diagram perbandingan).
Kata kunci: Edge detection, image processing Sobel operator, Fork-Join, parallel, serial

1. Pendahuluan
Data atau informasi tidak hanya disajikan dalam
bentuk teks, tetapi dapat juga berupa gambar, audio
(bunyi/ suara/musik) dan video. Pada gambar istilah
lainnya yaitu citra, mempunyai karakteristik yang
tidak dimiliki oleh data berbentuk teks. Peningkatan
kualitas citra bertujuan menghasilkan citra dengan
kualitas yang lebih baik dibandingkan dengan citra
semula. Untuk memenuhi tugas paper matakuliah
Sistem Paralel, kelompok kami akan membuat solusi
paralel pada image processing. Sebelum melangkah
lebih jauh, definisi image processing adalah suatu
bentuk pengolahan atau pemrosesan sinyal dengan
input berupa gambar (image) dan ditransformasikan
menjadi gambar lain sebagai keluarannya dengan
teknik tertentu.
Image processing memiliki peluang untuk
melakukan parallelism, karena inputannya yang
berupa image dan image pada dasarnya adalah array
2D yang berisi RGB (Red Green Blue) pada tiap
indeks array-nya (pixel). Kemudian untuk proses

lebih lanjut, kami memilih operasi Sobel pada


aplikasi image processing untuk dilakukan sebuah
parallelism.
Operasi
Sobel
merupakan
pengembangan metode Robert dengan menggunakan
filter HPF (High Pass Filter) yang diberi satu angka
nol penyangga. Kelebihan dari metode Sobel ini
adalah kemampuan untuk mengurangi noise sebelum
melakukan perhitungan deteksi tepi. Operasi Sobel
juga mampu melakukan edge detection yang dapat
membantu dalam proses pengenalan pola obyek.
Sobel sendiri bisa dibilang sudah efektif pada
prosesnya saat image memiliki resolusi rendah
sampai menengah dan mulai terasa tidak efektif saat
image beresolusi tinggi. Karena ketidakefektifan
operasi Sobel saat image beresolusi tinggi, kami
bermaksud untuk membuat solusi paralel pada
operasi Sobel dan membandingkan performanya
dengan operasi Sobel yang tidak diparalelkan,
sehingga bisa menyimpulkan mana yang lebih baik
digunakan.

2. Tinjauan pustaka
Kika & Greca (2013) melakukan penelitian yang
memperlihatkan bagaimana multithread dapat
meningkatkan performa algoritma yang dilakukan
pada single-core dan multi-core platform. Saat
ukuran dari citra tersebut dinaikkan maka
perhitungan komputasi pun juga bertambah, karena
kompleksitasnya meningkat.
Penelitian dilakukan dengan menggunakan empat
platform yang berbeda di mana masing-masng
menggunakan
single-core
(AMD
Athlon,
1.11GHz), single-core (Intel Pentium 4, 3.2 Ghz),
dual-core (Intel CoreTM2 Duo Processors, 2.2 GHz)
dan quad-core (Intel Core i5-4570R Processor,
2.7 GHz). Selain itu terdapat tiga ukuran citra yang
diterapkan yaitu 371x281 (Small), 500x500
(Medium) dan 1024x768 (Large). Selain itu terdapat
tiga algoritma yang diterapkan pada citra tersebut
yaitu Contrast, Brightness dan Steganography.
Hasil untuk citra yang berukuran Small
didapatkan eksekusi paling cepat dilakukan pada
processor dual-core, untuk citra berukuran Medium
adalah quad-core dan untuk citra berukuran Large
adalah processor quad-core. Hasil dari waktu
eksekusi selain bergantung pada ukuran citra juga
bergantung pada algoritma yang digunakan. Dalam
single-core hasil terbaik diberikan oleh kombinasi
ukuran gambar Small dan algoritma yang kurang
kompleks, sedangkan pada CPU multi-core
kombinasi ukuran gambar Small dan algoritma yang
lebih kompleks dapat meningkatkan performa.
Pemrograman multithread dapat meningkatkan
kinerja CPU ketika algoritma pengolahan citra yang
kompleks diterapkan.
Penelitian lain yang dilakukan oleh Cheikh, dll.
(2012)
membandingkan
antara
Loop-level
Parallelism (fine-grained parallelization) dan
Domain
Decomposition
(coarse-grained
parallelization) pada multi-core CPU dan many-core
GPU. Pada parallelization di multi-core CPU,
perbandingan antara Domain Decomposition dan
Loop-level
Parallelism
bahwa
Domain
Decomposition menunjukkan waktu eksekusi yang
lebih rendah daripada Loop-level Parallelism untuk
gambar ukuran besar, karena meningkatnya locality
data. Untuk gambar kecil terdapat perbedaan yang
cukup besar dalam waktu eksekusi yang ditemukan
antara dua strategi. Domain Decomposition
menyediakan speedup dan skalabilitas yang lebih
baik daripada Loop-level Parallelism dan semakin
meningkat untuk gambar yang makin besar.
Pada parallelization di many-core GPU, karena
GPU dirancang untuk fine-grained parallelization,
dari hasil percobaan menunjukkan bahwa coarsegrained paralellization menunjukkan waktu eksekusi
yang lebih rendah. Loop-level Parallelism bekerja
dengan baik pada paralel data yang berjalan pada
GPU di mana Domain Decomposition lebih cocok
untuk memproses data yang besar dan bekerja pada
multi-core CPU.

Terdapat pula Algoritma yang menggabungkan


antara Loop-level Parallelism dan Domain
Decomposition yang memangkas waktu proses
menjadi 2 hingga 3 kali lebih cepat bergantung pada
berapa core platform yang dipakai untuk uji coba.
Paralelisme pada multi-core CPU akan
memperlihatkan dampak waktu komputasi yang
lebih signifikan pada ukuran citra yang besar dan
algoritma yang kompleks, sedangkan pada singlecore CPU akan memberikan hasil terbaik saat
memproses citra dengan ukuran kecil dan algoritma
yang sederhana.

3. Perancangan
Aplikasi yang dibuat merupakan penerapan image
processing
yaitu
edge
detection
dengan
menggunakan Sobel Operator pada bahasa
pemrograman Java. Dibuat suatu sistem yang dapat
menjalankan operasi tersebut secara sekuensial
(serial) atau paralel sesuai keinginan user. Ini
bertujuan untuk melihat hasil dari operasi serial bila
dibandingkan dengan hasil dari operasi paralel dan
seberapa besar perubahan performanya. Algoritma
paralel yang digunakan pada sistem ini adalah
algoritma Fork-Join.
Input sistem berupa image berformat JPEG yang
kemudian akan dibagi menjadi 4 bagian untuk
diproses thread-thread yang tersedia. Semua ini akan
dijalankan
menggunakan
komputer
dengan
spesifikasi
Intel(R) Core(TM) i5-2410M CPU
@2.30 GHz.

3.1 Sobel operator


Sobel operator merupakan algoritma untuk
mencari bagian dari image yang memiliki high
spatial gradient (perbedaan kontras warna yang
jauh) yang akan menjadi edge atau boundary.

Gambar 1 Matriks konvolusi Sobel

Pada konvolusi Sobel yang ditunjukkan pada


Gambar 1 menggunakan matriks berukuran 3x3 dan
mendeteksi edge secara vertikal dan horizontal.
Masing-masing matriks konvolusi diterapkan secara
individual terhadap suatu image secara terpisah
kemudian hasil keduanya digabung untuk
mendapatkan gradient magnitude akhir (G).

(3.1)

Tiap pixel pada image output diisi dengan nilai G


pada pixel tersebut.

Algoritma:
Untuk setiap koordinat pixel dalam gambar
dilakukan konvolusi, yaitu perhitungan pixel
dengan adjacency pixel-nya.
a. inputImg(x,y) convolve (Gx)
b. inputImg(x,y) convolve (Gy)
c. Hitung Gradient Magnitude dengan
menggunakan rumus (3.1)
Untuk setiap koordinat pixel dalam gambar
lakukan: Set Gradient Magnitude as new pixel
value.

3.2 Fork-Join
Fork-Join adalah suatu algoritma paralel yang
memanfaatkan multiple processor dengan cara
memecah suatu pekerjaan menjadi pekerjaan yang
lebih kecil (Fork) dan mendidtribusikannya ke
prosesor-prosesor yang tersedia. Pada akhir eksekusi,
output disatukan kembali menjadi satu kesatuan
(Join). Fork-Join menggunakan work-stealing
algorithm, yaitu thread yang menganggur dapat
mengambil pekerjaan dari thread lain yang sedang
sibuk mengeksekusi. Tujuannya adalah untuk
memanfaatkan seluruh resource yang ada dan
mempercepat eksekusi.

3.3 Desain sistem


Alur kerja sistem dibuat dengan langkah-langkah
sebagai berikut:
a. Image dibaca program dan diubah menjadi 3
buah array dua dimensi berukuran width x
height image berisi keterangan nilai Red,
Green dan Blue pada masing-masing array.
b. Image dilewatkan filter dengan threshold
tertentu untuk menentukan proses secara
paralel atau serial. Threshold ditentukan oleh
user untuk mengatur paralel atau tidak paralel
eksekusi yang akan dilakukan.
Threshold yang digunakan:
= nilai threshold
Untuk proses secara paralel:
(3.2)

Untuk proses secara serial (non paralel):

(3.3)

c. Bila diproses secara paralel, image akan


dibagi menjadi 4 bagian dan dilakukan
operasi Sobel pada tiap bagiannya lalu
disatukan kembali saat proses selesai. Bila
diproses secara serial, langsung diterapkan
operasi Sobel tanpa pembagian kerja.
d. Image disatukan kembali dan dioutputkan
menjadi file JPEG baru.

4. Analisa
Daftar gambar yang digunakan dalam percobaan
adalah sebagai berikut:
Tabel 1 Daftar gambar untuk testing

Low-Res (in pixels)



Gambar 2 Cara kerja Fork-Join

Pada sistem yang kami rancang, Fork-Join


diterapkan untuk memecah image menjadi 4 bagian
yang masing-masingnya akan diproses oleh thread
yang berbeda pada prosesor yang berbeda.

125 x 125
256 x 256
389 x 352
504 x 360
600 x 464
960 x 360
High-Res (in pixels)
1366 x 768
2560 x 1600
3888 x 2592
4392 x 3210
6000 x 3000
6093 x 6000

Gambar 3 Penerapan Fork-Join pada sistem

Dengan menggunakan beberapa resolusi gambar


yang ada pada Tabel 1, kemudian dijalankan pada
komputer dengan spesifikasi prosesor Intel(R)
Core(TM) i5-2410M CPU @2.30 GHz dengan 4
prosesor yang lalu didapatkan hasil sebagai berikut:
Tabel 2 Daftar hasil percobaan dengan gambar
resolusi rendah
Serial
Parallel
Low-Res
(ms)
(ms)
125 x 125
97
73
256 x 256
219
94
389 x 352
135
62
504 x 360
698
308
600 x 464
338
130
960 x 360
344
125
Rata-rata efisiensi

Efisiensi
24.72%
57.08%
54.07%
55.87%
61.54%
63.66%
52.83%

Tabel 3 Daftar hasil percobaan dengan gambar


resolusi tinggi
High-Res

Serial
(ms)

Parallel
(ms)

Efisiensi

1366 x 768

1886

755

59.97%

2560 x 1600

5740

2104

63.34%

3888 x 2592

9480

2886

69.56%

4392 x 3210

45070

15298

66.06%

6000 x 3000

27548

9271

66.35%

6093 x 6000

85171

29220

65.69%

Rata-rata efisiensi

65.16%

Dari hasil percobaan tersebut juga didapatkan


tingkat performa dari gambar resolusi rendah dan
gambar resolusi tinggi yang ditunjukkan dalam
grafik berikut:

Gambar 4 Grafik performa gambar resolusi rendah

Gambar 5 Grafik performa gambar resolusi tinggi

Peningkatan performa sangat signifikan saat


pemrosesan dilakukan secara paralel. Dapat dilihat
juga dari grafik di atas bahwa secara umum efisiensi
meningkat pada resolusi yang lebih besar. Namun,
bila dilihat satu persatu, tingkat efisiensi sepertinya
tidak terlalu dipengaruhi oleh besarnya resolusi,
seperti pada low-res 960 x 360 dan high-res 2560 x
1600. Keduanya memiliki efisiensi yang hampir
sama yaitu sekitar 63%.
Hal ini dimungkinkan oleh faktor lain seperti
kompleksitas gambar dan warna gambar yang
menjadi pengaruh utama, karena pada dasarnya
operator Sobel mengoperasikan value RGB tiap pixel
dalam image yang besarnya berbeda-beda tergantung
dari image tersebut. Secara keseluruhan performa
pemrosesan
paralel
mengalahkan
performa
pemrosesan serial di segala resolusi.

5. Kesimpulan
Dari studi komparasi yang telah dilakukan maka
dapat disimpulkan bahwa:
Ditunjukkan bahwa peningkatan performa sangat
signifikan saat pemrosesan dilakukan secara
paralel.
Tingkat efisiensi meningkat pada resolusi yang
lebih besar.
Namun,
kedua
poin
di
atas
dengan
memperhatikan faktor-faktor antara lain yaitu
kompleksitas dan warna gambar, serta besar
resolusi gambar. Hal ini dikarenakan operator
Sobel mengoperasikan value RGB tiap pixel
dalam image yang besarnya berbeda-beda.
Secara garis besar dapat disimpulkan bahwa
performa pemrosesan secara paralel lebih tinggi
dibandingkan dengan pemrosesan secara serial. Jadi,
dapat dikatakan bahwa proses edge detection sebuah
image yang dilakukan dengan pemrosesan paralel
lebih efisien dan disarankan. Hal ini dikarenakan
pemrosesan paralel dapat menghemat waktu
pemrosesan 2-3 kali lipat lebih cepat daripada
pemrosesan serial.

6. Daftar pustaka
[1] Ade. 2009. Image Processing. (Mei 2009).
Diambil
13
Desember,
2014
dari
http://ndoware.com/image-processing.html
[2] Apriyana, dll. 2013. Perbandingan Metode
Sobel, Metode Prewitt dan Metode Robert untuk
Deteksi Tepi Objek pada Aplikasi Pengenalan
Bentuk Berbasis Citra Digital. Jurnal, STMIK
GI MDP.
[3] Cheikh, T.L., dll. 2012. Parallelization
Strategies of the Canny Edge Detector for Multicore CPUs and Many-core GPUs. In Proceeding
of the 10th IEEE Int. NEWCAS Conference,
(Montreal, Canada, 2012), IEEE, 49-52.
[4] Kika, A. & Greca, S. 2013. Multithreading
Image Processing in Single-core and Multi-core
CPU using Java. Int. J. of Advanced Computer
Science and Applications. 4 (9).

Lampiran
Source code program yang telah dibuat:
package forksobel;
import
import
import
import
import

java.awt.image.BufferedImage;
java.io.File;
java.util.concurrent.ForkJoinPool;
java.util.concurrent.RecursiveAction;
javax.imageio.ImageIO;

/**
*
* @author Pandu Wicaksono
*/
public class ForkSobel extends RecursiveAction {
private
private
private
private
private
private

int[][] red,green,blue;
int startH;
int startW;
int Height;
int Width;
int[][] Destination;

public ForkSobel(int[][] r, int[][] g, int[][] b, int sh, int sw, int h,


int w, int[][] dst) {
red = r;
green = g;
blue = b;
startH = sh;
startW = sw;
Height = h;
Width = w;
Destination = dst;
}
// Proses sobel dilakukan disini protected void computeDirectly()
System.out.println("jalan");
for(int y = startH; y<Height; y++){
for(int x = startW; x<Width; x++){
int r = SobelOperator(red,x,y);
int g = SobelOperator(green,x,y);
int b = SobelOperator(blue,x,y);
int

px=(r<<16)|(g<<8) | b;

Destination[x][y]= px;
}
}
}
//Percabangan, apakah akan paralel atau tidak
//threshold disesuaikan dengan ukuran resolusi
sThreshold = 30000000;

gambar

protected

static

int

@Override
protected void compute() {
if (((Height-startH)*(Width-startW)) < sThreshold) {
computeDirectly();
System.out.println("jalan 4");
return;
}
int splitH = Height/2;

int splitW = Width/2;


invokeAll(new
ForkSobel(red,green,blue,startH,startW,splitH,splitW,
Destination),
new
ForkSobel(red,green,blue,startH,splitW,splitH,Width,
Destination),
new
ForkSobel(red,green,blue,splitH,startW,Height,splitW,
Destination),
new
ForkSobel(red,green,blue,splitH,splitW,Height,Width,
Destination)
);
}
// Main Method
public static void main(String[] args) throws Exception {
String srcName = "high_woman.jpg";
File srcFile=new File(srcName);
BufferedImage image = ImageIO.read(srcFile);
System.out.println("Source image: " + srcName);
BufferedImage SobelImage = sobel(image);
String dstName="ImgHasil.jpg";
File dstFile=new File(dstName);
ImageIO.write(SobelImage,"jpg", dstFile);
System.out.println("Output image: " + dstName);
}
public static BufferedImage sobel (BufferedImage srcImage) {
int w = srcImage.getWidth();
int h = srcImage.getHeight();
int[][] r = new int[w][h];
int[][] g = new int[w][h];
int[][] b = new int[w][h];
for(int y=0;y<h;y++){
for(int x=0; x<w; x++){
int pixel
r[x][y] =
g[x][y] =
b[x][y] =

= srcImage.getRGB(x,y);
(pixel >> 16)&0xff;
(pixel >> 8)&0xff;
pixel&0xff;

}
}
int[][] dst = new int[w][h];
System.out.println("Array size is: "+"width:"+w+"Height:"+h);
System.out.println("Threshold is "+sThreshold);
int processors = Runtime.getRuntime().availableProcessors();
System.out.println(Integer.toString(processors) + "processor"
+ (processors != 1 ? "s are " : " is ")
+"available");
ForkSobel fs = new ForkSobel(r,g,b, 0, 0, h, w, dst);
ForkJoinPool pool = new ForkJoinPool();
long startTime = System.currentTimeMillis();
pool.invoke(fs);
long endTime = System.currentTimeMillis()
System.out.println("Lama Operasi:"+(endTime-startTime)+" milliseconds.");
BufferedImage dstImage=new BufferedImage(w,h,BufferedImage.TYPE_BYTE_GRAY);
for(int y=0;y<h;y++){
for(int x=0;x<w;x++){

int
Pixel
dstImage.setRGB(x, y,Pixel);
}
}

dst[x][y]<<16

dst[x][y]<<8

dst[x][y];

return dstImage;
}
//Methodd untuk memanggil Algoritma sobel
private int SobelOperator(int[][] pix, int x, int y){
int Gx = 0,
Gy = 0,
G;
if (x==0 || x==Width-1 || y==0 || y==Height-1)
Gx = Gy = G = 0; // Image boundary cleared
else{
Gx = pix[x+1][y-1] + 2*pix[x+1][y] + pix[x+1][y+1]
pix[x-1][y-1] - 2*pix[x-1][y] - pix[x-1][y+1];
Gy = pix[x-1][y+1] + 2*pix[x][y+1] + pix[x+1][y+1]
pix[x-1][y-1] - 2*pix[x][y-1] - pix[x+1][y-1];
G = (int) Math.sqrt(Math.pow(Gx,2)+Math.pow(Gy,2));
}
if(255<G) G=255;
else if(G<0) G=0;
return G;
}
}