# "KI und Ernährung"
Hallo zusammen!
Ich habe in diesem Dokument versucht alles zusammenzufügen. Insbesondere habe ich einige Sachen aus dem Dokument von Herrn Rongen kopiert. Falls das nicht gewünscht ist bitte "Einspruch" einlegen.
## Didaktischer Aufbau und Spielablauf (von Herrn Rongen [Dokument](https://myshare.uni-osnabrueck.de/f/fe8e44e7845d4873ad89/))
| Stationsaufbau | Spielablauf |
| -------- | -------- |
|  | 
## Interaktion zw. den Monitoren und der Erkennung
Hier habe ich gemäß den Spielablauf eine Grafik angefertigt.
Die entsprechenden Nachrichtien die auf den jeweiligen Monitor angezeigt werden finden sich weiter unten.

# Texte für den Kommunikationsbildschirm und Spielfeld
## Feinschliff
der Texte ueberarbeitet von Frau Feuerriegel für den Kommunikationsbildschirm
[Feinschliff Kommunikationsbildschirm](https://myshare.uni-osnabrueck.de/f/40b90b8e7b354379acc9/)

## Mockup für das Spielfeld und den Kommunikationsbildschirm von Herrn Jürges (der oben genannte Feinschliff ist hier bereits eingeflossen)
[Mockup Kommunikationsbildschirm](https://myshare.uni-osnabrueck.de/f/b224f23666974c29a810/)

[Mockup Spielfeld](https://myshare.uni-osnabrueck.de/f/bab09e77cf6e436f86cd/)

## Testaufnahmen der Objekte von Herrn Rongen
[Original](https://myshare.uni-osnabrueck.de/f/5c7fa3159cb2473ba48a/)

## Objekterkennung - Training
Prinzipell funktioniert die Objekterkennung befindet sich allerdings noch in einer Teststruktur.
Ohne Abbruch wird sie mit der Steinwabe durchlaufen.

Eingebunden hier als
```
#SteinWabe? - getested
#bricht bei Test auf Weizen und Reh
img = cv2.imread('steinWabe.jpg')
```
Bei den anderen Beiden Objekte müssen die Fehler noch abgefangen werden.


Ebenso muss die Struktur noch geändert werden, da ich zum Testen bei jedem Bild auf alle Objekte getestet habe um Fehler zu erkennen.
Die Koordinatenumrechnung sowie die Datei, in der erkannte Objekt geschrieben wird, folgt schnellstmöglich morgen.
### Kompletter Quellcode
```
#Training der Objekte
#detect OpenCV
import cv2
import numpy as np
#Aufnahme mit Standarteinstellungen
""" with picamera.PiCamera() as camera:
camera.capture('bild.jpg') """
""" print(img.size)
print(img.shape) """
#Bildgenerierung lediglich vom Spielfeld,
#d.h. nutzen der zuvor festgelegten Grenzen
#Werte einlesen, und neue Aufnahme zuschneiden
#pruefe auf Objekte
#wir haben ein ...
#Werte fuer gruen
lowerGreen = np.array([40,80,70])
upperGreen = np.array([80, 255, 255])
greenBool=False
#Werte fuer gelb
lowerYellow = np.array([3,46,163])
upperYellow = np.array([35, 168, 224])
yellowBool=False
#Werte fuer gray
lowerGray = np.array([56,2,73])
upperGray = np.array([129, 42, 226])
grayBool=False
#Anzahl der Trainingsversuche
#counter=0
#Funktion Farberkennung
def farberkennung(lower,upper,greenBool,grayBool,yellowBool):
#img = cv2.imread('wabe-weizen.png')
#img = cv2.imread('alleWaben.jpg')
#Test auf Rehproblem,
#Reh wird als Weizen und Stein identifiziert
#img = cv2.imread('rehWabe.jpg')
#Weizen Stein?
#Ja in den Randbereichen und bricht ab wenn ein Reh gesucht wird
#img = cv2.imread('weizenWabe.jpg')
#SteinWabe? - getested
#bricht bei Test auf Weizen und Reh
img = cv2.imread('steinWabe.jpg')
#img = cv2.imread('SpielfeldMitObjekten.jpg')
cv2.imshow("Original", img)
#Rauschen
blur = cv2.GaussianBlur(img, (9,9), 1)
cv2.imshow("blur", blur)
#Threshold
#thresh = cv2.adaptiveThreshold(blur,200,cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV,31,3)
#cv2.imshow("tresh", thresh)
#Aufteilung der Farbkanaele
b,g,r = cv2.split(blur)
#Graustufenbild
gray = cv2.cvtColor(blur, cv2.COLOR_BGR2GRAY)
#cv2.imshow("gray", gray)
# Kantendetektion
edge = cv2.Canny(blur, 100,200)
#cv2.imshow("Kanten", edge)
#Transformation von RGB nach HSV-Farbraum
HSVimage = cv2.cvtColor(blur, cv2.COLOR_BGR2HSV)
#Farberkennung nach vorgegeben Grenzen
HSVcolor = cv2.inRange(HSVimage, lower, upper)
#ueberlagertes Bild
color = cv2.bitwise_and(blur,blur, mask=HSVcolor)
cv2.imshow("Color", color)
#Position im Feld ermitteln
#Kanten auf dem maskierten Bild
edge_color=cv2.Canny(color,100,200)
cv2.imshow('KantenColor', edge_color)
#edge_color=255-edge_color
#findet min/max weisses Objekt
notBlack=cv2.findNonZero(edge_color)
#print("notBlack",notBlack[:,0,0])
try:
a = notBlack[:,0,0].min()
except TypeError:
print("TypeError Exception Raised.")
if (np.array_equal(lower,lowerYellow)):
set_yellowBool()
if (np.array_equal(lower,lowerGreen)):
set_greenBool()
if (np.array_equal(lower,lowerGray)):
set_grayBool()
else:
print("Ohne Fehler")
#if notBlack[:,0,0].min() >0 :
#Eckpkt, oben unten links rechts des Objekts
a = notBlack[:,0,0].min()
b = notBlack[:,0,0].max()
c = notBlack[:,0,1].min()
d = notBlack[:,0,1].max()
print('a:{},b:{},c:{},d:{}'.format(a,b,c,d))
#Mittelpkt
cA=(a+b)/2
cB=(c+d)/2
print('Objektmitte: {},{}'.format(cA,cB))
#zeichnet Rechteck
start=(a,c)
end=(b,d)
farbe=(255,0,0)
dicke=1
imgRechteck = cv2.rectangle(edge_color,start,end,farbe,dicke)
cv2.imshow('Objekt', imgRechteck)
#Objektposition[cA][cB] Mittelpunkt zunaechst fuer nur ein Objekt
objPosition = [[cA,cB]]
print(objPosition[0])
#schreibt das Ergebnisbild
cv2.imwrite('objectDetec.jpg', imgRechteck)
pruefeFund(lower,greenBool,grayBool,yellowBool)
def set_greenBool():
global greenBool
greenBool = True
def set_yellowBool():
global yellowBool
yellowBool = True
def set_grayBool():
global grayBool
grayBool = True
def pruefeFund(low1,greenBool,grayBool,yellowBool):
if(np.array_equal(low1,lowerGreen) and (greenBool==False)):
print("Wir haben ein Reh")
set_greenBool()
#print(greenBool)
elif(np.array_equal(low1,lowerYellow) and (yellowBool==False)):
print("Wir haben Weizen")
set_yellowBool()
#print(yellowBool)
elif(np.array_equal(low1,lowerGray) and (grayBool==False)):
print("Wir haben einen Stein")
set_grayBool()
#print(grayBool)
else:
print("nix")
while (greenBool==False and grayBool==False and yellowBool==False) :
#farberkennung(lowerGreen,upperGreen,greenBool,grayBool,yellowBool)
#pruefeFund(lowerGreen,upperGreen)
#print(np.array_equal(lowerGreen,lowerGreen))
#
if (grayBool==False):
farberkennung(lowerGray,upperGray,greenBool,grayBool,yellowBool)
print("Gray:",grayBool)
cv2.waitKey()
if (greenBool==False):
farberkennung(lowerGreen,upperGreen,greenBool,grayBool,yellowBool)
print("Green:",greenBool)
cv2.waitKey()
if (yellowBool==False):
farberkennung(lowerYellow,upperYellow,greenBool,grayBool,yellowBool)
print("Yellow:", yellowBool)
cv2.waitKey()
#haelt die Anzeigen offen
cv2.waitKey()
cv2.destroyAllWindows()
```
## Kalibrierung zum Testen
Originalaufnahme mit einem Abstand von 109 cm und Beleuchtung (den uninteressanten Bereich habe ich im Skript maskiert). Hier müssen Anpassungen an die Gegebenheiten im Truck erfolgen, je nachdem welche Auslenktolerantzen wir festlegen wollen (rollen, gieren, neigen).
Ebenso ist das Farbschema noch festzulegen, hier ist bereits eine obere und untere Grenze mit eingeflossen um einen entsprechenden Spielraum zu erhalten.
Ein Bild welches nach dem Download für das Skript in "bild.jpg" umgenannt werden muss, findet sich an dieser Stellen:

Alternativ können die drei Codezeilen unter "#Aufnahme mit Standarteinstellungen" im QuellCode, die Kommentare entfernt werden, um ein Bild mit der eigenen Kamera zu erzeugen.
Es wurde mit den original RasperryKamera-Bildern gearbeitet, um die Erfahrung der unterschiedlichen Lichteinflüsse berücksichtigen zu können.
Nach Ausführung des Skripts wird der neue, anhand der Marken ermittelte Aufnahmebereich, in ein Datei geschrieben.
Im folgenden Bild findet sich der kalibrierte Aufnahmebereich um einen Wert x "in alle Richtungen", der nur zu testzwecken eingsetzt ist.

```
#Cam
import time
import picamera
#detect OpenCV
import cv2
import numpy as np
#Aufnahme mit Standarteinstellungen
#with picamera.PiCamera() as camera:
# camera.capture('bild.jpg')
# time.sleep(1)
#Originalbild, abgelegt im Ordner des Skripts, wird zur weiteren Verareibtung geladen
img = cv2.imread('bild.jpg')
cv2.imshow("Original", img)
print img.size
print img.shape
#uninteressante Bereiche ausblenden (tbd TTT )
#Aufnahmebereich in Pixeln festlegen
untereGrenze=650
obererGrenze=200
linkeGrenze=680
rechteGrenze=1200
# erster Wert: oben, unten; zweiter Wert: rechts, links
#Rechteck links
img[0:1080, 0:linkeGrenze]=0
#Rechteck rechts
img[0:1080, rechteGrenze:1920]=0
#Rechteck oben
img[0:obererGrenze, linkeGrenze:rechteGrenze]=0
#Rechteck unten
img[untereGrenze:1080, linkeGrenze:rechteGrenze]=0
cv2.imshow('Ueberschrieben', img)
#schreibt das Ergebnisbild
cv2.imwrite('aufnahmeBereich.jpg', img)
#Aufteilung der Farbkanaele
b,g,r = cv2.split(img)
#Graustufenbild
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
#cv2.imshow("gray", gray)
# Kantendetektion
edge = cv2.Canny(img, 100,200)
#cv2.imshow("Kanten", edge)
#Transformation von RGB nach HSV-Farbraum
HSVimage = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
#Farberkennung rote Referenzpunkte
lower = np.array([165,82,43])
upper = np.array([179,127,255])
HSVred = cv2.inRange(HSVimage, lower, upper)
#ueberlagertes Bild
red = cv2.bitwise_and(img,img, mask=HSVred)
cv2.imshow("rot", red)
#Kanten auf dem maskierten Gruenbild
edge_red=cv2.Canny(red,100,200)
#nicht zu untersuchende Bereiche werden ueberschrieben/ausgeblendet
im= edge_red
#im[0:1080, 0:800]=0
#im[512:1110, 512:1110]=255
#im[0:1080, 1300:1920]=0
#cv2.imshow('Uberschriebene', im)
#findet min/max weisses Objekt
notBlack=cv2.findNonZero(im)
#Eckpkt
a = notBlack[:,0,0].min()
b = notBlack[:,0,0].max()
c = notBlack[:,0,1].min()
d = notBlack[:,0,1].max()
print('a:{},b:{},c:{},d:{}'.format(a,b,c,d))
#Mittelpkt
cA=(a+b)/2
cB=(c+d)/2
print('Objektmitte: {},{}'.format(cA,cB))
#Anpassungen TTT (tbd)
a=a-100
b=b+100
c=c-100
d=d+100
#zeichnet Rechteck des neuen Aufnahmebereichs
start=(a,c)
end=(b,d)
farbe=(255,0,0)
dicke=2
imgRechteck = cv2.rectangle(im,start,end,farbe,dicke)
cv2.imshow('Aufnahmebereich', imgRechteck)
#ermittelte Werte in ein Datei schreiben
aufnahmeBereich = open('aufnahmeBereich.txt', 'w')
aufnahmeBereich = open('aufnahmeBereich.txt','a')
aufnahmeBereich.write("a:linksoben, b:linksunten, c:rechtsoben, d:rechtsunten" + "\n")
aufnahmeBereich.write(str(a)+", " +str(b)+", " +str(c)+", " +str(d))
aufnahmeBereich.close()
#Objektposition[cA][cB] Mittelpunkt zunaechst fuer nur ein Objekt
objPosition = [[cA,cB]]
print(objPosition[0])
#schreibt das Ergebnisbild
cv2.imwrite('resultierenderAufnahmebereich.jpg', imgRechteck)
#haelt die Anzeigen offen
cv2.waitKey(0)
cv2.destroyAllWindows()
```
## Koordinatenermittlung zum Testen
Originalaufnahme mit einem Abstand von 109 cm und Tageslicht (den uninteressanten Bereich habe ich nachträglich maskiert. So werden wir auch den Aufnahmebereich nach der Installation maskieren bzw. den Aufnahmebereich mit einer entsprechenden Toleranz einschränken)
Verwendete Testaufnahme:

Zu Testen muss das bild (bild1.jpg) in den Ordner, wo sich auch das Python-Skript befindet oder der Pfad müsste noch angepasst werden
Zu Testzwecken liefert das Python lediglich ein Objekt bzw. dessen Koordinaten des Mittelpunkts.
Ergebnis der Objektermittlung (hier grün), das Rechteck ist lediglich wg. meiner Tests verbleiben:

Die Koordinaten finden sich in dem Array
objPosition, in Form des Mittelpunktspixel des Objekts hier (1100, 560) bei einer Gesamtgröße von 1920 zu 1080 Pixeln
Zum Ausbrobieren lege ich das Skript, relativ unaufgeräumt, hier ab.
```
#Cam
import time
import picamera
#detect OpenCV
import cv2
import numpy as np
#Aufnahme mit Standarteinstellungen
#with picamera.PiCamera() as camera:
# camera.capture('bild1.jpg')
img = cv2.imread('bild1.jpg')
#cv2.imshow("Original", img)
print img.size
print img.shape
#Aufteilung der Farbkanaele
b,g,r = cv2.split(img)
#Graustufenbild
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
#cv2.imshow("gray", gray)
# Kantendetektion
edge = cv2.Canny(img, 100,200)
#cv2.imshow("Kanten", edge)
#Transformation von RGB nach HSV-Farbraum
HSVimage = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
#Farberkennung Gelb
#Binaerbild gelbe Bereiche, weiss; Rest schwarz
HSVyellow = cv2.inRange(HSVimage, (18,85,85), (35, 255, 255))
#ueberlagertes Bild
yellow = cv2.bitwise_and(img,img, mask=HSVyellow)
#cv2.imshow("Gelb", yellow)
#Farberkennung Gruen
HSVgreen = cv2.inRange(HSVimage, (40,80,70), (80, 255, 255))
#ueberlagertes Bild
green = cv2.bitwise_and(img,img, mask=HSVgreen)
#cv2.imshow("Gruen", green)
#Kanten auf dem maskierten Gruenbild
edge_green=cv2.Canny(green,100,200)
#cv2.imshow('KantenGreun', edge_green)
#nicht zu untersuchende Bereiche werden ueberschrieben/ausgeblendet
im= edge_green
im[0:1080, 0:800]=0
#im[512:1110, 512:1110]=255
im[0:1080, 1300:1920]=0
#cv2.imshow('Uberschriebene', im)
#findet min/max weisses Objekt
notBlack=cv2.findNonZero(im)
#Eckpkt
a = notBlack[:,0,0].min()
b = notBlack[:,0,0].max()
c = notBlack[:,0,1].min()
d = notBlack[:,0,1].max()
print('a:{},b:{},c:{},d:{}'.format(a,b,c,d))
#Mittelpkt
cA=(a+b)/2
cB=(c+d)/2
print('Objektmitte: {},{}'.format(cA,cB))
#zeichnet Rechteck
start=(a,c)
end=(b,d)
farbe=(255,0,0)
dicke=2
imgRechteck = cv2.rectangle(im,start,end,farbe,dicke)
cv2.imshow('Objekt', imgRechteck)
#Objektposition[cA][cB] Mittelpunkt zunaechst fuer nur ein Objekt
objPosition = [[cA,cB]]
print(objPosition[0])
#schreibt das Ergebnisbild
cv2.imwrite('objectDetec.jpg', imgRechteck)
#haelt die Anzeigen offen
cv2.waitKey(0)
cv2.destroyAllWindows()
```
Herr Kirmess und ich haben uns gestern bzgl. der Algorithmus-Schnittstelle ausgetauscht. Ich wollte Ihnen hiermit ein kurzes Update geben und berichten, was wir besprochen haben.
Wir haben eine Nummerierung der 15 Waben/Felder festgelegt. Die Nummerierung beginnt beim oberen linken Feld mit der Zahl 0 und führt sich zeilenweise fort.
Die Umrechnung der Pixelkoordinaten in Zellennummern übernimmt der Algorithmus von Herrn Kirmess.
Wir haben definiert, dass die Kalibrierung der Kamera unabhängig von den anderen Bestandteilen des Algorithmus gestartet werden kann. Wir lösen die Kalibrierung aus, sobald ein Schüler auf der Startseite des „Guide“-Screens auf „Start“ drückt. Für die Kalibrierung will Herr Kirmess die von Herrn Rongen vorgesehenen Kalibrierungspunkte verwenden. Er muss das allerdings noch testen und implementieren. Auch will Herr Kirmess testen, wie groß die Toleranzen hierbei sind. Also um wieviel Grad sich die Kamera drehen kann, oder um wieviel Millimeter die Ausrichtung der Kamera abweichen kann, und trotzdem noch eine korrekte Klassifizierung und Positionsermittlung erfolgen kann.
Wir haben definiert, dass beim Trainingsprozess der Algorithmus prüft, ob es sich bei dem vom Schüler positionierten Objekt auch um das geforderte Objekt handelt. Trifft das nicht zu, so muss der Schüler den Trainingsprozess für das Objekt wiederholen. Es ist demnach nicht möglich der „KI“ beizubringen, dass bspw. ein Reh wie ein Stein aussieht oder sonstige manipulative Kombinationen.
Ein Kamerabild soll beim erfolgreichen Trainingsprozess eingeblendet werden. (Guide-Screen).
Der Algorithmus liefert uns über die Schnittstelle zwei Werte:
Das Kamerabild
Das erkannte Objekt in Textform („Reh“ | „Steine“ | „Weizen“ | „Leer“)
Wir haben definiert, dass der Schüler alle 15 Objekte auf der Spielfläche platzieren muss (wenn er/sie dazu aufgefordert wird). Sind es weniger als 15, oder konnten Teile nicht korrekt identifiziert werden, wird der Schüler aufgefordert den Prozess zu wiederholen.
Ein Kamerabild soll beim erfolgreichen Scanvorgang eingebaut werden (Guide-Screen).
Der Algorithmus liefert uns über die Schnittstelle folgende Werte:
Das Kamerabild
Eine Liste aller Positionen mit erkannten Objekten: [ „Reh“, „Weizen“, „Weizen“, „Leer“, „Steine“, … ] -> 0: Reh, 1: Weizen, 2: Weizen, 3: Leer, 4: Steine,…
=================================================================
=================================================================
# **Veraltet:**
### Textvorschläge (bereits überarbeitet [s.o.](#Feinschliff) ) , Kirmess, für den Kommunikationsbildschirm
> [name=Kirmess] Die Texte sind zunächst als erster Entwurf zu betrachten. Für Änderungen und Vorschläge, evtl. wie und welche Grafiken hier unterstützen können, wäre ich sehr dankbar.
### Begrüßung
~~Hallo und willkommen an der Station "KI und Ernährung"!
Du hast heute eine wichtige Aufgabe!
Ein Getreidefeld das noch aufzubauen ist, siehe vor Dir, soll heute geerntet werden.
Bevor dies geschiet, muss aber eine Drohne hinüberfliegen, um die dort darin versteckten Objekte zu identifizieren.
Dies geschieht mit einer "KI".
Damit diese funktioniert, muss sie zunächst trainiert werden, damit die KI weiß welche unterschidelichen Objekte überhaupt existieren.
Nach dem Training ist es ebenso deine Aufgabe das Feld aufzubauen.
Aber zunächst zum Training, wenn du bereit bist, drücke den Verstanden-Knopf auf dem Bidlschirm unten vor Dir.
### Training
#### Objekt 1
Wir beginnen mit dem Training. Platziere aus dem Regal vor Dir als erstes eine Wabe mit Getreide.
> [name=Kirmess] Feedback erfolgt über das Spielfeld (vgl. Pkt. 6 )
> [name=Kirmess] Ich lasse hier zunächst offen ob wir uns an strenge Vorgaben halten oder die SUS wählen lassen welches Objekt zu platzieren ist
##### Antwortmöglichkeit 1
Sehr gut! Wir haben der KI beigebracht Getreide zu erkennen.
Wie du siehst wurde links das Getreide-Symbol hinzugefügt.
Stelle das Getreide zurück ins Regal.
Nun wähle eins der beiden verbleibenden Objekte.
##### Antwortmöglichkeit 2
Das Objekt wurde nicht erkannt. Wiederhole dein Vorgehen mit einem der Objekte aus dem Regal.
#### Objekt 2
##### Antwortmöglichkeit 1
Sehr gut! Wir haben der KI beigebracht Tiere/Steine zu erkennen.
Wie du siehst wurde links das Tiere/Steine-Symbol hinzugefügt.
Stelle das Tier/Stein zurück ins Regal.
Nun wähle das letzte verbleibenden Objekte.
##### Antwortmöglichkeit 2
Das Objekt wurde nicht erkannt. Wiederhole dein Vorgehen mit dem Objekte Tier/Stein aus dem Regal.
#### Objekt 3
##### Antwortmöglichkeit 1
Sehr gut! Wir haben der KI beigebracht ... zu erkennen.
Wie du siehst wurde links das ...-Symbol hinzugefügt.
Stelle das ... zurück ins Regal.
##### Antwortmöglichkeit 2
Das Objekt wurde nicht erkannt. Wiederhole dein Vorgehen mit dem Objekte ... aus dem Regal.
### Trainingsende
Du hast soeben die KI angelernt alle verfügbaren Objekt aus dem Regal zu erkennen! Gut gemacht!
### Spielfeldaufbau
Baue nun das zu erntende Getreidefeld auf. Hierzu plaziest du alle verfügaberen Objekte in dem vorgegeben Raster auf ganz nach belieben.
##### Antwortmöglichkeit 1
Alle verwendtbaren Objekte wurden plaziert, gleich beginnt der Erntevorgang.
##### Antwortmöglichkeit 2
Leider sind noch nicht alle Objekte plaziert, schaue nochmal im Regal nach, ob du nicht ein Element vergessen hast.
### ErnteNachricht
Du hast das Getreidefeld erfolgreich konstruiert, nun können wir mit der Ernte beginnen.
Bevor wir starten nehme aber zunächst alle Objekte Gegenstände von dem "Spielfeld".
### EndNachricht
Toll! Das Getreide wurde geerntet ohne Verletzung eines Tiers bzw. eine Beschädigung einer Maschine.
## Testaufnahmen
[eine Reihe von Testaufnahmen mit Monitor](https://myshare.uni-osnabrueck.de/d/18e4a4d81caa4f46b300/)
Hier wurden 3 unterschiedliche Höhen/Abstände von Kamera zum Aufnahmebereich verwendet
mittlerer Abstand: ca 55 cm
geringster Abstand: ca. 41 cm, die Kamera nimmt lediglich den Monitor auf +
größter Abstand: ca. 86 cm, anzunehmende Mindesthöhe, damit die Drohne nicht im Sichtfeld hängt
Ebenso habe wurden, nach Möglichkeit unterschiedliche Beleuchtungen eingesetz, um einen möglichen Effekt auf den Monitor zu simulieren.
- keine Beleuchtung
- relativ direkte Beleuchtung einer Deckenleuchte
- sowie indirekte Beleuchtung mit einer Stehlampe
[Monitor: Dell 24 Touch-Monitor P2418HT](https://www.dell.com/de-de/shop/dell-24-touch-monitor-p2418ht/apd/210-akbd/monitore-und-monitorzubeh%C3%B6r)
TTT-Station

Die "Tischhöhe" der Station beträgt 87 cm. Würden wir die Kamera in einem Abstand von 86 cm aufhängen, kämen wir auf eine Drohnenhöhe, gemessen vom Boden ca. 1,73 m. Die Höhe sollte meiner Meinung nach mindestens erreicht werden damit sie sich nicht im Sichtfeld der SuS befindet.
idealAbstandCa86cmHintergrundbeleuchtungDunkel

idealAbstandCa86cmHintergrundbeleuchtungHell (hier liegt ein Feher vor, die Objekte lagen wie im obigen Bild zu sehen auf dem hellen Desktophintergrund, und waren im Erkennungsbild nicht so klar abgegrenzt wie im Obigen)

idealAbstandCa86cmIndirektBeleuchtungAufMonitor

idealAbstandCa86cmMitBeleuchtungAufMonitor

idealAbstandCa86cmMitBeleuchtungAufMonitor2

idealAbstandCa86cmOhneBeleuchtungAufMonitor

minAbstandCa40cmOhneBeleuchtungAufMonitor2

minAbstandCa40cmOhneBeleuchtungAufMonitor

minAbstandCa40cmMitBeleuchtungAufMonitor

idealAbstandCa51cmOhneBeleuchtungAufMonitor

idealAbstandCa51cmMitBeleuchtungAufMonitor

idealAbstandCa51cmIndirektBeleuchtungAufMonitor

ca55cmOhneBeleuchtObjAufMonitor

ca55cmMitBeleuchtObjAufMonitor

ca55cmOhneBeleucht

ca55cmMitBeleucht

ERSTE: mit der Kamera und Farbdetektion Abstand ca. 55 cm
gelb:

=================================================================