Pixelizar rostos: Ruby e ImageMagick

Tim Koschützki

Cofundador · Berlim, Alemanha ·

A pixelização de rostos é uma técnica poderosa para aumentar a privacidade, ocultando características identificáveis em imagens. Seja para criar um app de rede social ou um sistema de vigilância, seja apenas para anonimizar imagens, automatizar a pixelização de rostos pode ser extremamente útil.

Por que pixelizar rostos?

A pixelização de rostos pode reduzir a visibilidade de características identificadoras. A detecção pode deixar rostos passarem despercebidos, e a pixelização não garante o anonimato. Entre as aplicações práticas estão:

Plataformas de redes sociais que anonimizam imagens enviadas por usuários
Anonimização de gravações de vigilância
Ocultação de rostos como uma das etapas de um processo de proteção da privacidade
Proteção de menores em imagens públicas
Anonimização de dados de pesquisa com participantes humanos

Configurar o Ruby e o ImageMagick

Use Ruby 3.2+, RMagick 7.x, a gem Google Cloud Vision 2.x e ImageMagick 6.8.9+ ou 7. O RMagick precisa de um compilador C++ e dos headers de desenvolvimento do ImageMagick quando sua extensão nativa é compilada:

# 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 a Google Cloud Vision API

Para a detecção de rostos, vamos usar a Google Cloud Vision API, que oferece recursos de detecção de rostos precisos e confiáveis.

1. Criar um projeto no Google Cloud

Acesse o Google Cloud Console.
Crie um novo projeto ou selecione um existente.
Anote o ID do projeto e ative o faturamento para ele.

2. Ativar a Vision API

Acesse “APIs e serviços” > “Biblioteca”.
Pesquise “Vision API” e ative-a.

3. Configurar a autenticação

Para desenvolvimento local, use o Application Default Credentials com a Google Cloud CLI:

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

A identidade precisa de permissão para usar serviços no projeto de cota (serviceusage.services.use). Em produção, prefira uma conta de serviço anexada ou o Workload Identity Federation. Se uma chave de conta de serviço baixada for necessária, armazene-a fora do controle de versão e restrinja o acesso a ela.

4. Configurar um arquivo de chave somente se a sua implantação exigir

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

Integrar a detecção de rostos ao Ruby com a Google Cloud Vision API

Os exemplos abaixo funcionam com um JPEG ou PNG local, de quadro único e com pixels na orientação correta. Normalize a orientação EXIF antes da detecção e processe localmente essa mesma imagem normalizada para que as coordenadas correspondam. Salve as duas definições de função a seguir juntas em 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 efeitos de pixelização com o ImageMagick

Com o RMagick, limite cada retângulo às bordas da imagem, reduza-o para no mínimo um pixel e amplie-o com amostragem por vizinho mais próximo para obter blocos de pixels visíveis. Libere as alocações nativas das imagens mesmo quando o recorte ou a gravação falhar:

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

Exemplo de código Ruby passo a passo

Adicione este wrapper ao final de pixelate.rb para combinar as duas funções acima. Publique o resultado somente após um retorno bem-sucedido e revise-o em busca de rostos não detectados ou detalhes identificadores:

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

Otimizar o desempenho e lidar com casos extremos

Considerações sobre a API

Limites de taxa: a cota padrão de solicitações é de 1.800 solicitações por minuto, com cotas separadas por recurso. Confira as cotas e os limites do seu projeto.
Tamanho da imagem: o tamanho máximo da imagem é 20 MB, mas as solicitações JSON têm um limite separado de 10 MB, e a codificação base64 aumenta o tamanho do payload. Use imagens locais pequenas neste exemplo.
Processamento em lote: para várias imagens, use solicitações em lote para reduzir o número de chamadas à API.
Gestão de custos: monitore o uso para permanecer dentro do orçamento.

Lidar com casos extremos

Nenhum rosto detectado: o wrapper retorna false; revise a imagem em vez de tratá-la como anônima.
Detecções com baixa confiança: mantenha-as em um fluxo de trabalho de privacidade ou envie-as para revisão. Descartá-las pode deixar um rosto visível sem ocultação.
Rostos parciais: a função de pixelização limita os retângulos às bordas da imagem e rejeita regiões que não se sobrepõem à imagem.

# 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

APIs alternativas de detecção de rostos

Se o Google Cloud Vision não atender às suas necessidades, considere estas alternativas:

Amazon Rekognition: detecção de rostos robusta, com recursos adicionais como estimativa de idade.
Microsoft Azure Face API: recursos abrangentes de análise facial.
Luxand Cloud: especializada em tecnologia de reconhecimento facial.

Como o ImageMagick se integra ao Ruby para o processamento de imagens?

O ImageMagick se integra ao Ruby por meio da gem RMagick, que oferece um conjunto abrangente de recursos de manipulação de imagens. Essa integração permite que desenvolvedores:

Redimensionem, recortem e transformem imagens
Apliquem filtros e efeitos
Combinem várias imagens
Convertam imagens entre formatos
Extraiam metadados de imagens

A biblioteca RMagick encapsula a funcionalidade do ImageMagick em uma API adequada ao estilo do Ruby, tornando operações complexas com imagens acessíveis por meio de chamadas de método simples.

Considerações sobre privacidade

A pixelização, por si só, não garante a conformidade com as leis de privacidade. Enviar uma imagem original a um detector na nuvem também expõe esse original ao provedor. Revise o acordo de processamento e os requisitos aplicáveis ao seu caso de uso e:

Obtenha o consentimento adequado ao processar imagens identificáveis.
Pratique a minimização de dados, armazenando apenas as informações necessárias.
Documente suas atividades de processamento.
Avalie se você precisa realizar uma avaliação de impacto sobre a proteção de dados (Data Protection Impact Assessment, DPIA).
Garanta o tratamento seguro tanto das imagens originais quanto das processadas.

Conclusão

Automatizar a pixelização de rostos com Ruby, Google Cloud Vision API e ImageMagick oferece uma solução poderosa para aplicações focadas em privacidade. Ao combinar a detecção de rostos na nuvem com a manipulação local de imagens, você pode criar fluxos de trabalho de ocultação de rostos com uma etapa de revisão para detecções que passaram despercebidas.

Para necessidades mais avançadas de processamento de imagens, considere conhecer a API de processamento de imagens da Transloadit, que oferece ferramentas poderosas para processar e transformar imagens em escala.