MODUL PENGOLAHAN CITRA DIGITAL

“Dilasi”

Oleh :
Kris Widyo Febyanti (1641720006)
Piping Adel Wijaya Putri Y. (1741723006)
Sheyba Adinda Azigita (1641720170)
Syilvia Windy Kharisma P. (1641720026)

TI - 4C

JURUSAN TEKNOLOGI INFORMASI

PROGRAM STUDI TEKNIK INFORMATIKA
POLITEKNIK NEGERI MALANG
2019
 MODUL 11 – Operasi Delasi

A. TUJUAN
- Mahasiswa dapat membuat aplikasi dengan Operasi Delasi

B. PETUNJUK
1. Awali setiap kegiatan praktikum dengan berdoa
2. Baca dan pahami tujuan, dasar teori, dan latihan-latihan praktikum dengan baik
3. Kerjakan tugas-tugas praktikum dengan baik, sabar dan jujur
4. Tanyakan kepada dosen apabila ada hal-hal yang kurang jelas
C. ALOKASI WAKTU: 6 jam pelajaran
D. DASAR TEORI
- Operasi Morfologi
Morfologi merupakan teknik pengolahan citra berdasarkan bentuk segmen
citra. Yang bertujuan untuk memperbaiki hasil segmentasi. Teknik morfologi biasanya
digunakan pada citra biner atau untuk beberapa kasus juga bisa diterapkan pada citra
keabuan (grayscale).
Secara umum, pemrosesan citra secara morfologi dilakukan dengan cara mem-
passing sebuah structuring element terhadap sebuah citra dengan cara yang hampir
sama dengan konvolusi. Structuring element dapat diibaratkan dengan mask pada
pemrosesan citra biasa (bukan secara morfologi).

Structuring Element
● Structuring element dapat berukuran sembarang
● Structuring element juga memiliki titik poros (disebut juga titik origin/ titik
asal/titik acuan)

Pada contoh berikut, piksel pusat (biasa diberi nama hotspot) ditandai dengan warna
abu-abu. Piksel pusat ini yang menjadi pusat dalam melakukan operasi terhadap citra,
sebagaimana diilustrasikan pada Gambar 1.

Gambar 1 Structuring Element

 ⮚ Image yang akan dimorphology, akan dilakukan operasi refleksi dan translasi oleh
struktur yang dinamakan dengan Structure Element (SE).
⮚ Saat bekerja dengan image, SE harus dalam bentuk rectangular arrays, dengan
cara menambahkan element background terkecil
⮚ Cross, Rectangle, Line, dan Circle SE adalah SE yang paling sering dipakai

Gambar 2 Cross, Rectangle, Line dan Circle Structure Element

- Operasi Delasi
Delasi adalah teknik untuk memperbesar segmen objek (citra biner) dengan
menambah lapisan disekeliling objek. Atau dengan menjadi titik latar (0) yang
bertetangga dengan titik objek (1) menjadi titik objek (1).
Delasi ini sangat berguna ketika diterapkan dalam obyek-obyek yang terputus
dikarenakan hasil pengambilan citra yang terganggu oleh noise, kerusakan objek fisik
yang dijadikan citra digital, atau disebabkan resolusi yang jelek. Misalnya teks pada
kertas yang sudah agak rusak sehingga bentuk hurufnya terputus, dan sebagainya.

Perhitungan Delasi :

Fully Match 1

Some Match 1

No Match 0

Rumus :
Berikut adalah ilustrasi hasil operasi morfologi menggunakan erosi.
E. TUGAS PRAKTIKUM DILATION

Pertama-tama tambah menu Dilasi pada form utama, lalu tambahkan syntax program
seperti berikut pada form utama.

Source Code :
Fungsi Cross 3x3

private Bitmap filter3x3(Bitmap bit, int[] kernel, string str = "")

{
copy = new Bitmap(bit);

w = bit.Width - 1;
h = bit.Height - 1;

blok = 0;

prog.Visible = true;
for (int i = 0; i <= w; i++)
{
for (int j = 0; j <= h; j++)
{
b01 = b02 = b03 = false;
b04 = b05 = b06 = false;
b07 = b08 = b09 = false;
sumR = sumG = sumB = 0;
blok = 0;

// top
if (j == 0)
{
// top left
if (i == 0)
{
b05 = b06 = true;
b08 = b09 = true;
}

// top center
else if (0 < i && i < w)
 {
b04 = b05 = b06 = true;
b07 = b08 = b09 = true;
}

// top right
else if (i == w)
{
b04 = b05 = true;
b07 = b08 = true;
}
}

// middle
else if (0 < j && j < h)
{
// middle left
if (i == 0)
{
b02 = b03 = true;
b05 = b06 = true;
b08 = b09 = true;
}

// middle center
else if (0 < i && i < w)
{
b01 = b02 = b03 = true;
b04 = b05 = b06 = true;
b07 = b08 = b09 = true;
}

// middle right
else if (i == w)
{
b01 = b02 = true;
b04 = b05 = true;
b07 = b08 = true;
}
}

// bottom
else if (j == h)
{
// bottom left
if (i == 0)
{
b02 = b03 = true;
b05 = b06 = true;
 }

// bottom center
else if (0 < i && i < w)
{
b01 = b02 = b03 = true;
b04 = b05 = b06 = true;
}

// bottom right
else if (i == w)
{
b01 = b02 = true;
b04 = b05 = true;
}
}

if (b01)
{
c = bit.GetPixel(i - 1, j - 1);
sumR += (c.R * kernel[0]);
sumG += (c.G * kernel[0]);
sumB += (c.B * kernel[0]);
blok += kernel[0];
}

if (b02)
{
c = bit.GetPixel(i, j - 1);
sumR += (c.R * kernel[1]);
sumG += (c.G * kernel[1]);
sumB += (c.B * kernel[1]);
blok += kernel[1];
}

if (b03)
{
c = bit.GetPixel(i + 1, j - 1);
sumR += (c.R * kernel[2]);
sumG += (c.G * kernel[2]);
sumB += (c.B * kernel[2]);
blok += kernel[2];
}

///

if (b04)
{
c = bit.GetPixel(i - 1, j);
 sumR += (c.R * kernel[3]);
sumG += (c.G * kernel[3]);
sumB += (c.B * kernel[3]);
blok += kernel[3];
}

if (b05)
{
c = bit.GetPixel(i, j);
sumR += (c.R * kernel[4]);
sumG += (c.G * kernel[4]);
sumB += (c.B * kernel[4]);
blok += kernel[4];
}

if (b06)
{
c = bit.GetPixel(i + 1, j);
sumR += (c.R * kernel[5]);
sumG += (c.G * kernel[5]);
sumB += (c.B * kernel[5]);
blok += kernel[5];
}

///

if (b07)
{
c = bit.GetPixel(i - 1, j + 1);
sumR += (c.R * kernel[6]);
sumG += (c.G * kernel[6]);
sumB += (c.B * kernel[6]);
blok += kernel[6];
}

if (b08)
{
c = bit.GetPixel(i, j + 1);
sumR += (c.R * kernel[7]);
sumG += (c.G * kernel[7]);
sumB += (c.B * kernel[7]);
blok += kernel[7];
}

if (b09)
{
c = bit.GetPixel(i + 1, j + 1);
sumR += (c.R * kernel[8]);
sumG += (c.G * kernel[8]);
 sumB += (c.B * kernel[8]);
blok += kernel[8];
}

if (str.Equals(""))
{
r = blok != 0 ? (int)sumR / blok : (int)sumR;
g = blok != 0 ? (int)sumG / blok : (int)sumG;
b = blok != 0 ? (int)sumB / blok : (int)sumB;
}
else
{
if (str.Equals("erosi"))
{
r = erosi((int)sumR, blok);
g = erosi((int)sumG, blok);
b = erosi((int)sumB, blok);
}

if (str.Equals("dilasi"))
{
r = dilasi((int)sumR, blok);
g = dilasi((int)sumG, blok);
b = dilasi((int)sumB, blok);
}
}

r = truncate(r);
g = truncate(g);
b = truncate(b);

copy.SetPixel(i, j, Color.FromArgb(r, g, b));

}

prog.Value = Convert.ToInt16(100 * (i + 1) / bit.Width);

}
prog.Visible = false;

return copy;
}

Fungsi Square 5x5

private Bitmap filter5x5(Bitmap bit, int[] kernel, string str = "")

{
copy = new Bitmap(bit);
w = bit.Width - 1;
h = bit.Height - 1;

blok = 0;

prog.Visible = true;
for (int i = 0; i <= w; i++)
{
for (int j = 0; j <= h; j++)
{
b01 = b02 = b03 = b04 = b05 = false;
b06 = b07 = b08 = b09 = b10 = false;
b11 = b12 = b13 = b14 = b15 = false;
b16 = b17 = b18 = b19 = b20 = false;
b21 = b22 = b23 = b24 = b25 = false;

sumR = sumG = sumB = 0;

blok = 0;

// row 1
if (j == 0)
{
// column 1
if (i == 0)
{
b13 = b14 = b15 = true;
b18 = b19 = b20 = true;
b23 = b24 = b25 = true;
}

// column 2
else if (i == 1)
{
b12 = b13 = b14 = b15 = true;
b17 = b18 = b19 = b20 = true;
b22 = b23 = b24 = b25 = true;
}

// column 3
else if (1 < i && i < w - 1)
{
b11 = b12 = b13 = b14 = b15 = true;
b16 = b17 = b18 = b19 = b20 = true;
b21 = b22 = b23 = b24 = b25 = true;
}

// column 4
else if (i == w - 1)
 {
b11 = b12 = b13 = b14 = true;
b16 = b17 = b18 = b19 = true;
b21 = b22 = b23 = b24 = true;
}

// column 5
else if (i == w)
{
b11 = b12 = b13 = true;
b16 = b17 = b18 = true;
b21 = b22 = b23 = true;
}
}

// row 2
else if (j == 1)
{
// column 1
if (i == 0)
{
b08 = b09 = b10 = true;
b13 = b14 = b15 = true;
b18 = b19 = b20 = true;
b23 = b24 = b25 = true;
}

// column 2
else if (i == 1)
{
b07 = b08 = b09 = b10 = true;
b12 = b13 = b14 = b15 = true;
b17 = b18 = b19 = b20 = true;
b22 = b23 = b24 = b25 = true;
}

// column 3
else if (1 < i && i < w - 1)
{
b06 = b07 = b08 = b09 = b10 = true;
b11 = b12 = b13 = b14 = b15 = true;
b16 = b17 = b18 = b19 = b20 = true;
b21 = b22 = b23 = b24 = b25 = true;
}

// column 4
else if (i == w - 1)
{
b06 = b07 = b08 = b09 = true;
 b11 = b12 = b13 = b14 = true;
b16 = b17 = b18 = b19 = true;
b21 = b22 = b23 = b24 = true;
}

// column 5
else if (i == w)
{
b06 = b07 = b08 = true;
b11 = b12 = b13 = true;
b16 = b17 = b18 = true;
b21 = b22 = b23 = true;
}
}

// row 3
else if (1 < j && j < h - 1)
{
// column 1
if (i == 0)
{
b03 = b04 = b05 = true;
b08 = b09 = b10 = true;
b13 = b14 = b15 = true;
b18 = b19 = b20 = true;
b23 = b24 = b25 = true;
}

// column 2
else if (i == 1)
{
b02 = b03 = b04 = b05 = true;
b07 = b08 = b09 = b10 = true;
b12 = b13 = b14 = b15 = true;
b17 = b18 = b19 = b20 = true;
b22 = b23 = b24 = b25 = true;
}

// column 3
else if (1 < i && i < w - 1)
{
b01 = b02 = b03 = b04 = b05 = true;
b06 = b07 = b08 = b09 = b10 = true;
b11 = b12 = b13 = b14 = b15 = true;
b16 = b17 = b18 = b19 = b20 = true;
b21 = b22 = b23 = b24 = b25 = true;
}

// column 4
 else if (i == w - 1)
{
b01 = b02 = b03 = b04 = true;
b06 = b07 = b08 = b09 = true;
b11 = b12 = b13 = b14 = true;
b16 = b17 = b18 = b19 = true;
b21 = b22 = b23 = b24 = true;
}

// column 5
else if (i == w)
{
b01 = b02 = b03 = true;
b06 = b07 = b08 = true;
b11 = b12 = b13 = true;
b16 = b17 = b18 = true;
b21 = b22 = b23 = true;
}
}

// row 4
else if (j == h - 1)
{
// column 1
if (i == 0)
{
b03 = b04 = b05 = true;
b08 = b09 = b10 = true;
b13 = b14 = b15 = true;
b18 = b19 = b20 = true;
}

// column 2
else if (i == 1)
{
b02 = b03 = b04 = b05 = true;
b07 = b08 = b09 = b10 = true;
b12 = b13 = b14 = b15 = true;
b17 = b18 = b19 = b20 = true;
}

// column 3
else if (1 < i && i < w - 1)
{
b01 = b02 = b03 = b04 = b05 = true;
b06 = b07 = b08 = b09 = b10 = true;
b11 = b12 = b13 = b14 = b15 = true;
b16 = b17 = b18 = b19 = b20 = true;
}
 // column 4
else if (i == w - 1)
{
b01 = b02 = b03 = b04 = true;
b06 = b07 = b08 = b09 = true;
b11 = b12 = b13 = b14 = true;
b16 = b17 = b18 = b19 = true;
}

// column 5
else if (i == w)
{
b01 = b02 = b03 = true;
b06 = b07 = b08 = true;
b11 = b12 = b13 = true;
b16 = b17 = b18 = true;
}
}

// row 5
else if (j == h)
{
// column 1
if (i == 0)
{
b03 = b04 = b05 = true;
b08 = b09 = b10 = true;
b13 = b14 = b15 = true;
}

// column 2
else if (i == 1)
{
b02 = b03 = b04 = b05 = true;
b07 = b08 = b09 = b10 = true;
b12 = b13 = b14 = b15 = true;
}

// column 3
else if (1 < i && i < w - 1)
{
b01 = b02 = b03 = b04 = b05 = true;
b06 = b07 = b08 = b09 = b10 = true;
b11 = b12 = b13 = b14 = b15 = true;
}

// column 4
else if (i == w - 1)
 {
b01 = b02 = b03 = b04 = true;
b06 = b07 = b08 = b09 = true;
b11 = b12 = b13 = b14 = true;
}

// column 5
else if (i == w)
{
b01 = b02 = b03 = true;
b06 = b07 = b08 = true;
b11 = b12 = b13 = true;
}
}

if (b01)
{
c = bit.GetPixel(i - 2, j - 2);
sumR += (c.R * kernel[0]);
sumG += (c.G * kernel[0]);
sumB += (c.B * kernel[0]);
blok += kernel[0];
}

if (b02)
{
c = bit.GetPixel(i - 1, j - 2);
sumR += (c.R * kernel[1]);
sumG += (c.G * kernel[1]);
sumB += (c.B * kernel[1]);
blok += kernel[1];
}

if (b03)
{
c = bit.GetPixel(i, j - 2);
sumR += (c.R * kernel[2]);
sumG += (c.G * kernel[2]);
sumB += (c.B * kernel[2]);
blok += kernel[2];
}

if (b04)
{
c = bit.GetPixel(i + 1, j - 2);
sumR += (c.R * kernel[3]);
sumG += (c.G * kernel[3]);
sumB += (c.B * kernel[3]);
blok += kernel[3];
}

if (b05)
{
c = bit.GetPixel(i + 2, j - 2);
sumR += (c.R * kernel[4]);
sumG += (c.G * kernel[4]);
sumB += (c.B * kernel[4]);
blok += kernel[4];
}

///

if (b06)
{
c = bit.GetPixel(i - 2, j - 1);
sumR += (c.R * kernel[5]);
sumG += (c.G * kernel[5]);
sumB += (c.B * kernel[5]);
blok += kernel[5];
}

if (b07)
{
c = bit.GetPixel(i - 1, j - 1);
sumR += (c.R * kernel[6]);
sumG += (c.G * kernel[6]);
sumB += (c.B * kernel[6]);
blok += kernel[6];
}

if (b08)
{
c = bit.GetPixel(i, j - 1);
sumR += (c.R * kernel[7]);
sumG += (c.G * kernel[7]);
sumB += (c.B * kernel[7]);
blok += kernel[7];
}

if (b09)
{
c = bit.GetPixel(i + 1, j - 1);
sumR += (c.R * kernel[8]);
sumG += (c.G * kernel[8]);
sumB += (c.B * kernel[8]);
blok += kernel[8];
}
if (b10)
{
c = bit.GetPixel(i + 2, j - 1);
sumR += (c.R * kernel[9]);
sumG += (c.G * kernel[9]);
sumB += (c.B * kernel[9]);
blok += kernel[9];
}

///

if (b11)
{
c = bit.GetPixel(i - 2, j);
sumR += (c.R * kernel[10]);
sumG += (c.G * kernel[10]);
sumB += (c.B * kernel[10]);
blok += kernel[10];
}

if (b12)
{
c = bit.GetPixel(i - 1, j);
sumR += (c.R * kernel[11]);
sumG += (c.G * kernel[11]);
sumB += (c.B * kernel[11]);
blok += kernel[11];
}

if (b13)
{
c = bit.GetPixel(i, j);
sumR += (c.R * kernel[12]);
sumG += (c.G * kernel[12]);
sumB += (c.B * kernel[12]);
blok += kernel[12];
}

if (b14)
{
c = bit.GetPixel(i + 1, j);
sumR += (c.R * kernel[13]);
sumG += (c.G * kernel[13]);
sumB += (c.B * kernel[13]);
blok += kernel[13];
}

if (b15)
{
 c = bit.GetPixel(i + 2, j);
sumR += (c.R * kernel[14]);
sumG += (c.G * kernel[14]);
sumB += (c.B * kernel[14]);
blok += kernel[14];
}

///

if (b16)
{
c = bit.GetPixel(i - 2, j + 1);
sumR += (c.R * kernel[15]);
sumG += (c.G * kernel[15]);
sumB += (c.B * kernel[15]);
blok += kernel[15];
}

if (b17)
{
c = bit.GetPixel(i - 1, j + 1);
sumR += (c.R * kernel[16]);
sumG += (c.G * kernel[16]);
sumB += (c.B * kernel[16]);
blok += kernel[16];
}

if (b18)
{
c = bit.GetPixel(i, j + 1);
sumR += (c.R * kernel[17]);
sumG += (c.G * kernel[17]);
sumB += (c.B * kernel[17]);
blok += kernel[17];
}

if (b19)
{
c = bit.GetPixel(i + 1, j + 1);
sumR += (c.R * kernel[18]);
sumG += (c.G * kernel[18]);
sumB += (c.B * kernel[18]);
blok += kernel[18];
}

if (b20)
{
c = bit.GetPixel(i + 2, j + 1);
sumR += (c.R * kernel[19]);
 sumG += (c.G * kernel[19]);
sumB += (c.B * kernel[19]);
blok += kernel[19];
}

///

if (b21)
{
c = bit.GetPixel(i - 2, j + 2);
sumR += (c.R * kernel[20]);
sumG += (c.G * kernel[20]);
sumB += (c.B * kernel[20]);
blok += kernel[20];
}

if (b22)
{
c = bit.GetPixel(i - 1, j + 2);
sumR += (c.R * kernel[21]);
sumG += (c.G * kernel[21]);
sumB += (c.B * kernel[21]);
blok += kernel[21];
}

if (b23)
{
c = bit.GetPixel(i, j + 2);
sumR += (c.R * kernel[22]);
sumG += (c.G * kernel[22]);
sumB += (c.B * kernel[22]);
blok += kernel[22];
}

if (b24)
{
c = bit.GetPixel(i + 1, j + 2);
sumR += (c.R * kernel[23]);
sumG += (c.G * kernel[23]);
sumB += (c.B * kernel[23]);
blok += kernel[23];
}

if (b25)
{
c = bit.GetPixel(i + 2, j + 2);
sumR += (c.R * kernel[24]);
sumG += (c.G * kernel[24]);
sumB += (c.B * kernel[24]);
 blok += kernel[24];
}

if (str.Equals(""))
{
r = blok != 0 ? (int)sumR / blok : (int)sumR;
g = blok != 0 ? (int)sumG / blok : (int)sumG;
b = blok != 0 ? (int)sumB / blok : (int)sumB;
}
else
{
if (str.Equals("erosi"))
{
r = erosi((int)sumR, blok);
g = erosi((int)sumG, blok);
b = erosi((int)sumB, blok);
}

if (str.Equals("dilasi"))
{
r = dilasi((int)sumR, blok);
g = dilasi((int)sumG, blok);
b = dilasi((int)sumB, blok);
}
}

r = truncate(r);
g = truncate(g);
b = truncate(b);

copy.SetPixel(i, j, Color.FromArgb(r, g, b));

}

prog.Value = Convert.ToInt16(100 * (i + 1) / bit.Width);

}
prog.Visible = false;

return copy;
}

Kernel 3x3

public Bitmap keDilationCross3(Bitmap bit)

{
kernel = new int[9] {
0, 1, 0,
1, 1, 1,
 0, 1, 0
};

return filter3x3(bit, kernel, "dilasi");

}

public Bitmap keDilationSquare5(Bitmap bit)

{
kernel = new int[25] {
1, 1, 1, 1, 1,
1, 1, 1, 1, 1,
1, 1, 1, 1, 1,
1, 1, 1, 1, 1,
1, 1, 1, 1, 1,
};

return filter5x5(bit, kernel, "dilasi");

}
Output
a. Dilation Cross 3

b. Dilation Square 5