Contoh penggunaan ImageMagick -- konvolusi gambar

Kata pengantar dan indeks contoh penggunaan ImageMagick

Pengantar konvolusi

• Convolve
• Penskalaan kernel Convolve
• Normalisasi kernel (penskalaan otomatis)
• Normalisasi berjumlah nol
• Memadukan kernel dengan kernel identitas

• Kontrol bias hasil keluaran

  Mengaburkan gambar (filter lolos-rendah)

• Kernel blur

  • Kernel Unity atau identitas
  • Kernel mean atau rata-rata berbentuk
  • Kernel blur Gaussian
  • Gaussian linear 1D (Blur)
  • Setengah Gaussian (Comet)
• Kernel Gaussian vs Blur
• Blur yang dilembutkan (memadukan dengan gambar asli)

• 'Un-sharpen' gambar menggunakan blur (mengurangkan dari gambar asli)

  Konvolusi deteksi tepi (filter lolos-tinggi)

• Kernel deteksi tepi

  • Laplacian Of Gaussians (LoG)
  • Difference Of Gaussians (DoG)
  • Kernel Laplacian diskrit

• Menajamkan gambar dengan deteksi tepi (mempertegas tepi gambar asli)

  Konvolusi berarah (kemiringan, filter kompas)

• Kernel berarah

  • Sobel, Roberts, Prewitt, Compass, Kirsch, FreiChen

  Correlate

• Convolve vs Correlate (efek kernel asimetris)

• Korelasi dan pencarian bentuk

• Correlate vs HitAndMiss

  Penghitungan tetangga

• Menghitung tetangga

• Game of Life

Konvolusi memakai 'lingkungan tetangga' lokal dari piksel untuk mengubah gambar. Caranya adalah menggabungkan dan merata-ratakan semua nilai warna di sekitar setiap piksel untuk mengaburkan gambar, menonjolkan tepi dan batas, serta menajamkan gambar. Variasi konvolusi, 'korelasi', juga dipakai untuk memindai dan mencari pola tertentu, menghasilkan gambar yang menunjukkan seberapa dekat gambar cocok satu sama lain.

Pengantar konvolusi

Metode 'Convolve' dan 'Correlate' yang berkerabat dekat dengannya dalam banyak hal sangat mirip dengan morfologi. Bahkan keduanya bekerja dengan cara yang hampir persis sama, mencocokkan 'kernel' lingkungan tetangga di setiap lokasi, sehingga keduanya sebenarnya hanyalah 'metode' khusus lain dari morfologi. Keduanya bahkan memakai banyak kode yang sama, dan bahkan definisi kernel yang sama seperti yang didefinisikan di Kernel dasar dan Kernel buatan pengguna. Untuk kernel yang lebih spesifik yang dirancang untuk operator ini (dan jumlahnya banyak), saya persilakan Anda melihat Kernel blur dan Kernel deteksi tepi. Kernel yang paling penting adalah kernel 'Gaussian'. Namun, konvolusi jauh lebih tua daripada morfologi, dan lebih banyak menghasilkan efek gradien grayscale, alih-alih efek kajian bentuk biner yang biasanya dihasilkan morfologi. Karena itulah konvolusi sering dianggap sebagai operasi yang sangat berbeda atau terpisah dari morfologi, dan lebih sentral bagi pemrosesan gambar. Pada dasarnya, konvolusi atau korelasi melakukan 'rata-rata berbobot' dari semua piksel di lingkungan tetangga yang ditentukan. Artinya, nilai setiap piksel di dekatnya dikalikan dengan nilai yang diberikan di kernel, lalu semua nilai itu dijumlahkan untuk menghasilkan hasil akhir. Dengan demikian, setiap piksel di gambar akhir umumnya akan mengandung setidaknya sebagian kecil dari semua piksel lain yang mengelilinginya di gambar sumber. Dilihat dari sisi lain, warna setiap piksel di gambar akan ditambahkan ke (blur) atau dikurangkan dari (penajaman/deteksi tepi) warna semua tetangga terdekatnya, sesuai kernel yang dipakai. 'Convolve' dan 'correlate' adalah operasi yang sama, kecuali dalam satu hal yang sangat kecil tetapi penting, dan untuk contoh serta kontrol yang akan kita lihat sekarang, keduanya boleh dianggap pada dasarnya sama. Nanti (lihat Konvolusi vs korelasi) kita akan memeriksa persis bagaimana kedua operator ini benar-benar berbeda dan mengapa perbedaannya sekecil itu. Namun dalam kebanyakan situasi keduanya adalah metode yang sama.

Convolve ( )

Seperti disebutkan di atas, metode 'Convolve' bekerja dengan memberi bobot pada setiap piksel di lingkungan tetangga lokal, sesuai nilai floating point di dalam kernel. Nilai-nilai berbobot itu kemudian dijumlahkan begitu saja untuk menghasilkan piksel pengganti baru di gambar hasil. Sebagai contoh, mari kita konvolusikan satu piksel tunggal, menggunakan kernel konvolusi buatan pengguna yang sangat kecil. Saya juga mengaktifkan pengaturan Show Kernel khusus, supaya detail kernel yang didefinisikan dan dipakai bisa terlihat (gambar yang ditampilkan sudah diperbesar).

  magick xc: -bordercolor black -border 5x5 pixel.gif
  magick pixel.gif -define morphology:showKernel=1 \
         -morphology Convolve '3x3: 0.0, 0.5, 0.0
                                    0.5, 1.0, 0.5
                                    0.0, 0.5, 0.0' pixel_spread.gif

Seperti terlihat, piksel tunggal di gambar itu kini melebar menghasilkan piksel abu-abu 50% di sekelilingnya. Artinya, ketika 'origin' kernel (dalam hal ini pusatnya) berada di sebelah piksel tunggal di gambar asli, hanya piksel tunggal itu yang bernilai bukan nol. Nilai piksel ini lalu diberi bobot oleh nilai '0.5' dari kernel, dan piksel 'separuh terang' hasilnya ditambahkan ke gambar hasil. Demikian pula ketika origin kernel berada tepat di atas piksel asli, ia mendapat nilai '1.0' yang mereproduksi piksel asli, tanpa nilai lain (hitam) di lingkungan sekitarnya yang menambahkan komponen apa pun ke hasil. Perhatikan bahwa nilai kernel '0.0' tidak ikut serta dalam perhitungan akhir. Nilai nol sebenarnya bukan bagian dari 'lingkungan tetangga', persis seperti nilai 'Nan' di kernel morfologi yang tidak ikut serta. Dengan demikian kernel ini terdiri dari lingkungan tetangga 5 elemen. Dalam banyak hal metode 'Convolve' sangat mirip dengan metode morfologi 'Dilate', tetapi 'Dilate' hanya memperlakukan kernel sebagai semacam mask bitmap, mencari nilai terbesar di dalam lingkungan tetangga. Sebaliknya 'Convolve' adalah jumlah berbobot dari semua nilai di lingkungan tetangga, sehingga nilai setiap elemen kernel ikut berperan dalam hasil keseluruhan. Sintaksis operasi konvolusi adalah...

**-morphology Convolve {_convolution_kernel_}
**

Tetapi operator lama yang lebih langsung juga bisa dipakai...

**-convolve {_convolution_kernel_}
**

| _Sebelum IM v6.5.9, "-convolve" yang lama tidak memahami definisi kernel morfologi. Ia hanya menerima 'gaya lama' kernel buatan pengguna, yang berupa sekadar deretan nilai dipisah koma untuk menghasilkan kernel persegi berukuran ganjil. Kini ia menerima definisi kernel konvolusi 'gaya baru'.

Namun ia masih terbatas pada kernel persegi 'berukuran ganjil'. Dan akan tetap begitu sampai ia mulai memakai metode konvolusi 'morphology' yang baru.

_
| _Operator "-convolve" yang lama tidak persis sama dengan metode morfologi 'Convolve' yang lebih baru. Berikut daftar perbedaan kedua operasi tersebut...

_

• _Operator lama diimplementasikan sebagai korelasi alih-alih konvolusi sejati. Ini berarti kernel tidak ditumpangkan pada gambar sumber dalam bentuk pantulannya. Lihat Convolve vs Correlate untuk efeknya pada hasil.

_ * _Ia hanya menerima kernel persegi berukuran ganjil. Versi morphology mengizinkan larik persegi panjang apa pun, dengan titik mana pun di dalam larik dapat dinyatakan sebagai origin.

_ * _Operator lama selalu menormalisasi kernel tanpa kontrol pengguna atas penskalaan kernel. Versi baru tidak menormalisasi secara otomatis; Anda perlu memintanya. Namun kebanyakan kernel hasil pembangkitan sudah dinormalisasi untuk Anda.

_ * Bentuk apa pun dari pemaduan dengan kernel identitas tidak bisa dipakai, meskipun bias keluaran tetap dilakukan seperti biasa. * _Namun ia dapat memanfaatkan kode 'GPU' yang cepat, jika komputer host memiliki fasilitas itu. Morphology belum mengaktifkan ini.

_ * _Saat ini operator lain yang terkait konvolusi, seperti "-gaussian-blur", "-blur", "-sharpen", "-unsharp", memakai versi lama operator ini.

_ * _Secara default perintah lama hanya mengonvolusi kanal warna (sesuai pengaturan "-channel"). Jika Anda mengonvolusi dengan pengaturan "-channel RGBA", ia juga akan menimbang nilai kernel dengan kanal alpha untuk memastikan blur yang benar terkait transparansi.

Metode 'convolve' pada morphology secara default otomatis menangani pembobotan transparansi pada kanal warna. Artinya, blur gambar dengan metode ini memperlakukan warna transparan sebagai transparan, sehingga secara default terhindar dari bug blur transparansi.

Namun jika pengguna mengubah pengaturan "-channel" default (dengan tidak menyertakan flag khusus 'Sync'), konvolusi akan ditangani sebagai operator grayscale murni per kanal.

Lihat dokumentasi pengaturan "-channel", atau lihat Matematika kanal gambar yang memakai flag yang sama dengan cara yang sama, untuk informasi lebih lanjut.

_

_

Pada akhirnya sebagian besar perbedaan di atas akan berubah seiring semuanya melebur dengan metode morfologi 'Convolve' yang lebih baru.

_
Jika ingin melihat contoh-contoh bagus tentang bagaimana 'Convolve' sebenarnya bekerja, saya sarankan Anda juga melihat EECE \ CS 253 Image Processing, Lecture 7, Spatial Convolution. Artikel Wikipedia, Convolve memuat animasi 1-D yang bagus tentang proses konvolusi.

Penskalaan kernel Convolve

Contoh di atas bekerja baik untuk gambar yang sebagian besar hitam seperti piksel tunggal, tetapi jika Anda menerapkannya pada gambar sungguhan, akan muncul masalah...

  magick logo: -resize 50% -crop 80x80+150+60 +repage  face.png

  magick face.png \
         -morphology Convolve '3x3: 0.0,0.5,0.0  0.5,1.0,0.5   0.0,0.5,0.0' \
         face_spread.png

Seperti terlihat, gambar hasil menjadi sangat terang (tepatnya 3 kali lebih terang) daripada gambar asli. Yang terjadi adalah setiap piksel dibagikan 3 kali. 4 × '0.5' di sisi-sisinya, ditambah satu salinan penuh piksel asli. Artinya penjumlahan semua nilai di kernel adalah 3, membuat gambar hasil tiga kali lebih terang! Jika Anda kembali melihat keluaran 'showKernel' di atas, kernel ini tercantum memiliki "convolution output range from 0 to 3". Ini menunjukkan bahwa kernel ini secara umum akan mencerahkan gambar 3 kali. Untuk memperbaikinya, semua nilai di kernel perlu dibagi 3. Yaitu nilai '0.5' semestinya sekitar '0.1667', sedangkan nilai pusat '1.0' semestinya '0.3333'. Proses ini dikenal sebagai 'normalisasi kernel '. Sebagai contoh, berikut hasil yang 'dinormalisasi' secara manual, beserta definisi kernelnya...

magick face.png -define morphology:showKernel=1 \
       -morphology Convolve \
       '3x3: 0.0,.1667,0.0  .1667,.3333,.1667  0.0,.1667,0.0' \
       face_spread_norm.png

Seperti terlihat, hasilnya adalah versi gambar wajah yang sedikit saja kabur, karena setiap piksel disebarkan ke masing-masing tetangga terdekatnya. | _'Gambar kernel' yang ditampilkan di atas (dibuat memakai skrip Kernel 2 Image khusus) juga memperlihatkan kernel ternormalisasi hasilnya. Seperti yang terlihat, kernel itu sendiri kini sangat gelap, karena semua nilainya juga gelap, meski semuanya berjumlah '1.0'.

Mulai dari titik ini, semua gambar kernel konvolusi yang ditampilkan akan selalu disesuaikan sehingga nilai maksimumnya menjadi putih; jika tidak, yang umumnya terlihat hanyalah 'gambar kernel' yang gelap dan pada dasarnya tak berguna.

_
Menormalisasi kernel sendiri bukan hal yang menyenangkan, dan seperti terlihat, itu membuat definisi kernel hasilnya jauh lebih sulit dipahami. Karena itu disediakan cara-cara alternatif. Sejak IM v6.5.9-2, opsi pakar khusus "-define convolve:scale={_kernel_scale_}' bisa dipakai untuk menentukan faktor skala global untuk kernel, dan dengan demikian mengatur kecerahan hasil keseluruhan. |

magick face.png -define convolve:scale=0.33333 \
       -morphology Convolve '3x3: 0.0,0.5,0.0  0.5,1.0,0.5  0.0,0.5,0.0' \
       face_spread_scale.png

Sebenarnya yang dilakukan ini adalah mengatur intensitas keseluruhan hasil kernel. Seperti akan terlihat di contoh-contoh berikutnya, hasil konvolusi mungkin perlu dibuat lebih kuat atau lebih lemah. Faktor 'kernel_scale ' inilah yang memungkinkannya.

Normalisasi kernel (penskalaan otomatis)

Alih-alih menghitung sendiri faktor skalanya (seperti di atas), IM bisa langsung diminta menghitung 'faktor skala normalisasi' ini secara internal dengan memberinya flag normalisasi khusus '!'. |

magick face.png -define convolve:scale=\! \
       -morphology Convolve  '3x3: 0,1,0  1,2,1  0,1,0' \
       face_spread_normalize.png

| Karakter '!' kadang juga dipakai untuk keperluan khusus oleh berbagai shell baris perintah UNIX. Jadi Anda mungkin perlu meng-escape karakter itu dengan backslash, bahkan di dalam tanda kutip. Berhati-hatilah.
Perhatikan bahwa karena kernel kini dinormalisasi, saya bisa mendefinisikannya dengan cara lebih sederhana memakai bilangan bulat. Kernel ternormalisasi itu tetap sama dengan kernel 'terskala' sebelumnya. Biasanya Anda akan selalu ingin menormalisasi kernel, dan karena itu varian "-convolve" yang lebih sederhana otomatis melakukan normalisasi ini. IM bisa diminta menormalisasi kernel, lalu menskalakannya lagi dengan besaran tertentu untuk mengatur rentang keluarannya. Supaya lebih mudah lagi, faktor skala bisa ditentukan sebagai persentase. Misalnya, di sini saya menormalisasi kernel tetapi kemudian menskalakan ulang nilainya menjadi 50% dari ukuran hasil hitung, sehingga menghasilkan hasil yang lebih gelap. |

  magick face.png -define convolve:scale=50%\! \
         -morphology Convolve  '3x3: 0,1,0  1,2,1  0,1,0' \
         face_spread_norm_half.png

Perhatikan bahwa memakai nilai '!' sebenarnya setara dengan memakai '1!' atau bahkan '100%!'. Faktor skala negatif bahkan bisa dipakai jika ingin membalik nilai positif dan negatif di dalam kernel. Untuk contohnya lihat 'Un-sharpen' gambar menggunakan blur. Jika kernel telah dinormalisasi dengan cara ini, keluaran Show Kernel akan memberi tahu bahwa kernel itu ternormalisasi.

Cara kerja normalisasi

Cara kerja 'normalisasi kernel ' sebenarnya adalah semua nilai kernel dijumlahkan (termasuk nilai negatif, yang juga mungkin ada). Jika hasilnya bukan nol, semua nilai diskalakan sehingga jumlah gabungannya menjadi satu ('1.0'). Perhatikan bahwa jika ada nilai negatif, ini justru bisa menghasilkan kernel dengan nilai lebih besar dari satu, biasanya di origin. Ini khususnya terjadi pada kernel Un-Sharp. Namun poin pentingnya adalah kernel secara keseluruhan berjumlah '1.0', sehingga gambar akhir tidak menjadi lebih gelap atau lebih terang oleh operasi konvolusi. Jika hasil penjumlahannya nol ('0.0'), kernel dianggap sebagai kernel berjumlah nol khusus. Dalam hal itu kernel diskalakan sehingga semua nilai positif berjumlah '1.0', dan dengan sendirinya semua nilai negatif berjumlah '-1.0'. Kernel semacam ini sangat lazim pada teknik deteksi tepi. Keluaran Show Kernel juga akan menyebutkan bahwa kernel bersifat zero-summing jika bentuknya demikian, bahkan bila bukan kernel zero-summing ternormalisasi, meski itu juga mudah terlihat dari angka-angka lain yang ditampilkan. Kebanyakan kernel yang ditentukan secara matematis sudah dinormalisasi sebelumnya. Ini mencakup kernel turunan matematis: 'Unity', 'Gaussian', 'LoG', 'DoG', 'Blur', 'Comet'. Kernel konstanta diskrit, sebaliknya, tidak dinormalisasi sebelumnya, jadi normalisasinya perlu dilakukan lewat pengaturan normalisasi kernel (di atas). Ini mencakup kernel: 'Laplacian', 'Sobel', 'Roberts', 'Prewitt', 'Compass', 'Kirsch', 'FreiChen'. Perhatikan bahwa kernel 'FreiChen' memiliki sub-tipe yang diberi bobot khusus untuk tujuan yang lebih spesifik. Kernel FreiChen tidak boleh dinormalisasi, melainkan dipakai apa adanya.

Normalisasi berjumlah nol

Tidak semua kernel konvolusi hanya memakai nilai positif. Ada juga kernel yang memakai campuran nilai positif dan negatif, dan sering kali nilai-nilai kernel itu memang dimaksudkan berjumlah nol sehingga menghasilkan kernel berjumlah nol. Kernel semacam ini sangat penting bagi konvolusi gambar yang lebih maju, karena menyediakan teknik deteksi tepi dan penajaman gambar. Seperti saya sebutkan di bagian sebelumnya, flag normalisasi biasa '!' bekerja dengan kernel semacam ini. Tetapi kadang, karena situasi khusus, Anda ingin memastikan kernel tetap 'berjumlah nol'. Metode normalisasi khusus '^' menyediakan cara untuk memastikan kernel 'berjumlah nol' dalam situasi seperti...

1. Jika definisi kernel dari pengguna tidak cukup presisi untuk memastikan jumlah nol. Misalnya Anda tidak bisa menuliskan '1/3' atau faktor pecahan 3 lainnya sebagai bilangan desimal floating point yang eksak.
2. Kurva matematisnya 'terpotong' oleh ukuran (radius) kernel sehingga mungkin tidak lagi berjumlah nol. Misalnya, ini terjadi pada kernel 'LoG' atau 'DoG', yang didasarkan pada kurva respons tak hingga. IM justru memakai normalisasi khusus ini secara internal pada kernel-kernel itu karena alasan ini.
3. Memastikan 'mask bentuk' korelasi berjumlah nol, supaya dalam pencarian IM dapat mencari kecocokan positif dan negatif secara setara. Lihat Korelasi dan pencarian bentuk di bawah.

Yang terjadi adalah semua nilai positif dan negatif kernel dinormalisasi sebagai entitas terpisah. Yaitu, semua nilai negatif diskalakan agar berjumlah '-1.0' dan semua nilai positif diskalakan agar berjumlah '+1.0'. Hasilnya, kernel secara keseluruhan dijamin berjumlah nol. Perhatikan bahwa jika Anda memakai metode normalisasi ini pada kernel yang seluruhnya positif seperti 'Gaussian', hasilnya tetap kernel yang ternormalisasi dengan benar. Karena itu bentuk normalisasi ini tetap bisa dipakai dengan kernel blur. Namun ia tidak boleh dipakai untuk menormalisasi kernel penajaman atau bahkan un-sharpen yang didefinisikan langsung, karena kernel itu bisa mengandung nilai negatif tetapi harus berjumlah satu (memakai metode normalisasi biasa).

Memadukan kernel dengan kernel identitas

Sintaksis lengkap pengaturan penskalaan kernel adalah salah satu dari...

**-define convolve:scale='{_kernel_scale_}[!^] [,{_origin_addition_}] [%]' -set option:convolve:scale '{_kernel_scale_}[!^] [,{_origin_addition_}] [%%]'**

Perhatikan penggandaan karakter persen saat memakai "-set". Flag normalisasi opsional '!' atau '^" akan diterapkan lebih dulu pada kernel buatan pengguna atau kernel bawaan (jika diminta). Setelah itu, kernel diskalakan dengan faktor 'kernel_scale ', menaikkan atau menurunkan 'kekuatan' efektif konvolusi pada hasil. Faktor skala default adalah '1.0'. Terakhir, nilai 'origin' kernel akan ditambah dengan angka setelah koma. Nilai default 'origin_addition ' adalah '0.0'. Langkah terakhir ini pada dasarnya 'menambahkan' sebuah kernel Unity dengan 'skala' tersebut ke kernel yang sudah dinormalisasi dan diskalakan sebelumnya. Ini menghasilkan kernel yang dapat...

• Melembutkan efek kernel blur.
• Mengubah kernel blur menjadi kernel yang bisa dipakai langsung untuk 'un-sharpen' gambar.
• Ia juga bisa dipakai untuk mengubah kernel deteksi tepi menjadi kernel penajaman gambar.

Perhatikan bahwa jika flag persen ('%') diberikan, persentase itu diterapkan pada KEDUA faktor 'kernel_scale ' dan 'origin_addition '. Ini bisa membuat skala lebih mudah dibaca dan dipahami saat melibatkan pecahan. Contoh pemakaian define penskalaan kernel...

  -define convolve:scale='!50%,100%'  -morphology Convolve Laplacian:2

Akan membangkitkan kernel 'Laplacian:2' yang diminta...

Menormalisasinya (flag '!')

Menskalakan dengan 50%

Menambahkan kernel Unity (menambah 100% ke nilai origin)

Dan kini konvolusi bisa dilakukan memakai 'Laplacian:2' sebagai kernel penajaman, tetapi hanya dengan kekuatan penajaman '50%. Ingat, flag '%' yang diberikan di mana pun dalam pengaturan skala akan membuat kedua nilai menjadi persentase. Jika tidak ada, kedua nilai hanyalah pengali langsung biasa. Misalnya semua opsi skala berikut ini setara

     50,100%     50%,100    %50,100      .5,1      0.5,1.0

Hal yang sama berlaku untuk kedua flag normalisasi. Keduanya boleh muncul di mana saja dalam pengaturan skala convolve, tetapi selalu diterapkan lebih dulu sebelum penskalaan lain dilakukan.

Kontrol bias hasil keluaran

Saat Anda berurusan dengan kernel yang mengandung nilai negatif, sebagian piksel di gambar hasil semestinya diberi nilai negatif. Ini terutama terjadi pada kernel berjumlah nol (lihat di bawah). Sayangnya, kecuali Anda memiliki versi HDRI ImageMagick yang dibangun khusus untuk mempertahankan nilai negatif yang dihasilkan, semua hasil negatif akan dipotong ke nol (hitam). Yang tersisa hanyalah hasil positif dari konvolusi. Nilai negatif itu memang tidak bisa disimpan di format gambar normal, jadi hasilnya tinggal separuh. Anda bisa membangun versi HDRI ImageMagick untuk mempertahankan nilai negatif yang dihasilkan, lalu mengekstrak informasi yang diinginkan. Atau, kernel bisa dinegasikan dengan memakai faktor skala negatif. Misalnya memakai...

-define convolve:scale='-1'

Namun dengan itu yang didapat hanyalah hasil negatif, sementara hasil positifnya menjadi terpotong. Dengan memakai pengaturan IM "-bias", Anda tetap bisa mempertahankan hasil positif maupun negatif. Pengaturan yang dipakai untuk IM versi non-HDRI adalah...

     -define convolve:scale=50%\!  -bias 50%

Pengaturan pertama menskalakan keluaran menjadi separuh dari ukuran yang biasanya Anda dapat (setelah dinormalisasi), untuk memberi ruang bagi hasil positif maupun negatif. Kemudian abu-abu 50% ditambahkan ke keluaran piksel sebelum hasilnya disimpan kembali ke gambar. Dengan pengaturan ini, hasil 'nol' menjadi abu-abu murni, hasil negatif lebih gelap dari itu, dan hasil positif lebih terang dari itu. Hitam mewakili '-1.0' dan putih berarti '+1.0'. Salah satu contohnya ditunjukkan di contoh pencarian bentuk dengan Correlate di bawah.

Mengaburkan gambar (filter lolos-rendah)

Bagian lain dari contoh IM, khususnya Blur dan penajaman gambar, justru membahas aspek praktis topik ini. Di sini kita melihat detail yang lebih spesifik. Namun pertama-tama, kita akan menjelaskan kernel-kernel dasar dan cara memakainya langsung tanpa modifikasi. Nanti kita akan melihat cara memodifikasi blur untuk menghasilkan efek lain.

Kernel blur

Unity

Ini kernel khusus yang sebenarnya tidak melakukan apa-apa. Hanya satu elemen kernel yang ditentukan, dan akibatnya setiap piksel digantikan oleh dirinya sendiri tanpa perubahan. Misalnya, berikut konvolusi tanpa-operasi...

  magick face.png -morphology Convolve Unity face_unity.png

Sejak IM v 6.6.9-4, kernel ini bisa menerima satu argumen, sebagai argumen skala khusus kernel. Ini membuatnya bisa dipakai untuk mengalikan nilai-nilai gambar, misalnya membuat gambar lebih terang atau lebih gelap. |

  magick face.png -morphology Convolve Unity:0.5 face_dimmed.png

Ini mungkin tampak tidak terlalu berguna, tetapi bisa dipakai untuk menghasilkan efek blur lembut dan unsharpen, atau dalam urutan multi-kernel yang tidak memungkinkan pemakaian penskalaan kernel atau pemaduan kernel identitas. Kernel satu elemen yang sama juga bisa dibangkitkan memakai 'Disk:0.5', yang juga menerima argumen skala tambahan sebagai bagian dari pembangkitan kernel. (Contoh: 'Disk:0.5,0.5' untuk contoh terakhir). Kernel serupa (untuk konvolusi) juga bisa dibangkitkan oleh generator kernel 'Gaussian' dengan 'sigma ' sebesar '0.0'. Namun itu hanya bisa menghasilkan kernel kecil 3x3, berupa nilai '1.0' di pusat yang dikelilingi 8 nilai '0.0'.

Filter mean atau rata-rata memakai kernel bentuk

Meskipun kebanyakan kernel konvolusi yang didefinisikan di bawah umumnya melibatkan kurva Gaussian dengan satu dan lain cara, salah satu kernel bentuk morfologi sebelumnya tetap bisa dipakai untuk sekadar merata-ratakan piksel di suatu area (besar) tertentu. Tentu saja perlu menormalisasi kernelnya agar benar-benar menghasilkan rata-rata, bukan sekadar jumlah lingkungan tetangga. Misalnya, di sini saya memakai kernel berbentuk 'Octagon' yang lebih kecil, untuk merata-ratakan semua nilai piksel yang berada dalam area melingkar di sekeliling setiap piksel.

  magick face.png -define convolve:scale=! \
         -morphology Convolve Octagon:2 face_mean.png

Hasilnya, nilai setiap piksel disebarkan merata ke seluruh 25 piksel di lingkungan tetangga yang ditentukan. Artinya, ini setara dengan filter 'mean' atau 'perataan' pada bentuk tersebut. Jika Anda ingin mengecualikan piksel asli dari rata-rata itu, hanya memakai piksel di sekitarnya, pakailah kernel 'Ring' (dengan hanya satu radius). Kernel bentuk lain juga bisa dipakai dengan cara yang sama untuk, misalnya, merata-ratakan nilai piksel pada bentuk 'Diamond', 'Square', atau 'Disk' besar, dengan ukuran berapa pun yang Anda mau. Namun, meski perataan konstan pada area berbentuk memang mengaburkan gambar, ia cenderung menimbulkan efek yang tak biasa (khususnya artefak aliasing) di gambar hasil. Lebih spesifiknya, memakai kernel perataan 'datar' cenderung mengubah tepi tajam menjadi lereng linear yang lebih tebal dengan perubahan kemiringan mendadak di tepi yang menebal. Ketebalan hasilnya adalah 'radius*2-1' dari kernel. Bagaimana sudut tepi yang berbeda memengaruhi ketebalan dan kelinearan lereng bergantung pada bentuk kernel 'datar' atau perata itu.

  magick -size 80x80 xc: -draw 'polygon 15,15 15,65 60,15' shape.png
  magick shape.png \
         -define convolve:scale=! -morphology Convolve Square:5 \
         shape_mean_square.png
  magick shape.png \
         -define convolve:scale=! -morphology Convolve Disk:5 \
         shape_mean_disk.png

Perhatikan bahwa blur diagonal di atas berbeda antara kernel persegi dan kernel disk. Cara lain menghasilkan blur 'lereng linear' persegi adalah memakai sigma sangat besar dengan radius tertentu. Konvolusi kernel persegi di atas misalnya juga bisa dicapai memakai -blur 5x65535. Cara ini biasa dipakai Fred Wienhaus di skrip-skripnya sebelum morphology tersedia.

Kernel Gaussian (gaussian blur 2d)

Seperti mungkin sudah bisa diduga, kernel 'Gaussian' adalah kernel yang paling umum dipakai untuk mengonvolusi gambar. Inilah kernel ideal secara matematis untuk efek blur. Berikut misalnya Show Kernel dari kernel 'Gaussian' kecil (kernel ini bisa menjadi sangat besar dengan sangat cepat)...

  magick xc: -define morphology:showKernel=1 \
         -morphology Convolve:0 Gaussian:0x0.8 null:

Saya sebenarnya tidak ingin menerapkan konvolusi pada perintah di atas; saya hanya ingin menampilkan kernel yang akan dipakainya. Karena itu saya memakai ':0' jumlah iterasi, sehingga tidak melakukan apa-apa. Demikian pula saya membuang keluaran gambarnya memakai format file khusus 'null:'. Seperti terlihat dari rentang keluaran konvolusinya, kernel 'Gaussian' sudah dinormalisasi (diskalakan) untuk Anda. Namun Anda juga akan melihat bahwa kernel ini tetap cukup besar, dipenuhi nilai pecahan kecil. Jika diperhatikan lebih dekat, nilai terbesar (2.48678, yang juga tercantum di baris pertama) berada di pusat, dengan nilai terkecil ke arah tepi dan sudut (sekitar .000000194). Berikut blur Gaussian yang umum memakai konvolusi...

  magick face.png -morphology Convolve Gaussian:0x2 face_gaussian.png

Sintaksis kernelnya lugas...

   Gaussian:[{_radius_}]x{_sigma_}

Argumen-argumen ini sebenarnya persis sama dengan yang dipakai operator "-gaussian-blur", yang memang melakukan konvolusi memakai kernel ini. Angka pertama, seperti kebanyakan kernel morfologi, adalah 'radius ' atau ukuran kernel. Ini bilangan bulat, dengan nilai minimum 1, sehingga kernel terkecil yang mungkin berukuran 3x3 elemen. Cara terbaik adalah selalu menentukan nol, yang membuat ImageMagick menghitung radius yang sesuai untuk nilai 'sigma ' yang diberikan. Argumen kedua yang lebih penting adalah 'sigma ', yang menentukan seberapa kabur atau 'tersebar' setiap piksel. Makin besar nilainya, makin kabur gambarnya. Nilainya floating point. Nilai sigma WAJIB diberikan. Jika nilai sigma '0.0' diberikan, hasilnya adalah kernel 'Unity' yang nyaris tak berguna (dengan radius yang diberikan, atau radius 1, sehingga menghasilkan kernel 3x3 berupa satu nilai '1.0' yang dikelilingi nilai '0.0'.). Seperti terlihat di atas, mengonvolusi dengan kernel 'Unity' jenis apa pun tidak melakukan apa-apa pada gambar! Jika Anda memang menentukan 'radius ', umumnya baik membuatnya setidaknya dua kali lebih besar dari 'sigma '; IM biasanya menghitung radius yang kira-kira 3 kali lebih besar (tepatnya radius terbesar yang masih memberi hasil bermakna), meski itu bergantung pada kualitas waktu-kompilasi instalasi IM Anda. Untuk informasi lebih lanjut tentang efek argumen kernel 'Gaussian', dan tentang blur gambar secara umum, lihat... Mengaburkan gambar.

Kernel Blur (gaussian blur 1d)

Kernel 'Blur' sangat mirip dengan kernel Gaussian, bahkan menerima argumen yang sama (lihat di bawah). Tetapi jika gaussian adalah kurva 2 dimensi, kernel 'Blur' menghasilkan kurva 1 dimensi. Artinya, ia membangkitkan satu baris nilai tunggal yang panjang dan tipis. Berikut keluaran Show Kernel dari kernel 'Blur' kecil. | |

  magick xc: -define morphology:showKernel=1 \
         -morphology Convolve:0 Blur:0x0.8 null:

|
Grafik di atas adalah profil sesungguhnya dari kernel 'Blur' default. Grafik itu dibuat memakai skrip Kernel Image "kernel2image", lalu gambar tersebut digrafikkan memakai skrip "im_profile". Grafik itu dengan jelas memperlihatkan 'kurva lonceng Gaussian' yang diwakili kernel ini. Berikut contoh memakai kernel ini untuk mem-blur gambar secara horizontal. |

  magick face.png -morphology Convolve Blur:0x4 face_blur.png

Sintaksis kernelnya persis seperti 'Gaussian' tetapi dengan tambahan sudut rotasi opsional.

   Blur:[{_radius_}]x{_sigma_}[,{_angle_}]

Seperti sebelumnya, nilai kedua 'sigma ' wajib ada, dan jika disetel nol hasilnya adalah padanan linear dari kernel 'Unity'. Argumen 'angle ' memungkinkan kernel diputar 90 derajat sehingga bisa mem-blur gambar secara vertikal. |

  magick face.png -morphology Convolve Blur:0x4,90 face_blur_vert.png

Saat ini hanya rotasi 90 derajat yang mungkin. Ini bisa berubah di versi ImageMagick mendatang. Tujuan kernel ini sebenarnya adalah menciptakan bentuk blur gambar 2 dimensi yang lebih cepat daripada yang dihasilkan kernel 'Gaussian'. Lihat Kernel Gaussian vs Blur di bawah untuk detail cara melakukannya.

Kernel Comet (setengah gaussian blur 1d)

Kernel 'Comet' hampir persis sama dengan kernel 'Blur', tetapi sebenarnya hanya separuh dari kernel blur.

  magick xc: -define morphology:showKernel=1 \
         -morphology Convolve:0 Comet:0x1.0 null:

Perhatikan bahwa lokasi origin yang ditentukan berada di tepi kiri, bukan di pusat kernel. Ini sangat tak lazim untuk kernel konvolusi, dan karenanya memberi hasil yang sangat tak biasa. Ia mengaburkan gambar ke satu arah, seperti jari yang mengusap permukaan lukisan basah, meninggalkan jejak warna. Agak mirip ekor komet, atau jejak meteor, atau bintang jatuh. |

  magick face.png -morphology Convolve Comet:0x5 face_comet.png

Perhatikan bahwa warna latar depan maupun latar belakang sama-sama 'terusap'. Jika Anda hanya ingin mem-blur warna latar depan, buat latar belakangnya transparan, lalu tambahkan kembali setelah latar depan di-blur. Argumen ketiga angle juga bisa diberikan untuk memutar kernel dalam kelipatan 90 derajat mana pun di sekitar 'origin'-nya. |

  magick face.png -morphology Convolve comet:0x5+90 face_comet_vert.png

Kernel ini sebenarnya kernel yang sama dengan yang dipakai operator khusus Motion Blur, meski operator itu juga melakukan penanganan pencarian koordinat yang sangat rumit agar blur bisa bekerja pada sudut berapa pun. Meski begitu hasilnya buruk, menghasilkan 'gumpalan' warna pada sudut besar seperti 45 derajat. Semoga rotasi kernel yang sebenarnya akan diimplementasikan untuk menciptakan efek motion blur yang lebih baik pada sudut di luar kelipatan 90 derajat.

Kernel Gaussian vs Blur

Seperti disebutkan, kernel 'Gaussian' dan 'Blur' berkerabat sangat dekat, dan sebenarnya bisa mengerjakan tugas yang sama. Keduanya adalah representasi kurva Gaussian, yang pertama representasi 2 dimensi, sedangkan yang lain representasi 1 dimensi. Sebagai contoh, berikut pengulangan operasi "-gaussian-blur 0x2" yang setara dengan "-morphology Convolve Gaussian:0x2". |

  magick face.png -gaussian-blur 0x2 face_gaussian-blur.png

Ini bisa digantikan dengan dua operasi blur linear atau 1 dimensi terpisah yang saling diputar sembilan puluh derajat (urutannya juga tidak terlalu penting)... |

  magick face.png -morphology Convolve Blur:0x2 \
         -morphology Convolve Blur:0x2+90 face_blur_x2.png

Alih-alih menentukan dua konvolusi terpisah, kedua kernel bisa diberikan sebagai daftar kernel. Misalnya

  magick face.png -morphology Convolve 'Blur:0x2;Blur:0x2+90' face_blur_x2.png

Secara default IM akan 'mengiterasi ulang' hasil kernel convolve pertama dengan kernel convolve kedua (dan seterusnya), sesuai pengaturan komposisi multi-kernel. Ini bahkan bisa disederhanakan lagi dengan meminta IM mengembangkan satu kernel menjadi daftar kernel yang diputar, memakai '>' untuk membuat daftar rotasi 90 derajat (dua kernel dalam kasus ini). Misalnya...

  magick face.png -morphology Convolve 'Blur:0x2>' face_blur_x2.png

Semua contoh di atas setara satu sama lain, dan begitulah cara kerja operator "-blur". |

  magick face.png -blur 0x2 face_blurred.png

Inilah perbedaan nyata antara operator "-blur" dan "-gaussian-blur". Pada yang terakhir dipakai satu kernel 2 dimensi besar, sedangkan yang pertama memakai dua kernel 1 dimensi kecil. Dari segi kecepatan, operator "-blur" biasanya lebih cepat satu orde besaran, karena memakai dua kernel yang jauh lebih kecil, alih-alih satu kernel sangat besar. Makin besar argumen blur (ukuran argumen sigma), makin besar kernelnya, dan makin besar pula selisih kecepatan kedua operasi itu. Karena itu operator "-blur" umumnya yang direkomendasikan untuk dipakai. Satu-satunya perbedaan hasil kedua operator ini adalah efek pembulatan kuantum kecil (kecuali Anda memakai HDRI) dan efek tepi (bergantung pada pengaturan piksel virtual). Keduanya disebabkan hilangnya informasi akibat penyimpanan gambar antara di sela dua lintasan terpisah konvolusi 'blur'. Perbedaan ini biasanya sangat kecil sehingga tak terlihat dan tak perlu dirisaukan dalam pemakaian praktis mana pun.

Blur yang dilembutkan (memadukan dengan gambar asli)

Dampak blur jenis apa pun bisa dilembutkan dengan memadukannya dengan sebagian gambar asli. Terutama saat menerapkan blur yang sangat kuat. Misalnya...

  magick face.png -morphology Convolve Gaussian:0x3 face_strong_blur.png
  magick face.png face_strong_blur.png \
         -compose Blend -define compose:args=60,40% -composite \
         face_soft_blur.png

Perintah ini memakai metode komposisi 'Blend' untuk mencampur '60%' gambar blur (gambar sumber komposisi) dengan '40%' gambar asli (gambar tujuan komposisi) sehingga memberi efek 'blur lembut' pada gambar akhir. Namun hal yang sama bisa dilakukan secara langsung dengan memadukan kernel dengan kernel identitas, memakai rasio yang sama. |

  magick face.png -define convolve:scale=60,40% \
         -morphology Convolve 'Gaussian:0x3' face_soft_blur2.png

Perhatikan bahwa urutan angka skalanya sama. Angka pertama ('60%') menskalakan kernel yang diberikan untuk mengurangi efeknya pada keluaran, sedangkan angka kedua ('40%') menambahkan kernel 'Unity' (atau 'identitas') secukupnya agar hasil tidak menjadi lebih gelap. Poin pentingnya, untuk kernel blur, kedua angka itu berjumlah '100%', persis seperti pada pemaduan komposit. Blur 2-lintasan yang lebih cepat juga bisa dipakai, tetapi dalam hal ini kita tidak bisa memasukkan 'Blend' langsung ke kernel, karena kedua konvolusi terpisah itu tidak akan 'terpisah' dengan bersih. Karena itu kita perlu kembali melakukan komposisi Blend sesudahnya. |

  magick face.png \( +clone -blur 0x3 \) \
         -compose Blend -define compose:args=60 -composite \
         face_soft_blur3.png

Perhatikan bahwa yang perlu diberikan hanyalah seberapa banyak gambar blur (sumber) yang ingin dipadukan dengan gambar asli. Jadi nilai '100' memberikan gambar blur, sedangkan '0' memberikan gambar asli. | Ingat, operator "-blur" persis setara dengan memakai kernel blur 2-lintasan yang lebih cepat.

'Un-sharpen' gambar menggunakan blur (mengurangkan dari gambar asli)

Dengan membawa pemaduan kernel ini lebih jauh, sampai Anda mulai memakai skala negatif, efek blur bisa dikurangkan dari gambar asli. Hasilnya adalah teknik bernama 'unsharp'. Lihat Unsharp, Wikipedia tentang bagaimana ia mendapat nama semalang itu. |

  magick face.png -define convolve:scale=-100,200% \
         -morphology Convolve 'Gaussian:0x2' face_unsharp.png

Perhatikan bahwa meski faktor skala kernel negatif dipakai, kedua angka itu tetap berjumlah '100%', persis seperti di atas. Hal itu juga bisa dilakukan dengan pemaduan komposit. Contoh di atas sebenarnya persis cara kerja operator "-sharpen" yang salah nama itu, tetapi hanya dengan kontrol blur 'sigma '. Tidak ada kontrol lain atas operasi itu yang disediakan. Pemaduannya persis seperti yang diberikan di atas. Bisa juga memakai kernel blur 1 dimensi 2-lintasan yang lebih cepat, tetapi lagi-lagi pemaduannya perlu dilakukan sebagai langkah terpisah. |

  magick face.png \( +clone -blur 0x2 \) \
         -compose Blend -define compose:args=-100,200 -composite \
         face_unsharp_fast.png

Ini, seperti mungkin sudah bisa disimpulkan, hampir identik dengan blur yang dilembutkan tetapi dengan gambar blur dikurangkan dari gambar asli alih-alih ditambahkan. Metode pemaduan ini dikenal sebagai pemaduan terekstrapolasi, atau pemaduan di luar rentang normal 0 sampai 100 persen. Sekali lagi, cukup ditentukan seberapa banyak gambar blur yang ingin dikurangkan dari gambar asli. Misalnya, mari kita berlebihan meng-unsharpen gambar, sehingga menimbulkan aliasing dan distorsi warna. |

  magick face.png \( +clone -blur 0x2 \) \
         -compose Blend -define compose:args=-200 -composite \
         face_unsharp_200.png

Operator "-unsharp" lengkap menyediakan satu jenis kontrol lagi. Yaitu ambang batas selisih, sehingga penajaman hanya diterapkan saat selisihnya lebih besar dari itu, misalnya di dekat tepi sesungguhnya dalam gambar. Ambang batas itu bisa dipakai untuk mencegah 'penajaman' cacat-cacat kecil, seperti kerutan atau noise kamera. Meng-unsharpen gambar biasanya dipakai dengan blur sangat kecil (kira-kira sigma=0.75) setelah mengubah ukuran atau mendistorsi gambar, untuk memperbaiki hasil akhir. Lihat Menajamkan gambar hasil resize untuk beberapa contohnya. Alternatif dari teknik 'unsharp' untuk penajaman gambar adalah benar-benar mencari tepi gambar dan memakainya untuk menajamkan gambar. Lihat Menajamkan gambar dengan deteksi tepi di bawah untuk detailnya. Namun cara itu umumnya dianggap lebih lambat, meski sebenarnya tidak banyak.

Konvolusi deteksi tepi (filter lolos-tinggi)

Deteksi tepi adalah bidang lain tempat konvolusi banyak dipakai. Tugasnya di sini adalah menonjolkan atau mempertegas tepi-tepi gambar dengan berbagai cara. Tujuannya bisa untuk menemukan lokasi tepi seakurat mungkin, atau menentukan sudut atau arah kemiringan setiap tepi. Namun pekerjaan ini bisa jadi jauh lebih sulit karena adanya noise di gambar, seperti yang dihasilkan pemindai, kamera digital, atau bahkan sekadar akibat kompresi lossy format file gambar JPEG. Secara umum, kernel yang lebih besar menangani noise lebih baik, tetapi dengan kehilangan ketepatan lokasi tepi, sedangkan kernel kecil memberi hasil penentuan tepi yang tajam tetapi dengan lebih banyak hasil palsu akibat noise di gambar. Ada banyak kernel kecil terkenal yang telah dikembangkan dan dikaji untuk deteksi tepi. Kebanyakan 'dinamai' menurut matematikawan yang mengkaji matematikanya atau mengembangkan tipe kernel tersebut. Karena itu ada kernel seperti 'Laplacian', 'Sobel', dan 'Prewitt'. Kernel-kernel 'bernama' ini umumnya sangat kecil dan didefinisikan memakai bilangan bulat, sehingga bisa ditanamkan ke perangkat lunak dan perangkat keras teroptimasi yang dirancang khusus demi kecepatan. Artinya, kernel-kernel itu disebut kernel 'diskrit'. Karena itu, perlu menskalakan atau menormalisasi kernel sebagai bagian dari pemakaiannya. Deteksi tepi juga punya efek samping menyediakan cara menajamkan tepi gambar.

Kernel berjumlah nol

Semua kernel deteksi tepi punya satu ciri yang sama. Semuanya berjumlah nol. Artinya kernel itu mengandung nilai negatif, tetapi seluruh nilai di kernel berjumlah nol. Untuk gambar berwarna datar mulus, konvolusi dengan kernel semacam itu menghasilkan gambar 'nol' alias hitam. Namun untuk gambar lain, hasilnya akan mengandung nilai negatif maupun positif. Misalnya, di sini saya menerapkan detektor tepi 'Sobel' diskrit pada gambar berisi beberapa bentuk dasar...

  magick -size 80x80 xc:black \
         -fill white -draw 'rectangle 15,15 65,65' \
         -fill black -draw 'circle 40,40 40,20' shapes.gif
  magick shapes.gif -define convolve:scale='!' \
         -morphology Convolve Sobel shapes_sobel.gif

Jika Anda perhatikan hasilnya, kernel itu bersifat berarah: hanya tepi vertikal yang ditemukan (sesuai definisi kernel 'Sobel' dengan sudut nol). Namun ia hanya menemukan satu kelompok tepi, yaitu lereng 'positif' kiri-ke-kanan hitam-ke-putih. Untuk mendapatkan lereng 'negatif', kernel perlu dinegasikan memakai pengaturan penskalaan kernel. Misalnya... |

  magick shapes.gif -define convolve:scale='-1!' \
         -morphology Convolve Sobel shapes_sobel_neg.gif

Kernel 'Sobel' juga bisa diputar 180 derajat untuk mendapat hasil yang sama dengan 'negasi skala' itu, tetapi tidak semua kernel simetris seperti ini. Solusi lain adalah menambahkan bias keluaran pada hasil. Yaitu menambahkan abu-abu 50% ke gambar hasil sehingga nilai negatif lebih gelap dari itu dan nilai positif lebih terang. Namun juga perlu menskalakan kernel agar hasilnya tetap tidak 'terpotong' oleh batas 'hitam' dan 'putih' gambar. |

  magick shapes.gif -define convolve:scale='50%!' -bias 50% \
         -morphology Convolve Sobel shapes_sobel_bias.gif

Jika Anda tidak peduli polaritasnya, nilai absolut dari hasilnya bisa didapat dengan sedikit trik.. |

  magick shapes.gif -define convolve:scale='50%!' -bias 50% \
         -morphology Convolve Sobel -solarize 50% -level 50,0% \
         shapes_sobel_abs.gif

Lihat kernel 'Sobel' untuk teknik penanganan hasil lebih lanjut, terutama teknik yang melibatkan penentuan arah. Alternatif lain dari memakai bias keluaran adalah membangun versi HDRI khusus dari Imagemagick. Versi ini menyimpan gambar di memori memakai nilai floating point, artinya nilai gambar tidak akan 'terpotong' atau 'dibulatkan' oleh pemakaian bilangan bulat. Namun, bahkan jika Anda memakai versi khusus IM ini, hasilnya tetap perlu diproses-lanjut sebelum disimpan ke format file gambar normal, atau perlu memakai format file gambar khusus yang mendukung floating point. Meski begitu Anda tak perlu khawatir soal efek pemotongan atau pembulatan pada hasil gambar antara, sehingga lebih mudah ditangani.

Kernel deteksi tepi

LoG: Laplacian Of Gaussians

   LoG:{_radius_},{_sigma_}

Kernel 'LoG' atau "Laplacian of a Gaussian" adalah salah satu kernel deteksi tepi terbaik yang bisa Anda dapatkan. Ia juga dikenal sebagai kernel "topi Meksiko". Pada dasarnya ini operator diferensial (kemiringan) 'Laplacian' yang telah dihaluskan dengan penambahan blur gaussian. Ini pada gilirannya menghapus sebagian besar dampak noise di gambar, yang bisa diatur lewat pengaturan 'sigma '. Kernel ini mengandung nilai negatif yang membentuk cincin di sekeliling puncak pusat yang kuat. Di 'gambar kernel' yang ditampilkan di atas, nilai negatif tampak sebagai warna gelap (hampir hitam) yang meluruh ke nol (abu-abu gelap) ke arah pinggir. Dan berikut efeknya.. memperlihatkan bagaimana ia menonjolkan tepi-tepi gambar.

  magick face.png -bias 50% -morphology Convolve LoG:0x2 face_log.png

Kernel laplacian tidak berarah, tetapi menghasilkan punggungan nilai positif dan negatif di kedua sisi sebuah tepi. Untuk menemukan lokasi tepi, Anda mencari titik-titik persilangan nol, di antara punggungan positif dan negatif, teknik yang dikenal sebagai deteksi tepi Marr dan Hildreth. Kernel ini juga ideal untuk menajamkan gambar.

DoG: Difference of Gaussians

   DoG:{_radius_},{_sigma1_}[,{_sigma2_}]

Ini akan membangkitkan kernel 'DoG' atau "Difference of Gaussians", yaitu gaussian yang dibangkitkan 'sigma1 ' dikurangi gaussian yang dibangkitkan 'sigma2 '. Biasanya 'sigma2 ' yang lebih besar, sehingga 'puncak pusat' kernel bernilai positif. Menukar kedua angka itu praktis menegasikan kernel hasilnya. Salah satu kritik utama terhadap Laplacian of a Gaussian adalah sulit diimplementasikan karena kurva matematisnya sangat tidak lazim. Kurvanya juga tidak terdokumentasi dengan baik. Aspek lainnya, ia tidak bisa 'dipisah' menjadi solusi 2-lintasan yang lebih cepat seperti pada Gaussian (lihat Kernel Gaussian vs Blur). Namun dengan membangkitkan dua kernel 'Gaussian' dengan nilai sigma sedikit berbeda (dengan rasio kira-kira 1.6), lalu saling mengurangkannya, sebenarnya bisa dibangkitkan hampiran yang dekat dari Laplacian of a Gaussian. Hasilnya, 'DoG' jauh lebih mudah dibangkitkan di perangkat keras daripada kernel 'LoG'. Sebagai contoh, di sini saya menaruh gambar kernel dari kernel 'LoG' dan 'DoG' berdampingan untuk perbandingan.

Di halaman web Difference of Gaussian, Wikipedia ada beberapa grafik yang juga membandingkan profil 'LoG' (atau "topi Meksiko") dengan 'DoG', memperlihatkan selisih yang amat sangat kecil antara kurva-kurva yang bersesuaian. Dibutuhkan informasi lebih lanjut tentang cara memetakan sigma sebuah LoG untuk membangkitkan 'DoG' yang hampir setara. Jika Anda tahu, silakan kirim surat ke saya di alamat pada catatan kaki. Hasil penerapannya juga sangat mirip. |

  magick face.png -bias 50% -morphology Convolve DoG:0,1.8,2.4 face_dog.png

Perhatikan bahwa kedua nilai 'sigma ' harus didefinisikan dan setidaknya satu harus bukan nol. Nilai nol untuk salah satu komponen sigma setara dengan kernel 'Unity', artinya gambar tidak berubah. Jika kedua nilai nol, kedua Gaussian itu menjadi kernel 'Unity', yang bila saling dikurangkan menghasilkan hasil nol sempurna alias hitam (ditambah nilai bias apa pun). Saat argumennya 'Dog:0,0,_non-zero_, DoG menjadi filter lolos-tinggi sederhana, yang didefinisikan sebagai kernel 'Unity' (menghasilkan gambar asli) dikurangi kernel filter lolos-rendah (gambar blur). Dalam hal ini sigma1=0 hanyalah kernel 'Unity' dan sigma2=non-zero adalah kernel filter lolos-rendah (blur) Gaussian. Perintah berikut karenanya menghasilkan gambar terfilter lolos-tinggi dengan nilai filter sigma2=2 |

  magick face.png -bias 50% -morphology Convolve DoG:0,0,2 face_dog_unity.png

Filter lolos-tinggi Photoshop dengan nilai filter radius=2 menghasilkan hasil yang sama. Perhatikan bahwa memakai 'DoG:0,2,0' mengembalikan gambar yang pada dasarnya versi ternegasi (di sekitar bias keluaran) dari gambar sebelumnya. Teknik ini juga bisa dipakai untuk membangkitkan kernel 3x3 'Laplacian isotropik', yaitu kernel 'Laplacian' yang memberi hasil sama di semua arah, alih-alih punya bias diagonal yang tak seimbang. Misalnya radius=1 (untuk kernel 3x3) dan sigma 1 akan membangkitkan... | |

  magick face.png -define morphology:showKernel=1 -bias 50% \
          -morphology Convolve DoG:1,0,1 face_laplacian_isotropic.png

|
Poin lain dari memakai "Difference of Gaussians" adalah Anda bisa memakai operator "-blur" yang jauh lebih cepat (yang secara internal memakai kernel 'Blur') untuk membangkitkan hasil yang sama. Namun untuk itu masing-masing dari dua gambar 'blur' itu perlu dibangkitkan secara terpisah, lalu hasilnya dikurangkan, dengan tambahan skala dan bias yang sesuai. Misalnya... |

  magick face.png \
         \( -clone 0 -blur 0x1.8 \) \( -clone 0 -blur 0x2.4 \) -delete 0 \
         -compose Mathematics -define compose:args=0,-4,4,0.5 -composite \
         face_diff_of_blurs.png

Contoh di atas memakai metode komposisi Mathematics khusus untuk menghindari masalah 'pemotongan' selama pengurangan gambar di versi IM non-HDRI. Untuk detailnya lihat Menambahkan gradien berbias. Satu-satunya faktor lain adalah pemakaian faktor skala lebih besar saat pengurangan (dua angka '4' di argumen Mathematics Compose). Ini karena mengurangkan dua blur ternormalisasi tidak menghasilkan besaran (yang membesar) yang sama seperti saat menormalisasi bersama dua kurva gaussian yang saling dikurangkan dalam kernel 'DoG'. Namun selain besarannya, gambar contoh di atas setara dengan hasil kernel 'DoG' pertama, hanya lebih cepat dibangkitkan, terutama untuk nilai sigma besar. Dan itulah intinya: meski lebih banyak pekerjaan, metode rumit itu lebih cepat daripada memakai kernel 'DoG' atau 'LoG' secara langsung.

Kernel Laplacian diskrit

   Laplacian:{_type_}

Ada banyak bentuk "kernel Laplacian" kecil yang pernah diterbitkan di berbagai makalah riset ilmiah. Di sini saya menyediakan versi bawaan dari yang lebih umum yang berhasil saya temukan di literatur akademis. Kernel-kernel ini pada dasarnya dihitung memakai kernel 'LoG' tetapi diskalakan agar memakai nilai bilangan bulat diskrit dalam larik kernel kecil. Ini memungkinkan pembuatan filter gambar cepat khusus yang hanya memakai matematika bilangan bulat untuk memproses data gambar. Namun ImageMagick adalah pemroses gambar yang lebih umum sehingga tidak menyediakan filter khusus ultra cepat semacam itu. Tetapi orang suka memakainya karena lebih sederhana dipahami, jadi banyak di antaranya telah dibangun ke dalam IM. Tak satu pun kernel yang disediakan di sini bisa diputar, dan kebanyakan bersifat 'anisotropik', artinya tidak bulat sempurna, terutama pada arah diagonal. Namun lihat bagian sebelumnya (kernel 'DoG') untuk cara membangkitkan "kernel Laplacian 3x3 isotropik" sejati. Dua kernel pertama, 'Laplacian:0' dan 'Laplacian:1', adalah bentuk "kernel Laplacian diskrit" yang paling umum dipakai. Keduanya sangat kecil, artinya menemukan lokasi tepi dengan sangat akurat, tetapi juga rentan memperkuat noise gambar. Perhatikan bahwa tidak semua angka 'type ' sudah didefinisikan; disisakan ruang untuk kernel diskrit lain yang akan didefinisikan di masa depan. Angka yang dipakai dipilih agar lebih cocok dengan kernel yang didefinisikan oleh angka itu.

Laplacian:0 (default)

Laplacian 8 tetangga. Barangkali kernel deteksi tepi Laplacian diskrit yang paling umum. Di sini saya memakai Show Kernel untuk mengekstrak kernel 'diskrit' dan 'belum ternormalisasi', sebelum memperlihatkan hasil kernel ternormalisasi dengan bias keluaran. | |

  magick xc: -define morphology:showKernel=1 -precision 2 \
         -morphology Convolve:0 Laplacian:0 null:
  magick face.png -define convolve:scale='!' -bias 50% \
         -morphology Convolve Laplacian:0 face_laplacian_0.png

|
Kadang sebuah Laplacian, entah Laplacian diskrit seperti contoh terakhir, atau 'LoG' maupun 'DoG' hasil pembangkitan, memberi hasil yang lebih rumit dari yang diinginkan. Dalam kasus semacam itu, membangkitkan gambar tanpa bias (tanpa bias keluaran) akan bekerja lebih baik. Jadi mari kita ulangi contoh di atas tanpa bias, agar hanya menyimpan tepi 'positif' yang lebih terang. |

  magick face.png -define convolve:scale='!' \
         -morphology Convolve Laplacian:0 \
         -auto-level face_laplacian_positives.png

Dalam hal ini kita mendapat garis gelap (hitam) di atas warna yang lebih terang (putih). Ini pada gilirannya membuat filter 'menggandakan' tepi, yang bisa dilihat di hasil yang ditampilkan. Untuk gambar ini, memakai faktor skala negatif (menyimpan tepi negatif alih-alih positif) tampak bekerja lebih baik pada gambar uji kita. |

  magick face.png -define convolve:scale='-1!' \
         -morphology Convolve Laplacian:0 \
         -auto-level face_laplacian_negatives.png

Seperti terlihat, untuk gambar ini pemakaian sisi negatif menghasilkan tepi yang lebih kuat tanpa efek 'penggandaan' yang dihasilkan versi positif. Ini karena pemakaian garis tepi 'hitam' di atas latar putih pada gambar yang dipakai. CATATAN SAMPING: Alasan Anda mendapat tepi biru di sekeliling bintang kuning adalah selisih antara bintang 'kuning' dan latar 'putih' merupakan pengurangan warna biru. Jika latarnya hitam, Anda akan mendapat warna tepi kuning.

Laplacian:1

Laplacian 4 tetangga. Juga sangat umum dipakai. | |

  magick xc: -define morphology:showKernel=1 -precision 2 \
         -morphology Convolve:0 Laplacian:1 null:
  magick face.png -define convolve:scale='!' -bias 50% \
         -morphology Convolve Laplacian:1 face_laplacian_1.png

|
Hasilnya tidak sekuat versi sebelumnya, tetapi sering lebih jernih daripada laplacian 8-tetangga.

Laplacian:2

Laplacian 3x3, dengan pusat:4 tepi:1 sudut:-2 | |

  magick xc: -define morphology:showKernel=1 -precision 2 \
        -morphology Convolve:0 Laplacian:2 null:
  magick face.png -define convolve:scale='!' -bias 50% \
         -morphology Convolve Laplacian:2 face_laplacian_2.png

|

Laplacian:3

Laplacian 3x3, dengan pusat:4 tepi:-2 sudut:1 | |

  magick xc: -define morphology:showKernel=1 -precision 2 \
             -morphology Convolve:0 Laplacian:3 null:
  magick face.png -define convolve:scale='400%!' -bias 50% \
         -morphology Convolve Laplacian:3  face_laplacian_3.png

|
Kernel ini menonjolkan tepi diagonal, dan cenderung membuat tepi vertikal dan horizontal menghilang. Namun hasilnya mungkin perlu diskalakan (seperti saya lakukan di atas) agar ada hasil yang terlihat.

Laplacian:5

Laplacian 5x5 | |

  magick xc: -define morphology:showKernel=1 -precision 2 \
         -morphology Convolve:0 Laplacian:5 null:
  magick face.png -define convolve:scale='!' -bias 50% \
         -morphology Convolve Laplacian:5 face_laplacian_5.png

|
Aturan praktis kernel laplacian: makin besar kernelnya, makin bersih hasilnya, terutama saat ada error. Namun detail yang didapat juga berkurang.

Laplacian:7

Laplacian 7x7 | |

  magick xc: -define morphology:showKernel=1 -precision 2 \
         -morphology Convolve:0 Laplacian:7 null:
  magick face.png -define convolve:scale='!' -bias 50% \
         -morphology Convolve Laplacian:7 face_laplacian_7.png

|

Laplacian:15

LoG diskrit 5x5 (sigma kira-kira 1.4) | |

  magick xc: -define morphology:showKernel=1 -precision 2 \
         -morphology Convolve:0 Laplacian:15 null:
  magick face.png -define convolve:scale='!' -bias 50% \
         -morphology Convolve Laplacian:15 face_laplacian_15.png

|

Laplacian:19

LoG diskrit 9x9 (sigma kira-kira 1.4) | |

  magick xc: -define morphology:showKernel=1 -precision 2 \
         -morphology Convolve:0 Laplacian:19 null:
  magick face.png -define convolve:scale='!' -bias 50% \
         -morphology Convolve Laplacian:19 face_laplacian_19.png

|

Menajamkan gambar dengan deteksi tepi (mempertegas tepi gambar asli)

Kernel 'LoG' dan 'DoG' juga bisa dipakai untuk menajamkan gambar, sebagai lawan dari 'un-sharpen' gambar menggunakan blur. Pada dasarnya yang perlu Anda lakukan hanyalah menambahkan hasil kernel (termasuk hasil negatif) ke gambar asli. Caranya mudah: cukup tambahkan kernel 'Unity' alias "identitas" berbobot 100% ke faktor skala. Untuk itulah fitur ini disediakan. Misalnya... |

  magick face.png -define convolve:scale='100,100%' \
         -morphology Convolve 'Log:0x2' face_sharpen.png

Ini penajaman gambar yang jauh lebih lebar dan lebih halus daripada yang dihasilkan teknik unsharpen (hasil ditampilkan di kanan). Sebab, ini penajaman gambar yang sungguhan, bukan tiruan lewat pengurangan blur. |
Seperti sebelumnya, saat hanya satu lintasan konvolusi yang dilakukan, kernel paduan bisa langsung dipakai. Misalnya, lebih tidak tajam... |

  magick face.png -define convolve:scale='50,100%' \
         -morphology Convolve 'Log:0x2' face_sharpen_50.png

Atau lebih tajam... |

  magick face.png -define convolve:scale='150,100%' \
         -morphology Convolve 'Log:0x2' face_sharpen_150.png

Metode 2-lintasan Difference of Gaussians bisa dipakai untuk menghasilkan operasi penajaman multi-langkah yang lebih cepat, tetapi seperti diperlihatkan di atas, skema semacam itu memerlukan 4 konvolusi dan satu operasi pemaduan terpisah untuk mencapai hasil yang sama. FUTURE: add example of this Kerumitan inilah alasan unsharpen lebih sering menjadi metode penajaman gambar yang dipilih. Tetapi seperti terlihat, untuk proses penajaman berat, memakai kernel penajaman sejati lebih disukai daripada penajaman unsharp. Namun untuk penajaman ringan, seperti menajamkan gambar hasil resize, tidak ada masalah memakai unsharp.

Konvolusi berarah (kemiringan dan kompas)

Seperti di atas, kernel-kernel ini mencari kemiringan dalam intensitas warna gambar, tetapi alih-alih kemiringan apa pun, mereka mencari kemiringan pada arah tertentu. Secara matematis ini dikenal sebagai 'turunan' (derivative), yang sebenarnya cuma cara mewah untuk mengatakan 'kemiringan'. Namun mengetahui informasi kemiringan untuk berbagai arah juga berguna sebagai sarana menentukan sudut atau arah 'kompas' suatu kemiringan atau tepi gambar. Yaitu arah 2 dimensi kemiringan dalam gambar di titik tertentu. Kemiringan juga dipakai dalam teknik pemrosesan gambar yang dikenal sebagai 'embossing' dan 'shading' gambar. Saat ini belum ada kernel 'hasil pembangkitan' yang tersedia, hanya kernel 'bernama' yang telah didefinisikan sebelumnya, seperti Sobel dan Roberts. Namun saya yakin fungsi pembangkitan kernel embossing dan shading akan dipindahkan ke himpunan kernel morfologi/konvolusi suatu saat nanti. Jadi mari kita lihat beberapa kernel berarah 'bernama' itu.

Kernel berarah

Sobel

   Sobel:{_angle_}

Kita sudah melihat kernel 'Sobel ' di atas dalam pembahasan kernel berjumlah nol. Kernel ini adalah kernel berarah mentah (turunan pertama) yang dirancang mengembalikan kemiringan sebuah tepi pada arah ortogonal tertentu. Secara default ia dirancang untuk deteksi kemiringan kiri-ke-kanan, memakai operasi 'convolve'. Hasilnya pada dasarnya adalah turunan-X (kemiringan) dari gambar.

  magick -size 60x60 xc:black xc:white +append slope_positive.gif
  magick slope_positive.gif -morphology Convolve Sobel slope_sobel.gif

| _Jika melihat kernelnya, Anda mungkin mengira ia dideklarasikan terbalik. Dalam satu arti, Anda memang benar. Namun ini karena cara 'Convolve' sebenarnya bekerja.

Soal 'pembalikan' ini bisa dipelajari lebih rinci di Convolve vs Correlate di bawah.

_
Perhatikan bahwa kernel ini juga bisa menghasilkan indikasi 'kemiringan negatif', tetapi itu tidak terlihat kecuali bias '50%' juga dipakai pada operasi convolve ini. Meski tidak ada kemiringan negatif di contoh sebelumnya, contoh berikut memilikinya, jadi saya juga menambahkan pengaturan bias supaya efeknya terlihat.

  magick -size 40x60 xc:black xc:white xc:black +append slope_both.gif
  magick slope_both.gif -define convolve:scale='50%!' -bias 50% \
         -morphology Convolve Sobel slope_sobel_bias.gif

| _Jika Anda memakai kernel ini dengan 'Correlate', akan ditemukan kemiringan yang 'cocok' dengan cara kernel didefinisikan. Dalam hal itu Anda mendapat hasil positif untuk kemiringan dari tinggi (nilai putih) di kiri ke rendah (nilai hitam) di kanan. Pada contoh di atas kedua garis itu akan tertukar.

Namun contoh di atas adalah 'konvolusi', bukan 'korelasi' (artinya mencocokkan kernel). Sekali lagi lihat Convolve vs Correlate untuk detail perbedaannya._
Seperti terlihat, kita kini mendapat garis putih (kemiringan positif) saat naik dari hitam ke putih, dan garis hitam (kemiringan negatif) saat turun kembali dari putih ke hitam. Berikut hasil pemakaian kernel 'Sobel' default pada gambar wajah.

  magick face.png -define convolve:scale='50%!' -bias 50% \
         -morphology Convolve Sobel face_sobel.png

Perhatikan bahwa sobel, dan kebanyakan kernel deteksi tepi lain, cenderung menghasilkan respons setebal 2 piksel di sepanjang tepi yang sangat kuat, dan respons 3 piksel pada garis selebar satu piksel. Ini jauh lebih kuat daripada detektor tepi laplacian. Kernel ini bisa diputar memakai argumen 'angle ', umumnya dalam kelipatan 90 derajat. Namun bisa juga diputar dalam kelipatan 45 derajat, meski kernel ini tidak dirancang untuk itu. Ini berguna untuk mendapatkan turunan berarah terkuantisasi 45 derajat, atau besaran gradien dari maksimum semua hasil turunan rotasi 45 derajat. Berikut hasilnya lagi, tetapi diputar 90 derajat (atas ke bawah). |

  magick face.png -define convolve:scale='50%!' -bias 50% \
         -morphology Convolve Sobel:90 face_sobel_90.png

Salah satu cara mengumpulkan semua tepi gambar memakai kernel 'Sobel' adalah menerapkan kernel itu 4 kali ke semua arah, lalu mengambil nilai maksimum yang terlihat (memakai komposisi matematis Lighten. Ini hampiran dari besaran gradien. |

   magick face.png -define convolve:scale='!' \
          \( -clone 0 -morphology Convolve Sobel:0 \) \
          \( -clone 0 -morphology Convolve Sobel:90 \) \
          \( -clone 0 -morphology Convolve Sobel:180 \) \
          \( -clone 0 -morphology Convolve Sobel:270 \) \
          -delete 0 -background Black -compose Lighten -flatten \
          face_sobel_maximum.png

Perintah di atas bisa disederhanakan dengan memanfaatkan fitur penanganan multi-kernel pada morphology IM. Yaitu dengan membuat daftar rotasi dari semua rotasi 90 derajat kernel 'Sobel'. |

   magick face.png -define convolve:scale='!' \
          -define morphology:compose=Lighten \
          -morphology Convolve 'Sobel:>' face_sobel_maximum_2.png

Jika Anda ingin melihat persis apa yang dilakukan perintah di atas, tambahkan pengaturan Show Kernel dan pengaturan Verbose. Teknik yang lebih efisien untuk membangkitkan besaran gradien adalah memanfaatkan fakta bahwa rotasi 180 derajat menghasilkan hal yang sama dengan menegasikan kernel, dan dengan demikian menegasikan hasil. Jadi turunan X dan Y (konvolusi rotasi 90 derajat), dengan sedikit trik untuk mendapatkan nilai absolut konvolusi, bisa mencapai hasil semacam itu dengan pemrosesan lebih sedikit. |

   magick face.png -define convolve:scale='50%!' -bias 50% \
          \( -clone 0 -morphology Convolve Sobel:0 \) \
          \( -clone 0 -morphology Convolve Sobel:90 \) \
          -delete 0 -solarize 50% -level 50,0% \
          -compose Lighten -composite face_sobel_maximum_3.png

Ini biasanya sudah cukup baik untuk kebanyakan keperluan. Besaran yang lebih eksak dari semua kemiringan bisa diekstrak dengan melakukan penjumlahan vektor kedua turunan X dan Y (sesuai teorema Pythagoras). |

   magick face.png -define convolve:scale='50%!' -bias 50% \
          \( -clone 0 -morphology Convolve Sobel:0 \) \
          \( -clone 0 -morphology Convolve Sobel:90 \) \
          -delete 0 -solarize 50% -level 50,0% \
          +level 0,70% -gamma 0.5 -compose plus -composite -gamma 2 \
          -auto-level face_sobel_magnitude.png

| _Fungsi "-gamma" di atas dipakai untuk melakukan 'kuadrat' dan 'akar kuadrat' matematis dari nilai-nilai yang dikembalikan hasil 'Sobel'. Untuk detail lebih lanjut lihat fungsi pangkat.

"+level" tambahan memastikan komposisi Plus tidak melampaui rentang kuantum gambar. Lihat Efek kuantum, non-HDRI vs HDRI untuk detailnya._
Alih-alih besarannya, arah kemiringan bisa diekstrak dari kedua hasil deteksi tepi itu.

  magick -size 30x600 xc:'#0F0' -colorspace HSB \
         gradient: -compose CopyRed -composite \
         -colorspace RGB -rotate 90  rainbow.jpg
  magick shapes.gif -define convolve:scale='50%!' -bias 50% \
         \( -clone 0 -morphology Convolve Sobel:0 \) \
         \( -clone 0 -morphology Convolve Sobel:90 \) \
         -delete 0 \
         \( -clone 0,1 -fx '0.5+atan2(v-0.5,0.5-u)/pi/2' rainbow.jpg -clut \) \
         \( -clone 0,1 -fx 'u>0.48&&u<0.52&&v>0.48&&v<0.52 ? 0.0 : 1.0' \) \
         -delete 0,1 -alpha off -compose CopyOpacity -composite \
         face_sobel_direction.png

Ekspresi "-fx" pertama adalah yang memakai fungsi 'atan()' untuk mengubah vektor X,Y menjadi sudut. Hasil ini lalu diwarnai dengan gambar gradien pelangi eksternal, sebagai tabel pencarian warna. Ekspresi "-fx" kedua membuat mask transparansi hasil thresholding agar area tanpa kemiringan menjadi transparan. Namun teknik di atas cenderung menghasilkan kekacauan informasi yang luar biasa untuk gambar nyata karena tidak memperhitungkan besaran kemiringan. Berikut versi lain yang lebih kompleks. Versi ini melakukan hampir semua perhitungan di kanal hijau 'G', untuk mengurangi jumlah pemrosesan gambar dengan faktor tiga. Ia lalu memakai ruang warna HSB untuk membuat arah (hue) dan besaran (kecerlangan). |

  magick face.png -colorspace Gray    -channel G \
         -define convolve:scale='50%!' -bias 50% \
         \( -clone 0 -morphology Convolve Sobel:0 \) \
         \( -clone 0 -morphology Convolve Sobel:90 \) \
         -delete 0 \
         \( -clone 0,1 -fx '0.5 + atan2(v-0.5,0.5-u)/pi/2' \) \
         \( -clone 0   -fill white -colorize 100% \) \
         \( -clone 0,1 -fx 'hypot(u-0.5,v-0.5)*2' \) \
         -delete 0,1 -separate +channel \
         -set colorspace HSB -combine -colorspace RGB \
         face_sobel_magnitude_n_direction.png

Roberts

   Roberts:{_angle_}

Kernel 'Roberts' jauh lebih sederhana daripada kernel 'Sobel' sebelumnya, dan menghasilkan lokasi tepi yang lebih ketat lagi (sampai 2 piksel). Tentu itu juga membuatnya lebih rentan efek noise. Biasanya kernel ini direpresentasikan dengan kernel 2x1 atau bahkan 2x2 yang jauh lebih kecil, tetapi dengan mengimplementasikannya sebagai kernel 3x3 saya bisa memutarnya secara 'siklis' dalam kelipatan 45 derajat. Misalnya, berikut hasil 45 derajat, yang lebih dikenal sebagai kernel 'Roberts-Cross'. |

  magick face.png -define convolve:scale='50%!' -bias 50% \
         -morphology Convolve Roberts:45 face_roberts.png

Seperti pada 'Sobel', penanganan multi-kernel juga bisa dipakai untuk membangkitkan kemiringan maksimum dari semua arah. Tetapi kali ini kita mendapat 8 arah 45 derajat, bukan hanya 4. |

   magick face.png -define morphology:compose=Lighten \
          -morphology Convolve 'Roberts:@' face_roberts_maximum.png

Perhatikan bahwa memutar kernel ini 180 derajat tidak membangkitkan hasil ternegasi (karena adanya offset). Karena itu separuh jumlah konvolusi tidak bisa begitu saja digabungkan seperti pada 'Sobel'. Pada dasarnya kemiringan yang dibangkitkan oleh satu konvolusi 'Roberts' saja tergeser setengah piksel dari kesejajaran dengan gambar sebenarnya. Yaitu kemiringan yang dihitung berlokasi di titik antara nilai '+1' dan '-1', di antara piksel-piksel, tetapi disimpan di piksel '-1' pusat. Namun ini juga berarti dengan menyimpan semua kemiringan di sekeliling sebuah piksel dan menjumlahkannya, yang didapat adalah deteksi tepi yang jauh lebih kecil dan lebih tajam, dengan hanya 2 piksel (bukan 4 piksel) menonjolkan batas tepi yang tajam.

Prewitt

   Prewitt:{_angle_}

Kernel 'Prewitt' sangat mirip dengan 'Sobel', meski jauh lebih longgar soal arah persis deteksi tepinya. Hasilnya karena itu sedikit lebih kabur. |

  magick face.png -define convolve:scale='50%!' -bias 50% \
         -morphology Convolve Prewitt face_prewitt.png

Compass

   Compass:{_angle_}

Ini kernel 'kompas Prewitt' yang konon punya kepekaan arah lebih kuat daripada 'Sobel'. |

  magick face.png -define convolve:scale='50%!' -bias 50% \
         -morphology Convolve Compass face_compass.png

Kirsch

   Kirsch:{_angle_}

Ini detektor tepi lain dengan kepekaan arah yang kuat. |

  magick face.png -define convolve:scale='50%!' -bias 50% \
         -morphology Convolve Kirsch face_kirsch.png

Frei-Chen

Kernel bawaan ini menyediakan tiga kelompok kernel. Yang pertama adalah varian 'isotropik' (arah seragam) dari 'Sobel', dengan nilai '2' digantikan akar kuadrat dari 2.

   Frei-Chen:[{_type_},][{_angle_}]

Kernel di atas adalah kernel default tanpa bobot yang menjadi inti kernel 'Frei-Chen'. |

  magick face.png -define convolve:scale='50%!' -bias 50% \
         -morphology Convolve Frei-Chen face_freichen.png

Seperti 'Sobel', kernel ini semestinya diterapkan memakai sudut dalam kelipatan 90 derajat. Untuk memudahkan, dua kernel (dengan bobot yang sama) telah disediakan, satu seperti di atas untuk pemakaian ortogonal, satunya lagi untuk pemakaian diagonal.

Frei-Chen:1

Frei-Chen:2

Kelompok tipe ketiga terdiri dari 9 kernel yang dirancang dan diberi bobot khusus, yang dipakai bukan hanya untuk deteksi tepi pada arah tertentu, tetapi juga untuk menentukan sudut sesungguhnya dari sebuah tepi tajam. 'type ' dalam hal ini adalah angka dari '11' sampai '19', memungkinkan salah satu dari 9 kernel dalam kelompok itu diekstrak. Namun jika Anda memberi nilai 'type ' '10', yang didapat adalah daftar multi-kernel berisi semua 9 kernel yang sudah diberi bobot.

Masing-masing kernel diterapkan pada gambar asli, lalu hasilnya dijumlahkan
untuk membangkitkan hasil deteksi tepi.

Ini paling baik dilakukan memakai versi [HDRI](basics.html#hdri) dari
ImageMagick.




   magick image.png \
          \( -clone 0 -morphology Convolve FreiChen:11 \) \
          \( -clone 0 -morphology Convolve FreiChen:12 \) \
          \( -clone 0 -morphology Convolve FreiChen:13 \) \
          \( -clone 0 -morphology Convolve FreiChen:14 \) \
          \( -clone 0 -morphology Convolve FreiChen:15 \) \
          \( -clone 0 -morphology Convolve FreiChen:16 \) \
          \( -clone 0 -morphology Convolve FreiChen:17 \) \
          \( -clone 0 -morphology Convolve FreiChen:18 \) \
          \( -clone 0 -morphology Convolve FreiChen:19 \) \
          -delete 0 -background Black -compose Plus -flatten \
          result.pfm




Jika tipe 10 diberikan, dibangkitkan daftar multi-kernel berisi semua 9 kernel berbobot
yang ditampilkan di atas. Ini memungkinkan komposisi multi-kernel dipakai untuk
melakukan hal di atas dengan jauh lebih sederhana...




    magick image.png -define morphology:compose=Plus \
           -morphology Convolve FreiChen:10 \
           result.pfm




Namun saya belum menemukan apa makna yang dimaksud dari hasil-hasil ini.  Jika
ada yang punya pengalaman atau pengetahuan tentang bagaimana ini sebenarnya dipakai,
tolong beri tahu saya, supaya bisa saya cantumkan di sini untuk dipakai orang lain.

Correlate ( )

Jika metode 'Convolve' pada dasarnya dipakai untuk pemrosesan gambar, metode 'Correlate' lebih dirancang untuk pencocokan pola. Yaitu ia melakukan 'korelasi silang' sebuah gambar dengan kernelnya, mencari kecocokan bentuk yang diberikan di dalam gambar. Kenyataannya 'Convolve' dan 'Correlate' adalah operasi yang sama. Satu-satunya perbedaan keduanya sebenarnya sangat kecil, yaitu pencerminan x dan y (setara rotasi 180 derajat) pada kernel. Panduan terbaik yang saya temukan tentang cara kerja korelasi dan konvolusi serta perbedaan keduanya adalah Class Notes for CMSC 426, Fall 2005, by David Jacobs.

Konvolusi vs korelasi (efek kernel asimetris)

Seperti saya sebutkan di atas, kedua operator 'Convolve' dan 'Correlate' pada dasarnya sama. Bahkan pengguna sering menyebut konvolusi padahal yang mereka maksud sebenarnya korelasi. Lagi pula korelasi memang metode yang lebih mudah dipahami. Untuk kernel yang simetris terhadap 'origin' pusat, yang merupakan kasus sangat umum, kedua metode itu memang sama. Perbedaannya baru tampak saat Anda memakai kernel yang asimetris atau tidak rata. Misalnya, di sini saya memakai kernel 'datar' berbentuk 'L' terhadap gambar 'satu piksel' kita.

  magick pixel.gif  \
         -morphology Convolve '3: 1,0,0
                                  1,0,0
                                  1,1,0' convolve_shape.gif

Seperti terlihat, 'Convolve' memperluas piksel tunggal di pusat sehingga membentuk huruf 'L' di sekelilingnya. Bahkan ketika origin itu sendiri bukan bagian dari 'lingkungan tetangga'. Sekarang mari kita ulangi contoh ini tetapi memakai 'Correlate'.

  magick pixel.gif  \
         -morphology Correlate '3: 1,0,0
                                   1,0,0
                                   1,1,0' correlate_shape.gif

Seperti terlihat, 'Correlate' juga memperluas piksel tunggal itu membentuk huruf 'L', tetapi berupa bentuk 'L' yang 'terputar'. Inilah pada dasarnya satu-satunya perbedaan kedua metode itu. Metode 'Correlate' menerapkan kernel 'APA ADANYA' sehingga piksel tunggal melebar menjadi bentuk yang 'terputar'. Sebaliknya 'Convolve' justru memakai bentuk kernel yang 'diputar' 180 derajat sehingga setiap piksel melebar menjadi bentuk yang sama tanpa rotasi. Jika ingin melihat contoh-contoh bagus tentang bagaimana 'Convolve' sebenarnya bekerja, saya sarankan Anda juga melihat EECE \ CS 253 Image Processing, Lecture 7, Spatial Convolution. Diagram di halaman 22-nya benar-benar menerapkan kernel 'terpantul' pada satu piksel tunggal, persis seperti yang saya lakukan di atas.
Perbedaan rotasi ini mungkin tampak sepele, tetapi artinya, dari sisi matematika, operasi convolve (dilambangkan tanda asterisk ('*')) bersifat komutatif: jika kernel dan gambar sama-sama diperlakukan sebagai sekadar larik nilai (atau dua gambar), maka F * G == G * F. Ini juga berarti convolve bersifat asosiatif: ( F * G ) * H == F * ( G * H ). Lihat Convolution Properties, Wikipedia untuk informasi lebih lanjut. Operasi 'Correlate' tidak komutatif maupun asosiatif, meski berkerabat dekat (lewat rotasi kernel). Pada dasarnya 'Convolve' berperilaku lebih seperti 'perkalian' matematis, sedangkan 'Correlate' tidak. Pengecualian dari semua keributan ini adalah saat kernel yang dipakai identik bila diputar 180 derajat. Yaitu kernel yang simetris terhadap 'origin'. Dalam kasus khusus itu kedua operasi menghasilkan hasil yang setara. Yang membingungkan orang, kebanyakan kernel yang dipakai untuk konvolusi, seperti Gaussian blur, Laplacian, dan seterusnya, memang simetris, sehingga tidak jadi soal apakah Anda sebenarnya melakukan konvolusi atau korelasi. Maka orang pun menjadi santai dan kabur soal makna keduanya. Baru ketika kernelnya tidak simetris, seperti pada pencarian bentuk (lihat berikutnya), atau dengan kernel berarah seperti Sobel, perbedaan itu menjadi benar-benar penting.

Korelasi dan pencarian bentuk

Kegunaan sebenarnya metode 'Correlate' (menerapkan lingkungan tetangga kernel 'apa adanya' tanpa rotasi) adalah metode lama tetapi sederhana untuk menemukan objek berbentuk yang kira-kira cocok dengan bentuk di kernel yang diberikan. Misalnya, jika kita memakai 'Correlate' dengan kernel berbentuk 'L' dan mencoba mencari pada gambar yang kita buat dengan contoh metode konvolusi di atas, kita mendapat...

  magick convolve_shape.gif -define convolve:scale='1!' \
         -morphology Correlate '3: 1,0,0
                                   1,0,0
                                   1,1,0' correlate.gif

_CATATAN SAMPING: perhatikan bahwa area 'hitam' di gambar kernel di atas mewakili nilai nol. Tidak ada nilai negatif di kernel ini, hanya nilai positif untuk bentuk yang dicocokkan.

_

Perhatikan bahwa saya memakai normalisasi kernel IM untuk mencegah hasil akhir menjadi terlalu terang dan menenggelamkan 'puncak' dalam lautan titik putih. Seperti terlihat, metode 'Correlate' menghasilkan kecerahan maksimum di titik tempat 'origin' kernel persis cocok dengan bentuk yang sama di gambar. Tetapi ia juga menghasilkan titik yang kurang terang di tempat yang hanya sebagian bentuknya cocok. Makin banyak bagian bentuk yang cocok, makin terang pikselnya. Namun saya ingatkan: meski 'Correlate' berhasil dalam kasus ini, ini bukan cara yang benar-benar bagus. Misalnya, ia bisa membangkitkan sangat banyak kecocokan palsu di area dengan kecerahan sangat tinggi. Masalah ini bisa dikurangi dengan memakai nilai negatif untuk area yang semestinya cocok dengan latar belakang gelap gambar. Yaitu area yang tidak cocok dengan latar belakang akan membuat piksel hasil kurang terang.

  magick convolve_shape.gif -define convolve:scale='1^'  \
         -morphology Correlate '4x5+2+2:  0 -1  0  0
                                         -1 +1 -1  0
                                         -1 +1 -1  0
                                         -1 +1 +1 -1
                                          0 -1 -1  0 ' correlate_pattern.gif

_CATATAN SAMPING: Agar gambar kernel lebih jelas, saya membangkitkan gambar kernel sehingga nilai positif (latar depan) putih, nilai negatif (latar belakang) hitam, dan nilai nol ('tak peduli') transparan. Namun kernel yang benar-benar dipakai terdefinisi lengkap, dalam bentuk angka, dan 'lingkungan tetangga'-nya adalah persegi panjang penuh.

_

Seperti terlihat, puncak kecocokan jauh lebih menonjol, karena kini Anda bukan hanya mencocokkan piksel latar depan, tetapi juga piksel latar belakang. Perhatikan pemakaian flag normalisasi khusus '^' di atas. Ini penting karena ia menormalisasi nilai positif dan negatif di kernel secara terpisah. Yaitu Anda ingin mencari piksel latar depan secara setara dengan piksel latar belakang. Ini berarti kecocokan positif maupun negatif dari bentuk yang diberikan bisa dicari dengan memakai versi HDRI IM atau dengan pemakaian bias keluaran yang sesuai (lihat di atas). Misalnya, di sini saya menerapkan pencarian bentuk 'L' pada gambar uji yang berisi bentuk 'L' positif maupun negatif. (gambar yang ditampilkan sudah diperbesar)

  magick test_morphology.gif  -bias 50% -define convolve:scale='50%^' \
         -morphology Correlate '4x5+2+2:  0 -1  0  0
                                         -1  1 -1  0
                                         -1  1 -1  0
                                         -1  1  1 -1
                                          0 -1 -1  0 ' correlate_bias.gif

Bias keluaran membuat keluaran normal pencarian menjadi abu-abu tengah, sementara bentuk yang cocok diberi warna lebih terang atau lebih gelap, bergantung pada jumlah piksel yang benar-benar cocok dengan 'kernel bentuk'. Jika Anda memeriksa nilai-nilai sebenarnya di gambar keluaran, hanya ada satu piksel putih-murni dan satu piksel hitam-murni, menandakan kecocokan sempurna. Namun ada juga cukup banyak kecocokan-hampir. Jika saya tidak tertarik pada kecocokan negatif alias 'hitam', saya bisa menghapus bias keluaran dan faktor skala '50%', sehingga piksel tanpa kecocokan menjadi hitam dan kecocokan sempurna menjadi putih. Begitu Anda punya gambar kecocokan 'Correlate', langkah berikutnya adalah mencoba menemukan 'puncak' kecocokan. Ini bisa dilakukan memakai korelasi lain, tetapi tidak selalu bekerja dengan baik. Cara yang lebih baik adalah memakai metode pencocokan pola yang lebih eksak, morfologi 'HitAndMiss', dengan kernel khusus 'Peaks' yang memang dibuat untuk tujuan ini. Ia menemukan piksel tunggal mana pun yang hanya dikelilingi piksel berwarna lebih gelap. Kernel 'Peaks' lain bisa dipakai untuk menemukan kecocokan yang lebih 'longgar'.

  magick correlate_bias.gif  -morphology hitandmiss peaks:1.9 \
         -auto-level correlate_peaks.gif

Dan di sini lokasi tempat kecocokan bentuk terbaik mudah ditemukan, meski derajat kecocokannya sudah hilang. Anda mungkin ingin melihat bagian 'pencarian puncak' di Compare dan pencarian sub-gambar. Tetapi lihat juga skrip Fred Weinhaus "maxima". FUTURE: Normalized Cross Correlation with the Fast Fourier Transform, for generating very fast image Correlations with very large images (both source image and sub-image).

Korelasi vs morfologi HitAndMiss

Penghitungan tetangga

Salah satu kegunaan konvolusi yang lebih tak biasa dikenal sebagai penghitungan tetangga. Yaitu mencari tahu berapa banyak piksel yang ada di area tertentu di sekeliling setiap titik piksel dalam gambar.

Menghitung tetangga

Pada dasarnya, dengan kernel konvolusi yang sangat sederhana bisa dibuat gambar yang berisi hitungan jumlah tetangga di sekeliling titik tertentu dalam gambar biner. Dengan mengonvolusi memakai kernel Ring berukuran '1.5', didapat hitungan tetangga. Berikut penghitungan tetangga setiap piksel di area kecil, beserta pembesaran piksel-piksel sebelum dan sesudahnya (dibuat memakai skrip Enlarge Image)...

  magick area.gif -define convolve:scale=\! \
         -morphology Convolve Ring:1.5 neighbour.gif

Seperti terlihat, tingkat abu-abu semua piksel menunjukkan berapa banyak tetangga yang mereka miliki, termasuk tetangga piksel virtual di sepanjang tepi. Jika Anda ingin menyertakan piksel itu sendiri dalam hitungan, pakai kernel Square sebagai gantinya. Dengan konversi yang sesuai (termasuk penyesuaian level) dan memakai format file PbmPlus, tingkat abu-abu di atas bisa diubah menjadi angka sungguhan jika itu yang Anda mau.

  magick neighbour.gif +depth +level 0,8 pgm: | pnmnoraw | tail -n +4

Jika Anda ingin mengecualikan piksel yang berada di dalam bentuk itu sendiri, pakailah kernel dengan piksel pusat negatif yang kuat, lalu meng-clamp hasil negatif apa pun (jika memakai versi HDRI IM). Satu cara sederhana membangkitkan kernel semacam itu, berupa nilai 1 positif yang mengelilingi pusat negatif besar, adalah menskalakan negatif sebuah kernel Laplacian diskrit standar.

  magick area.gif -define convolve:scale=-1\! \
         -morphology Convolve Laplacian:0 -clamp neigh_edge.gif

Tentu saja kita juga bisa memakai gambar asli sebagai mask untuk menghapus piksel yang tidak menarik.

Game of Life

Pada 1970 seorang matematikawan Inggris, John Horton Conway, menerbitkan di Scientific American sebuah simulasi khusus yang menjadi sangat populer. Kini ia dikenal sebagai Conway's Game of Life. Simulasi ini didasarkan pada kisi titik-titik yang masing-masing 'hidup' atau 'mati'. 'Sel' mana yang lalu digolongkan 'hidup' atau 'mati' pada 'generasi' berikutnya bergantung pada seperangkat aturan sangat sederhana yang murni didasarkan pada jumlah sel tetangga yang hidup di sekelilingnya.

• Lingkungan tetangganya adalah 8 piksel di sekeliling setiap 'sel'.
• Sel 'hidup' terus hidup jika punya 2 atau 3 tetangga.
• Sel 'mati' menjadi 'hidup' (lahir) jika punya tepat 3 tetangga.
• Selain itu sel menjadi atau tetap 'mati'.

Hasil aturan-aturan ini pada pola biner sungguh luar biasa: muncul gugus-gugus 'sel' yang tampak mengembang, menyusut, berosilasi, bahkan bergerak perlahan melintasi kisi. Ini menjadi titik riset teoretis besar, untuk melihat apakah replikasi gaya 'DNA' dari 'pola kehidupan' yang lebih besar pun bisa dibangkitkan. CATATAN SAMPING: Tampaknya itu mungkin, tetapi begitu rapuh sehingga tidak praktis, yang membuat kehidupan DNA masa kini jauh lebih menakjubkan. Ini juga memicu minat besar pada kajian dan implementasi bentuk lain Cellular Automation, sebagai metode membangkitkan dan mengkaji efek besar memakai aturan yang amat sangat sederhana pada skala amat kecil. Mirip yang terjadi dalam kimia di tingkat atom dan molekul, tetapi dengan kompleksitas lebih besar. Jadi mari kita implementasikan 'Life' memakai ImageMagick. Pertama, untuk memudahkan, sel 'hidup' kita buat putih dan sel 'mati' hitam. Dengan begitu kita hanya menghitung piksel 'putih' di sekeliling setiap sel, dalam lingkungan tetangga 8 piksel. Kita juga bisa mengimplementasikannya dengan hitam dan putih ditukar, meski jadi lebih sulit diikuti cara kerjanya. Namun aturannya sangat bergantung pada apakah sel pusat hidup atau mati. Jadi kita perlu memisahkan hitungan tetangga untuk sel 'mati' dari hitungan sel 'hidup'. Itu bisa dilakukan sederhana dengan memberi sel pusat nilai lebih besar daripada jumlah semua tetangganya. Nilai '10' bagus untuk ini. Angka bulat yang enak dan lebih besar dari hitungan tetangga maksimum 8. Itu membuat kernel konvolusi 'Game of Life' setara dengan..

    '3: 1,  1,  1
        1, 10,  1
        1,  1,  1'

Hasilnya adalah hitungan 8 tetangga di sekeliling setiap piksel (yang 'putih'), ditambah nilai 10 jika piksel pusat 'hidup' alias 'putih'. Dengan demikian nilai kernel ini akan berupa '0' sampai '8' untuk piksel mati atau '10' sampai '18' untuk piksel hidup. Jika kita menskalakan kernel ini dengan nilai 20 (tepatnya menskalakan dengan '0.05' untuk membangkitkan gradien, lihat di bawah), akan dihasilkan gambar dengan 21 kemungkinan tingkat abu-abu. Yaitu didapat 'hitam' untuk tingkat abu-abu '0' dan nilai putih untuk tingkat abu-abu '21', meski kernel itu sebenarnya tidak bisa membangkitkan nilai tersebut. Sekarang kita bisa menyandikan aturan 'Game of Life ' ke dalam sebuah gambar tabel pencarian warna, untuk mengubah 'tingkat abu-abu' hitungan tetangga hasil kernel di atas menjadi hasil 'hidup dan mati' yang sesuai menurut 'aturan Life'.

  magick -size 21x1 xc:black -fill white \
          -draw 'point 3,0  point 12,0  point 13,0' \
          life_clut.gif
  enlarge_image -25.3 -ml 'Life Rules' life_clut.gif life_clut_enlarged.png

Gambarnya sangat kecil, jadi saya memakai skrip Enlarge Image untuk membuat versi lebih besar yang ditampilkan di atas, dengan setiap piksel terpisah jelas. Pada dasarnya 10 piksel pertama adalah apa yang dilakukan untuk 'sel mati', 10 piksel berikutnya untuk 'sel hidup'. Piksel putih pertama di sisi kiri (hitungan tetangga = 3 di sekeliling sel mati) adalah 'kelahiran', sedangkan dua piksel putih di sisi kanan (hitungan tetangga 2 dan 3 di sebelah sel hidup) membiarkan 'sel hidup' yang ada terus hidup. Hasil lain membiarkan hasilnya hitam (mati). Tabel pencarian warna itu panjangnya 21 piksel karena saya akan membagi dengan faktor skala 20, artinya kita bisa membangkitkan nilai dalam rentang 0 sampai 20, alias 21 tingkat grayscale yang berbeda. Kita sebenarnya bisa memakai nilai selain 10 untuk pusat (keadaan sel sebelumnya) dan 20 untuk skala, tetapi nilai-nilai ini angka yang mudah diolah. Ringkasnya, kita membagi kernel konvolusi dengan 20, dan memakai CLUT sepanjang 21 piksel (dengan interpolasi integer) untuk mencocokkan hasil konvolusi (tingkat abu-abu) ke nilai warna keluaran yang tepat. CATATAN SAMPING: CLUT 'aturan Life' ini bisa dianggap tabel aturan Cellular Automata umum. Pola lingkungan tetangga yang dipakai untuk penghitungan tetangga juga bagian dari cellular automata itu. Teknik ini juga diuraikan di Cellular Automata Rules Lexicon, pada bagian Rules Tables, sebagai cara mendefinisikan bentuk cellular automata 'bebas-batas' umum dari yang didaftarnya. Pada dasarnya hampir semua automata bisa didefinisikan memakai kombinasi lingkungan tetangga/tabel semacam itu, meski kebanyakan didefinisikan memakai bentuk yang lebih sederhana. Jadi mari kita terapkan ini pada gambar berisi pola 'life', beberapa kali, untuk melihat bagaimana polanya berubah dari satu generasi ke generasi berikutnya, dan memastikan semuanya bekerja seperti diharapkan.

  magick -size 15x15 xc:black -fill white \
         -draw 'line  3,2 3,4  line 10,10 12,10  point 10,11  point 11,12' \
         life_gen_000.gif
  magick life_gen_000.gif -define convolve:scale=0.05 \
         -morphology Convolve '3:1,1,1 1,10,1 1,1,1' \
         life_clut.gif -interpolate integer -clut \
         life_gen_001.gif
  magick life_gen_001.gif -define convolve:scale=0.05 \
         -morphology Convolve '3:1,1,1 1,10,1 1,1,1' \
         life_clut.gif -interpolate integer -clut \
         life_gen_002.gif
  magick life_gen_002.gif -define convolve:scale=0.05 \
         -morphology Convolve '3:1,1,1 1,10,1 1,1,1' \
         life_clut.gif -interpolate integer -clut \
         life_gen_003.gif
  magick life_gen_003.gif -define convolve:scale=0.05 \
         -morphology Convolve '3:1,1,1 1,10,1 1,1,1' \
         life_clut.gif -interpolate integer -clut \
         life_gen_004.gif

Ingat, gambar-gambar di atas sudah diperbesar; untuk melihat gambar 'mungil' asli yang dibangkitkan, klik gambar yang diperbesar. Seperti terlihat, pola 'Life' berperilaku sebagaimana mestinya (jika Anda akrab dengan pola-polanya). 'Blinker' di sudut kiri atas berkedip bolak-balik, sedangkan 'glider' di bawah bergerak 1 langkah diagonal ke arahnya selama 4 'generasi' kita mengiterasi aturan life. Dan berikut contoh lebih besar yang dikenal sebagai Gosper's Glider Gun; di sini saya membangkitkan animasi 60 frame dari sebuah pola life khusus. Ukuran sebenarnya gambar yang dipakai ditampilkan di kanan, tetapi saya menskalakan animasi hasilnya agar lebih enak dilihat.

  magick glider_gun.gif life_pattern.gif
  for i in `seq 59`; do
    magick life_pattern.gif -define convolve:scale=0.05 \
           -morphology Convolve '3:1,1,1 1,10,1 1,1,1' \
           life_clut.gif -interpolate integer -clut \
           -write life_pattern.gif miff:-
  done | magick - -scale 500% \
                -set delay 10 -layers Optimize -loop 0  glider_gun_anim.gif
  magick glider_gun.gif -scale 500% life_pattern.gif

Perhatikan bahwa alasan glider 'meledak' di tepi bawah adalah penanganan 'piksel virtual' default yang dipakai convolve, dan hilangnya informasi life saat melewati batas gambar. Gambar pola life lain bisa ditemukan di Life Pattern Catalog, meski gambar-gambarnya perlu diwarnai ulang (dinegasikan) untuk dipakai di pemroses life di atas. Saya serahkan sebagai latihan bagi siapa pun untuk menuangkan langkah di atas ke sebuah skrip yang bisa membangkitkan urutan life untuk gambar masukan tertentu.
Ini hanyalah satu contoh dari seluruh jajaran 'Cellular Automata ' yang bisa diproses IM. Tentu ada banyak program khusus yang lebih cepat untuk 'Life' dan 'Cellular Automata', yang umumnya melakukan hal yang persis sama, tetapi saya ingin menunjukkan bahwa IM cukup lentur untuk melakukannya juga. Karena hasilnya gambar biner sederhana, metode morfologi IM seperti pencarian pola Hit and Miss atau korelasi silang juga bisa dipakai untuk mencari pola life tertentu, membuat pemakaian IM untuk riset life lebih praktis, meski lambat.