Wie programmiert man eine Objekterkennung im Kamerabild?

[Olli Z. (z80freak)]

Ich beschäftige mich immer wieder mal mit Themen rund um 
Videosignalverarbeitung (Analog wie auch digital), meine Kentnisse sind 
jedoch recht oberflächlich.

Objekterkennung in Videosignalen, sagen wir mal von einer kleinen 
CCD-Kamera ist heutzutage ja eigentlich nichts besonderes mehr. Ich 
meine damit das eine Software aus einem Bild oder Bildstrom darin 
befindliche Objekte erkennt und ggf. auch verfolgt.

Die dahinter steckende Theorie, sowie die grundlegenden Verfahren um 
sowas in Software und vor allem in Echtzeit umzusetzen würde ich gern 
verstehen. Was braucht es dazu alles? Ich habe irgendwie keine Idee wie 
ich da anfangen und wonach ich konkret suchen soll?

Einzelne Fragen zu irgendwelchen Spezialbereichen daraus zu stellen 
scheint mir aktuell wenig sinnvoll, ich glaube ich muss erstmal ein paar 
Grundlagen büffeln...

[Max M. (jens2001)]

Olli Z. schrieb:
> ich muss erstmal ein paar
> Grundlagen büffeln...

Mach das!

[Hannes J. (Firma: _⌨_) (pnuebergang)]

Für den Privatbastler ist wahrscheinlich die OpenCV Bibliothek 
https://opencv.org/ am zugängigsten wenn es um die paar hundert 
Basisalgorithmen geht. Ein paar hundert Algorithmen ist dabei kein Witz.

Damit kann man dann Copy-Paste von im Internet gefundenen Code zu 
Objekterkennung machen, oder man setzt sich mit einem halben 
Hochschulstudium für die Grundlagen auseinander.

[Framulestigo (Gast)]

Mal was zum herumprobieren:
https://www.codeproject.com/Articles/196168/Contour-Analysis-for-Image-Recognition-in-C

[Olli Z. (z80freak)]

Gibt es denn sowas wie einen grundsätzlichen, theoretischen Ansatz für 
ein solches Problem? Oder sind aufgrund der genannten zahlreichen 
Algorithmen (100+) garkeine allgemeingültigen Vorgehensweisen nennbar?
Wohlgemerkt, ich will garnicht den aktuellen Stand der Technik 
ergründen, sondern die Basiskonzepte denen es zugrunde liegt.

Ich denke ja das man komplexe Objekte, besonders im 3D Raum irgendwie 
über ein neuronales Netz antrainieren muss.

Wenn ich das Problem nun vereinfache und sage ich möchte nur im 2D Raum 
Objekte erkennen, evtl. auf Basis eines S/W-Bildes, wie erkennt eine 
Software in dem Array von Bytes ein geometrisches Objekt? Geht sowas 
über ein komplettes Bild oder über den Stream?

[Theor (Gast)]

Um sich in einem (fast) völlig unbekannten Thema ersteinmal grob zu 
orientieren, lohnt sich meiner Meinung nach ein Blick in Wikipedia.
Einmal auf Deutsch https://de.wikipedia.org/wiki/Objekterkennung und 
einmal auf Englisch 
https://en.wikipedia.org/wiki/Outline_of_object_recognition

Ich bevorzuge die englische Version, weil sie oft lesbarer und 
ausführlicher geschrieben und mit mehr Kontext und Literaturangaben 
versehen ist.

Darüber hinaus ist eine Suche im Internet meist ziemlich hilfreich.

[c-hater (Gast)]

Olli Z. schrieb:

> Gibt es denn sowas wie einen grundsätzlichen, theoretischen Ansatz für
> ein solches Problem?

Im Prinzip läuft es immer darauf hinaus, "Merkmale" eines gesuchten 
Objektes zu definieren und geeignete Filter, die es ermöglichen, eben 
diese Merkmale möglichst zweifelsfrei und gleichzeitig effizient 
aufzuspüren.

Das beides in kompetenter Form zu tun, erfordert ein tiefes Verständnis 
der Signalverarbeitung, welches du offensichtlich nicht besitzt. Da 
hilft nur eins: Lernen...

Hart ist das Leben...

[Timmo H. (masterfx)]

Für den Start würde ich mit den Tensorflow examples anfangen mit einem 
Pretrained Model (z.B.) ssd_mobilenet_v1_coco.
Ist recht einfach:

#!/usr/bin/env python
# coding: utf-8

# Imports

import numpy as np
import os
import six.moves.urllib as urllib
import sys
import tarfile
import tensorflow as tf
import zipfile

from collections import defaultdict
from io import StringIO
from matplotlib import pyplot as plt
from PIL import Image

print(tf.__version__)

if tf.__version__ < '1.10.0':
  raise ImportError('Please upgrade your tensorflow installation to v1.4.* or later!')


# ## Env setup

# This is needed to display the images.
#get_ipython().run_line_magic('matplotlib', 'inline')

# This is needed since the notebook is stored in the object_detection folder.
#sys.path.append("..")


# ## Object detection imports
# Here are the imports from the object detection module.


from utils import label_map_util

from utils import visualization_utils as vis_util


# # Model preparation 

# ## Variables
# 
# Any model exported using the `export_inference_graph.py` tool can be loaded here simply by changing `PATH_TO_CKPT` to point to a new .pb file.  
# 
# By default we use an "SSD with Mobilenet" model here. See the [detection model zoo](https://github.com/tensorflow/models/blob/master/research/object_detection/g3doc/detection_model_zoo.md) for a list of other models that can be run out-of-the-box with varying speeds and accuracies.


# What model to download.
MODEL_NAME = 'ssd_mobilenet_v1_coco_2017_11_17'
MODEL_FILE = MODEL_NAME + '.tar.gz'
DOWNLOAD_BASE = 'http://download.tensorflow.org/models/object_detection/'

# Path to frozen detection graph. This is the actual model that is used for the object detection.
PATH_TO_CKPT = MODEL_NAME + '/frozen_inference_graph.pb'

# List of the strings that is used to add correct label for each box.
PATH_TO_LABELS = os.path.join('data', 'mscoco_label_map.pbtxt')

NUM_CLASSES = 90


# ## Download Model


opener = urllib.request.URLopener()
opener.retrieve(DOWNLOAD_BASE + MODEL_FILE, MODEL_FILE)
tar_file = tarfile.open(MODEL_FILE)
for file in tar_file.getmembers():
  file_name = os.path.basename(file.name)
  if 'frozen_inference_graph.pb' in file_name:
    tar_file.extract(file, os.getcwd())


detection_graph = tf.Graph()
with detection_graph.as_default():
  od_graph_def = tf.GraphDef()
  with tf.gfile.GFile(PATH_TO_CKPT, 'rb') as fid:
    serialized_graph = fid.read()
    od_graph_def.ParseFromString(serialized_graph)
    tf.import_graph_def(od_graph_def, name='')


# ## Loading label map
# Label maps map indices to category names, so that when our convolution network predicts `5`, we know that this corresponds to `airplane`.  Here we use internal utility functions, but anything that returns a dictionary mapping integers to appropriate string labels would be fine

label_map = label_map_util.load_labelmap(PATH_TO_LABELS)
categories = label_map_util.convert_label_map_to_categories(label_map, max_num_classes=NUM_CLASSES, use_display_name=True)
category_index = label_map_util.create_category_index(categories)


import cv2
cap=cv2.VideoCapture(0) # 0 stands for very first webcam attach
cap.set(3,640)
cap.set(4,480)

   
with detection_graph.as_default():
  with tf.Session(graph=detection_graph) as sess:
    
    ret=True
            
    while (ret):
                
        ret, image_np=cap.read() 

        # Definite input and output Tensors for detection_graph
        image_tensor = detection_graph.get_tensor_by_name('image_tensor:0')
        # Each box represents a part of the image where a particular object was detected.
        detection_boxes = detection_graph.get_tensor_by_name('detection_boxes:0')
        # Each score represent how level of confidence for each of the objects.
        # Score is shown on the result image, together with the class label.
        detection_scores = detection_graph.get_tensor_by_name('detection_scores:0')
        detection_classes = detection_graph.get_tensor_by_name('detection_classes:0')
        num_detections = detection_graph.get_tensor_by_name('num_detections:0')
       
          # Expand dimensions since the model expects images to have shape: [1, None, None, 3]
        image_np_expanded = np.expand_dims(image_np, axis=0)
          # Actual detection.
        (boxes, scores, classes, num) = sess.run(
              [detection_boxes, detection_scores, detection_classes, num_detections],
              feed_dict={image_tensor: image_np_expanded})
          # Visualization of the results of a detection.
        vis_util.visualize_boxes_and_labels_on_image_array(
              image_np,
              np.squeeze(boxes),
              np.squeeze(classes).astype(np.int32),
              np.squeeze(scores),
              category_index,
              use_normalized_coordinates=True,
              line_thickness=8)
  

        cv2.imshow('live_detection',image_np)
        if cv2.waitKey(25) & 0xFF==ord('q'):
            break
            cv2.destroyAllWindows()
            cap.release()

[Industrieknipser (Gast)]

Olli Z. schrieb:
> ich glaube ich muss erstmal ein paar
> Grundlagen büffeln...

Das ist gut für Grundlagen:
ISBN: 978-3642130960

[Pandur S. (jetztnicht)]

Das vereinfachte Vorgehen ist die Korrelation. Nun ist das direkt eher 
rechenintensiv, in Fourierraum aber einfach. Die Korrelation wird im 
Fourierraum zu einer Multiplikation. Also das Bild 
Fouriertransformieren, und mit den verschiedenen zu findenden, 
fouriertransformierten Mustern einzeln multiplizieren. Das in Echtzeit 
ist eine Menge Holz.
Allenfalls, mit etwas mehr Theorie kann man's beschleunigen.

[Xilinx Entwickler (Gast)]

Olli Z. schrieb:
> Gibt es denn sowas wie einen grundsätzlichen, theoretischen Ansatz für
> ein solches Problem? Oder sind aufgrund der genannten zahlreichen
> Algorithmen (100+) garkeine allgemeingültigen Vorgehensweisen nennbar?
> Wohlgemerkt, ich will garnicht den aktuellen Stand der Technik
> ergründen, sondern die Basiskonzepte denen es zugrunde liegt.

Der grundlegene Ansatz ist ein Vergleich zwischen Soll und Ist.

Das kann ein direkter Vergleich von Pixelfolgen sein, oder man zerlegt 
die Pixelfolgen in Frequenzen und vergleicht es im Frequenzbereich unter 
Weglassen von Nichtbenötigtem.

Um Vergleiche durchzuführen (was ist ein Kreis, was eine Kante, was eine 
Ecke und was ist eine Fläche gleicher Farbe) muss das Bild passend 
vorverarbeitet werden, also

- globaler / lokaler offset raus
- Rauschen raus
- Beleuchtungsgradient raus

Hinzu kommem Mechanismen, um Bewegungen zu erkennen, also Vergleiche das 
Bildes mit sich selbst. Dann kann man z.B. direkt ablesen, welche 
Bereiche sich wohin bewegt haben, was eine Hintegrund, eine Vordergrund 
oder Boden oder ein Objekt ist.