Zuletzt aktualisiert: 12. September

Gesichter verpixeln: Ruby & ImageMagick

Tim Koschützki

Mitgründer · Berlin, Deutschland ·

Das Verpixeln von Gesichtern ist eine wirkungsvolle Technik, um die Privatsphäre zu schützen, indem identifizierbare Merkmale in Bildern unkenntlich gemacht werden. Ob Sie eine Social-Media-App oder ein Überwachungssystem entwickeln oder Bilder einfach anonymisieren möchten: Die automatische Verpixelung von Gesichtern kann äußerst nützlich sein.

Warum Gesichter verpixeln?

Das Verpixeln von Gesichtern kann die Sichtbarkeit identifizierender Merkmale verringern. Die Erkennung kann Gesichter übersehen, und Verpixelung garantiert keine Anonymität. Zu den praktischen Anwendungen gehören:

Social-Media-Plattformen, die von Nutzern hochgeladene Bilder anonymisieren
Anonymisierung von Überwachungsaufnahmen
Das Schwärzen von Gesichtern als ein Teil eines Datenschutzprozesses
Schutz von Minderjährigen auf öffentlichen Bildern
Anonymisierung von Forschungsdaten mit menschlichen Probanden

Ruby und ImageMagick einrichten

Verwenden Sie Ruby 3.2+, RMagick 7.x, das Gem Google Cloud Vision 2.x und ImageMagick 6.8.9+ oder 7. RMagick benötigt einen C++-Compiler und die Entwicklungs-Header von ImageMagick, wenn seine native Erweiterung gebaut wird:

# For macOS
brew install imagemagick pkg-config
gem install rmagick -v '~> 7.0'
gem install google-cloud-vision -v '~> 2.0'

# For Ubuntu/Debian
sudo apt-get install build-essential pkg-config imagemagick libmagickwand-dev
gem install rmagick -v '~> 7.0'
gem install google-cloud-vision -v '~> 2.0'

Google Cloud Vision API einrichten

Für die Gesichtserkennung verwenden wir die Google Cloud Vision API, die genaue und zuverlässige Funktionen zur Gesichtserkennung bietet.

1. Ein Google-Cloud-Projekt erstellen

Rufen Sie die Google Cloud Console auf.
Erstellen Sie ein neues Projekt oder wählen Sie ein vorhandenes aus.
Notieren Sie sich Ihre Projekt-ID und aktivieren Sie die Abrechnung für das Projekt.

2. Die Vision API aktivieren

Navigieren Sie zu „APIs & Services“ > „Library“.
Suchen Sie nach „Vision API“ und aktivieren Sie sie.

3. Authentifizierung einrichten

Verwenden Sie für die lokale Entwicklung Application Default Credentials mit der Google Cloud CLI:

gcloud auth application-default login
gcloud auth application-default set-quota-project PROJECT_ID

Die Identität benötigt die Berechtigung, Dienste im Kontingentprojekt (serviceusage.services.use) zu nutzen. Für den Produktivbetrieb sind ein angehängtes Dienstkonto oder Workload Identity Federation vorzuziehen. Falls ein heruntergeladener Dienstkontoschlüssel erforderlich ist, bewahren Sie ihn außerhalb der Versionsverwaltung auf und beschränken Sie den Zugriff darauf.

4. Eine Schlüsseldatei nur dann konfigurieren, wenn Ihr Deployment sie erfordert

export GOOGLE_APPLICATION_CREDENTIALS="/path/to/your-project-credentials.json"

Gesichtserkennung in Ruby mithilfe der Google Cloud Vision API integrieren

Die folgenden Beispiele arbeiten mit einer lokalen JPEG- oder PNG-Datei mit einem einzelnen Frame und aufrecht stehenden Pixeln. Normalisieren Sie die EXIF-Ausrichtung vor der Erkennung und verarbeiten Sie genau dieses normalisierte Bild lokal, damit die Koordinaten übereinstimmen. Speichern Sie die folgenden beiden Funktionsdefinitionen gemeinsam in pixelate.rb:

require "google/cloud/vision"

def detect_faces(image_path)
  # Initialize the Vision client
  vision = Google::Cloud::Vision.image_annotator

  # Perform face detection
  response = vision.face_detection(
    image: image_path,
    max_results: 10
  )

  # Extract face coordinates
  faces = []
  response.responses.each do |res|
    if res.error && res.error.code != 0
      raise "Face detection failed (code #{res.error.code})"
    end
    if res.face_annotations.length >= 10
      raise "Face detection limit reached; review this image manually"
    end
    res.face_annotations.each do |face|
      vertices = face.bounding_poly.vertices
      raise "Missing face coordinates" if vertices.empty?

      # Calculate face rectangle
      x, right = vertices.map(&:x).minmax
      y, bottom = vertices.map(&:y).minmax

      faces << { x: x, y: y, width: right - x, height: bottom - y,
                 confidence: face.detection_confidence }
    end
  end

  faces
end

Verpixelungseffekte mit ImageMagick anwenden

Begrenzen Sie mit RMagick jedes Rechteck auf das Bild, verkleinern Sie es auf mindestens ein Pixel und vergrößern Sie es mit Nearest-Neighbor-Sampling, um sichtbare Pixelblöcke zu erhalten. Geben Sie die nativen Bildallokationen auch dann frei, wenn das Zuschneiden oder Schreiben fehlschlägt:

require 'rmagick'

def pixelate_faces(image_path, faces, pixelation_factor = 0.1, output_path = 'pixelated_output.jpg')
  unless pixelation_factor.finite? && pixelation_factor > 0 && pixelation_factor < 1
    raise ArgumentError, "Pixelation factor must be between 0 and 1"
  end
  raise ArgumentError, "No face regions to pixelate" if faces.empty?

  images = Magick::Image.read(image_path)
  raise ArgumentError, "Use a single-frame image" unless images.length == 1
  img = images.first

  faces.each do |face|
    x = [face.fetch(:x).floor, 0].max
    y = [face.fetch(:y).floor, 0].max
    right = [(face.fetch(:x) + face.fetch(:width)).ceil, img.columns].min
    bottom = [(face.fetch(:y) + face.fetch(:height)).ceil, img.rows].min
    width, height = right - x, bottom - y
    raise ArgumentError, "Face rectangle is outside the image" if width <= 0 || height <= 0

    face_region = small = pixelated = nil
    begin
      face_region = img.crop(x, y, width, height, true)
      small = face_region.sample([(width * pixelation_factor).floor, 1].max,
                                 [(height * pixelation_factor).floor, 1].max)
      pixelated = small.sample(width, height)
      img.composite!(pixelated, x, y, Magick::OverCompositeOp)
    ensure
      [face_region, small, pixelated].compact.each(&:destroy!)
    end
  end

  img.strip!
  img.write(output_path)
  output_path
ensure
  images&.each(&:destroy!)
end

Ruby-Codebeispiel Schritt für Schritt

Hängen Sie diesen Wrapper an pixelate.rb an, um die beiden obigen Funktionen zu kombinieren. Veröffentlichen Sie die Ausgabe erst nach einer erfolgreichen Rückgabe und prüfen Sie sie auf übersehene Gesichter oder identifizierende Details:

require "google/cloud/vision"
require 'rmagick'

def pixelate_image(image_path, output_path = 'pixelated_output.jpg', pixelation_factor = 0.1)
  begin
    # Detect faces
    faces = detect_faces(image_path)

    if faces.empty?
      puts "No faces detected in the image."
      return false
    end

    pixelate_faces(image_path, faces, pixelation_factor, output_path)
    puts "Successfully pixelated #{faces.count} faces in '#{output_path}'"
    return true

  rescue StandardError => e
    warn "Face pixelation failed (#{e.class})"
  end

  return false
end

# Usage
exit(1) unless pixelate_image('input.jpg', 'output.jpg')

Performance optimieren und Sonderfälle behandeln

Überlegungen zur API

Ratenbegrenzungen: Das Standardkontingent für Anfragen liegt bei 1.800 Anfragen pro Minute, mit separaten Kontingenten pro Funktion. Prüfen Sie die Kontingente und Limits Ihres Projekts.
Bildgröße: Die maximale Bildgröße beträgt 20 MB, JSON-Anfragen haben jedoch ein separates Limit von 10 MB, und die base64-Codierung erhöht die Größe der Nutzlast. Verwenden Sie für dieses Beispiel kleine lokale Bilder.
Stapelverarbeitung: Verwenden Sie bei mehreren Bildern Batch-Anfragen, um API-Aufrufe zu reduzieren.
Kostenmanagement: Überwachen Sie die Nutzung, um im Budgetrahmen zu bleiben.

Sonderfälle behandeln

Keine Gesichter erkannt: Der Wrapper gibt false zurück; prüfen Sie das Bild, statt es als anonym zu betrachten.
Erkennungen mit geringer Konfidenz: Behalten Sie sie in einem Datenschutz-Workflow oder geben Sie sie zur Prüfung weiter. Werden sie verworfen, kann ein sichtbares Gesicht ungeschwärzt bleiben.
Teilweise sichtbare Gesichter: Die Verpixelungsfunktion begrenzt Rechtecke auf die Bildgrenzen und weist Regionen zurück, die sich nicht mit dem Bild überschneiden.

# Use confidence for review without removing faces from the pixelation input.
faces = detect_faces('input.jpg')
needs_review = faces.any? { |face| face[:confidence] < 0.7 }
puts "Manual review required" if needs_review

Alternative APIs zur Gesichtserkennung

Falls Google Cloud Vision Ihre Anforderungen nicht erfüllt, kommen diese Alternativen infrage:

Amazon Rekognition: Robuste Gesichtserkennung mit zusätzlichen Funktionen wie der Altersschätzung.
Microsoft Azure Face API: Umfassende Funktionen zur Gesichtsanalyse.
Luxand Cloud: Spezialisiert auf Technologie zur Gesichtserkennung.

Wie integriert sich ImageMagick für die Bildverarbeitung in Ruby?

ImageMagick lässt sich über das RMagick-Gem in Ruby integrieren und stellt eine umfassende Sammlung von Funktionen zur Bildbearbeitung bereit. Diese Integration ermöglicht es Entwicklern:

Bilder in der Größe zu ändern, zuzuschneiden und zu transformieren
Filter und Effekte anzuwenden
Mehrere Bilder zusammenzusetzen
Zwischen Bildformaten zu konvertieren
Bildmetadaten zu extrahieren

Die RMagick-Bibliothek kapselt die Funktionalität von ImageMagick in einer Ruby-freundlichen API und macht komplexe Bildoperationen über einfache Methodenaufrufe zugänglich.

Überlegungen zum Datenschutz

Verpixelung allein stellt noch keine Konformität mit dem Datenschutzrecht her. Wenn Sie ein Originalbild zu einem Cloud-Detektor hochladen, legen Sie dieses Original zudem gegenüber dem Anbieter offen. Prüfen Sie die Verarbeitungsvereinbarung und die für Ihren Anwendungsfall geltenden Anforderungen, und:

Holen Sie eine ordnungsgemäße Einwilligung ein, wenn Sie identifizierbare Bilder verarbeiten.
Setzen Sie Datenminimierung um, indem Sie nur notwendige Informationen speichern.
Dokumentieren Sie Ihre Verarbeitungstätigkeiten.
Prüfen Sie, ob Sie eine Datenschutz-Folgenabschätzung (DSFA) durchführen müssen.
Stellen Sie einen sicheren Umgang mit den Originalbildern und den verarbeiteten Bildern sicher.

Fazit

Die Automatisierung der Gesichtsverpixelung mit Ruby, der Google Cloud Vision API und ImageMagick bietet eine leistungsstarke Lösung für datenschutzorientierte Anwendungen. Indem Sie cloudbasierte Gesichtserkennung mit lokaler Bildbearbeitung kombinieren, können Sie Workflows zum Schwärzen von Gesichtern mit einem Prüfschritt für übersehene Erkennungen aufbauen.

Für anspruchsvollere Anforderungen an die Bildverarbeitung lohnt sich ein Blick auf Transloadits API für Bildverarbeitung, die leistungsstarke Werkzeuge für die Verarbeitung und Transformation von Bildern im großen Maßstab bietet.