Pixelar rostros: Ruby e ImageMagick

Tim Koschützki

Cofundador · Berlín, Alemania · Mostrar bio

El pixelado de rostros es una técnica potente para mejorar la privacidad al ocultar rasgos identificables en las imágenes. Ya sea que estés creando una app de redes sociales, un sistema de vigilancia o simplemente quieras anonimizar imágenes, automatizar el pixelado de rostros puede resultar sumamente útil.

¿Por qué pixelar rostros?

El pixelado de rostros puede reducir la visibilidad de los rasgos identificativos. La detección puede pasar por alto rostros y el pixelado no garantiza el anonimato. Entre las aplicaciones prácticas se incluyen:

• Plataformas de redes sociales que anonimizan las imágenes subidas por los usuarios
• Anonimización de grabaciones de vigilancia
• Ocultar rostros como una parte de un proceso de protección de la privacidad
• Proteger a menores en imágenes públicas
• Anonimizar datos de investigación que contienen sujetos humanos

Configurar Ruby e ImageMagick

Usa Ruby 3.2+, RMagick 7.x, la gema Google Cloud Vision 2.x e ImageMagick 6.8.9+ o 7. RMagick necesita un compilador de C++ y los encabezados de desarrollo de ImageMagick cuando se compila su extensión nativa:

# 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'

Configurar la API de Google Cloud Vision

Para la detección de rostros usaremos la API de Google Cloud Vision, que ofrece capacidades de detección de rostros precisas y fiables.

1. Crear un proyecto de Google Cloud

1. Ve a la Google Cloud Console⁠.
2. Crea un proyecto nuevo o selecciona uno existente.
3. Anota el ID de tu proyecto y habilita la facturación del proyecto.

2. Habilitar la API de Vision

1. Navega a «APIs & Services» > «Library».
2. Busca «Vision API» y habilítala.

3. Configurar la autenticación

Para el desarrollo local, usa Application Default Credentials con la CLI de Google Cloud:

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

La identidad necesita permiso para usar servicios en el proyecto de cuota (serviceusage.services.use). Para producción, es preferible una cuenta de servicio adjunta o Workload Identity Federation. Si es necesaria una clave de cuenta de servicio descargada, guárdala fuera del control de versiones y restringe el acceso a ella.

4. Configurar un archivo de clave solo si tu implementación lo requiere

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

Integrar la detección de rostros con Ruby usando la API de Google Cloud Vision

Los ejemplos siguientes funcionan con un JPEG o PNG local, de un solo fotograma y con los píxeles ya en su orientación correcta. Normaliza la orientación EXIF antes de la detección y procesa localmente esa misma imagen normalizada para que las coordenadas coincidan. Guarda juntas las dos definiciones de función siguientes en 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

Aplicar efectos de pixelado con ImageMagick

Con RMagick, ajusta cada rectángulo a los límites de la imagen, redúcelo a al menos un píxel y amplíalo con muestreo del vecino más cercano para obtener bloques de píxeles visibles. Libera las asignaciones nativas de imagen incluso cuando falle el recorte o la escritura:

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

Ejemplo de código Ruby paso a paso

Añade este envoltorio a pixelate.rb para combinar las dos funciones anteriores. Publica el resultado solo después de un retorno exitoso y revísalo en busca de rostros omitidos o de detalles identificativos:

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')

Optimizar el rendimiento y manejar casos límite

Consideraciones sobre la API

• Límites de frecuencia: la cuota de solicitudes predeterminada es de 1800 solicitudes por minuto, con cuotas de funciones independientes. Consulta las cuotas y los límites de tu proyecto⁠.
• Tamaño de imagen: el tamaño máximo de imagen es de 20 MB, pero las solicitudes JSON tienen un límite independiente de 10 MB y la codificación en base64 aumenta el tamaño de la carga útil. Usa imágenes locales pequeñas para este ejemplo.
• Procesamiento por lotes: para varias imágenes, usa solicitudes por lotes para reducir las llamadas a la API.
• Gestión de costos: monitorea el uso para mantenerte dentro de tu presupuesto.

Manejo de casos límite

• No se detectan rostros: el envoltorio devuelve false; revisa la imagen en lugar de darla por anónima.
• Detecciones de baja confianza: consérvalas en un flujo de trabajo de privacidad o envíalas a revisión. Descartarlas puede dejar un rostro visible sin ocultar.
• Rostros parciales: la función de pixelado ajusta los rectángulos a los límites de la imagen y rechaza las regiones que no se superponen con la imagen.

# 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

API alternativas de detección de rostros

Si Google Cloud Vision no cubre tus necesidades, considera estas alternativas:

• Amazon Rekognition: detección de rostros robusta con funciones adicionales como la estimación de la edad.
• Microsoft Azure Face API: capacidades completas de análisis facial.
• Luxand Cloud: especializada en tecnología de reconocimiento facial.

¿Cómo se integra ImageMagick con Ruby para el procesamiento de imágenes?

ImageMagick se integra con Ruby a través de la gema RMagick, que ofrece un conjunto completo de capacidades de manipulación de imágenes. Esta integración permite a los desarrolladores:

• Redimensionar, recortar y transformar imágenes
• Aplicar filtros y efectos
• Componer varias imágenes
• Convertir entre formatos de imagen
• Extraer metadatos de las imágenes

La biblioteca RMagick envuelve la funcionalidad de ImageMagick en una API amigable con Ruby, de modo que las operaciones de imagen complejas resultan accesibles mediante simples llamadas a métodos.

Consideraciones de privacidad

El pixelado por sí solo no establece el cumplimiento de la legislación de privacidad. Subir una imagen original a un detector en la nube también expone ese original al proveedor. Revisa el acuerdo de tratamiento y los requisitos aplicables a tu caso de uso, y:

• Obtén el consentimiento adecuado al procesar imágenes identificables.
• Aplica la minimización de datos almacenando solo la información necesaria.
• Documenta tus actividades de tratamiento.
• Evalúa si necesitas realizar una Evaluación de Impacto relativa a la Protección de Datos (EIPD).
• Garantiza el manejo seguro tanto de las imágenes originales como de las procesadas.

Conclusión

Automatizar el pixelado de rostros con Ruby, la API de Google Cloud Vision e ImageMagick ofrece una solución potente para aplicaciones centradas en la privacidad. Al combinar la detección de rostros en la nube con la manipulación local de imágenes, puedes crear flujos de trabajo de ocultación de rostros con un paso de revisión para las detecciones omitidas.

Para necesidades más avanzadas de procesamiento de imágenes, explora la API de procesamiento de imágenes de Transloadit, que ofrece herramientas potentes para procesar y transformar imágenes a escala.