Machine learning pizza herkenner
Dat AI en machine learning een groot deel van ons leven zouden worden, wisten we al een tijdje. Daarom is het belangrijk om zelf te experimenteren met deze concepten en er beter in te worden zo heb ik een aantal jaar geleden 3 certificaten gehaald over machine learning bij Harvard en is het nu tijd om te kijken of ik die kennis nog een beetje heb opgeslagen. Om te kijken of ik dit nog kan heb ik software gemaakt en getraind die 4 verschillende soorten pizza’s kan herkennen door middel van beeldherkenning. In de onderstaande blog heb ik beschreven hoe ik dat heb gedaan.
Hoe herkennen we pizza’s
Voor het herkennen van pizza’s door middel van beeldherkenning ga ik gebruikmaken van verschillende toppings op pizza’s en deze herkennen door verschillende beeldherkenningsmodellen te gebruiken op basis van de textuur, vorm en kleur van de toppings. Denk hierbij aan een kleur uitfilteren, vierkante vormen vinden of rechte lijnen. (bijvoorbeeld bij vierkante blokjes ham of ananas) Maar om pizza’s te herkennen, moet ik eerst pizza’s kiezen en foto’s maken.
Welke pizza’s ga ik herkennen
Na even nadenken over welke pizza’s ik wil gebruiken, heb ik de keuze gemaakt aan de hand van twee belangrijke kenmerken
Welke toppings zijn makkelijk te herkennen bijvoorbeeld spinazie, salami, ananas en ham.
Welke pizza’s vind ik lekker en kan ik opeten nadat ik foto’s heb gemaakt.
Hieruit kwamen de 4 volgende pizza’s allemaal van dr.oetker zodat ik ze voordelig en altijd hetzelfde opnieuw zou kunnen kopen als het nodig moest zijn.
Salami (vind ik niet lekker maar mijn vriendin gelukkig wel)
Hawaii
Pollo
Spinazie
Omdat het eerste plan was om echt een machine learning model te trainen heb ik 1000en foto’s gemaakt van alle pizza’s met verschillende belichtingen en hoeken. dit heb ik gedaan door een functie op me telefoon die meerdere foto’s per keer maakt en dit netjes opslaat in mapjes.
Welke kenmerken ga ik gebruiken om pizza’s te herkennen
Om elke pizza goed te kunnen herkennen, is het eerst belangrijk om te bekijken wat deze pizza’s anders maakt en waaraan we ze het makkelijkst kunnen herkennen. Stel je voor dat je 3 verschillende auto’s uit elkaar moest halen en je weet dat er eentje altijd geel is, de tweede geen dak heeft en de derde een spoiler. Dan zou je de auto’s natuurlijk gaan herkennen aan de spoiler, het ontbreken van een dak, en de kleur geel. Ik ga hetzelfde doen met de pizza’s.
Salami
Zoals hierboven te zien is, is de salami goed te herkennen aan twee attributen: de kleur en vorm van de salamiplakjes. Deze zijn namelijk duidelijk erg rond, hoewel er soms wel kaas op ligt, wat het herkennen hiervan moeilijker kan maken. Maar ze zijn ook duidelijk een andere kleur dan de rest van de pizza.
Hawaii
De pizza Hawaii lijkt deels op de salami, maar heeft twee attributen waaraan we hem gemakkelijk kunnen herkennen: de kleur van de ananas en de duidelijke rechte hoeken van de stukjes ham en ananas.
Pollo
De pizza pollo is herkenbaar aan de groene kleur van de spinazie, maar omdat we ook een pizza spinazie hebben, is dat niet genoeg. Daarom ga ik ook kijken naar de kleur van de maïs. Er wordt ook gekeken naar de kleur van de kip, hoewel dat moeilijker is, want die heeft twee verschillende kleuren in het midden en de rand.
Spinazie
De pizza spinazie is makkelijk te herkennen omdat er maar 2 toppings opzitten en dat zijn kaas en spinazie waardoor ik vooral hierop ga letten om hem te onderscheiden met de pizza pollo.
Wat is er nodig om pizza’s te herkennen met machine learning in python
Om de pizza’s te kunnen herkennen met Python, moet er gekeken worden naar welke methodes ik kan en ga gebruiken om dit te laten werken. Deze worden opgedeeld in twee subdelen, namelijk preprocessing en de beeldherkenning zelf. Preprocessing is het voorbereiden van de afbeelding om herkenning toe te passen. Hiervoor zijn enorm veel mogelijkheden, zoals:
Image resizing
Als een afbeelding te groot is en niet alleen maar de belangrijkste informatie laat zien, kan je door middel van code de onbelangrijke informatie wegsnijden. Dit kan je zelfs automatisch doen door bijvoorbeeld een cirkeldetectie op de pizza uit te voeren en een klein vierkant eromheen weg te snijden, zodat je alleen de pizza overhoudt.Grayscaling of images
Het converteren van een afbeelding naar grijstinten kan de complexiteit van een afbeelding verminderen. Ook wordt dit gebruikt omdat veel functies in de OpenCV2-bibliotheek (de bibliotheek die vaak gebruikt wordt voor beeldherkenning) alleen afbeeldingen in grijstinten accepteren.Blurring an image
Om ruis in een afbeelding te verminderen en details zachter te maken, kan je met een Gaussian filter de afbeelding blurren. Hierdoor kan je makkelijker analyses zoals randdetectie of objectherkenning uitvoeren.
filter colors
Een belangrijke stap is het filteren van kleuren, dit zorgt ervoor dat je alle informatie uit een afbeelding kunt verwijderen, behalve een bepaald spectrum van kleuren. Dit wordt niet gedaan in het RGB-spectrum maar in het HSV-spectrum, omdat je dan een minimale en maximale waarde kunt invullen.
analyzing with histograms
Een interessante manier om naar afbeeldingen te kijken is door ze om te zetten naar histograms. Hiermee kun je namelijk zien hoeveel pixels er van een bepaalde waarde in een afbeelding zitten zonder dat je zelf de ruis van de afbeelding hoeft te bekijken. Hieronder zie je een histogram van een pizza pollo.
segmentation
Een manier die je kunt gebruiken om delen van een pizza te herkennen is segmentatie. Dit zorgt ervoor dat je de afbeelding opdeelt in segmenten van bepaalde kleuren, alsof je de afbeelding schildert. Dit werkt op basis van gemeenschappelijke kenmerken zoals kleur, textuur, helderheid, enz.
Er zijn er nog veel meer maar dit zijn een paar van de belangrijkste.
Het 2de deel is de beeldherkenning zelf en ook hier heb je een aantal methodes ik heb er voor dit project 2 belangrijke uitgelegd.
Circle detection
Om cirkels te kunnen herkennen zoals de salami op een pizza kan je cirkeldetectie uitvoeren. dit werkt het best met een afbeelding die al gefilterd is op kleur zoals te zien was bij filter colors. als je daar dan cirkels op detecteerd en die resultaten over de originele afbeelding legt krijg je het volgende resultaat.
find contours
Contouren zijn lijnen die alle punten langs een rand in een afbeelding verbindt die dezelfde intensiteit hebben. Een moeilijke zin maar makkelijker uit te leggen met een foto.
In de bovenstaande foto kun je zien dat ik een pizza Hawaii heb gefilterd op de kleur van een ananas. Hier kun je goed zien dat de ananas nu duidelijke lijnen heeft tegenover het zwart van de achtergrond. Door middel van het vinden van contouren kun je die detecteren en weer over de originele afbeelding maskeren. En dan krijg je het onderstaande resultaat, zeker niet perfect maar goed genoeg om pizza’s te herkennen.
Ontwerp van de code
Om al deze stappen te gebruiken om de pizza's te herkennen, moet er eerst gekeken worden naar hoe ik dit ga doen. De beste manier is om een afbeelding van pizza’s per pizza te testen. Dus ik kijk eerst of het een salami is; als dat niet zo is, ga je door naar Hawaii, daarna pollo, en daarna spinazie. Dit doe ik omdat het het makkelijkst is om een salami te herkennen, en je dan niet een salami als Hawaii kan herkennen, omdat die pizza nooit bij die code komt. Om dit duidelijk te maken, heb ik een flowchart gemaakt van hoe de code gaat werken..
Om de herkenning uit te voeren heb ik verschillende bibliotheken gebruikt dat zijn de volgende
CV2 (openCV - Open Source Computer Vision Library) opencv is een krachtig en vaak gebruikte bibliotheek voor het processen van afbeeldingen en heeft ook functies voor beeldherkenning
OS deze bibliotheek gaat gebruikt worden om foto’s van de computer naar het programma te laden en deze later te verplaatsten naar correcte mapjes.
numpy en matplotlib zijn 2 bibliotheken die ik ga gebruiken voor berekeningen en het maken van grafieken en andere visiualisaties.
Gebruikte functies
De code is opgebouwd uit verschillende functies zoals mais_finder of pizza_image die allemaal hun eigen functie hebben hieronder worden er een paar uitgelegd.
Pizza_image
Deze functie wordt gebruikt om de gehele pizza in een afbeelding te detecteren en de afbeelding correct bij te snijden, zodat alle onnodige delen van de afbeelding niet door de code worden verwerkt. Dit gebeurt door de afbeelding om te zetten naar grijstinten en een randdetectie-algoritme toe te passen om de randen van de pizza te vinden. Vervolgens worden contouren geïdentificeerd en de grootste contour (de pizza) geselecteerd. Dan wordt de afbeelding bijgesneden en dit resultaat wordt geretourneerd naar de code.
def pizza_image(image): # functie om de achtergrond van de pizza weg te halen
image_copy = image.copy()
gray = cv2.cvtColor(image_copy, cv2.COLOR_BGR2GRAY)
Gaussian1 = cv2.GaussianBlur(gray, (5, 5), 0)
edges = cv2.Canny(Gaussian1, threshold1=80, threshold2=100) # zoekt edges in de afbeelding
Gaussian2 = cv2.GaussianBlur(edges, (11, 11), 0)
contours, _ = cv2.findContours(Gaussian2, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
contours = sorted(contours, key=cv2.contourArea, reverse=True) # sorteert de contouren op grootte
pizza_contour = contours[0]
x, y, w, h = cv2.boundingRect(pizza_contour) # maakt een vierkant om de grootste contour heen
cropped_image = image[y:y+h, x:x+w]
return cropped_image
ananas_finder
Deze functie is gemaakt om de ananas op een afbeelding te detecteren. Het past een HSV-masker toe om specifieke kleuren te isoleren die overeenkomen met ananas. Hierna wordt de afbeelding omgezet naar grijstinten en waziger gemaakt om het rekenwerk te verminderen bij het vinden van de contouren. Deze functie lijkt erg op die van het vinden van mais, maar gebruikt andere HSV-waardes.
def ananas_finder(image): # functie om ananas te vinden
lower_ham = np.array([9, 0, 0])
upper_ham = np.array([28, 255, 255])
threshold1 = 50
threshold2 = 150
ananas_image = image.copy()
mask_image = hsv_mask(ananas_image, hsv_ananas) # maak een HSV mask van de ananas
gray = cv2.cvtColor(mask_image, cv2.COLOR_BGR2GRAY)
gray = cv2.GaussianBlur(gray, (11,11), 24)
_, threshold = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
contours, _ = cv2.findContours(threshold, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
i = 0
num_contours = len(contours)
for contour in contours:
if i == 0:
i = 1
continue
approx = cv2.approxPolyDP(contour, 0.1 * cv2.arcLength(contour, True), True)
cv2.drawContours(ananas_image, [contour], 0, (0, 0, 255), 1)
segments = slic(image, # verdeelt de afbeelding op in 500 segmenten gekozen op kleur textuur en plaatsing
n_segments=500,
compactness=20)
segmented_image = (label2rgb(segments, #zet de segmenten om in een afbeelding
image,
kind = 'avg'))
hsv_image = cv2.cvtColor(segmented_image, cv2.COLOR_BGR2HSV)
ham_mask = cv2.inRange(hsv_image, lower_ham, upper_ham)
filtered_image = cv2.bitwise_and(image, image, mask=~ham_mask)
blurred = cv2.GaussianBlur(filtered_image, (5, 5), 10)
edges = cv2.Canny(blurred, threshold1, threshold2)
ananas_image[edges != 0] = [0, 255, 0] # overlayt de randen van de ham op de ananas afbeelding
contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
num_edges = len(contours)
return ananas_image, num_contours, num_edges
find_contours
Deze functie zoekt naar contouren in een afbeelding en markeert deze op de oorspronkelijke afbeelding. Het maakt gebruik van drempelwaarden en randdetectie. Je geeft deze functie een afbeelding waarop het tekent en een masker waarop het de contouren moet vinden.
def find_contours(image,mask,a): # functie om de contouren op een afbeelding te vinden
gray = cv2.cvtColor(mask, cv2.COLOR_BGR2GRAY)
gray = cv2.GaussianBlur(gray, (a[0],a[0]), a[1])
edged = cv2.Canny(gray, a[2], a[3])
contours, hierarchy = cv2.findContours(edged, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
cv2.drawContours(image, contours, -1, (a[4], a[5], a[6]), 1)
return image
Er zijn nog meer functies maar ze gebruiken allemaal soortgelijke methodes om andere toppings te vinden of de afbeelding op verschillende manieren aan te passen.
Gehele code
De gehele code is hieronder neergezet zodat je er even doorheen kan kijken.
# -*- coding: utf-8 -*-
"""
Created on Thu Sep 28 08:56:48 2023
@author Daniël Röling
"""
"""Imports"""
import cv2
import os
import numpy as np
import matplotlib.pyplot as plt
import array as arr
from skimage.segmentation import slic, mark_boundaries
from skimage import filters
from skimage.color import label2rgb
"""Funtions"""
def ananas_finder(image): # functie om ananas te vinden
lower_ham = np.array([9, 0, 0])
upper_ham = np.array([28, 255, 255])
threshold1 = 50
threshold2 = 150
ananas_image = image.copy()
mask_image = hsv_mask(ananas_image, hsv_ananas) # maak een HSV mask van de ananas
gray = cv2.cvtColor(mask_image, cv2.COLOR_BGR2GRAY)
gray = cv2.GaussianBlur(gray, (11,11), 24)
_, threshold = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
contours, _ = cv2.findContours(threshold, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
i = 0
num_contours = len(contours)
for contour in contours:
if i == 0:
i = 1
continue
approx = cv2.approxPolyDP(contour, 0.1 * cv2.arcLength(contour, True), True)
cv2.drawContours(ananas_image, [contour], 0, (0, 0, 255), 1)
segments = slic(image, # verdeelt de afbeelding op in 500 segmenten gekozen op kleur textuur en plaatsing
n_segments=500,
compactness=20)
segmented_image = (label2rgb(segments, #zet de segmenten om in een afbeelding
image,
kind = 'avg'))
hsv_image = cv2.cvtColor(segmented_image, cv2.COLOR_BGR2HSV)
ham_mask = cv2.inRange(hsv_image, lower_ham, upper_ham)
filtered_image = cv2.bitwise_and(image, image, mask=~ham_mask)
blurred = cv2.GaussianBlur(filtered_image, (5, 5), 10)
edges = cv2.Canny(blurred, threshold1, threshold2)
ananas_image[edges != 0] = [0, 255, 0] # overlayt de randen van de ham op de ananas afbeelding
contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
num_edges = len(contours)
return ananas_image, num_contours, num_edges
def small_image(bigimage): # functie om de originele afbeelding van grootte te veranderen
scale_percent = 30
width = int(bigimage.shape[1] * scale_percent / 100)
height = int(bigimage.shape[0] * scale_percent / 100)
dim = (width, height)
smallimage = cv2.resize(bigimage, dim, interpolation = cv2.INTER_AREA) # wijzigt het formaat van de afbeelding
return smallimage
def pizza_image(image): # functie om de achtergrond van de pizza weg te halen
image_copy = image.copy()
gray = cv2.cvtColor(image_copy, cv2.COLOR_BGR2GRAY)
Gaussian1 = cv2.GaussianBlur(gray, (5, 5), 0)
edges = cv2.Canny(Gaussian1, threshold1=80, threshold2=100) # zoekt edges in de afbeelding
Gaussian2 = cv2.GaussianBlur(edges, (11, 11), 0)
contours, _ = cv2.findContours(Gaussian2, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
contours = sorted(contours, key=cv2.contourArea, reverse=True) # sorteert de contouren op grootte
pizza_contour = contours[0]
x, y, w, h = cv2.boundingRect(pizza_contour) # maakt een vierkant om de grootste contour heen
cropped_image = image[y:y+h, x:x+w]
return cropped_image
def hsv_mask(image, a): # funcite om HSV masks over een afbeelding te leggen
hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
lower_blue = np.array([a[0], a[1], a[2]])
upper_blue = np.array([a[3], a[4], a[5]])
mask = cv2.inRange(hsv, lower_blue, upper_blue)
result = cv2.bitwise_and(image, image, mask = mask) # legt de mask over de originele afbeelding heen
return result
def find_contours(image,mask,a): # functie om de contouren op een afbeelding te vinden
gray = cv2.cvtColor(mask, cv2.COLOR_BGR2GRAY)
gray = cv2.GaussianBlur(gray, (a[0],a[0]), a[1])
edged = cv2.Canny(gray, a[2], a[3])
contours, hierarchy = cv2.findContours(edged, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
cv2.drawContours(image, contours, -1, (a[4], a[5], a[6]), 1)
return image
def salami_finder(image): # functie om de salami op een pizza te vinden
copy_image = image.copy()
mask_image = hsv_mask(copy_image, hsv_salami) # maak een HSV mask van de salami
gray = cv2.cvtColor(mask_image, cv2.COLOR_BGR2GRAY)
circles = cv2.HoughCircles(gray, cv2.HOUGH_GRADIENT, dp=1, minDist=105, param1=25, param2=17, minRadius=40, maxRadius=52) # vind de salami doormiddel van cirkels vinden
circle_count = 0
if circles is not None:
circles = circles[0].astype("int")
for (x, y, r) in circles:
cv2.circle(image, (x, y), r, (0, 0, 255), 2)
circle_count += 1
return image, circle_count
def mais_finder(image): # functie om mais te vinden
i = 0
mask_image = hsv_mask(image, hsv_mais) # maak een HSV mask met de kleur van mais
gray = cv2.cvtColor(mask_image, cv2.COLOR_BGR2GRAY)
gray = cv2.GaussianBlur(gray, (5,5), 5)
_, threshold = cv2.threshold(gray, 90, 255, cv2.THRESH_BINARY)
contours, _ = cv2.findContours(threshold, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) # vind de randen van de mais uit de mask
above_threshold_count = 0
for contour in contours:
if i == 0:
i = 1
continue
approx = cv2.approxPolyDP(contour, 0.1 * cv2.arcLength(contour, True), True)
cv2.drawContours(image, [contour], 0, (0, 255, 255), 1)
size = cv2.contourArea(contour)
if size > 20:
above_threshold_count += 1
threshold1 = 50
threshold2 = 150
segments = slic(image,
n_segments=180,
compactness=16)
segmented_image = (label2rgb(segments,
image,
kind = 'avg'))
filtered_image = hsv_mask(segmented_image, hsv_pollo)
blurred = cv2.GaussianBlur(filtered_image, (5, 5), 10)
edges = cv2.Canny(blurred, threshold1, threshold2)
return image, above_threshold_count, edges
def spinaci_finder(image):
mask = hsv_mask(pizza_box, s3)
gray = cv2.cvtColor(mask, cv2.COLOR_BGR2GRAY)
gray = cv2.GaussianBlur(gray, (sfc3[0],sfc3[0]), sfc3[1])
edged = cv2.Canny(gray, sfc3[2], sfc3[3])
contours, hierarchy = cv2.findContours(edged, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
num_contours = 0
num_contours = len(contours)
return num_contours
"""variable"""
#variable die gebruikt worden voor de hsv mask's
s1 = arr.array('i', [0, 0, 0, 179, 224, 82])
s2 = arr.array('i', [0, 0, 0, 179, 224, 120])
s3 = arr.array('i', [0, 0, 0, 179, 224, 82])
k1 = arr.array('i', [0, 65, 105, 18, 255, 255])
k2 = arr.array('i', [15, 54, 205, 21, 255, 255])
hsv_mozzerella = arr.array('i', [0, 0, 200, 180, 80, 255])
hsv_mais = arr.array('i', [23, 90, 123, 28, 255, 255])
hsv_pollo = arr.array('i', [13, 135, 100, 20, 255, 255])
hsv_ananas = arr.array('i', [16, 50, 50, 40, 255, 255])
hsv_salami = arr.array('i', [30, 0, 0, 179, 255, 255])
#Variable die gebruikt worden voor het vinden van de contouren
sfc1 = arr.array('i', [3, 0, 50, 200, 0, 255, 0])
sfc2 = arr.array('i', [7, 0, 50, 200, 0, 255, 0])
sfc3 = arr.array('i', [1, 0, 50, 200, 0, 255, 0])
kfc1 = arr.array('i', [15, 0, 50, 150, 0, 0, 255])
kfc2 = arr.array('i', [15, 0, 50, 150, 0, 0, 255])
"""Code"""
#afbeeldingen in de directroy inladen
directory = r"C:\Users\daniel\OneDrive - Stichting Hogeschool Utrecht\PVJL\Beeldherkenning\Demo Foto's\Input Foto's"
files = os.listdir(directory)
jpeg_files = [f for f in files if f.endswith('.JPG') or f.lower().endswith('.jpg')]
#directory voor de resultaten
folder_name = r"C:\Users\daniel\OneDrive - Stichting Hogeschool Utrecht\PVJL\Beeldherkenning opdracht\Demo Foto's\Output Foto's"
#maak de resultaten directory aan als hij nog niet bestaat
if not os.path.exists(folder_name):
os.mkdir(folder_name)
#verwijder alles in de resultaten directory als er wat in staat
for filename in os.listdir(folder_name):
file_path = os.path.join(folder_name, filename)
if os.path.isfile(file_path):
os.remove(file_path)
#nummering voor de resultaten afbeeldingen
x = 0
for jpeg_file in jpeg_files:
image_path = os.path.join(directory, jpeg_file) #vindt het path naar de afbeelding
bigimage = cv2.imread(image_path) #laad de afbeelding in
if bigimage is not None: #Kijk of de afbeelding succes voor ingeladen is
x = x+1
image = small_image(bigimage)#resize de afbeelding
pizza_box = pizza_image(image)#bijsnijden van de afbeelding
salami_image = pizza_box.copy()
salami = salami_finder(salami_image)
hawaii_image = pizza_box.copy()
hawaii = ananas_finder(hawaii_image)
pollo_image = pizza_box.copy()
pollo = mais_finder(pollo_image)
if 5 < salami[1] < 10:
#Sla de afbeelding op
output_path = os.path.join(folder_name, f"{x}_Salami.jpg")
cv2.imwrite(output_path, salami[0])
print('Salami found')
elif 20 < hawaii[1] < 50 and 500 < hawaii[2] < 600:
#Sla de afbeelding op
output_path = os.path.join(folder_name, f"{x}_Hawaii.jpg")
cv2.imwrite(output_path, hawaii[0])
print('Hawaii found')
elif 20 < pollo[1] < 40:
pollo[0][pollo[2] != 0] = [0, 150, 255] # voeg de mais contouren van de kip en de mais samen
#spinaci finder
resultaat = pollo[0]
gray_image = cv2.cvtColor(pizza_box, cv2.COLOR_BGR2GRAY)# Convert the image to grayscale
hist = cv2.calcHist([gray_image], [0], None, [256], [0, 256])# Calculate the histogram
total = 0
# Print the histogram values
for i, value in enumerate(hist):#bekijk de histogram waardes
if i>49 and i<100:
total = total+value
total = total/50
if total>1100: #voor felle foto's
spinaci_mask = hsv_mask(pizza_box, s1)
resultaat = find_contours(resultaat, spinaci_mask,sfc1)
elif total<1100:#voor minder felle foto's
spinaci_mask = hsv_mask(pizza_box, s2)
resultaat = find_contours(resultaat, spinaci_mask,sfc2)
#Sla de afbeelding op
output_path = os.path.join(folder_name, f"{x}_Pollo.jpg")
cv2.imwrite(output_path, resultaat)
print('Pollo found')
elif spinaci_finder(pizza_box) > 250:
mask_spinaci = hsv_mask(pizza_box, s3)
resultaat = find_contours(pizza_box, mask_spinaci,sfc3)
#Sla de afbeelding op
output_path = os.path.join(folder_name, f"{x}_Spinaci.jpg")
cv2.imwrite(output_path, resultaat)
print('spinaci found')
else:
print('nothing found')
cv2.waitKey(0)
cv2.destroyAllWindows()
else:
print(f"Unable to load image: {jpeg_file}")
Resultaten
Om de resultaten te laten zien is hieronder elke soort pizza door de code gehaald om te laten zien wat er uitkomt.
Salami
De pizza salami werd herkend met een nauwkeurigheid van ongeveer 90%
Hawaii
De pizza hawaii werd herkend met een percentage rond de 75% zoals je hierboven kan zien had de software nog moeite met het herkennen van de ham.
Pollo
De pollo werd ongeveer 80% van de tijd correct herkend grotendeels door de mais en de kip.
Spinazie
De spinazie werd ongeveer 90% van de tijd goed herkend alleen maar door te kijken of er spinazie en verder niks op zat.
leuke informatie
De gemiddelde tijd dat een pizza werd herkend was rond de 2 seconden. Een pizza salami was het snelst met 1,5 seconden en een Hawaii het langzaamst met een tijd rond de 3,5 seconden.
De totale nauwkeurigheid van het systeem was 75%.
Er is ook gekeken naar wat er gebeurt als er andere pizza’s door het programma worden gehaald. Hier kwamen verschillende resultaten uit, maar helaas vaker een verkeerde pizza dan de 5e optie dat er geen match was gevonden.
