Software • 06. Dezember 2024
Datenschutzkonforme Bildveröffentlichung: Gesichter und Nummernschilder automatisch verpixeln mit Python
ACHTUNG: Vorsicht mit Ultralytics, die Versionen 8.3.41. und 8.3.42 wurden mit einem Cryptominer ausgeliefert. In der Version 8.3.43 wurde das Problem behoben, wir bitten dennoch darum, Vorsicht walten zu lassen.
In einer Welt, in der das Teilen von Bildern zum Alltag gehört, ist es wichtiger denn je, persönliche Informationen zu schützen. Gesichter, Autokennzeichen und andere erkennbare Merkmale können ohne ordentliche Anonymisierung zu Datenschutzproblemen führen. In diesem Artikel zeigen wir Ihnen, wie Sie mit wenigen Schritten in Python automatisch Gesichter und Nummernschilder verpixeln können, um datenschutzkonforme Bilder zu erstellen.
Im speziellen ist der Einsatz bei unserem langjährigen Kunden EDG - Entsorgung Dortmund GmbH geplant. In ihrem aktiven Außendienst nehmen dabei Mitarbeiter Fotos von Grünanlagen, Papierkörben oder Depotcontainern auf. Dabei lässt sich manchmal die Aufnahme von Gesichtern oder Nummernschildern nicht vermeiden. Aus diesem Grund ist die Einführung eines automatisierten Systems zur Anonymisierung der aufgenommenen Bilder notwendig.
Technische Grundlagen
Für die Erkennung von Gesichtern und Nummernschildern in Bildern setzten wir auf leistungsstarke, vortrainierte KI-Modelle, die speziell für diese Zwecke entwickelt wurden und auf GitHub frei verfügbar sind. Nach eingehender Recherche fanden wir zwei gut dokumentierte und performante Modelle, die unsere Anforderungen optimal erfüllen: RetinaFace für die Gesichtserkennung und YOLOv8 für die Nummernschilderkennung.
RetinaFace ist ein hochmodernes Tool zur Gesichtserkennung. Dieses Modell ist Teil des InsightFace-Projekts und wurde ursprünglich auf der mxnet-Bibliothek aufgebaut, mit einer späteren Implementierung in TensorFlow. RetinaFace kann Gesichter selbst in dichten Menschenmengen genau erkennen und erfasst die wesentlichen Gesichtsmerkmale wie Augen und Mund. Dies ermöglicht zusätzlich die Ausrichtung der Gesichter, was die Erkennungsgenauigkeit weiter erhöht. Die Installation ist einfach über PyPI möglich und das Modul lässt sich anschließend problemlos in Python integrieren.
$ pip install retina-face
from retinaface import RetinaFaceFür die Erkennung von Nummernschildern verwenden wir ein YOLOv8-Modell, das speziell für die Erkennung kleiner Objekte trainiert wurde und eine hervorragende Performance in der Echtzeit-Objekterkennung bietet. Das Modell aus diesem GitHub-Projekt „license_plate_detector.pt“ wurde mit YOLOv8 trainiert, lässt sich leicht herunterladen und in bestehende Python-Projekte integrieren. Die Installation und Integration erfolgen analog zur RetinaFace-Bibliothek:
$ pip install ultralytics
from ultralytics import YOLOIn beiden Fällen verwenden wir die Open-Source-Bibliothek OpenCV, um die erkannten Bildbereiche zu anonymisieren. OpenCV (Open Source Computer Vision Library) ist eine umfassende, von Intel initiierte Programmbibliothek für Bildverarbeitung, die in C++, Python und Java verfügbar ist und unter der Apache 2 License steht. Für die Verpixelung erfüllt dabei die resize-Funktion vollständig unsere Zwecke.
Mit dieser Kombination aus RetinaFace für die Gesichtserkennung, YOLOv8 für die Nummernschilderkennung und OpenCV zur Bearbeitung der gefundenen Bildausschnitte erreichen wir eine effiziente, datenschutzfreundliche Anonymisierung, die für unseren Anwendungsfall bei der EDG Dortmund zuverlässig ihren Zweck erfüllt.
Implementierung mittels Python
In unserem Python-Skript erstellen wir nun separate Funktionen, die die automatisierte Anonymisierung der Bilder ermöglichen. Jede Funktion hat ihren eigenen Zweck, um das Bild Schritt für Schritt zu verarbeiten und sensible Bereiche zu verpixeln.
1. Verpixeln
Die Funktion pixelate übernimmt das Verpixeln eines Bildausschnitts. Sie verkleinert den ausgewählten Bereich zunächst auf eine sehr niedrige Auflösung und skaliert ihn dann auf die ursprüngliche Größe zurück. Das erzeugt den „Pixel-Effekt“, bei dem Details verwischt und unkenntlich gemacht werden. Die Anzahl der Pixel in Breite und Höhe können dabei selbst festgelegt und der Funktion als Parameter übergeben werden. Für Nummernschilder empfiehlt es sich z.B. mehr Pixel in der Breite als in der Höhe zu verwenden – bei Gesichtern ist eher das Gegenteil der Fall.
def pixelate(image, pixel_width, pixel_height):
# Resize the region to a smaller, "pixelated" size
temp = cv2.resize(image, (pixel_width, pixel_height), interpolation=cv2.INTER_LINEAR)
# Scale it back up to the original size using nearest-neighbor interpolation
return cv2.resize(temp, (image.shape[1], image.shape[0]), interpolation=cv2.INTER_NEAREST)2. Gesichter erkennen und verarbeiten
Mit RetinaFace werden die Positionen der Gesichter identifiziert. Anschließend werden die Koordinaten der erkannten Bereiche an die pixelate-Funktion übergeben. Die verpixelten Gesichtsbereiche werden dann im Originalbild eingefügt.
face_detections = RetinaFace.detect_faces(image_path)
process_faces(image, face_detections)
def process_faces(image, faces):
for face_id, face_info in faces.items():
x1, y1, x2, y2 = face_info["facial_area"]
face_region = image[y1:y2, x1:x2]
# Apply pixelation to face region
pixelated_face = pixelate(face_region, 4, 6)
image[y1:y1 + face_region.shape[0], x1:x1 + face_region.shape[1]] = pixelated_face3. Nummernschilder erkennen und verarbeiten
Diese Funktion ist für die Erkennung von Nummernschildern zuständig. Sie nutzt das vortrainierte YOLOv8-Modell aus dem erwähnten GitHub-Projekt. Auch hier werden die Koordinaten der gefundenen Nummernschildbereiche an die pixelate-Funktion übergeben und anschließend die verpixelten Bildausschnitte im Orignal eingefügt.
yolo_model = YOLO('license_plate_detector.pt')
process_license_plates(image, yolo_model)
def process_license_plates(image, detections):
for result in detections:
for detection in result.boxes:
x1, y1, x2, y2 = map(int, detection.xyxy[0])
plate_region = image[y1:y2, x1:x2]
# Apply pixelation to license plate region
pixelated_plate = pixelate(plate_region, 8, 4)
image[y1:y1 + plate_region.shape[0], x1:x1 + plate_region.shape[1]] = pixelated_plate4. main - Funktion
Die Hauptfunktion vereint alle Schritte. Nachdem das Bild erfolgreich eingelesen wurde, erfolgt die Gesichtserkennung und -anonymisierung und anschließend die Nummernschilderkennung – und Anonymisierung. Danach wird das verpixelte Resultat als neue Datei abgespeichert und bei Bedarf mittels des matplotlib-Moduls angezeigt.
import cv2
from retinaface import RetinaFace
from ultralytics import YOLO
import matplotlib.pyplot as plt
import sys
import os
def main(image_path):
# Load image
image = cv2.imread(image_path)
# Load face detection model and detect faces
face_detections = RetinaFace.detect_faces(image_path)
process_faces(image, face_detections)
# Load YOLO model for license plate detection
yolo_model = YOLO('license_plate_detector.pt')
process_license_plates(image, yolo_model)
# Save the result
filename, ext = os.path.splitext(image_path)
output_path = f"{filename}_blurred{ext}"
cv2.imwrite(output_path, image)
# Display the result
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.axis('off')
plt.show()
if __name__ == "__main__":
if len(sys.argv) < 2:
print("Usage: python3 image_blurring.py [PATH-TO-IMAGE]")
else:
main(sys.argv[1])Ergebnisse
Mit diesem Code und den zugehörigen KI-Modellen können wir nun zuverlässig Nummernschilder und Gesichter verpixeln:
Bei Bedarf kann statt dem Verpixeln auch ein Gaußscher Weichzeichner oder eine andere Bildverarbeitungsmethode verwendet werden. So können wir beispielsweise auch einfach ein anderes Bild über die detektierten Bereiche legen (dieses muss vorher mit der resize-Methode von OpenCV entsprechend skaliert werden) und damit unsere Kollegen in Weihnachtsstimmung versetzen.
Fazit – weiterführende Überlegungen
Die vorgestellte Lösung bietet eine robuste Grundlage für die Anonymisierung, lässt sich jedoch gezielt optimieren. Ein Ansatz wäre, das YOLO-Modell spezifisch für regionale Anforderungen, etwa die Erkennung deutscher Nummernschilder, durch eigenes Training weiter anzupassen. Der Einsatz neuerer Modellgenerationen wie YOLOv11 könnte zudem sowohl die Genauigkeit als auch die Verarbeitungsgeschwindigkeit signifikant verbessern.
Ein beobachteter Schwachpunkt ist die Erkennung kleiner oder weit entfernter Nummernschilder. Hier bietet die Zerlegung des Bildes in überlappende Teilbereiche eine praktikable Lösung. In diesen Ausschnitten erscheinen Nummernschilder im Vergleich zur Bildgröße größer, was die Erkennungsrate deutlich steigert.
Zukünftig könnten auch KI-Modelle speziell für komplexe Anonymisierungsanforderungen trainiert werden, etwa für verdeckte oder beschädigte Kennzeichen, ungewöhnliche Schriftarten oder Designs. Solche spezialisierten Modelle könnten zusätzliche Anwendungsfälle abdecken, falls dies von der EDG gewünscht wird.
Unterstützung der Software-Projekte und Lizensierung
RetinaFace ist ein Open-Source-Projekt, das auf anderen Arbeiten wie dem InsightFace-Projekt und RetinaFace-TensorFlow-Implementierungen basiert und die MIT-Lizenz nutzt. Die Unterstützung erfolgt einfach über GitHub, etwa durch die Vergabe eines Sterns oder Spenden auf Plattformen wie Patreon oder By Me a Coffee.
Das vortrainierte YOLOv8-Modellfür die Nummernschilderkennung auf GitHub wird ebenfalls unter der MIT-Lizenz bereitgestellt und ist damit frei nutzbar und anpassbar, solange der ursprüngliche Urhebervermerk erhalten bleibt. Bei der allgemeinen Nutzung des YOLOv8-Modells von Ultralytics gilt jedoch die AGPL-3.0-Lizenz für nicht-kommerzielle Zwecke. Für kommerzielle Anwendungen bietet Ultralytics eine Unternehmenslizenz an.
Weitere Beiträge, die Sie interessieren könnten:
- Material UI Themes und MapComponents
- Mapbender 4 – Praxisbericht nach dem Major Release
- Treffen der QGIS-Gemeinschaft in Bratislava
