DEEP LEARNING BOOTCAMP

Computer Vision Basics

created by codecentric.AI

Computer Vision

  • Disziplin Computer Vision gibt es schon sehr lange
  • Einführung in einfache "klassische" Algorithmen
  • Vorteile und Grenzen dieser Algorithmen
  • Am Beispiel einer interaktiven Drohne

DROHNE FINDE DIE PERSON!

WELCHE TOOLS GIBT ES?

  • Weit verbreitet: OpenCV
  • Im Machine Learning Umfeld häufig mit Python
  • Auch interessant: dlib, Pillow

WIE SIEHT DER
RECHNER EIN BILD?

  • Bilder sind 3 dimen-sionale Arrays
  • Punkt (0, 0) oben links
  • OpenCV: erst Y, dann X (Zeile, Spalte)
  • 3 Farbkanäle (RGB bzw. BGR)
  • Farben: Integer 0-255

LADE EIN BILD

(mit OpenCV)



import cv2

image = cv2.imread("test.png")  

y, x = 100, 50
(b, g, r) = image[y, x]  

print(b,g,r)  

image[y, x] = (0, 0, 255)

cv2.imshow("Bild", image)

FARBRÄUME

  • OpenCV default: BGR (Blue Green Red)
  • HSV (Hue Saturation Value)
  • Graustufen (nur 1 Kanal)
  • Farbräume haben Vor- und Nachteile, je nach Applikation

FARBRAUM KONVERTIEREN

import cv2

# lade Bild mit OpenCV
image = cv2.imread("test.png")

# konvertiere das Bild in Graustufen
image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# zeige das Bild an
cv2.imshow("Bild in Graustufen", image)

"KLASSISCHE" ALGORITHMEN UND METHODEN

  • Thresholding
  • Konturen finden
  • Haar Cascade Classifier
  • HOG (Histogram of Oriented Gradients)
  • Laborbedingungen!

THRESHOLDING

  • Thresholding = Filtern
  • nach Farben
  • oder Helligkeit
  • Reduzierung von Noise
  • oder Finden von Objekten

HOG (Histogram of Oriented Gradients)

  • Bild in Grid unterteilen
  • ermittle Kanten pro Zelle
  • = Winkel pro Zelle
  • Sliding Window
  • Viele Rechenoperationen!
  • Viele Fehler!

HOG Feature Vektor eines Gesichts
Quelle: dlib.net

SLIDING WINDOW

 

Detektor Fenster von links

nach rechts

Zeile für Zeile

für jedes Bild in einem Video

import cv2

img = cv2.imread("foto.png")

height, width = img.shape[:2]
window_size = 100
color = (0, 255, 0)  # = green
y, x = 0, 0
step_size = 40

while y < height:
    while x < width:
        new_img = cv2.rectangle(img.copy(), (x, y), 
                    (x + window_size, y + window_size), color)
        cv2.imshow("Sliding Window Demo", new_img)
        cv2.waitKey(1)
        x += step_size
    y += step_size
    x = 0

Image Pyramiden

Detektor findet so auch unterschiedliche Größen

Beispiel: HOG Person Detektor

Dieser HOG Detektor findet nur Personen mit ausgebreiteten Armen

 

Nur gut für sehr

ähnliche Formen.

(z.B. Stoppschild)

Drohne, finde den Marker!

class ObjectDetector:
    def __init__(self, min_area=10):
        self.color_lower = (3, 130, 130)
        self.color_upper = (10, 190, 255)
        self.min_area = min_area

    def detect(self, frame):
        hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
        mask = cv2.inRange(hsv, self.color_lower, self.color_upper)
        mask = cv2.erode(mask, None, iterations=2)
        mask = cv2.dilate(mask, None, iterations=2)

        _, contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL,
                                          cv2.CHAIN_APPROX_SIMPLE)
        try:
            contour = sorted(contours, key=cv2.contourArea, reverse=True)[0]
            if cv2.contourArea(contour) < self.min_area:
                contour = None
        except IndexError:
            contour = None

        return contour

Step 1:

Step 2:

class FaceDetector:
    def __init__(self, scale=1.25, num=3):
        self.cascade = cv2.CascadeClassifier(
                                os.path.join(os.path.dirname(__file__),
                               'detectors/haarcascade_frontalface_default.xml'))
        self.scale = scale
        self.num = num

    def detect(self, frame):
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        rois = self.cascade.detectMultiScale(gray, self.scale, self.num)
        return rois

def get_region(marker):
    x1, y1, w, h = marker
    x1 -= margin_x
    y1 -= margin_y
    x2 = x1 + w + 2 * margin_x
    y2 = y1 + h + margin_y
    return x1, y1, x2, y2


def in_region(marker, face):
    x1, y1, x2, y2 = get_region(marker)
    fx1, fy1, fw, fh = face
    # logging.debug(face)
    if (x1 < fx1) and ((fx1 + fw) < x2) and (y1 < fy1) and ((fy1 + fh) < y2):
        return True

    return False


def find_person(ws):
    marker_detector = ObjectDetector()
    face_detector = FaceDetector()
    frame_idx = 0

    while True:
        ret, frame = cam.read()
        marker = marker_detector.detect(frame)
        if marker is not None:

            marker = cv2.boundingRect(marker)
            faces = face_detector.detect(frame)
            for face in faces:
                if in_region(marker, face):
                    hud.mark_rois(frame, [face], label="face")
                    x1, y1, w, h = face

        hud.get_hud(frame, None, frame_idx)
        cv2.imshow("frame", frame)

Finde Gesichter in der Nähe des Markers!

FAZIT

  • viele "klassische" Algorithmen sind schnell
    und brauchen wenig Rechenleistung
  • sie funktionieren gut unter Laborbedingungen
  • es passieren viele Fehler
  • man muss manuell für jede Szene "tunen"
  • sie "verstehen" nicht, was sie in einem Bild sehen

Ausblick:

 

Mit DEEP LEARNING und NEURONALEN NETZEN ergeben sich neue Möglichkeiten!

...

Computer Vision Basics - codecentric.AI Bootcamp

By Oliver Moser

Computer Vision Basics - codecentric.AI Bootcamp

In dieser Lektion des codecentric.AI Bootcamps geben wir eine grobe Einführung in das Thema Computer Vision. Am Beispiel einer interaktiven Drohne betrachten wir einige "klassische" Computer Vision Algorithmen sowie deren Vor- und Nachteile.

  • 217
Loading comments...

More from Oliver Moser