BAB IV

HASIL ANALISIS

Analisis adalah proses penelitian untuk kepentingan diskusi dan untuk

pemahaman yang lebih dalam tentang subjek pertanyaan. analisis yang dilakukan
dalam penelitian ini bertujuan untuk mendapatkan wawasan tentang masalah, data,
proses pengujian, dan semua hal yang berhubungan dengan penelitian.

4.1 Pengumpulan Data

Penelitian ini berjudul Klasifikasi Kematangan Buah Apel Menggunakan
Metode Support Vector Machine (SVM) Berbasis Pengolahan Citra Digital” proses
pertama dilakukan pengumpulan data dari buah apel untuk mengetahui kualitas
buah mentah,matang,busuk. dari proses pengambilan gambar foto pada buah
pengujian ini menggunakan 150 data buah apel untuk mendapatkan buah mentah
50, matang 50, busuk 50. penentuan buah apel di butuhkan data training dan data
testing, untuk menjalankan program prediksi kematangan apel sebelumnya
dilakukan training data dulu dari datasheet.

4.2 Implementasi Perangkat Keras Dan Lunak

Pada proses implementasi, diperlukan beberapa komponen pendukung yang
digunakan untuk mengklasifikasi kematangan buah apel berbasis pengolahan citra
digital berdasarkan fitur warna dengan menggunakan metode support vector
machine. Pada tahap ini dijelaskan tentang implementasi dari desain perangkat
keras, perangkat lunak dan kebutuhan operatioanal pengujian.

Spesifikasi perangkat keras yang digunakan dalam penelitian sebagai berikut :

1. AMD Ryzen 5 3500U with Radeon Vega Mobile Gfx 2.10 GHz
2. Installed RAM 8,00 GB
3. System type 64-bit operating system, x64-based processor
4. Windows 10 Home Single Language
Perangkat lunak yang digunakan dalam pembuatan program ini adalah :
1. Sistem Operasi Windows 10 64 bit
2. Bahasa pemrograman (Python 3.9.9)
3. Visual Studio Code
4. Library open cv, numpy, matplotlib, sklearn, scikit- image, padas.

4.3 Analisis Data

Pada tahap analisis kebutuhan data penelitian dari prosedur analisis
pengumpulan data, analisis data (dalam bentuk gambar) dan berbagi data dilakukan
untuk berbagai tahapan proses klasifikasi. analisis dirancang untuk
mengidentifikasi ruang lingkup penelitian yang lebih spesifik. proses analisis data
ini adalah sebagai berikut:

1. Pengambilan data citra dilakukan dengan memotret objek buah

menggunakan kamera handphone 64 megapiksel dan data gambar di ambil
dari jarak yang sama.
2. Ukuran gambar 300 x 300 piksel, ukuran citra yang kecil bertujuan untuk
mempercepat komputasi dalam pengolahan data selama tahap
implementasi.
3. Jenis citra yang digunakan pada citra digital yaitu 3 tingkat kematangan
buah. Setiap buah diambil dengan kamera handphone, dan total data yang
digunakan 150 gambar buah. Pemisahan seluruh data citra latih (training
data) dan data citra uji (testing data) yang digunakan untuk pengujian terdiri
dari 90% data latih dan 10% data uji (tanpa menggunakan background) serta
80% data latih dan 20% data uji. Di bawah ini data citra training yang nanti
digunakan untuk testing.
4.3.1 Data Training

Gambar 4.1 Data Training Apel Mentah

Gambar 4.2 Data Training Apel Matang

 Gambar 4.3 Data Training Apel Busuk
Setelah data training selanjutnya data uji akan melalui Proses pengujian
konversi RGB kedalam HSV dan ekstraksi fitur. Proses menguji menggunakan
klasifikasi SVM akan menentukan kelas testing yang akan mempengaruhi akurasi
sistem kerja.

4.4 Ektraksi Ciri Warna Konversi RGB ke HSV

Dari kumpulan data buah apel training di atas yang akan di konversi gambar
RGB untuk mencari nilai HSV, dari data training 50 apel mentah, 50 apel matang
dan 50 apel busuk. pada proses ini akan dilakukan tahap data akan melewati
pemrosesan gambar yang diperoleh dengan memprediksi ekstraksi fitur warna
untuk memperoleh nilai dari data citra buah apel. denggan melakukan normalisasi
nilai RGB dan menentukan nilai hue, saturation and value HSV pada data citra buah
training berikut adalah contoh gambar hasil konversi dan program:

Citra asli Citra hasil konversi RGB ke HSV

# rentang nilai hsv
cv2.namedWindow("Range HSV")
cv2.resizeWindow("Range HSV", 500, 350)
cv2.createTrackbar("HUE Min", "Range HSV", 0,180,empty)
cv2.createTrackbar("HUE Max", "Range HSV", 180,180,empty)
cv2.createTrackbar("SAT Min", "Range HSV", 0,255,empty)
cv2.createTrackbar("SAT Max", "Range HSV", 255,255,empty)
cv2.createTrackbar("VALUE Min", "Range HSV", 0,255,empty)
cv2.createTrackbar("VALUE Max", "Range HSV", 255,255,empty)

data_path = 'datasheet\\data_training\\1_apel_matang\\train.MATANG_09.jpg'

data = cv2.imread(data_path)
scale_percent = 10 # percent of original size
width = int(data.shape[1] * scale_percent / 100)
height = int(data.shape[0] * scale_percent / 100)
dim = (width, height)

# resize image
image = cv2.resize(data, dim, interpolation = cv2.INTER_AREA)
# gray = cv2.cvtColor(hsv, cv2.COLOR_RGB2GRAY)

while True:

# get value from trackbar

h_min = cv2.getTrackbarPos("HUE Min", "Range HSV")
h_max = cv2.getTrackbarPos("HUE Max", "Range HSV")
s_min = cv2.getTrackbarPos("SAT Min", "Range HSV")
s_max = cv2.getTrackbarPos("SAT Max", "Range HSV")
v_min = cv2.getTrackbarPos("VALUE Min", "Range HSV")
v_max = cv2.getTrackbarPos("VALUE Max", "Range HSV")

# define range of some color in HSV

lower_range = np.array([h_min,s_min,v_min])
upper_range = np.array([h_max, s_max, v_max])

# convert image to HSV

hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)

# threshold the hsv image to get some color

thresh = cv2.inRange(hsv, lower_range, upper_range)
4.5 Ekstraksi Fitur Citra Buah
Citra yang telah melewati proses awal kemudian diekstraksi fitur histogram.
Dalam penelitian ini, fitur histogram diperoleh dengan mengolah data yang
direpresentasikan dalam histogram citra. Fitur histogram yang digunakan adalah
mean, entropi, standar deviasi, skewness, entropi, dan homogenity. metode
ekstraksi fitur histogram ini merupakan metode statistik yang menggunakan
perhitungan statistik distribusi skala keabuan (histogram) pada suatu citra. Nilai
dari masing-masing fitur tersebut kemudian digunakan sebagai parameter untuk
mengklasifikasikan citra apel ke dalam kelompok. berikut hasil ekstrasi fitur dari
10 citra testing apel Matang :

Gambar 4.4 Tabel Testing Apel Busuk.

Menggunakan fitur mean, entropi, standar deviasi, skewness, entropi, dan

homogenity. dianggap relevan dalam penelitian ini karena 6 fitur didasarkan pada
perbedaan nilai skala abu-abu dan bentuk histogram citra.

4.6 Pengujian Denggan Metode Support Vector Machine

Pengujian dijalankan untuk memastikan bahwa sistem yang dibuat sesuai
dengan rancangan sistem yang dibuat sebelumnya. Pengujian sistem yang
dilakukan meliputi tahap pengujian perancangan, dan pengujian akurasi. Pengujian
akurasi merupakan tahap yang memiliki tujuan untuk mengetahui tingkat akurasi
dari penggunaan metode Support Vector Machine dengan cara menghitung jumlah
data uji yang kelasnya diprediksi secara benar. Pengujian klasifikasi SVM untuk
mengenali hasil dari sistem analisis apakah sesuai dengan data uji yang ada atau
terjadi kesalahan hasil klasifikasi.
import os
import cv2
import numpy as np
from math import e
import pandas as pd
from skimage.feature import graycomatrix, graycoprops
from sklearn.svm import SVC
from sklearn import metrics
import pickle
from skimage.measure import label, regionprops

def entropy(labels, base=None):

value,counts = np.unique(labels, return_counts=True)
norm_counts = counts / counts.sum()
base = e if base is None else base
return -(norm_counts * np.log(norm_counts)/np.log(base)).sum()

path_ds = "datasheet/cvt"
properties =np.zeros(7)
glcmMAtrix=[]
final=[]

folders = ['matang', 'busuk', 'mentah']

for folder in folders:

print("======Proses kelas :",folder)
labell=folders.index(folder)
INPUT_SCAN_FOLDER=path_ds+"/"+folder+"/"
# print(INPUT_SCAN_FOLDER)

image_folder_list = os.listdir(INPUT_SCAN_FOLDER)

for i in range(len(image_folder_list)):

abc =cv2.imread(INPUT_SCAN_FOLDER+image_folder_list[i])

gray_image = cv2.cvtColor(abc, cv2.COLOR_BGR2GRAY)

# images = images.f.arr_0
# print(INPUT_SCAN_FOLDER+image_folder_list[i])

val_mean = np.mean(gray_image)
val_std = np.std(gray_image)
val_skewness = val_mean/val_std
val_entropy = entropy(gray_image)
glcmMatrix = (graycomatrix(gray_image, distances=[2], angles=[0]))
val_energy = (graycoprops(glcmMatrix, prop='energy'))
val_homogeneity = (graycoprops(glcmMatrix, prop='homogeneity'))

properties[0] = val_mean
properties[1] = val_std
properties[2] = val_skewness
properties[3] = val_entropy
 properties[4] = val_energy
properties[5] = val_homogeneity
properties[6] = labell
# print("mean > ",val_mean)
# print("std deviasion > ",val_std)
# print("skewness > ", val_skewness)
# print("entropy > ",val_entropy)
# print("energy > ",val_energy)
# print("homogeneity > ",val_homogeneity)

features = np.array(
[properties[0], properties[1], properties[2],
properties[3], properties[4],properties[5],
labell])
final.append(features)

df = pd.DataFrame(final)
Y= df[6]
X = df.drop([6],axis=1)

from sklearn.model_selection import train_test_split

X_train,X_test,y_train,y_test=train_test_split(X,Y, test_size=.3, random_state=100)

names = ["Linear SVM", "RBF SVM"]

classifiers = [
SVC(kernel="linear", C=0.025),
SVC(kernel = 'rbf', C = 0.3, gamma = 0.21)]

for name, clf in zip(names, classifiers):

clf.fit(X_train,y_train)
score = clf.score(X_test, y_test)
print(name,":",score)
filename = 'model.pkl'
with open(filename, 'wb') as file:
pickle.dump(clf, file)
predict = clf.predict(X_test)
accuracy = metrics.accuracy_score(y_test, predict)
precission = metrics.precision_score(y_test, predict, average='micro')
recall = metrics.recall_score(y_test, predict, average='micro')
print("Accuracy:{:.2f}%".format(accuracy * 100))
print("Precicssion:{:.8f}".format(precission))
print("Recall:{:.8f}".format(recall))
print(metrics.confusion_matrix(y_test, predict))
print(metrics.classification_report(y_test, predict))
4.7 Hasil Pengujian Program:

1. menjalankan prgram prediksi ekstraksi fitur kematangan buah apel. di

bawah ini adalah hasil prediksi buah apel matang

2. Untuk mendapatkan accuracy sebelum menjalakan program training data

dulu dari datashet. Di bawah ini hasil training buah apel busuk dengan
accuracy 87.50%.