Pilih dataset gambar dan terapkan teknik Deteksi Tepi Canny dan Otsu Thresholding untuk segmentasi kontur. Kembangkan algoritma segmentasi gambar yang inovatif yang mengatasi keterbatasan pendekatan tradisional seperti Deteksi Tepi Canny dan Thresholding Otsu. Mempresentasikan algoritma kalian dan membandingkan kinerjanya dengan metode yang sudah ada.
Kode pertama:
import cv2
from google.colab.patches import cv2_imshow
img = cv2.imread('/content/drive/MyDrive/Computer Vision/Tugas/Latihan /Image Enhancement/sample2.png', 0)
cv2_imshow(img)
canny = cv2.Canny(img, 30, 150)
cv2_imshow(canny)
T, thresh1 = cv2.threshold(canny, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
cv2_imshow(thresh1)
kode setelah dikembangkan:
import cv2
import numpy as np
from matplotlib import pyplot as plt
from google.colab.patches import cv2_imshow
img = cv2.imread('/content/drive/MyDrive/Computer Vision/Tugas/Latihan /Canny dan Otsu/posaku.jpg', 0)
edges = cv2.Canny(img, 30, 150)
cv2_imshow(edges)
T, thresh1 = cv2.threshold(edges, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
cv2_imshow(thresh1)
contours, _ = cv2.findContours(thresh1, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
segmentation = np.zeros_like(img)
min_contour_area = 100
for contour in contours:
if cv2.contourArea(contour) > min_contour_area:
cv2.drawContours(segmentation, [contour], -1, 255, thickness=cv2.FILLED)
plt.figure(figsize=(12, 4))
plt.subplot(131), plt.imshow(img, cmap='gray'), plt.title('Citra Asli')
plt.subplot(132), plt.imshow(edges, cmap='gray'), plt title('Hasil Canny')
plt.subplot(133), plt.imshow(segmentation, cmap='gray'), plt.title('Hasil Segmentasi')
plt.show()
Algoritma:
Pertama, gambar dimuat menggunakan OpenCV (cv2.imread). Gambar dibaca dalam mode skala abu-abu (dengan 0 ditetapkan sebagai argumen kedua), sehingga gambar dikonversi menjadi gambar abu-abu.
Selanjutnya, tepi gambar dideteksi menggunakan metode Canny dengan batas bawah 30 dan batas atas 150.
Otsu thresholding kemudian diterapkan ke tepi gambar yang terdeteksi. Otsu thresholding secara otomatis menghitung nilai ambang batas terbaik untuk mengubah gambar menjadi gambar biner.
Kontur kemudian dicari dalam gambar biner yang dihasilkan oleh proses Otsu thresholding menggunakan cv2.findContours. Hasilnya adalah daftar kontur.
Untuk meningkatkan hasil segmentasi, kode tersebut mengulangi daftar kontur dan cv2.contourArea untuk menghapus kontur dengan area yang lebih kecil dari nilai tertentu (di sini 100). Kontur-kontur ini dianggap sebagai noise atau komponen yang kurang relevan dalam segmentasi.
Gambar segmentasi akhirnya dibuat dengan menggambar kontur yang memenuhi syarat pada gambar nol dengan ukuran yang sama dengan gambar asli. Hal ini dilakukan dengan mengisi kontur gambar segmentasi dengan nilai 255 menggunakan cv2.drawContours.
Perbandingannya:
Kode kedua lebih lengkap dengan penambahan operasi pencarian kontur dan penyaringan kontur berdasarkan luasnya. Sehingga pemisahan objek dari latar belakang dalam gambar lebih terlihat.
import cv2
from google.colab.patches import cv2_imshow
img = cv2.imread('/content/drive/MyDrive/Computer Vision/Tugas/Latihan /Image Enhancement/sample2.png', 0)
cv2_imshow(img)
canny = cv2.Canny(img, 30, 150)
cv2_imshow(canny)
T, thresh1 = cv2.threshold(canny, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
cv2_imshow(thresh1)
kode setelah dikembangkan:
import cv2
import numpy as np
from matplotlib import pyplot as plt
from google.colab.patches import cv2_imshow
img = cv2.imread('/content/drive/MyDrive/Computer Vision/Tugas/Latihan /Canny dan Otsu/posaku.jpg', 0)
edges = cv2.Canny(img, 30, 150)
cv2_imshow(edges)
T, thresh1 = cv2.threshold(edges, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
cv2_imshow(thresh1)
contours, _ = cv2.findContours(thresh1, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
segmentation = np.zeros_like(img)
min_contour_area = 100
for contour in contours:
if cv2.contourArea(contour) > min_contour_area:
cv2.drawContours(segmentation, [contour], -1, 255, thickness=cv2.FILLED)
plt.figure(figsize=(12, 4))
plt.subplot(131), plt.imshow(img, cmap='gray'), plt.title('Citra Asli')
plt.subplot(132), plt.imshow(edges, cmap='gray'), plt title('Hasil Canny')
plt.subplot(133), plt.imshow(segmentation, cmap='gray'), plt.title('Hasil Segmentasi')
plt.show()
Algoritma:
Pertama, gambar dimuat menggunakan OpenCV (cv2.imread). Gambar dibaca dalam mode skala abu-abu (dengan 0 ditetapkan sebagai argumen kedua), sehingga gambar dikonversi menjadi gambar abu-abu.
Selanjutnya, tepi gambar dideteksi menggunakan metode Canny dengan batas bawah 30 dan batas atas 150.
Otsu thresholding kemudian diterapkan ke tepi gambar yang terdeteksi. Otsu thresholding secara otomatis menghitung nilai ambang batas terbaik untuk mengubah gambar menjadi gambar biner.
Kontur kemudian dicari dalam gambar biner yang dihasilkan oleh proses Otsu thresholding menggunakan cv2.findContours. Hasilnya adalah daftar kontur.
Untuk meningkatkan hasil segmentasi, kode tersebut mengulangi daftar kontur dan cv2.contourArea untuk menghapus kontur dengan area yang lebih kecil dari nilai tertentu (di sini 100). Kontur-kontur ini dianggap sebagai noise atau komponen yang kurang relevan dalam segmentasi.
Gambar segmentasi akhirnya dibuat dengan menggambar kontur yang memenuhi syarat pada gambar nol dengan ukuran yang sama dengan gambar asli. Hal ini dilakukan dengan mengisi kontur gambar segmentasi dengan nilai 255 menggunakan cv2.drawContours.
Perbandingannya:
Kode kedua lebih lengkap dengan penambahan operasi pencarian kontur dan penyaringan kontur berdasarkan luasnya. Sehingga pemisahan objek dari latar belakang dalam gambar lebih terlihat.
Kodingan yang Anda bagikan adalah sebuah contoh implementasi pemrosesan citra menggunakan Python dengan beberapa library utama, seperti OpenCV, NumPy, Matplotlib, dan Seaborn. Kode ini berfungsi untuk membaca citra, melakukan pra-pemrosesan, deteksi tepi menggunakan Canny, Thresholding Otsu, dan memplot citra serta histogramnya.
import cv2
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
# Baca citra dalam mode grayscale
image = cv2.imread('/content/kucing.jpg', cv2.IMREAD_GRAYSCALE)
imgrgb= cv2.imread('/content/kucing.jpg')
imgrgb = cv2.cvtColor(imgrgb, cv2.COLOR_BGR2RGB)
# Pra-pemrosesan citra - penghalusan menggunakan filter Gaussian
blurred_image = cv2.GaussianBlur(image, (5, 5), 0)
# Deteksi tepi dengan Canny
canny_edge = cv2.Canny(blurred_image, 100, 200)
# Thresholding Otsu
_, otsu_thresh = cv2.threshold(blurred_image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
# Hitung histogram untuk masing-masing citra
hist_original = cv2.calcHist([image], [0], None, [256], [0, 256])
hist_canny = cv2.calcHist([canny_edge], [0], None, [256], [0, 256])
hist_otsu = cv2.calcHist([otsu_thresh], [0], None, [256], [0, 256])
# Plot citra asli, histogram, hasil deteksi tepi Canny, histogram, Thresholding Otsu, dan histogram
plt.figure(figsize=(15, 8))
# Plot citra asli
plt.subplot(231)
plt.imshow(imgrgb, cmap='gray')
plt.title('original image', fontsize=12, color='red', ha='center')
# Plot histogram citra asli
plt.subplot(232)
plt.plot(hist_original, color='blue')
plt.title('Histogram - Original Image')
plt.xlabel('Intensitas')
plt.ylabel('Frekuensi')
# Plot citra hasil deteksi tepi Canny
plt.subplot(233)
plt.imshow(canny_edge, cmap='gray')
plt.title('Canny Edge Detection')
# Plot histogram hasil deteksi tepi Canny
plt.subplot(234)
plt.hist(canny_edge.ravel(), bins=256, range=(0, 256), color='blue', alpha=0.6)
plt.title('Histogram - Canny Edge Detection')
plt.ylabel('Frekuensi')
# Plot citra hasil Thresholding Otsu
plt.subplot(235)
plt.imshow(otsu_thresh, cmap='gray')
plt.title('Otsu Thresholding')
# Plot histogram hasil Thresholding Otsu
plt.subplot(236)
plt.hist(otsu_thresh.ravel(), bins=256, range=(0, 256), color='blue', alpha=0.6)
plt.title('Histogram - Otsu Thresholding')
plt.xlabel('Intensitas')
plt.ylabel('Frekuensi')
# Tampilkan plot tanpa whitegrid
plt.show()
#import beberapa library python
import cv2
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
#membaca citra dalam mode grayscale dan citra RGB
img = cv2.imread('/content/drive/MyDrive/Colab Notebooks/brain.png', cv2.IMREAD_GRAYSCALE)
imgrgb = cv2.imread('/content/drive/MyDrive/Colab Notebooks/brain.png')
imgrgb = cv2.cvtColor(imgrgb, cv2.COLOR_BGR2RGB)
#pre-processing citra menggunakan filter Gaussian
blurred_img = cv2.GaussianBlur(img, (9,9),0)
#deteksi tepi menggunakan Canny
canny_edge = cv2.Canny(blurred_img, 50, 150)
#thresholding otsu dengan nilai ambang batas
_, otsu_thresh = cv2.threshold(blurred_img, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
#menghitung histogram, untuk masing-masing citra
hist_original = cv2.calcHist([img], [0], None, [256], [0, 256])
hist_canny = cv2.calcHist([canny_edge], [0], None, [256], [0, 256])
hist_otsu = cv2.calcHist([otsu_thresh], [0], None, [256], [0, 256])
#menampilkan citra dan histogram
hist_original = cv2.calcHist([img],[0],None,[256],[0,256])
hist_canny = cv2.calcHist([canny_edge],[0],None,[256],[0,256])
hist_otsu = cv2.calcHist([otsu_thresh],[0],None,[256],[0,256])
#plot hasil deteksi tepi canny, histogram, otsu dan citra asli
plt.figure(figsize=(12,6))
#plot citra asli
plt.subplot(2, 3, 2)
plt.imshow(canny_edge, cmap='Oranges')
plt.title('Original image', fontsize=12, color='blue', ha='center')
plt.axis('off')
#plot histogram citra asli
plt.subplot(2, 3, 2)
plt.plot(hist_original, color='blue')
plt.title('Histogram original image', fontsize=12, color='black', ha='center')
plt.xlabel('Intensitas')
plt.ylabel('Frekuensi')
plt.grid(axis='y', linestyle='--', alpha=0.7)
#plot citra hasil deteksi tepi Canny
plt.subplot(2, 3, 3)
plt.imshow(canny_edge, cmap='gray')
plt.title('Canny Edge Detection')
# Plot histogram hasil deteksi tepi Canny
plt.subplot(2, 3, 3)
plt.hist(canny_edge.ravel(), bins=256, range=(0, 256), color='red', alpha=0.7)
plt.title('Histogram Canny Edge Detection')
plt.ylabel('Frekuensi')
# Plot citra hasil Thresholding Otsu
plt.subplot(2, 3, 4)
plt.imshow(otsu_thresh, cmap='gray')
plt.title('Otsu Thresholding', fontsize=12, color='red', ha='center')
plt.axis('off')
# Plot histogram hasil Thresholding Otsu
plt.subplot(2, 3, 5)
plt.hist(otsu_thresh.ravel(), bins=256, range=(0, 256), color='red', alpha=0.7)
plt.title('Histogram Otsu Thresholding', fontsize=12, color='blue', ha='center')
plt.xlabel('Intensitas')
plt.ylabel('Frekuensi')
import cv2
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
#membaca citra dalam mode grayscale dan citra RGB
img = cv2.imread('/content/drive/MyDrive/Colab Notebooks/brain.png', cv2.IMREAD_GRAYSCALE)
imgrgb = cv2.imread('/content/drive/MyDrive/Colab Notebooks/brain.png')
imgrgb = cv2.cvtColor(imgrgb, cv2.COLOR_BGR2RGB)
#pre-processing citra menggunakan filter Gaussian
blurred_img = cv2.GaussianBlur(img, (9,9),0)
#deteksi tepi menggunakan Canny
canny_edge = cv2.Canny(blurred_img, 50, 150)
#thresholding otsu dengan nilai ambang batas
_, otsu_thresh = cv2.threshold(blurred_img, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
#menghitung histogram, untuk masing-masing citra
hist_original = cv2.calcHist([img], [0], None, [256], [0, 256])
hist_canny = cv2.calcHist([canny_edge], [0], None, [256], [0, 256])
hist_otsu = cv2.calcHist([otsu_thresh], [0], None, [256], [0, 256])
#menampilkan citra dan histogram
hist_original = cv2.calcHist([img],[0],None,[256],[0,256])
hist_canny = cv2.calcHist([canny_edge],[0],None,[256],[0,256])
hist_otsu = cv2.calcHist([otsu_thresh],[0],None,[256],[0,256])
#plot hasil deteksi tepi canny, histogram, otsu dan citra asli
plt.figure(figsize=(12,6))
#plot citra asli
plt.subplot(2, 3, 2)
plt.imshow(canny_edge, cmap='Oranges')
plt.title('Original image', fontsize=12, color='blue', ha='center')
plt.axis('off')
#plot histogram citra asli
plt.subplot(2, 3, 2)
plt.plot(hist_original, color='blue')
plt.title('Histogram original image', fontsize=12, color='black', ha='center')
plt.xlabel('Intensitas')
plt.ylabel('Frekuensi')
plt.grid(axis='y', linestyle='--', alpha=0.7)
#plot citra hasil deteksi tepi Canny
plt.subplot(2, 3, 3)
plt.imshow(canny_edge, cmap='gray')
plt.title('Canny Edge Detection')
# Plot histogram hasil deteksi tepi Canny
plt.subplot(2, 3, 3)
plt.hist(canny_edge.ravel(), bins=256, range=(0, 256), color='red', alpha=0.7)
plt.title('Histogram Canny Edge Detection')
plt.ylabel('Frekuensi')
# Plot citra hasil Thresholding Otsu
plt.subplot(2, 3, 4)
plt.imshow(otsu_thresh, cmap='gray')
plt.title('Otsu Thresholding', fontsize=12, color='red', ha='center')
plt.axis('off')
# Plot histogram hasil Thresholding Otsu
plt.subplot(2, 3, 5)
plt.hist(otsu_thresh.ravel(), bins=256, range=(0, 256), color='red', alpha=0.7)
plt.title('Histogram Otsu Thresholding', fontsize=12, color='blue', ha='center')
plt.xlabel('Intensitas')
plt.ylabel('Frekuensi')
import cv2
import numpy as np
import matplotlib.pyplot as plt
# Baca gambar
image = cv2.imread('image1.jpeg', cv2.IMREAD_GRAYSCALE)
# Deteksi tepi Canny
edges_canny = cv2.Canny(image, 100, 200)
# Otsu Thresholding
_, thresh_otsu = cv2.threshold(image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
# Tampilkan gambar hasil
plt.figure(figsize=(12, 6))
plt.subplot(131), plt.imshow(image, cmap='gray'), plt.title('Gambar Asli')
plt.subplot(132), plt.imshow(edges_canny, cmap='gray'), plt.title('Deteksi Tepi Canny')
plt.subplot(133), plt.imshow(thresh_otsu, cmap='gray'), plt.title('Otsu Thresholding')
# Plot histogram
plt.figure(figsize=(12, 4))
plt.subplot(121), plt.hist(image.ravel(), bins=256, range=(0, 256), color='k', alpha=0.7)
plt.title('Histogram Gambar Asli')
plt.xlabel('Intensitas Piksel')
plt.ylabel('Frekuensi')
plt.subplot(122), plt.hist(thresh_otsu.ravel(), bins=256, range=(0, 256), color='k', alpha=0.7)
plt.title('Histogram Setelah Otsu Thresholding')
plt.xlabel('Intensitas Piksel')
plt.ylabel('Frekuensi')
plt.show()
import numpy as np
import matplotlib.pyplot as plt
# Baca gambar
image = cv2.imread('image1.jpeg', cv2.IMREAD_GRAYSCALE)
# Deteksi tepi Canny
edges_canny = cv2.Canny(image, 100, 200)
# Otsu Thresholding
_, thresh_otsu = cv2.threshold(image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
# Tampilkan gambar hasil
plt.figure(figsize=(12, 6))
plt.subplot(131), plt.imshow(image, cmap='gray'), plt.title('Gambar Asli')
plt.subplot(132), plt.imshow(edges_canny, cmap='gray'), plt.title('Deteksi Tepi Canny')
plt.subplot(133), plt.imshow(thresh_otsu, cmap='gray'), plt.title('Otsu Thresholding')
# Plot histogram
plt.figure(figsize=(12, 4))
plt.subplot(121), plt.hist(image.ravel(), bins=256, range=(0, 256), color='k', alpha=0.7)
plt.title('Histogram Gambar Asli')
plt.xlabel('Intensitas Piksel')
plt.ylabel('Frekuensi')
plt.subplot(122), plt.hist(thresh_otsu.ravel(), bins=256, range=(0, 256), color='k', alpha=0.7)
plt.title('Histogram Setelah Otsu Thresholding')
plt.xlabel('Intensitas Piksel')
plt.ylabel('Frekuensi')
plt.show()
Cuplikan layar 2023-10-21 123333.png
In reply to IRMA AMELIA DEWI
Re: Sintesis: Canny dan Otsu
import cv2
import numpy as np
from google.colab.patches import cv2_imshow
# Membaca citra
image = cv2.imread('jantung.jpeg', cv2.IMREAD_GRAYSCALE) # Ubah ke citra grayscale
# Deteksi tepi dengan Canny
edges = cv2.Canny(image, 100, 200) # Mengatur ambang atas dan bawah
# Thresholding Otsu untuk segmentasi kontur
_, otsu_thresholded = cv2.threshold(image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
# Menampilkan citra tepi Canny
cv2_imshow(edges)
# Menampilkan hasil segmentasi Otsu
cv2_imshow(otsu_thresholded)
import numpy as np
from google.colab.patches import cv2_imshow
# Membaca citra
image = cv2.imread('jantung.jpeg', cv2.IMREAD_GRAYSCALE) # Ubah ke citra grayscale
# Deteksi tepi dengan Canny
edges = cv2.Canny(image, 100, 200) # Mengatur ambang atas dan bawah
# Thresholding Otsu untuk segmentasi kontur
_, otsu_thresholded = cv2.threshold(image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
# Menampilkan citra tepi Canny
cv2_imshow(edges)
# Menampilkan hasil segmentasi Otsu
cv2_imshow(otsu_thresholded)
import cv2
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
#membaca citra dalam mode grayscale dan citra RGB
img = cv2.imread('152021031_Ajri Inda Robby.jpg', cv2.IMREAD_GRAYSCALE)
imgrgb = cv2.imread('152021031_Ajri Inda Robby.jpg')
imgrgb = cv2.cvtColor(imgrgb, cv2.COLOR_BGR2RGB)
#pre-processing citra menggunakan filter Gaussian
blurred_img = cv2.GaussianBlur(img, (9,9),0)
#deteksi tepi menggunakan Canny
canny_edge = cv2.Canny(blurred_img, 50, 150)
#thresholding otsu dengan nilai ambang batas
_, otsu_thresh = cv2.threshold(blurred_img, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
#menghitung histogram, untuk masing-masing citra
hist_original = cv2.calcHist([img], [0], None, [256], [0, 256])
hist_canny = cv2.calcHist([canny_edge], [0], None, [256], [0, 256])
hist_otsu = cv2.calcHist([otsu_thresh], [0], None, [256], [0, 256])
#menampilkan citra dan histogram
hist_original = cv2.calcHist([img],[0],None,[256],[0,256])
hist_canny = cv2.calcHist([canny_edge],[0],None,[256],[0,256])
hist_otsu = cv2.calcHist([otsu_thresh],[0],None,[256],[0,256])
#plot hasil deteksi tepi canny, histogram, otsu dan citra asli
plt.figure(figsize=(12,6))
#plot citra asli
plt.subplot(2, 3, 2)
plt.imshow(canny_edge, cmap='Oranges')
plt.title('Original image', fontsize=12, color='blue', ha='center')
plt.axis('off')
#plot histogram citra asli
plt.subplot(2, 3, 2)
plt.plot(hist_original, color='blue')
plt.title('Histogram original image', fontsize=12, color='black', ha='center')
plt.xlabel('Intensitas')
plt.ylabel('Frekuensi')
plt.grid(axis='y', linestyle='--', alpha=0.7)
#plot citra hasil deteksi tepi Canny
plt.subplot(2, 3, 3)
plt.imshow(canny_edge, cmap='gray')
plt.title('Canny Edge Detection')
# Plot histogram hasil deteksi tepi Canny
plt.subplot(2, 3, 3)
plt.hist(canny_edge.ravel(), bins=256, range=(0, 256), color='red', alpha=0.7)
plt.title('Histogram Canny Edge Detection')
plt.ylabel('Frekuensi')
# Plot citra hasil Thresholding Otsu
plt.subplot(2, 3, 4)
plt.imshow(otsu_thresh, cmap='gray')
plt.title('Otsu Thresholding', fontsize=12, color='red', ha='center')
plt.axis('off')
# Plot histogram hasil Thresholding Otsu
plt.subplot(2, 3, 5)
plt.hist(otsu_thresh.ravel(), bins=256, range=(0, 256), color='red', alpha=0.7)
plt.title('Histogram Otsu Thresholding', fontsize=12, color='blue', ha='center')
plt.xlabel('Intensitas')
plt.ylabel('Frekuensi')
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
#membaca citra dalam mode grayscale dan citra RGB
img = cv2.imread('152021031_Ajri Inda Robby.jpg', cv2.IMREAD_GRAYSCALE)
imgrgb = cv2.imread('152021031_Ajri Inda Robby.jpg')
imgrgb = cv2.cvtColor(imgrgb, cv2.COLOR_BGR2RGB)
#pre-processing citra menggunakan filter Gaussian
blurred_img = cv2.GaussianBlur(img, (9,9),0)
#deteksi tepi menggunakan Canny
canny_edge = cv2.Canny(blurred_img, 50, 150)
#thresholding otsu dengan nilai ambang batas
_, otsu_thresh = cv2.threshold(blurred_img, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
#menghitung histogram, untuk masing-masing citra
hist_original = cv2.calcHist([img], [0], None, [256], [0, 256])
hist_canny = cv2.calcHist([canny_edge], [0], None, [256], [0, 256])
hist_otsu = cv2.calcHist([otsu_thresh], [0], None, [256], [0, 256])
#menampilkan citra dan histogram
hist_original = cv2.calcHist([img],[0],None,[256],[0,256])
hist_canny = cv2.calcHist([canny_edge],[0],None,[256],[0,256])
hist_otsu = cv2.calcHist([otsu_thresh],[0],None,[256],[0,256])
#plot hasil deteksi tepi canny, histogram, otsu dan citra asli
plt.figure(figsize=(12,6))
#plot citra asli
plt.subplot(2, 3, 2)
plt.imshow(canny_edge, cmap='Oranges')
plt.title('Original image', fontsize=12, color='blue', ha='center')
plt.axis('off')
#plot histogram citra asli
plt.subplot(2, 3, 2)
plt.plot(hist_original, color='blue')
plt.title('Histogram original image', fontsize=12, color='black', ha='center')
plt.xlabel('Intensitas')
plt.ylabel('Frekuensi')
plt.grid(axis='y', linestyle='--', alpha=0.7)
#plot citra hasil deteksi tepi Canny
plt.subplot(2, 3, 3)
plt.imshow(canny_edge, cmap='gray')
plt.title('Canny Edge Detection')
# Plot histogram hasil deteksi tepi Canny
plt.subplot(2, 3, 3)
plt.hist(canny_edge.ravel(), bins=256, range=(0, 256), color='red', alpha=0.7)
plt.title('Histogram Canny Edge Detection')
plt.ylabel('Frekuensi')
# Plot citra hasil Thresholding Otsu
plt.subplot(2, 3, 4)
plt.imshow(otsu_thresh, cmap='gray')
plt.title('Otsu Thresholding', fontsize=12, color='red', ha='center')
plt.axis('off')
# Plot histogram hasil Thresholding Otsu
plt.subplot(2, 3, 5)
plt.hist(otsu_thresh.ravel(), bins=256, range=(0, 256), color='red', alpha=0.7)
plt.title('Histogram Otsu Thresholding', fontsize=12, color='blue', ha='center')
plt.xlabel('Intensitas')
plt.ylabel('Frekuensi')
import cv2
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
# Baca citra dalam mode grayscale
image = cv2.imread('alif.jpg', cv2.IMREAD_GRAYSCALE)
imgrgb= cv2.imread('alif.jpg')
imgrgb = cv2.cvtColor(imgrgb, cv2.COLOR_BGR2RGB)
# Pra-pemrosesan citra - penghalusan menggunakan filter Gaussian
blurred_image = cv2.GaussianBlur(image, (5, 5), 0)
# Deteksi tepi dengan Canny
canny_edge = cv2.Canny(blurred_image, 100, 200)
# Thresholding Otsu
_, otsu_thresh = cv2.threshold(blurred_image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
# Hitung histogram untuk masing-masing citra
hist_original = cv2.calcHist([image], [0], None, [256], [0, 256])
hist_canny = cv2.calcHist([canny_edge], [0], None, [256], [0, 256])
hist_otsu = cv2.calcHist([otsu_thresh], [0], None, [256], [0, 256])
# Plot citra asli, histogram, hasil deteksi tepi Canny, histogram, Thresholding Otsu, dan histogram
plt.figure(figsize=(15, 8))
# Plot citra asli
plt.subplot(231)
plt.imshow(imgrgb, cmap='gray')
plt.title('Original image')
# Plot histogram citra asli
plt.subplot(232)
plt.plot(hist_original, color='blue')
plt.title('Histogram - Original Image')
plt.xlabel('Intensitas')
plt.ylabel('Frekuensi')
# Plot citra hasil deteksi tepi Canny
plt.subplot(233)
plt.imshow(canny_edge, cmap='gray')
plt.title('Canny Edge Detection')
# Plot histogram hasil deteksi tepi Canny
plt.subplot(234)
plt.hist(canny_edge.ravel(), bins=256, range=(0, 256), color='blue', alpha=0.6)
plt.title('Histogram - Canny Edge Detection')
plt.ylabel('Frekuensi')
# Plot citra hasil Thresholding Otsu
plt.subplot(235)
plt.imshow(otsu_thresh, cmap='gray')
plt.title('Otsu Thresholding')
# Plot histogram hasil Thresholding Otsu
plt.subplot(236)
plt.hist(otsu_thresh.ravel(), bins=256, range=(0, 256), color='blue', alpha=0.6)
plt.title('Histogram - Otsu Thresholding')
plt.xlabel('Intensitas')
plt.ylabel('Frekuensi')
# Tampilkan plot tanpa whitegrid
plt.show()
import cv2
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
# Baca citra dalam mode grayscale
image = cv2.imread('merbabu.jpg', cv2.IMREAD_GRAYSCALE)
imgrgb= cv2.imread('merbabu.jpg')
imgrgb = cv2.cvtColor(imgrgb, cv2.COLOR_BGR2RGB)
# Pra-pemrosesan citra - penghalusan menggunakan filter Gaussian
blurred_image = cv2.GaussianBlur(image, (5, 5), 0)
# Deteksi tepi dengan Canny
canny_edge = cv2.Canny(blurred_image, 100, 200)
# Thresholding Otsu
_, otsu_thresh = cv2.threshold(blurred_image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
# Hitung histogram untuk masing-masing citra
hist_original = cv2.calcHist([image], [0], None, [256], [0, 256])
hist_canny = cv2.calcHist([canny_edge], [0], None, [256], [0, 256])
hist_otsu = cv2.calcHist([otsu_thresh], [0], None, [256], [0, 256])
# Plot citra asli, histogram, hasil deteksi tepi Canny, histogram, Thresholding Otsu, dan histogram
plt.figure(figsize=(15, 8))
# Plot citra asli
plt.subplot(231)
plt.imshow(imgrgb, cmap='gray')
plt.title('Original image')
# Plot histogram citra asli
plt.subplot(232)
plt.plot(hist_original, color='blue')
plt.title('Histogram - Original Image')
plt.xlabel('Intensitas')
plt.ylabel('Frekuensi')
# Plot citra hasil deteksi tepi Canny
plt.subplot(233)
plt.imshow(canny_edge, cmap='gray')
plt.title('Canny Edge Detection')
# Plot histogram hasil deteksi tepi Canny
plt.subplot(234)
plt.hist(canny_edge.ravel(), bins=256, range=(0, 256), color='blue', alpha=0.6)
plt.title('Histogram - Canny Edge Detection')
plt.ylabel('Frekuensi')
# Plot citra hasil Thresholding Otsu
plt.subplot(235)
plt.imshow(otsu_thresh, cmap='gray')
plt.title('Otsu Thresholding')
# Plot histogram hasil Thresholding Otsu
plt.subplot(236)
plt.hist(otsu_thresh.ravel(), bins=256, range=(0, 256), color='blue', alpha=0.6)
plt.title('Histogram - Otsu Thresholding')
plt.xlabel('Intensitas')
plt.ylabel('Frekuensi')
# Tampilkan plot tanpa whitegrid
plt.show()
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
# Baca citra dalam mode grayscale
image = cv2.imread('merbabu.jpg', cv2.IMREAD_GRAYSCALE)
imgrgb= cv2.imread('merbabu.jpg')
imgrgb = cv2.cvtColor(imgrgb, cv2.COLOR_BGR2RGB)
# Pra-pemrosesan citra - penghalusan menggunakan filter Gaussian
blurred_image = cv2.GaussianBlur(image, (5, 5), 0)
# Deteksi tepi dengan Canny
canny_edge = cv2.Canny(blurred_image, 100, 200)
# Thresholding Otsu
_, otsu_thresh = cv2.threshold(blurred_image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
# Hitung histogram untuk masing-masing citra
hist_original = cv2.calcHist([image], [0], None, [256], [0, 256])
hist_canny = cv2.calcHist([canny_edge], [0], None, [256], [0, 256])
hist_otsu = cv2.calcHist([otsu_thresh], [0], None, [256], [0, 256])
# Plot citra asli, histogram, hasil deteksi tepi Canny, histogram, Thresholding Otsu, dan histogram
plt.figure(figsize=(15, 8))
# Plot citra asli
plt.subplot(231)
plt.imshow(imgrgb, cmap='gray')
plt.title('Original image')
# Plot histogram citra asli
plt.subplot(232)
plt.plot(hist_original, color='blue')
plt.title('Histogram - Original Image')
plt.xlabel('Intensitas')
plt.ylabel('Frekuensi')
# Plot citra hasil deteksi tepi Canny
plt.subplot(233)
plt.imshow(canny_edge, cmap='gray')
plt.title('Canny Edge Detection')
# Plot histogram hasil deteksi tepi Canny
plt.subplot(234)
plt.hist(canny_edge.ravel(), bins=256, range=(0, 256), color='blue', alpha=0.6)
plt.title('Histogram - Canny Edge Detection')
plt.ylabel('Frekuensi')
# Plot citra hasil Thresholding Otsu
plt.subplot(235)
plt.imshow(otsu_thresh, cmap='gray')
plt.title('Otsu Thresholding')
# Plot histogram hasil Thresholding Otsu
plt.subplot(236)
plt.hist(otsu_thresh.ravel(), bins=256, range=(0, 256), color='blue', alpha=0.6)
plt.title('Histogram - Otsu Thresholding')
plt.xlabel('Intensitas')
plt.ylabel('Frekuensi')
# Tampilkan plot tanpa whitegrid
plt.show()
# Import library yang diperlukan
import cv2
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
# Baca citra dalam mode grayscale
image = cv2.imread('dota_2_juggernaut.jpeg', cv2.IMREAD_GRAYSCALE)
imgrgb = cv2.imread('dota_2_juggernaut.jpeg')
imgrgb = cv2.cvtColor(imgrgb, cv2.COLOR_BGR2RGB)
# Pra-pemrosesan citra - penghalusan menggunakan filter Gaussian
blurred_image = cv2.GaussianBlur(image, (5, 5), 0)
# Deteksi tepi dengan Canny
canny_edge = cv2.Canny(blurred_image, 100, 200)
# Thresholding Otsu
_, otsu_thresh = cv2.threshold(blurred_image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
# Hitung histogram untuk masing-masing citra
hist_original = cv2.calcHist([image], [0], None, [256], [0, 256])
hist_canny = cv2.calcHist([canny_edge], [0], None, [256], [0, 256])
hist_otsu = cv2.calcHist([otsu_thresh], [0], None, [256], [0, 256])
# Plot citra asli, histogram, hasil deteksi tepi Canny, histogram, Thresholding Otsu, dan histogram
plt.figure(figsize=(15, 8))
# Plot citra asli
plt.subplot(231)
plt.imshow(imgrgb, cmap='gray')
plt.title('Original image')
# Plot histogram citra asli
plt.subplot(232)
plt.plot(hist_original, color='blue')
plt.title('Histogram - Original Image')
plt.xlabel('Intensitas')
plt.ylabel('Frekuensi')
# Plot citra hasil deteksi tepi Canny
plt.subplot(233)
plt.imshow(canny_edge, cmap='gray')
plt.title('Canny Edge Detection')
# Plot histogram hasil deteksi tepi Canny
plt.subplot(234)
plt.hist(canny_edge.ravel(), bins=256, range=(0, 256), color='blue', alpha=0.6)
plt.title('Histogram - Canny Edge Detection')
plt.ylabel('Frekuensi')
# Plot citra hasil Thresholding Otsu
plt.subplot(235)
plt.imshow(otsu_thresh, cmap='gray')
plt.title('Otsu Thresholding')
# Plot histogram hasil Thresholding Otsu
plt.subplot(236)
plt.hist(otsu_thresh.ravel(), bins=256, range=(0, 256), color='blue', alpha=0.6)
plt.title('Histogram - Otsu Thresholding')
plt.xlabel('Intensitas')
plt.ylabel('Frekuensi')
# Tampilkan plot tanpa whitegrid
plt.show()
Nama : Tiani Ayu Lestari
NRP : 992023069
import cv2
import numpy as np
import matplotlib.pyplot as plt
# Membaca citra asli
image = cv2.imread('6.jpg', cv2.IMREAD_GRAYSCALE)
# 1. Deteksi Tepi (Canny)
edges = cv2.Canny(image, threshold1=30, threshold2=100)
# 2. Thresholding (Otsu)
_, thresholded = cv2.threshold(image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
# 3. Menampilkan hasil
plt.figure(figsize=(10, 4))
plt.subplot(131), plt.imshow(image, cmap='gray')
plt.title('Citra Asli'), plt.axis('off')
plt.subplot(132), plt.imshow(edges, cmap='gray')
plt.title('Hasil Deteksi Tepi (Canny)'), plt.axis('off')
plt.subplot(133), plt.imshow(thresholded, cmap='gray')
plt.title('Hasil Thresholding (Otsu)'), plt.axis('off')
plt.show()
Penjelasan:
1. Citra Asli:
- Citra asli adalah citra sumber yang akan di-segmentasi. Ini adalah gambar grayscale yang digunakan sebagai dasar untuk semua proses segmentasi.
2. Hasil Deteksi Tepi (Canny):
- Hasil Deteksi Tepi (Canny) adalah citra yang dihasilkan setelah menerapkan algoritma deteksi tepi Canny pada citra asli. Citra ini menyoroti tepi dan batas objek dalam citra. Tepi-tagi yang tampil dalam gambar ini adalah bagian dari citra di mana intensitas cahaya tiba-tiba berubah, dan citra ini membantu dalam mengidentifikasi batas objek.
3. Hasil Thresholding (Otsu):
- Hasil Thresholding (Otsu) adalah citra yang dihasilkan setelah menerapkan metode thresholding Otsu pada citra asli. Citra ini mengklasifikasikan piksel-piksel menjadi dua kelas, yaitu objek dan latar belakang, berdasarkan ambang batas yang dihitung secara otomatis. Hasil thresholding membantu dalam mengidentifikasi objek dalam citra dengan latar belakang.
4. Kesimpulan:
- Ketiga citra ini ditampilkan menggunakan Matplotlib untuk memvisualisasikan proses segmentasi. Citra asli memberikan pandangan awal sebelum proses segmentasi dimulai. Hasil deteksi tepi (Canny) menyoroti tepi objek dalam citra, sedangkan hasil thresholding (Otsu) memberikan gambar biner yang memisahkan objek dan latar belakang. Kombinasi dari ketiga citra ini memberikan pemahaman visual tentang bagaimana metode deteksi tepi dan thresholding berkontribusi dalam proses segmentasi gambar.
Nama : Dahyoung Yenuargo
NRP : 992023068
import cv2
import numpy as np
import matplotlib.pyplot as plt
# Membaca citra asli
image = cv2.imread('gbr4.jpg', cv2.IMREAD_GRAYSCALE)
# 1. Deteksi Tepi (Canny)
edges = cv2.Canny(image, threshold1=30, threshold2=100)
# 2. Thresholding (Otsu)
_, thresholded = cv2.threshold(image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
# 3. Menampilkan hasil
plt.figure(figsize=(10, 4))
plt.subplot(131), plt.imshow(image, cmap='gray')
plt.title('Citra Asli'), plt.axis('off')
plt.subplot(132), plt.imshow(edges, cmap='gray')
plt.title('Hasil Deteksi Tepi (Canny)'), plt.axis('off')
plt.subplot(133), plt.imshow(thresholded, cmap='gray')
plt.title('Hasil Thresholding (Otsu)'), plt.axis('off')
plt.show()
Penjelasan:
1. Citra Asli:
- Citra asli adalah citra sumber yang akan di-segmentasi. Ini adalah gambar grayscale yang digunakan sebagai dasar untuk semua proses segmentasi.
2. Hasil Deteksi Tepi (Canny):
- Hasil Deteksi Tepi (Canny) adalah citra yang dihasilkan setelah menerapkan algoritma deteksi tepi Canny pada citra asli. Citra ini menyoroti tepi dan batas objek dalam citra. Tepi-tagi yang tampil dalam gambar ini adalah bagian dari citra di mana intensitas cahaya tiba-tiba berubah, dan citra ini membantu dalam mengidentifikasi batas objek.
3. Hasil Thresholding (Otsu):
- Hasil Thresholding (Otsu) adalah citra yang dihasilkan setelah menerapkan metode thresholding Otsu pada citra asli. Citra ini mengklasifikasikan piksel-piksel menjadi dua kelas, yaitu objek dan latar belakang, berdasarkan ambang batas yang dihitung secara otomatis. Hasil thresholding membantu dalam mengidentifikasi objek dalam citra dengan latar belakang.
4. Kesimpulan:
- Ketiga citra ini ditampilkan menggunakan Matplotlib untuk memvisualisasikan proses segmentasi. Citra asli memberikan pandangan awal sebelum proses segmentasi dimulai. Hasil deteksi tepi (Canny) menyoroti tepi objek dalam citra, sedangkan hasil thresholding (Otsu) memberikan gambar biner yang memisahkan objek dan latar belakang. Kombinasi dari ketiga citra ini memberikan pemahaman visual tentang bagaimana metode deteksi tepi dan thresholding berkontribusi dalam proses segmentasi gambar.
Nama : Hardianto
NRP : 992023066
import cv2
import numpy as np
import matplotlib.pyplot as plt
# Membaca citra asli
image = cv2.imread('gbr4.jpg', cv2.IMREAD_GRAYSCALE)
# 1. Deteksi Tepi (Canny)
edges = cv2.Canny(image, threshold1=30, threshold2=100)
# 2. Thresholding (Otsu)
_, thresholded = cv2.threshold(image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
# 3. Menampilkan hasil
plt.figure(figsize=(10, 4))
plt.subplot(131), plt.imshow(image, cmap='gray')
plt.title('Citra Asli'), plt.axis('off')
plt.subplot(132), plt.imshow(edges, cmap='gray')
plt.title('Hasil Deteksi Tepi (Canny)'), plt.axis('off')
plt.subplot(133), plt.imshow(thresholded, cmap='gray')
plt.title('Hasil Thresholding (Otsu)'), plt.axis('off')
plt.show()
Penjelasan:
1. Citra Asli:
Citra asli adalah citra sumber yang akan di-segmentasi. Ini adalah gambar grayscale yang digunakan sebagai dasar untuk semua proses segmentasi.
2. Hasil Deteksi Tepi (Canny):
Hasil Deteksi Tepi (Canny) adalah citra yang dihasilkan setelah menerapkan algoritma deteksi tepi Canny pada citra asli. Citra ini menyoroti tepi dan batas objek dalam citra. Tepi-tagi yang tampil dalam gambar ini adalah bagian dari citra di mana intensitas cahaya tiba-tiba berubah, dan citra ini membantu dalam mengidentifikasi batas objek.
3. Hasil Thresholding (Otsu):
Hasil Thresholding (Otsu) adalah citra yang dihasilkan setelah menerapkan metode thresholding Otsu pada citra asli. Citra ini mengklasifikasikan piksel-piksel menjadi dua kelas, yaitu objek dan latar belakang, berdasarkan ambang batas yang dihitung secara otomatis. Hasil thresholding membantu dalam mengidentifikasi objek dalam citra dengan latar belakang.
4. Kesimpulan:
Ketiga citra ini ditampilkan menggunakan Matplotlib untuk memvisualisasikan proses segmentasi. Citra asli memberikan pandangan awal sebelum proses segmentasi dimulai. Hasil deteksi tepi (Canny) menyoroti tepi objek dalam citra, sedangkan hasil thresholding (Otsu) memberikan gambar biner yang memisahkan objek dan latar belakang. Kombinasi dari ketiga citra ini memberikan pemahaman visual tentang bagaimana metode deteksi tepi dan thresholding berkontribusi dalam proses segmentasi gambar.
NRP : 992023066
import cv2
import numpy as np
import matplotlib.pyplot as plt
# Membaca citra asli
image = cv2.imread('gbr4.jpg', cv2.IMREAD_GRAYSCALE)
# 1. Deteksi Tepi (Canny)
edges = cv2.Canny(image, threshold1=30, threshold2=100)
# 2. Thresholding (Otsu)
_, thresholded = cv2.threshold(image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
# 3. Menampilkan hasil
plt.figure(figsize=(10, 4))
plt.subplot(131), plt.imshow(image, cmap='gray')
plt.title('Citra Asli'), plt.axis('off')
plt.subplot(132), plt.imshow(edges, cmap='gray')
plt.title('Hasil Deteksi Tepi (Canny)'), plt.axis('off')
plt.subplot(133), plt.imshow(thresholded, cmap='gray')
plt.title('Hasil Thresholding (Otsu)'), plt.axis('off')
plt.show()
Penjelasan:
1. Citra Asli:
Citra asli adalah citra sumber yang akan di-segmentasi. Ini adalah gambar grayscale yang digunakan sebagai dasar untuk semua proses segmentasi.
2. Hasil Deteksi Tepi (Canny):
Hasil Deteksi Tepi (Canny) adalah citra yang dihasilkan setelah menerapkan algoritma deteksi tepi Canny pada citra asli. Citra ini menyoroti tepi dan batas objek dalam citra. Tepi-tagi yang tampil dalam gambar ini adalah bagian dari citra di mana intensitas cahaya tiba-tiba berubah, dan citra ini membantu dalam mengidentifikasi batas objek.
3. Hasil Thresholding (Otsu):
Hasil Thresholding (Otsu) adalah citra yang dihasilkan setelah menerapkan metode thresholding Otsu pada citra asli. Citra ini mengklasifikasikan piksel-piksel menjadi dua kelas, yaitu objek dan latar belakang, berdasarkan ambang batas yang dihitung secara otomatis. Hasil thresholding membantu dalam mengidentifikasi objek dalam citra dengan latar belakang.
4. Kesimpulan:
Ketiga citra ini ditampilkan menggunakan Matplotlib untuk memvisualisasikan proses segmentasi. Citra asli memberikan pandangan awal sebelum proses segmentasi dimulai. Hasil deteksi tepi (Canny) menyoroti tepi objek dalam citra, sedangkan hasil thresholding (Otsu) memberikan gambar biner yang memisahkan objek dan latar belakang. Kombinasi dari ketiga citra ini memberikan pemahaman visual tentang bagaimana metode deteksi tepi dan thresholding berkontribusi dalam proses segmentasi gambar.
Di proses Canny Modifikasi saya menambahkan proses contrast linier agar citra menjadi lebih cerah dengan alpha sama dengan alpha awal nya yang membuat peningkatan contrast tidak terlalu kuat menyebabkan tepi objek yang tidak terdeteksi menjadi terdeteksi
import cv2
import numpy as np
from matplotlib import pyplot as plt
from google.colab.patches import cv2_imshow
# Load your image
img = cv2.imread('/content/contoh COMVIS.jpeg', 0)
# Apply Canny edge detection
edges = cv2.Canny(img, 30, 150)
cv2_imshow(edges)
# Apply Otsu's thresholding
T, thresh1 = cv2.threshold(edges, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
cv2_imshow(thresh1)
# Find and draw contours
contours, _ = cv2.findContours(thresh1, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
segmentation = np.zeros_like(img)
min_contour_area = 100
for contour in contours:
if cv2.contourArea(contour) > min_contour_area:
cv2.drawContours(segmentation, [contour], -1, 255, thickness=cv2.FILLED)
# Display the images
plt.figure(figsize=(12, 4))
plt.subplot(131), plt.imshow(img, cmap='gray'), plt.title('Citra Asli')
plt.subplot(132), plt.imshow(edges, cmap='gray'), plt.title('Hasil Canny')
plt.subplot(133), plt.imshow(segmentation, cmap='gray'), plt.title('Hasil Segmentasi')
plt.show()
analisis:
import numpy as np
from matplotlib import pyplot as plt
from google.colab.patches import cv2_imshow
# Load your image
img = cv2.imread('/content/contoh COMVIS.jpeg', 0)
# Apply Canny edge detection
edges = cv2.Canny(img, 30, 150)
cv2_imshow(edges)
# Apply Otsu's thresholding
T, thresh1 = cv2.threshold(edges, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
cv2_imshow(thresh1)
# Find and draw contours
contours, _ = cv2.findContours(thresh1, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
segmentation = np.zeros_like(img)
min_contour_area = 100
for contour in contours:
if cv2.contourArea(contour) > min_contour_area:
cv2.drawContours(segmentation, [contour], -1, 255, thickness=cv2.FILLED)
# Display the images
plt.figure(figsize=(12, 4))
plt.subplot(131), plt.imshow(img, cmap='gray'), plt.title('Citra Asli')
plt.subplot(132), plt.imshow(edges, cmap='gray'), plt.title('Hasil Canny')
plt.subplot(133), plt.imshow(segmentation, cmap='gray'), plt.title('Hasil Segmentasi')
plt.show()
analisis:
-
Membaca Gambar: Pertama, citra dibaca menggunakan OpenCV dengan
cv2.imread. Citra tersebut akan diubah menjadi citra grayscale karena argumen kedua adalah0. Gambar asli kemudian ditampilkan menggunakancv2_imshow. -
Deteksi Tepi Canny: Langkah berikutnya adalah mendeteksi tepi pada citra menggunakan metode Canny dengan
cv2.Canny. Tepi yang terdeteksi kemudian ditampilkan menggunakancv2_imshow. -
Thresholding Otsu: Citra hasil deteksi tepi kemudian ditangani dengan mengaplikasikan metode thresholding Otsu. Nilai threshold ditentukan dengan menggunakan
cv2.thresholddengan modecv2.THRESH_BINARY + cv2.THRESH_OTSU. Hasil thresholding ditampilkan dengancv2_imshow. -
Segmentasi dengan Contours: Citra yang telah di-threshold kemudian digunakan untuk menemukan kontur objek di dalamnya dengan
cv2.findContours. Kemudian, citra segmentasi diinisialisasi sebagai citra nol dengan ukuran yang sama dengan citra asli. Hanya kontur dengan luas di atas batas tertentu (dalam contoh ini, 100) yang akan digambar pada citra segmentasi. Hasil segmentasi kemudian ditampilkan menggunakanplt.imshow. -
Menampilkan Hasil: Hasil akhir dari semua langkah pengolahan citra ditampilkan dalam satu jendela dengan bantuan Matplotlib (
plt.figure). Citra asli, hasil deteksi tepi Canny, dan hasil segmentasi ditampilkan secara bersamaan.
untuk mengembangkan algoritma canny edge, digunakan sebuah proses yaitu contrast linier. Proses ini digunakan untuk mengatasi keterbatasan canny, dengan cara membuat citranya lebih cerah menggunakan nilai alpha yang sama dengan nilai alpha awalnya menggunakan fungsi
con_image = cv2.convertScaleAbs(gray, alpha=2, beta=0) pada python.
Fungsi ini membuat peningkatan kontras tidak terlalu kuat sehingga tepi objek yang asalnya tidak terdeteksi menjadi terdeteksi
Muhammad Arkan Adli
152021168
Disini saya mengembangkan proses algoritma tradisional, menjadi lebih adaptif dan menghasilkan gambar segmentasi yang lebih baik. Menggunakan Mean filter yang bekerja dengan merata-ratakan intensitas piksel di sekitar setiap titik dalam citra, efektif mengurangi noise dan menghilangkan detail kecil yang tidak relevan dalam konteks deteksi tepi. Dengan mengurangi frekuensi tinggi dalam citra, hanya fitur-fitur yang dianggap penting, seperti tepi yang lebih signifikan, yang tetap terlihat setelah proses ini. Pendekatan ini membantu menciptakan citra yang lebih bersih dan lebih fokus pada fitur-fitur utama yang dapat dikenali oleh algoritma deteksi tepi.
Di sisi lain, peregangan kontras berkontribusi pada peningkatan perbedaan intensitas antar piksel, khususnya di sekitar tepi. Dengan membuat tepi lebih tajam, peregangan kontras memfasilitasi proses deteksi tepi seperti yang dilakukan oleh algoritma Canny. Selain itu, peregangan kontras juga berperan dalam menyoroti fitur-fitur yang mungkin sebelumnya kurang terlihat, menjadikannya lebih mudah untuk mengidentifikasi tepi dan batas objek dalam citra. Dengan kombinasi kedua proses ini sebelum deteksi tepi, hasilnya dapat menjadi lebih optimal dalam menangkap dan mempertahankan fitur-fitur tepi yang relevan.
Hasil sebelum : 
Hasil sesudah memakai algoritma :
Dapat dilihat bahwa hasil dari algoritma yang sudah dimodifikasi bisa menentukan tepian yang lebih tepat.
MARTIN HALAWA
152021231
import cv2
import numpy as np
import matplotlib.pyplot as plt
# Mengambil gambar
gambar = cv2.imread('otak.jpg')
# Konversi Citra ke Grayscale
grayscale_image = cv2.cvtColor(gambar, cv2.COLOR_BGR2GRAY)
# Filter Sobel untuk Menghitung Gradien
sobel_x = cv2.Sobel(grayscale_image, cv2.CV_64F, 1, 0, ksize=3)
sobel_y = cv2.Sobel(grayscale_image, cv2.CV_64F, 0, 1, ksize=3)
# Hitung Magnitude Gradien
magnitude = np.sqrt(sobel_x ** 2 + sobel_y ** 2)
tepian_canny_manual = np.uint8(magnitude)
# Melakukan Otsu Thresholding
_, ambang_otsu = cv2.threshold(grayscale_image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
# Menampilkan hasil gambar
plt.figure(figsize=(12, 6))
plt.subplot(131), plt.imshow(grayscale_image, cmap='gray'), plt.title('INPUT')
plt.subplot(132), plt.imshow(tepian_canny_manual, cmap='gray'), plt.title('CANNY EDGE DETECTION')
plt.subplot(133), plt.imshow(ambang_otsu, cmap='gray'), plt.title('OTSU THRESHOLDING')
# Membuat histogram
plt.figure(figsize=(12, 4))
plt.subplot(121), plt.hist(grayscale_image.ravel(), bins=256, range=(0, 256), color='k', alpha=0.7)
plt.title('Histogram Gambar Awal')
plt.xlabel('Intensitas Piksel')
plt.ylabel('Frekuensi')
plt.subplot(122), plt.hist(ambang_otsu.ravel(), bins=256, range=(0, 256), color='k', alpha=0.7)
plt.title('Histogram Setelah Otsu Thresholding')
plt.xlabel('Intensitas Piksel')
plt.ylabel('Frekuensi')
plt.show()
import cv2
import numpy as np
import matplotlib.pyplot as plt
# Mengambil gambar
gambar = cv2.imread('otak.jpg')
# Konversi Citra ke Grayscale
grayscale_image = cv2.cvtColor(gambar, cv2.COLOR_BGR2GRAY)
# Filter Sobel untuk Menghitung Gradien
sobel_x = cv2.Sobel(grayscale_image, cv2.CV_64F, 1, 0, ksize=3)
sobel_y = cv2.Sobel(grayscale_image, cv2.CV_64F, 0, 1, ksize=3)
# Hitung Magnitude Gradien
magnitude = np.sqrt(sobel_x ** 2 + sobel_y ** 2)
tepian_canny_manual = np.uint8(magnitude)
# Melakukan Otsu Thresholding
_, ambang_otsu = cv2.threshold(grayscale_image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
# Menampilkan hasil gambar
plt.figure(figsize=(12, 6))
plt.subplot(131), plt.imshow(grayscale_image, cmap='gray'), plt.title('INPUT')
plt.subplot(132), plt.imshow(tepian_canny_manual, cmap='gray'), plt.title('CANNY EDGE DETECTION')
plt.subplot(133), plt.imshow(ambang_otsu, cmap='gray'), plt.title('OTSU THRESHOLDING')
# Membuat histogram
plt.figure(figsize=(12, 4))
plt.subplot(121), plt.hist(grayscale_image.ravel(), bins=256, range=(0, 256), color='k', alpha=0.7)
plt.title('Histogram Gambar Awal')
plt.xlabel('Intensitas Piksel')
plt.ylabel('Frekuensi')
plt.subplot(122), plt.hist(ambang_otsu.ravel(), bins=256, range=(0, 256), color='k', alpha=0.7)
plt.title('Histogram Setelah Otsu Thresholding')
plt.xlabel('Intensitas Piksel')
plt.ylabel('Frekuensi')
plt.show()
Program ini melakukan dua operasi utama pada gambar menggunakan teknik pengolahan citra: Canny Edge Detection dan Otsu Thresholding.
1. Canny Edge Detection
Algoritma deteksi tepi Canny mengidentifikasi tepi pada gambar. Langkah-langkah deteksi tepi Canny secara manual dalam program ini adalah sebagai berikut:
- Pertama, gambar diubah menjadi citra grayscale.
- Kemudian, operator Sobel digunakan untuk menghitung gradien gambar dalam arah horizontal (`sobel_x`) dan arah vertikal (`sobel_y`).
- Magnitude gradien dihitung menggunakan rumus sqrt(sobel_x^2 + sobel_y^2).
- Hasilnya kemudian diubah kembali ke tipe data uint8 untuk mendapatkan citra hasil deteksi tepi (`tepian_canny_manual`).
2. Otsu Thresholding:
Otsu Thresholding adalah teknik untuk menentukan ambang (threshold) optimal secara otomatis untuk mengklasifikasikan piksel ke dalam dua kelas: latar belakang dan objek. Teknik ini meminimalkan variasi dalam dua kelas tersebut. Dalam program ini, Otsu Thresholding dilakukan secara manual dengan langkah-langkah berikut:
- Histogram gambar awal dihitung.
- Variasi rata-rata intensitas piksel dihitung.
- Ambang Otsu dicari dengan membandingkan variasi antara kelas latar belakang dan objek untuk setiap nilai ambang yang mungkin.
- Gambar asli kemudian di-threshold menggunakan nilai ambang Otsu, menghasilkan citra hasil thresholding (`ambang_otsu_manual`).
Program menampilkan gambar input, hasil deteksi tepi Canny, dan hasil Otsu Thresholding. serta histogram gambar awal dan histogram setelah Otsu Thresholding juga ditampilkan untuk memvisualisasikan distribusi intensitas piksel sebelum dan sesudah proses thresholding.
Nama: Firhan Hafiansyah |152021004
import cv2
import numpy as np
from matplotlib import pyplot as plt
# Membaca citra
image = cv2.imread('hati.jpg') # Gambar asli
# Menampilkan gambar asli
plt.figure(figsize=(12, 6))
plt.subplot(2, 3, 1)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Gambar Asli')
plt.axis('off')
# Konversi gambar ke grayscale
grayscale_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# Deteksi tepi dengan Canny
edges = cv2.Canny(grayscale_image, 100, 200) # Mengatur ambang atas dan bawah
# Menampilkan citra tepi Canny
plt.subplot(2, 3, 2)
plt.imshow(edges, cmap='gray')
plt.title('Citra Tepi Canny')
plt.axis('off')
# Menampilkan histogram citra tepi Canny
plt.subplot(2, 3, 3)
plt.hist(edges.ravel(), 256, [0, 256])
plt.title('Histogram Tepi Canny')
plt.xlabel('Intensitas Piksel')
plt.ylabel('Frekuensi')
# Thresholding Otsu untuk segmentasi kontur
_, otsu_thresholded = cv2.threshold(grayscale_image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
# Menampilkan hasil segmentasi Otsu
plt.subplot(2, 3, 5)
plt.imshow(otsu_thresholded, cmap='gray')
plt.title('Hasil Segmentasi Otsu')
plt.axis('off')
# Menampilkan histogram hasil segmentasi Otsu
plt.subplot(2, 3, 6)
plt.hist(otsu_thresholded.ravel(), 256, [0, 256])
plt.title('Histogram Segmentasi Otsu')
plt.xlabel('Intensitas Piksel')
plt.ylabel('Frekuensi')
plt.tight_layout()
plt.show()
algoritma dijelaskan:
-Membaca Gambar Asli: Gambar asli dibaca dari file 'hati.jpg' menggunakan OpenCV.
-Konversi ke Grayscale: Gambar asli dikonversi ke citra grayscale. Konversi ini mengubah gambar berwarna menjadi gambar hitam putih tanpa informasi warna.
-Deteksi Tepi dengan Canny: Algoritma Canny digunakan untuk mendeteksi tepi pada citra grayscale. Tepi adalah area di mana intensitas piksel berubah secara tajam.
-Thresholding Otsu: Metode thresholding Otsu digunakan untuk mengubah citra grayscale menjadi citra biner (hitam putih) dengan menemukan ambang (threshold) yang optimal. Ambang ini dipilih berdasarkan analisis histogram citra.
-Menampilkan Gambar dan Histogram:
-Gambar Asli: Gambar asli ditampilkan dalam bentuk warna.
-Citra Tepi Canny: Citra tepi Canny (hasil deteksi tepi) ditampilkan dalam bentuk grayscale.
-Histogram Tepi Canny: Histogram intensitas piksel untuk citra tepi Canny ditampilkan.
-Hasil Segmentasi Otsu: Hasil segmentasi Otsu (citra biner) ditampilkan dalam bentuk grayscale.
-Histogram Segmentasi Otsu: Histogram intensitas piksel untuk hasil segmentasi Otsu ditampilkan.
Program ini memberikan visualisasi dari gambar asli, deteksi tepi menggunakan algoritma Canny, hasil segmentasi menggunakan metode thresholding Otsu, serta histogram untuk kedua proses tersebut. Hal ini membantu pengguna untuk memahami perubahan citra yang terjadi melalui setiap langkah pengolahan.
import cv2
import numpy as np
from matplotlib import pyplot as plt
# Membaca citra
image = cv2.imread('hati.jpg') # Gambar asli
# Menampilkan gambar asli
plt.figure(figsize=(12, 6))
plt.subplot(2, 3, 1)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Gambar Asli')
plt.axis('off')
# Konversi gambar ke grayscale
grayscale_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# Deteksi tepi dengan Canny
edges = cv2.Canny(grayscale_image, 100, 200) # Mengatur ambang atas dan bawah
# Menampilkan citra tepi Canny
plt.subplot(2, 3, 2)
plt.imshow(edges, cmap='gray')
plt.title('Citra Tepi Canny')
plt.axis('off')
# Menampilkan histogram citra tepi Canny
plt.subplot(2, 3, 3)
plt.hist(edges.ravel(), 256, [0, 256])
plt.title('Histogram Tepi Canny')
plt.xlabel('Intensitas Piksel')
plt.ylabel('Frekuensi')
# Thresholding Otsu untuk segmentasi kontur
_, otsu_thresholded = cv2.threshold(grayscale_image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
# Menampilkan hasil segmentasi Otsu
plt.subplot(2, 3, 5)
plt.imshow(otsu_thresholded, cmap='gray')
plt.title('Hasil Segmentasi Otsu')
plt.axis('off')
# Menampilkan histogram hasil segmentasi Otsu
plt.subplot(2, 3, 6)
plt.hist(otsu_thresholded.ravel(), 256, [0, 256])
plt.title('Histogram Segmentasi Otsu')
plt.xlabel('Intensitas Piksel')
plt.ylabel('Frekuensi')
plt.tight_layout()
plt.show()
algoritma dijelaskan:
-Membaca Gambar Asli: Gambar asli dibaca dari file 'hati.jpg' menggunakan OpenCV.
-Konversi ke Grayscale: Gambar asli dikonversi ke citra grayscale. Konversi ini mengubah gambar berwarna menjadi gambar hitam putih tanpa informasi warna.
-Deteksi Tepi dengan Canny: Algoritma Canny digunakan untuk mendeteksi tepi pada citra grayscale. Tepi adalah area di mana intensitas piksel berubah secara tajam.
-Thresholding Otsu: Metode thresholding Otsu digunakan untuk mengubah citra grayscale menjadi citra biner (hitam putih) dengan menemukan ambang (threshold) yang optimal. Ambang ini dipilih berdasarkan analisis histogram citra.
-Menampilkan Gambar dan Histogram:
-Gambar Asli: Gambar asli ditampilkan dalam bentuk warna.
-Citra Tepi Canny: Citra tepi Canny (hasil deteksi tepi) ditampilkan dalam bentuk grayscale.
-Histogram Tepi Canny: Histogram intensitas piksel untuk citra tepi Canny ditampilkan.
-Hasil Segmentasi Otsu: Hasil segmentasi Otsu (citra biner) ditampilkan dalam bentuk grayscale.
-Histogram Segmentasi Otsu: Histogram intensitas piksel untuk hasil segmentasi Otsu ditampilkan.
Program ini memberikan visualisasi dari gambar asli, deteksi tepi menggunakan algoritma Canny, hasil segmentasi menggunakan metode thresholding Otsu, serta histogram untuk kedua proses tersebut. Hal ini membantu pengguna untuk memahami perubahan citra yang terjadi melalui setiap langkah pengolahan.
Nama : Dhevan Fasya R
NRP : 152021030
import cv2
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
image = cv2.imread('/content/serigala.jpg', cv2.IMREAD_GRAYSCALE)
imgrgb = cv2.imread('/content/serigala.jpg')
imgrgb = cv2.cvtColor(imgrgb, cv2.COLOR_BGR2RGB)
# Pra-pemrosesan citra - penghalusan menggunakan filter Gaussian
blurred_image = cv2.GaussianBlur(image, (5, 5), 0)
# Deteksi tepi dengan Canny
canny_edge = cv2.Canny(blurred_image, 100, 200)
# Thresholding Otsu
_, otsu_thresh = cv2.threshold(blurred_image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
hist_original = cv2.calcHist([image], [0], None, [256], [0, 256])
hist_canny = cv2.calcHist([canny_edge], [0], None, [256], [0, 256])
hist_otsu = cv2.calcHist([otsu_thresh], [0], None, [256], [0, 256])
plt.figure(figsize=(15, 8))
# citra asli
plt.subplot(231)
plt.imshow(imgrgb, cmap='gray')
plt.title('GAMBAR ASLI')
# histogram citra asli
plt.subplot(232)
plt.plot(hist_original, color='blue')
plt.title('Histogram - Original Image')
plt.xlabel('Intensitas')
plt.ylabel('Frekuensi')
# Plot citra hasil deteksi tepi Canny
plt.subplot(233)
plt.imshow(canny_edge, cmap='gray')
plt.title('Canny Edge Detection')
# Plot histogram hasil deteksi tepi Canny
plt.subplot(234)
plt.hist(canny_edge.ravel(), bins=256, range=(0, 256), color='blue', alpha=0.6)
plt.title('Histogram - Canny Edge Detection')
plt.ylabel('Frekuensi')
# Plot citra hasil Thresholding Otsu
plt.subplot(235)
plt.imshow(otsu_thresh, cmap='gray')
plt.title('Otsu Thresholding')
# Plot histogram hasil Thresholding Otsu
plt.subplot(236)
plt.hist(otsu_thresh.ravel(), bins=256, range=(0, 256), color='blue', alpha=0.6)
plt.title('Histogram - Otsu Thresholding')
plt.xlabel('Intensitas')
plt.ylabel('Frekuensi')
plt.show()
import cv2
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
image = cv2.imread('/content/serigala.jpg', cv2.IMREAD_GRAYSCALE)
imgrgb = cv2.imread('/content/serigala.jpg')
imgrgb = cv2.cvtColor(imgrgb, cv2.COLOR_BGR2RGB)
# Pra-pemrosesan citra - penghalusan menggunakan filter Gaussian
blurred_image = cv2.GaussianBlur(image, (5, 5), 0)
# Deteksi tepi dengan Canny
canny_edge = cv2.Canny(blurred_image, 100, 200)
# Thresholding Otsu
_, otsu_thresh = cv2.threshold(blurred_image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
hist_original = cv2.calcHist([image], [0], None, [256], [0, 256])
hist_canny = cv2.calcHist([canny_edge], [0], None, [256], [0, 256])
hist_otsu = cv2.calcHist([otsu_thresh], [0], None, [256], [0, 256])
plt.figure(figsize=(15, 8))
# citra asli
plt.subplot(231)
plt.imshow(imgrgb, cmap='gray')
plt.title('GAMBAR ASLI')
# histogram citra asli
plt.subplot(232)
plt.plot(hist_original, color='blue')
plt.title('Histogram - Original Image')
plt.xlabel('Intensitas')
plt.ylabel('Frekuensi')
# Plot citra hasil deteksi tepi Canny
plt.subplot(233)
plt.imshow(canny_edge, cmap='gray')
plt.title('Canny Edge Detection')
# Plot histogram hasil deteksi tepi Canny
plt.subplot(234)
plt.hist(canny_edge.ravel(), bins=256, range=(0, 256), color='blue', alpha=0.6)
plt.title('Histogram - Canny Edge Detection')
plt.ylabel('Frekuensi')
# Plot citra hasil Thresholding Otsu
plt.subplot(235)
plt.imshow(otsu_thresh, cmap='gray')
plt.title('Otsu Thresholding')
# Plot histogram hasil Thresholding Otsu
plt.subplot(236)
plt.hist(otsu_thresh.ravel(), bins=256, range=(0, 256), color='blue', alpha=0.6)
plt.title('Histogram - Otsu Thresholding')
plt.xlabel('Intensitas')
plt.ylabel('Frekuensi')
plt.show()
import cv2
import numpy as np
from google.colab.patches import cv2_imshow
import matplotlib.pyplot as plt
# Baca gambar
image = cv2.imread('1337745.jpeg')
# Deteksi Tepi dengan Canny
canny_edges = cv2.Canny(image, 50, 150)
# Konversi gambar ke ruang warna keabuan (grayscale) untuk Otsu Thresholding
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
_, otsu_threshold = cv2.threshold(gray_image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
# Plot histogram
def plot_histogram(img, title):
plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
plt.title(title)
plt.subplot(1, 2, 2)
plt.hist(img.flatten(), bins=256, range=[0, 256], color='r', alpha=0.5)
plt.title('Histogram')
plt.show()
# Tampilkan histogram untuk setiap gambar
plot_histogram(image, 'Original Image')
plot_histogram(canny_edges, 'Canny Edges')
plot_histogram(otsu_threshold, 'Otsu Thresholding')
import numpy as np
from google.colab.patches import cv2_imshow
import matplotlib.pyplot as plt
# Baca gambar
image = cv2.imread('1337745.jpeg')
# Deteksi Tepi dengan Canny
canny_edges = cv2.Canny(image, 50, 150)
# Konversi gambar ke ruang warna keabuan (grayscale) untuk Otsu Thresholding
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
_, otsu_threshold = cv2.threshold(gray_image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
# Plot histogram
def plot_histogram(img, title):
plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
plt.title(title)
plt.subplot(1, 2, 2)
plt.hist(img.flatten(), bins=256, range=[0, 256], color='r', alpha=0.5)
plt.title('Histogram')
plt.show()
# Tampilkan histogram untuk setiap gambar
plot_histogram(image, 'Original Image')
plot_histogram(canny_edges, 'Canny Edges')
plot_histogram(otsu_threshold, 'Otsu Thresholding')
import cv2
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
# Baca citra dalam mode grayscale
image = cv2.imread('152021034 GERY AKBAR FIRMANSYAH.jpg', cv2.IMREAD_GRAYSCALE)
imgrgb= cv2.imread('152021034 GERY AKBAR FIRMANSYAH.jpg')
imgrgb = cv2.cvtColor(imgrgb, cv2.COLOR_BGR2RGB)
# Pra-pemrosesan citra - penghalusan menggunakan filter Gaussian
blurred_image = cv2.GaussianBlur(image, (5, 5), 0)
# Deteksi tepi dengan Canny
canny_edge = cv2.Canny(blurred_image, 100, 200)
# Thresholding Otsu
_, otsu_thresh = cv2.threshold(blurred_image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
# Hitung histogram untuk masing-masing citra
hist_original = cv2.calcHist([image], [0], None, [256], [0, 256])
hist_canny = cv2.calcHist([canny_edge], [0], None, [256], [0, 256])
hist_otsu = cv2.calcHist([otsu_thresh], [0], None, [256], [0, 256])
# Plot citra asli, histogram, hasil deteksi tepi Canny, histogram, Thresholding Otsu, dan histogram
plt.figure(figsize=(15, 8))
# Plot citra asli
plt.subplot(231)
plt.imshow(imgrgb, cmap='gray')
plt.title('Original image')
# Plot histogram citra asli
plt.subplot(232)
plt.plot(hist_original, color='blue')
plt.title('Histogram - Original Image')
plt.xlabel('Intensitas')
plt.ylabel('Frekuensi')
# Plot citra hasil deteksi tepi Canny
plt.subplot(233)
plt.imshow(canny_edge, cmap='gray')
plt.title('Canny Edge Detection')
# Plot histogram hasil deteksi tepi Canny
plt.subplot(234)
plt.hist(canny_edge.ravel(), bins=256, range=(0, 256), color='blue', alpha=0.6)
plt.title('Histogram - Canny Edge Detection')
plt.ylabel('Frekuensi')
# Plot citra hasil Thresholding Otsu
plt.subplot(235)
plt.imshow(otsu_thresh, cmap='gray')
plt.title('Otsu Thresholding')
# Plot histogram hasil Thresholding Otsu
plt.subplot(236)
plt.hist(otsu_thresh.ravel(), bins=256, range=(0, 256), color='blue', alpha=0.6)
plt.title('Histogram - Otsu Thresholding')
plt.xlabel('Intensitas')
plt.ylabel('Frekuensi')
# Tampilkan plot tanpa whitegrid
plt.show()
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
# Baca citra dalam mode grayscale
image = cv2.imread('152021034 GERY AKBAR FIRMANSYAH.jpg', cv2.IMREAD_GRAYSCALE)
imgrgb= cv2.imread('152021034 GERY AKBAR FIRMANSYAH.jpg')
imgrgb = cv2.cvtColor(imgrgb, cv2.COLOR_BGR2RGB)
# Pra-pemrosesan citra - penghalusan menggunakan filter Gaussian
blurred_image = cv2.GaussianBlur(image, (5, 5), 0)
# Deteksi tepi dengan Canny
canny_edge = cv2.Canny(blurred_image, 100, 200)
# Thresholding Otsu
_, otsu_thresh = cv2.threshold(blurred_image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
# Hitung histogram untuk masing-masing citra
hist_original = cv2.calcHist([image], [0], None, [256], [0, 256])
hist_canny = cv2.calcHist([canny_edge], [0], None, [256], [0, 256])
hist_otsu = cv2.calcHist([otsu_thresh], [0], None, [256], [0, 256])
# Plot citra asli, histogram, hasil deteksi tepi Canny, histogram, Thresholding Otsu, dan histogram
plt.figure(figsize=(15, 8))
# Plot citra asli
plt.subplot(231)
plt.imshow(imgrgb, cmap='gray')
plt.title('Original image')
# Plot histogram citra asli
plt.subplot(232)
plt.plot(hist_original, color='blue')
plt.title('Histogram - Original Image')
plt.xlabel('Intensitas')
plt.ylabel('Frekuensi')
# Plot citra hasil deteksi tepi Canny
plt.subplot(233)
plt.imshow(canny_edge, cmap='gray')
plt.title('Canny Edge Detection')
# Plot histogram hasil deteksi tepi Canny
plt.subplot(234)
plt.hist(canny_edge.ravel(), bins=256, range=(0, 256), color='blue', alpha=0.6)
plt.title('Histogram - Canny Edge Detection')
plt.ylabel('Frekuensi')
# Plot citra hasil Thresholding Otsu
plt.subplot(235)
plt.imshow(otsu_thresh, cmap='gray')
plt.title('Otsu Thresholding')
# Plot histogram hasil Thresholding Otsu
plt.subplot(236)
plt.hist(otsu_thresh.ravel(), bins=256, range=(0, 256), color='blue', alpha=0.6)
plt.title('Histogram - Otsu Thresholding')
plt.xlabel('Intensitas')
plt.ylabel('Frekuensi')
# Tampilkan plot tanpa whitegrid
plt.show()
import cv2
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
# Baca citra dalam mode grayscale
image = cv2.imread('/content/anime.jpg', cv2.IMREAD_GRAYSCALE)
imgrgb= cv2.imread('/content/anime.jpg')
imgrgb = cv2.cvtColor(imgrgb, cv2.COLOR_BGR2RGB)
# Pra-pemrosesan citra - penghalusan menggunakan filter Gaussian
blurred_image = cv2.GaussianBlur(image, (5, 5), 0)
# Deteksi tepi dengan Canny
canny_edge = cv2.Canny(blurred_image, 100, 200)
# Thresholding Otsu
_, otsu_thresh = cv2.threshold(blurred_image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
# Hitung histogram untuk masing-masing citra
hist_original = cv2.calcHist([image], [0], None, [256], [0, 256])
hist_canny = cv2.calcHist([canny_edge], [0], None, [256], [0, 256])
hist_otsu = cv2.calcHist([otsu_thresh], [0], None, [256], [0, 256])
# Plot citra asli, histogram, hasil deteksi tepi Canny, histogram, Thresholding Otsu, dan histogram
plt.figure(figsize=(15, 8))
# Plot citra asli
plt.subplot(231)
plt.imshow(imgrgb, cmap='gray')
plt.title('original image', fontsize=12, color='red', ha='center')
# Plot histogram citra asli
plt.subplot(232)
plt.plot(hist_original, color='blue')
plt.title('Histogram - Original Image')
plt.xlabel('Intensitas')
plt.ylabel('Frekuensi')
# Plot citra hasil deteksi tepi Canny
plt.subplot(233)
plt.imshow(canny_edge, cmap='gray')
plt.title('Canny Edge Detection')
# Plot histogram hasil deteksi tepi Canny
plt.subplot(234)
plt.hist(canny_edge.ravel(), bins=256, range=(0, 256), color='blue', alpha=0.6)
plt.title('Histogram - Canny Edge Detection')
plt.ylabel('Frekuensi')
# Plot citra hasil Thresholding Otsu
plt.subplot(235)
plt.imshow(otsu_thresh, cmap='gray')
plt.title('Otsu Thresholding')
# Plot histogram hasil Thresholding Otsu
plt.subplot(236)
plt.hist(otsu_thresh.ravel(), bins=256, range=(0, 256), color='blue', alpha=0.6)
plt.title('Histogram - Otsu Thresholding')
plt.xlabel('Intensitas')
plt.ylabel('Frekuensi')
# Tampilkan plot tanpa whitegrid
plt.show()
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
# Baca citra dalam mode grayscale
image = cv2.imread('/content/anime.jpg', cv2.IMREAD_GRAYSCALE)
imgrgb= cv2.imread('/content/anime.jpg')
imgrgb = cv2.cvtColor(imgrgb, cv2.COLOR_BGR2RGB)
# Pra-pemrosesan citra - penghalusan menggunakan filter Gaussian
blurred_image = cv2.GaussianBlur(image, (5, 5), 0)
# Deteksi tepi dengan Canny
canny_edge = cv2.Canny(blurred_image, 100, 200)
# Thresholding Otsu
_, otsu_thresh = cv2.threshold(blurred_image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
# Hitung histogram untuk masing-masing citra
hist_original = cv2.calcHist([image], [0], None, [256], [0, 256])
hist_canny = cv2.calcHist([canny_edge], [0], None, [256], [0, 256])
hist_otsu = cv2.calcHist([otsu_thresh], [0], None, [256], [0, 256])
# Plot citra asli, histogram, hasil deteksi tepi Canny, histogram, Thresholding Otsu, dan histogram
plt.figure(figsize=(15, 8))
# Plot citra asli
plt.subplot(231)
plt.imshow(imgrgb, cmap='gray')
plt.title('original image', fontsize=12, color='red', ha='center')
# Plot histogram citra asli
plt.subplot(232)
plt.plot(hist_original, color='blue')
plt.title('Histogram - Original Image')
plt.xlabel('Intensitas')
plt.ylabel('Frekuensi')
# Plot citra hasil deteksi tepi Canny
plt.subplot(233)
plt.imshow(canny_edge, cmap='gray')
plt.title('Canny Edge Detection')
# Plot histogram hasil deteksi tepi Canny
plt.subplot(234)
plt.hist(canny_edge.ravel(), bins=256, range=(0, 256), color='blue', alpha=0.6)
plt.title('Histogram - Canny Edge Detection')
plt.ylabel('Frekuensi')
# Plot citra hasil Thresholding Otsu
plt.subplot(235)
plt.imshow(otsu_thresh, cmap='gray')
plt.title('Otsu Thresholding')
# Plot histogram hasil Thresholding Otsu
plt.subplot(236)
plt.hist(otsu_thresh.ravel(), bins=256, range=(0, 256), color='blue', alpha=0.6)
plt.title('Histogram - Otsu Thresholding')
plt.xlabel('Intensitas')
plt.ylabel('Frekuensi')
# Tampilkan plot tanpa whitegrid
plt.show()
import cv2
import numpy as np
from matplotlib import pyplot as plt
img = cv2.imread('/content/drive/MyDrive/Computer Vision/Tugas/Latihan /Canny dan Otsu/posaku.jpg', 0)
edges = cv2.Canny(img, 30, 150)
T, thresh1 = cv2.threshold(edges, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
contours, _ = cv2.findContours(thresh1, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
segmentation = np.zeros_like(img)
min_contour_area = 100
for contour in contours:
if cv2.contourArea(contour) > min_contour_area:
cv2.drawContours(segmentation, [contour], -1, 255, thickness=cv2.FILLED)
plt.figure(figsize=(12, 4))
plt.subplot(131), plt.imshow(img, cmap='gray'), plt.title('Citra Asli')
plt.subplot(132), plt.imshow(edges, cmap='gray'), plt.title('Hasil Canny')
plt.subplot(133), plt.imshow(segmentation, cmap='gray'), plt.title('Hasil Segmentasi')
plt.show()
Penjelasan dan Langkah :
1. Mengimpor Modul: Kode dimulai dengan mengimpor modul yang diperlukan, termasuk modul cv2 untuk pemrosesan citra, numpy untuk operasi array, dan pyplot dari matplotlib untuk menampilkan gambar.
2. Membaca Citra: Citra asli dibaca menggunakan cv2.imread dari lokasi yang sesuai. Citra ini akan digunakan sebagai input untuk proses selanjutnya.
3. Deteksi Tepi (Canny): Citra asli diolah menggunakan metode deteksi tepi Canny dengan memanggil cv2.Canny. Ini menghasilkan citra tepi dengan mengidentifikasi tepi dalam citra.
4. Thresholding (Otsu): Citra tepi kemudian dikenai thresholding Otsu menggunakan metode cv2.threshold untuk menghasilkan citra biner yang mengidentifikasi objek dalam citra.
5. Pencarian Kontur: Citra hasil thresholding diolah untuk mencari kontur menggunakan cv2.findContours. Kontur yang ditemukan akan digunakan untuk segmentasi.
6. Segmentasi: Sebuah citra kosong yang sama ukuran dengan citra asli dibuat. Kontur-kontur yang sesuai dengan kriteria tertentu (dalam hal ini, dengan area di atas ambang tertentu) digambar pada citra ini dengan warna putih.
7. Menampilkan Hasil: Hasil segmentasi ditampilkan menggunakan pyplot. Ada tiga gambar yang ditampilkan: citra asli, citra hasil deteksi tepi Canny, dan citra hasil segmentasi yang menyoroti objek dalam citra.
import numpy as np
from matplotlib import pyplot as plt
img = cv2.imread('/content/drive/MyDrive/Computer Vision/Tugas/Latihan /Canny dan Otsu/posaku.jpg', 0)
edges = cv2.Canny(img, 30, 150)
T, thresh1 = cv2.threshold(edges, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
contours, _ = cv2.findContours(thresh1, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
segmentation = np.zeros_like(img)
min_contour_area = 100
for contour in contours:
if cv2.contourArea(contour) > min_contour_area:
cv2.drawContours(segmentation, [contour], -1, 255, thickness=cv2.FILLED)
plt.figure(figsize=(12, 4))
plt.subplot(131), plt.imshow(img, cmap='gray'), plt.title('Citra Asli')
plt.subplot(132), plt.imshow(edges, cmap='gray'), plt.title('Hasil Canny')
plt.subplot(133), plt.imshow(segmentation, cmap='gray'), plt.title('Hasil Segmentasi')
plt.show()
Penjelasan dan Langkah :
1. Mengimpor Modul: Kode dimulai dengan mengimpor modul yang diperlukan, termasuk modul cv2 untuk pemrosesan citra, numpy untuk operasi array, dan pyplot dari matplotlib untuk menampilkan gambar.
2. Membaca Citra: Citra asli dibaca menggunakan cv2.imread dari lokasi yang sesuai. Citra ini akan digunakan sebagai input untuk proses selanjutnya.
3. Deteksi Tepi (Canny): Citra asli diolah menggunakan metode deteksi tepi Canny dengan memanggil cv2.Canny. Ini menghasilkan citra tepi dengan mengidentifikasi tepi dalam citra.
4. Thresholding (Otsu): Citra tepi kemudian dikenai thresholding Otsu menggunakan metode cv2.threshold untuk menghasilkan citra biner yang mengidentifikasi objek dalam citra.
5. Pencarian Kontur: Citra hasil thresholding diolah untuk mencari kontur menggunakan cv2.findContours. Kontur yang ditemukan akan digunakan untuk segmentasi.
6. Segmentasi: Sebuah citra kosong yang sama ukuran dengan citra asli dibuat. Kontur-kontur yang sesuai dengan kriteria tertentu (dalam hal ini, dengan area di atas ambang tertentu) digambar pada citra ini dengan warna putih.
7. Menampilkan Hasil: Hasil segmentasi ditampilkan menggunakan pyplot. Ada tiga gambar yang ditampilkan: citra asli, citra hasil deteksi tepi Canny, dan citra hasil segmentasi yang menyoroti objek dalam citra.
import cv2
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import cv2
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
# Baca citra dalam mode grayscale
image = cv2.imread('botol.jpg', cv2.IMREAD_GRAYSCALE)
imgrgb= cv2.imread('botol.jpg')
imgrgb = cv2.cvtColor(imgrgb, cv2.COLOR_BGR2RGB)
# Pra-pemrosesan citra - penghalusan menggunakan filter Gaussian
blurred_image = cv2.GaussianBlur(image, (5, 5), 0)
# Deteksi tepi dengan Canny
canny_edge = cv2.Canny(blurred_image, 100, 200)
# Thresholding Otsu
_, otsu_thresh = cv2.threshold(blurred_image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
# Hitung histogram untuk masing-masing citra
hist_original = cv2.calcHist([image], [0], None, [256], [0, 256])
hist_canny = cv2.calcHist([canny_edge], [0], None, [256], [0, 256])
hist_otsu = cv2.calcHist([otsu_thresh], [0], None, [256], [0, 256])
# Plot citra asli, histogram, hasil deteksi tepi Canny, histogram, Thresholding Otsu, dan histogram
plt.figure(figsize=(15, 8))
# Plot citra asli
plt.subplot(231)
plt.imshow(imgrgb, cmap='gray')
plt.title('original image', fontsize=12, color='red', ha='center')
# Plot histogram citra asli
plt.subplot(232)
plt.plot(hist_original, color='blue')
plt.title('Histogram - Original Image')
plt.xlabel('Intensitas')
plt.ylabel('Frekuensi')
# Plot citra hasil deteksi tepi Canny
plt.subplot(233)
plt.imshow(canny_edge, cmap='gray')
plt.title('Canny Edge Detection')
# Plot histogram hasil deteksi tepi Canny
plt.subplot(234)
plt.hist(canny_edge.ravel(), bins=256, range=(0, 256), color='blue', alpha=0.6)
plt.title('Histogram - Canny Edge Detection')
plt.ylabel('Frekuensi')
# Plot citra hasil Thresholding Otsu
plt.subplot(235)
plt.imshow(otsu_thresh, cmap='gray')
plt.title('Otsu Thresholding')
# Plot histogram hasil Thresholding Otsu
plt.subplot(236)
plt.hist(otsu_thresh.ravel(), bins=256, range=(0, 256), color='blue', alpha=0.6)
plt.title('Histogram - Otsu Thresholding')
plt.xlabel('Intensitas')
plt.ylabel('Frekuensi')
# Tampilkan plot tanpa whitegrid
plt.show()
import cv2
import numpy as np
import matplotlib.pyplot as plt
# Baca citra
image = cv2.imread('jantung.jpeg', cv2.IMREAD_GRAYSCALE) # Ganti 'citra.jpg' dengan nama file citra Anda
# Deteksi tepi menggunakan algoritma Canny
edges = cv2.Canny(image, 100, 200) # 100 dan 200 adalah ambang bawah dan atas
# Hitung histogram citra
hist = cv2.calcHist([image], [0], None, [256], [0, 256])
# Pemambangan ambang Otsu
ret, otsu_threshold = cv2.threshold(image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
# Hitung histogram citra hasil pemambangan Otsu
otsu_hist = cv2.calcHist([otsu_threshold], [0], None, [256], [0, 256])
# Hitung histogram citra hasil deteksi tepi Canny
edges_hist = cv2.calcHist([edges], [0], None, [256], [0, 256])
# Plot citra asli, tepi Canny, dan hasil pemambangan Otsu
plt.figure(figsize=(12, 8))
plt.subplot(231), plt.imshow(image, cmap='gray'), plt.title('Citra Asli')
plt.subplot(232), plt.imshow(edges, cmap='gray'), plt.title('Hasil Canny Edge Detection')
plt.subplot(233), plt.imshow(otsu_threshold, cmap='gray'), plt.title('Hasil Pemambangan Otsu')
plt.subplot(234), plt.plot(hist), plt.title('Histogram Citra Asli')
plt.subplot(235), plt.plot(edges_hist), plt.title('Histogram Canny Edge Detection')
plt.subplot(236), plt.plot(otsu_hist), plt.title('Histogram Pemambangan Otsu')
plt.show()
import numpy as np
import matplotlib.pyplot as plt
# Baca citra
image = cv2.imread('jantung.jpeg', cv2.IMREAD_GRAYSCALE) # Ganti 'citra.jpg' dengan nama file citra Anda
# Deteksi tepi menggunakan algoritma Canny
edges = cv2.Canny(image, 100, 200) # 100 dan 200 adalah ambang bawah dan atas
# Hitung histogram citra
hist = cv2.calcHist([image], [0], None, [256], [0, 256])
# Pemambangan ambang Otsu
ret, otsu_threshold = cv2.threshold(image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
# Hitung histogram citra hasil pemambangan Otsu
otsu_hist = cv2.calcHist([otsu_threshold], [0], None, [256], [0, 256])
# Hitung histogram citra hasil deteksi tepi Canny
edges_hist = cv2.calcHist([edges], [0], None, [256], [0, 256])
# Plot citra asli, tepi Canny, dan hasil pemambangan Otsu
plt.figure(figsize=(12, 8))
plt.subplot(231), plt.imshow(image, cmap='gray'), plt.title('Citra Asli')
plt.subplot(232), plt.imshow(edges, cmap='gray'), plt.title('Hasil Canny Edge Detection')
plt.subplot(233), plt.imshow(otsu_threshold, cmap='gray'), plt.title('Hasil Pemambangan Otsu')
plt.subplot(234), plt.plot(hist), plt.title('Histogram Citra Asli')
plt.subplot(235), plt.plot(edges_hist), plt.title('Histogram Canny Edge Detection')
plt.subplot(236), plt.plot(otsu_hist), plt.title('Histogram Pemambangan Otsu')
plt.show()
Canny Edge Detection:
Kelebihan:
Canny menghasilkan tepi yang tajam dan halus. Ini berguna untuk aplikasi seperti pengenalan objek dan visi komputer.
Dapat mengidentifikasi tepi dengan baik, bahkan di bawah variasi kontras atau pencahayaan.
Canny memiliki dua ambang (threshold) yang dapat disesuaikan, memungkinkan Anda untuk mengatur sensitivitas deteksi tepi.
Kelemahan:
Algoritma Canny membutuhkan waktu komputasi yang lebih lama dibandingkan dengan metode pemambangan ambang sederhana seperti Otsu.
Cenderung rentan terhadap noise dalam citra.
Memerlukan beberapa langkah komputasi, termasuk operasi Gaussian dan pemambangan ambang, yang meningkatkan kerumitan algoritma.
Otsu Thresholding:
Kelebihan:
Otsu Thresholding adalah metode pemambangan ambang yang cepat dan sederhana.
Tidak memerlukan pengaturan ambang yang manual karena ambang dihitung secara otomatis berdasarkan distribusi intensitas piksel dalam citra.
Cocok untuk aplikasi yang membutuhkan segmentasi citra berdasarkan ambang intensitas.
Kelemahan:
Otsu Thresholding mungkin tidak menghasilkan tepi yang tajam seperti Canny, karena itu adalah metode pemambangan ambang yang hanya memisahkan piksel menjadi dua kelompok (objek dan latar belakang).
Tidak memiliki mekanisme bawaan untuk mengatasi variasi kontras atau pencahayaan dalam citra.
Tidak dapat menghasilkan tepi yang lebih halus atau memiliki detail tambahan.
Saya menerapkan optimisasi untuk penentuan threshold pada proses hysteris canny edge. Pada dasar, proses hysteris menjadi proses thresholding biasa.
Hasilnya, lebih banyak tepi yang dideteksi. Pada kasus ini, gambar bintang menjadi pembeda paling signifikan
import cv2
from google.colab.patches import cv2_imshow
from skimage import io
img = io.imread('https://cdn.cnn.com/cnnnext/dam/assets/150813112231-donald-trump-joe-biden-super-tease.jpg')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
threshold = 127
maxval = 255
best_threshold, thresholded_img = cv2.threshold(gray, threshold, maxval, cv2.THRESH_BINARY+cv2.THRESH_OTSU)
normal_canny = cv2.Canny(image=img, threshold1=100, threshold2=200)
optimized = cv2.Canny(image=img, threshold1=best_threshold, threshold2=best_threshold)
cv2_imshow(img)
cv2_imshow(thresholded_img)
cv2_imshow(normal_canny)
cv2_imshow(optimized)
normal_canny
Hasilnya, lebih banyak tepi yang dideteksi. Pada kasus ini, gambar bintang menjadi pembeda paling signifikan
import cv2
from google.colab.patches import cv2_imshow
from skimage import io
img = io.imread('https://cdn.cnn.com/cnnnext/dam/assets/150813112231-donald-trump-joe-biden-super-tease.jpg')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
threshold = 127
maxval = 255
best_threshold, thresholded_img = cv2.threshold(gray, threshold, maxval, cv2.THRESH_BINARY+cv2.THRESH_OTSU)
normal_canny = cv2.Canny(image=img, threshold1=100, threshold2=200)
optimized = cv2.Canny(image=img, threshold1=best_threshold, threshold2=best_threshold)
cv2_imshow(img)
cv2_imshow(thresholded_img)
cv2_imshow(normal_canny)
cv2_imshow(optimized)
normal_canny
optimized
import cv2
import numpy as np
import matplotlib.pyplot as plt
from google.colab.patches import cv2_imshow
img = cv2.imread('test.jpg', cv2.IMREAD_COLOR)
# pra-processing menggunakan gaussian blur
blurred_img = cv2.GaussianBlur(img, (5, 5), 0)
# mengubah citra menjadi gray scale
gray_img = cv2.cvtColor(blurred_img, cv2.COLOR_BGR2GRAY)
# pemrosesan canny
canny = cv2.Canny(gray_img, 30, 150)
# pemrosesan otsu
T, thresh1 = cv2.threshold(gray_img, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
# Plot citra asli
plt.subplot(231)
plt.imshow(img, cmap='gray')
plt.axis('off')
plt.title('Original image')
# Plot citra hasil deteksi tepi Canny
plt.subplot(232)
plt.imshow(canny, cmap='gray')
plt.axis('off')
plt.title('Canny Edge Detection')
# Plot citra hasil Thresholding Otsu
plt.subplot(233)
plt.imshow(thresh1, cmap='gray')
plt.axis('off')
plt.title('Otsu Thresholding')
Algoritma perbedaan, untuk pemrosesan canny dengan mengubah ambang pertama dan kedua menyebabkan perbedaan pada hasil deteksi tepi. Begitupula bila citra langsung diolah dengan pemrosesan canny tanpa melalui proses gaussian blur menyebabkan perbedaan hasil tepi citra.
import cv2
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
# Baca citra dalam mode grayscale
image = cv2.imread('/content/contoh1.jpeg', cv2.IMREAD_GRAYSCALE)
imgrgb= cv2.imread('/content/contoh1.jpeg')
imgrgb = cv2.cvtColor(imgrgb, cv2.COLOR_BGR2RGB)
# Pra-pemrosesan citra - penghalusan menggunakan filter Gaussian
blurred_image = cv2.GaussianBlur(image, (5, 5), 0)
# Deteksi tepi dengan Canny
canny_edge = cv2.Canny(blurred_image, 100, 200)
# Thresholding Otsu
_, otsu_thresh = cv2.threshold(blurred_image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
# Hitung histogram untuk masing-masing citra
hist_original = cv2.calcHist([image], [0], None, [256], [0, 256])
hist_canny = cv2.calcHist([canny_edge], [0], None, [256], [0, 256])
hist_otsu = cv2.calcHist([otsu_thresh], [0], None, [256], [0, 256])
# Plot citra asli, histogram, hasil deteksi tepi Canny, histogram, Thresholding Otsu, dan histogram
plt.figure(figsize=(15, 8))
# Plot citra asli
plt.subplot(231)
plt.imshow(imgrgb, cmap='gray')
plt.title('original image', fontsize=12, color='red', ha='center')
# Plot histogram citra asli
plt.subplot(232)
plt.plot(hist_original, color='blue')
plt.title('Histogram - Original Image')
plt.xlabel('Intensitas')
plt.ylabel('Frekuensi')
# Plot citra hasil deteksi tepi Canny
plt.subplot(233)
plt.imshow(canny_edge, cmap='gray')
plt.title('Canny Edge Detection')
# Plot histogram hasil deteksi tepi Canny
plt.subplot(234)
plt.hist(canny_edge.ravel(), bins=256, range=(0, 256), color='blue', alpha=0.6)
plt.title('Histogram - Canny Edge Detection')
plt.ylabel('Frekuensi')
# Plot citra hasil Thresholding Otsu
plt.subplot(235)
plt.imshow(otsu_thresh, cmap='gray')
plt.title('Otsu Thresholding')
# Plot histogram hasil Thresholding Otsu
plt.subplot(236)
plt.hist(otsu_thresh.ravel(), bins=256, range=(0, 256), color='blue', alpha=0.6)
plt.title('Histogram - Otsu Thresholding')
plt.xlabel('Intensitas')
plt.ylabel('Frekuensi')
# Tampilkan plot tanpa whitegrid
plt.show()
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
# Baca citra dalam mode grayscale
image = cv2.imread('/content/contoh1.jpeg', cv2.IMREAD_GRAYSCALE)
imgrgb= cv2.imread('/content/contoh1.jpeg')
imgrgb = cv2.cvtColor(imgrgb, cv2.COLOR_BGR2RGB)
# Pra-pemrosesan citra - penghalusan menggunakan filter Gaussian
blurred_image = cv2.GaussianBlur(image, (5, 5), 0)
# Deteksi tepi dengan Canny
canny_edge = cv2.Canny(blurred_image, 100, 200)
# Thresholding Otsu
_, otsu_thresh = cv2.threshold(blurred_image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
# Hitung histogram untuk masing-masing citra
hist_original = cv2.calcHist([image], [0], None, [256], [0, 256])
hist_canny = cv2.calcHist([canny_edge], [0], None, [256], [0, 256])
hist_otsu = cv2.calcHist([otsu_thresh], [0], None, [256], [0, 256])
# Plot citra asli, histogram, hasil deteksi tepi Canny, histogram, Thresholding Otsu, dan histogram
plt.figure(figsize=(15, 8))
# Plot citra asli
plt.subplot(231)
plt.imshow(imgrgb, cmap='gray')
plt.title('original image', fontsize=12, color='red', ha='center')
# Plot histogram citra asli
plt.subplot(232)
plt.plot(hist_original, color='blue')
plt.title('Histogram - Original Image')
plt.xlabel('Intensitas')
plt.ylabel('Frekuensi')
# Plot citra hasil deteksi tepi Canny
plt.subplot(233)
plt.imshow(canny_edge, cmap='gray')
plt.title('Canny Edge Detection')
# Plot histogram hasil deteksi tepi Canny
plt.subplot(234)
plt.hist(canny_edge.ravel(), bins=256, range=(0, 256), color='blue', alpha=0.6)
plt.title('Histogram - Canny Edge Detection')
plt.ylabel('Frekuensi')
# Plot citra hasil Thresholding Otsu
plt.subplot(235)
plt.imshow(otsu_thresh, cmap='gray')
plt.title('Otsu Thresholding')
# Plot histogram hasil Thresholding Otsu
plt.subplot(236)
plt.hist(otsu_thresh.ravel(), bins=256, range=(0, 256), color='blue', alpha=0.6)
plt.title('Histogram - Otsu Thresholding')
plt.xlabel('Intensitas')
plt.ylabel('Frekuensi')
# Tampilkan plot tanpa whitegrid
plt.show()
Penjelasan:
Gambar asli dibaca dari file 'pictnight.jpg' menggunakan OpenCV.
- Gambar dikonversi ke citra grayscale dengan mengubah gambar berwarna menjadi gambar hitam putih tanpa informasi warna.
-Deteksi tepi pada citra grayscale dengan algoritma Canny. Tepi adalah area di mana intensitas piksel berubah secara tajam.
- Metode thresholding Otsu digunakan untuk mengubah citra grayscale menjadi citra biner (hitam putih) dengan menemukan ambang (threshold) yang optimal. Ambang ini dipilih berdasarkan analisis histogram citra.
Script Code :
import cv2
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
# membaca citra mode grayscale
image = cv2.imread('pictnight1.jpg', cv2.IMREAD_GRAYSCALE)
imgrgb= cv2.imread('pictnight1.jpg')
imgrgb = cv2.cvtColor(imgrgb, cv2.COLOR_BGR2RGB)
# Pra-pemrosesan citra - penghalusan menggunakan filter Gaussian
blurred_image = cv2.GaussianBlur(image, (5, 5), 0)
# Deteksi tepi dengan Canny
canny_edge = cv2.Canny(blurred_image, 100, 200)
# Thresholding Otsu
_, otsu_thresh = cv2.threshold(blurred_image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
# Hitung histogram untuk masing-masing citra
hist_original = cv2.calcHist([image], [0], None, [256], [0, 256])
hist_canny = cv2.calcHist([canny_edge], [0], None, [256], [0, 256])
hist_otsu = cv2.calcHist([otsu_thresh], [0], None, [256], [0, 256])
# Plot citra asli, histogram, hasil deteksi tepi Canny, histogram, Thresholding Otsu, dan histogram
plt.figure(figsize=(15, 8))
# Plot citra asli
plt.subplot(231)
plt.imshow(imgrgb, cmap='gray')
plt.title('original image', fontsize=12, color='red', ha='center')
# Plot histogram citra asli
plt.subplot(232)
plt.plot(hist_original, color='blue')
plt.title('Histogram - Original Image')
plt.xlabel('Intensitas')
plt.ylabel('Frekuensi')
# Plot citra hasil deteksi tepi Canny
plt.subplot(233)
plt.imshow(canny_edge, cmap='gray')
plt.title('Canny Edge Detection')
# Plot histogram hasil deteksi tepi Canny
plt.subplot(234)
plt.hist(canny_edge.ravel(), bins=256, range=(0, 256), color='blue', alpha=0.6)
plt.title('Histogram - Canny Edge Detection')
plt.ylabel('Frekuensi')
# Plot citra hasil Thresholding Otsu
plt.subplot(235)
plt.imshow(otsu_thresh, cmap='gray')
plt.title('Otsu Thresholding')
# Plot histogram hasil Thresholding Otsu
plt.subplot(236)
plt.hist(otsu_thresh.ravel(), bins=256, range=(0, 256), color='blue', alpha=0.6)
plt.title('Histogram - Otsu Thresholding')
plt.xlabel('Intensitas')
plt.ylabel('Frekuensi')
# Tampilkan plot tanpa whitegrid
plt.show()
- Menampilkan Gambar dan Histogram:
-Gambar Asli: Gambar asli ditampilkan dalam bentuk warna.
-Citra Tepi Canny: Citra tepi Canny (hasil deteksi tepi) ditampilkan dalam bentuk grayscale.
-Histogram Tepi Canny: Histogram intensitas piksel untuk citra tepi Canny ditampilkan.
-Hasil Segmentasi Otsu: Hasil segmentasi Otsu (citra biner) ditampilkan dalam bentuk grayscale.
-Histogram Segmentasi Otsu: Histogram intensitas piksel untuk hasil segmentasi Otsu ditampilkan.
Program ini memberikan visualisasi dari gambar asli, deteksi tepi menggunakan algoritma Canny, hasil segmentasi menggunakan metode thresholding Otsu, serta histogram untuk kedua proses tersebut. Hal ini membantu pengguna untuk memahami perubahan citra yang terjadi melalui setiap langkah pengolahan.
