Realisierung eines Farberkennungssensors mit Python und OpenCV – Teil 1

In der Praxis gibt es häufig die Aufgabe, die Farbe von Objekten  (z.B, Produkten) automatisch zu erkennen und aus der ermittelten Information irgendwelche Aktionen abzuleiten, sei es das Generieren einer Nachricht oder auch das Schalten eines Relais.

Aus diesem Grunde zeige ich heute, wie man mit sehr wenig Aufwand mittels einer Webcam, einem Rechner (kann auch ein Raspberry Pi sein), Python und OpenCV) ein System erstellt, welche die Farbe eines beliebigen Objektes (repräsentiert durch die 3 Werte des HSV-Farbraumes) digital ermittelt. Dies geschieht, in dem man ein Fadenkreuz auf den interessierenden Bereich des Bildes bewegt. Hierzu lassen sich im Programm folgende Tasten benutzen:

G- nach links

Z- nach oben

J-nach rechts

N- nach unten

Hat mein den interessierenden Farbwert (Hue) gefunden, lässt er sich mit der m -Taste (Memory) abspeichern.

Aus dem hier vorgestellten Code-Snippet lässt sich dann einfach ein Sensor entwickeln, der bei Auftauchen einer vorher festgelegten Farbe  (Farbbereich) eine Aktion auslöst, dies wird dann im Teil 2 dieses Artikel behandelt, wenn Interesse besteht.

Code-snippet Erkennung von Farbwerten in einer Region of Interest (ROI) mit Python 3.x und OpenCV

Dieses Codesnippet einfach in den Editor Deiner Wahl kopieren und mit Python ausführen. nympy und OpenCV müssen installiert sein.

# calculation  of HSV - color values

import numpy as np
import cv2

# initialisiere Webcam
cam = cv2.VideoCapture(0)

cam.set(3,1280)
cam.set(4,720)

# initiale Koordinaten für Auslesung definieren
x, y, w, h = 250, 150, 100, 100

# show stream from WebCam
while cam.isOpened():
    # lese frame von WebCam
    ret, frame = cam.read()

    # convert Frame into HSV
    frame = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)

    # zeige Hue-Wert im Fadenkreuz
    cv2.putText(frame, "HSV: {0}".format(frame[y + 1, x + 1]), (x, 100),
                cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), thickness=2)
    cv2.line(frame,(x-100,y),(x+100,y),(0,0,0),2)
    cv2.line(frame, (x, y-100), (x , y+100), (0, 0, 0), 2)
    cv2.circle(frame,(x, y) ,50 , (0, 0, 0), 2)

    # show complete frame
    cv2.imshow("frame", frame)

    # wait for key
    key = cv2.waitKey(1)
    print (key)
    if key == 106:        # J-Taste
        x=x+5
    elif key == 103:      # G -Taste
        x = x - 5
    elif key == 122:      # Z-Taste
        y = y -5
    elif key == 110:      #  N-Taste
        y = y +5
    elif key == 109:      #  M-Taste (memory)
        HSV_mem = frame [(x,y)]
        H_mem = HSV_mem[0]
        # break
    # wenn ESC gedrueckt, beende Programm
    elif key == 27:
        cv2.destroyAllWindows()
        break

Ergebnisse

Nach Positionierung des Fadenkreuzes auf dem entsprechenden Modellauto werden die HSV- Werte des jeweiligen Modells angezeigt.

Originalansicht des verwendeten „Test-Aufbaus“

Erläuterungen

Das von der Camera gelieferte Bild wird zunächst in den HSV-Farbraum, konvertiert

Der HSV-Farbraum wird in OpenCV in folgenden Wertebereichen gepeichert:

  • Hue (H, Farbwert):  0 bis 180 
  • Saturation (S, Sättigung):  0 bis 255
  • Value (V, Helligkeit):  0 bis 255

Diesr Wertebereich unterscheidet sich von vielen anderen Programmen und Bibliotheken (wie z.B. Gimp), also Vorsicht, das ist die Ursache für einige schwer zu findende Fehler. 

Das Bild liegt jetzt in Form einer Matrix vor, die alle gewünschten Informationen bereitstellt.     Über ein Fadenkreuz, welches sich über das eingelesen Bild mittels der Tasten auf der Tastatur bewegen läßt, wird dem Programm die gewünscht Position für die Farbwertermittlung mitgeteilt. Die HSV-Werte werden jetzt ermittelt und auf dem Bild angezeigt. Zur späteren Weiterverarbeitung läßt sich aktuelle Farbwert durch die „m“-Taste in einer Variable speichern.

Dieser Artikel zeigt natürlich nur de generelle Vorgehensweise. Unter industriellen Bedingungen müsste man sich als erstes um konstante Beleuchtungsbedingen kümmern, um verlässliche Aussagen zu erhalten.

Kanten zählen mit Python und OpenCV

Computer Vision 

Heute stellen wir und der Aufgabe, die Schärfe eines auf dem Datenträger vorliegenden Bildes automatisch zu ermitteln. Hierzu habe ich mir von Pixabay ein Bild ((https://pixabay.com/de/youtuber-blogger-drehbuchautor-2838945 vielen Dank an Lucas!) besorgt und mit Photoshop über den Gaußschen Weichzeichner 3 verschiedene Schärfe-Muster erstellt. Das erste Bild ist unverändert (also scharf), die folgenden wurden mit dem Gaußschen Weichzeichner jeweils mit Einstellung 2px bearbeitet.

Der Lösungsansatz für die Schärfeermittlung ist es, über Python 3.6 und OpenCV 3.x  die Anzahl der Kanten in den Bildern zu ermitteln. Voraussetzung ist, wie bei allen Computer -Vision-Projekten hier, das die OpenCV-Bibliothek auf dem Entwicklungssystem installiert ist. Den verwendeten Algorithmus und Quelltext werde ich in den nächsten Tagen gerne detailliert erklären, falls das gewünscht wird. 

Das lauffähige Code-Snipplet (Python 3.6, OpenCV 3.x) für das Zählen der Kanten (Schärfeermittlung) in einem Bild:

import numpy as np
import cv2
image = cv2.imread("test07.jpg")
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
blurred = cv2.GaussianBlur(gray, (11, 11), 0)
cv2.imshow("blurred", image)
canny = cv2.Canny(image, 30, 150)
cv2.imshow("Canny-Algorithmus", canny)
edged = cv2.Canny(blurred, 30, 150)
cv2.imshow("Kanten", edged)
(_, cnts, _) = cv2.findContours(edged.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
anz= str(len(cnts))
kanten = image.copy()
cv2.putText(kanten, "gezaehlt: "+ anz + " Kanten", (50, 50), cv2.FONT_HERSHEY_SIMPLEX,
0.75, (0, 255, 0), 2)
cv2.drawContours(kanten, cnts, -1, (0, 255, 0), 2)
cv2.imshow("Kanten", kanten)
cv2.waitKey(0)
cv2.destroyAllWindows()

Das sind die 3 Ausgangsbilder, derminimale Schärfeverlust von Bild zu Bild ist mit dem Auge kaum feststellbar

trotzdem fallen die Zählergebnisse des Kantenzählalgorithmus signifikant unterschiedlich aus, was eine sichere automatische Schärfebeurteilung erlaubt.

Zusammenfassung

Der vorgestellte Algorithmus ist sehr gut in der Lage, die Schärfe eines Bildes durch Zählen der Kanten im Bild zu beurteilen. Mit bloßem Auge kaum wahrnehmbare Unterschiede in der Schärfe wirken sich signifikant in der Anzahl der Kanten aus.