Offuscare i volti con Analisi Servizi multimediali di Azure

Panoramica

Azure Media Redactor è un processore di contenuti multimediali di Analisi Servizi multimediali di Azure che offre funzionalità scalabili di offuscamento dei volti nel cloud. L'offuscamento dei volti consente di modificare un video per sfocare i volti di persone selezionate. Può essere opportuno usare tale servizio in scenari di pubblica sicurezza e notizie giornalistiche. Offuscare manualmente alcuni minuti di filmato contenenti più volti può richiedere ore, ma con questo servizio il processo di offuscamento dei volti richiederà pochi semplici passaggi. Per altre informazioni, vedere questo blog.

Questo argomento contiene informazioni dettagliate su Azure Media Redactor e illustra come usare questa funzionalità con Media Services SDK per .NET.

Il processore di contenuti multimediali Azure Media Redactor è attualmente in anteprima. È disponibile in tutte le aree di Azure pubbliche, nonché nei data center cinesi e del governo degli USA. Al momento questa versione di anteprima è disponibile gratuitamente.

Modalità per l'offuscamento dei volti

La funzionalità di offuscamento dei volti rileva i volti in ogni fotogramma del video e monitora l'oggetto volto avanti e indietro nel tempo in modo da consentire la sfocatura della stessa persona anche da altre angolazioni. Il processo di offuscamento automatizzato è molto complesso e non sempre produce al 100% l'output desiderato. Per tale motivo, Analisi Servizi multimediali offre alcuni modi per modificare l'output finale.

In aggiunta a una modalità interamente automatica, esiste un flusso di lavoro in due passaggi che consente di selezionare/deselezionare i volti trovati tramite un elenco di ID. Per apportare modifiche arbitrarie per singolo fotogramma, inoltre, il processore di contenuti multimediali usa un file di metadati in formato JSON. Il flusso di lavoro è suddiviso nelle modalità analisi e offuscamento. È possibile combinare le due modalità in un singolo passaggio che esegue entrambe le attività in un unico processo. Questa modalità è detta combinata.

Modalità combinata

Questa modalità produce automaticamente un file mp4 offuscato senza alcun input manuale.

Fase File Name Note
Asset di input foo.bar Video in formato WMV, MOV o MP4
Configurazione di input Set di impostazioni di configurazione del processo {'version':'1.0', 'options': {'mode':'combined'}}
Asset di output foo_redacted.mp4 Video con sfocatura applicata

Esempio di input:

Guardare il video

Esempio di output:

Guardare il video

Modalità analisi

Nel flusso di lavoro in due passaggi, il passaggio dell' analisi usa un input video e produce un file JSON di posizioni di volti e immagini jpg di ogni volto rilevato.

Fase File Name Note
Asset di input foo.bar Video in formato WMV, MPV o MP4
Configurazione di input Set di impostazioni di configurazione del processo {'version':'1.0', 'options': {'mode':'analyze'}}
Asset di output foo_annotations.json Dati di annotazione delle posizioni dei volti in formato JSON, modificabili dall'utente per modificare i rettangoli di selezione della sfocatura. Vedere l'esempio di seguito.
Asset di output foo_thumb%06d.jpg [foo_thumb000001.jpg, foo_thumb000002.jpg] File jpg ritagliato di ogni volto rilevato, in cui il numero indica l'ID etichetta del volto

Esempio di output:

{
  "version": 1,
  "timescale": 24000,
  "offset": 0,
  "framerate": 23.976,
  "width": 1280,
  "height": 720,
  "fragments": [
    {
      "start": 0,
      "duration": 48048,
      "interval": 1001,
      "events": [
        [],
        [],
        [],
        [],
        [],
        [],
        [],
        [],
        [],
        [],
        [],
        [],
        [],
        [
          {
            "index": 13,
            "id": 1138,
            "x": 0.29537,
            "y": -0.18987,
            "width": 0.36239,
            "height": 0.80335
          },
          {
            "index": 13,
            "id": 2028,
            "x": 0.60427,
            "y": 0.16098,
            "width": 0.26958,
            "height": 0.57943
          }
        ],

… truncated

Modalità offuscamento

Il secondo passaggio del flusso di lavoro usa un numero superiore di input che devono essere combinati in un singolo asset.

Gli input includono un elenco di ID da sfocare, il video originale e il file JSON delle annotazioni. Questa modalità usa le annotazioni per applicare la sfocatura nel video di input.

L'output del passaggio dell'analisi non include il video originale. Il video deve essere caricato nell'asset di input per l'attività della modalità offuscamento ed essere selezionato come file primario.

Fase File Name Note
Asset di input foo.bar Video in formato WMV, MPV o MP4. Stesso video del passaggio 1.
Asset di input foo_annotations.json File di metadati delle annotazioni della prima fase, con modifiche facoltative.
Asset di input foo_IDList.txt (facoltativo) Elenco facoltativo separato da caratteri di nuova riga di ID volto da offuscare. Se viene lasciato vuoto, vengono sfocati tutti i volti.
Configurazione di input Set di impostazioni di configurazione del processo {'version':'1.0', 'options': {'mode':'redact'}}
Asset di output foo_redacted.mp4 Video con sfocatura applicata in base alle annotazioni.

Output di esempio

Questo output viene ottenuto da un elenco di ID con un ID selezionato.

Guardare il video

Esempio foo_IDList.txt

 1
 2
 3

Tipi di sfocature

Nella modalità Combined o Redact, sono disponibili 5 modalità di sfocatura diverse tra cui scegliere tramite la configurazione di input JSON: Low, Med, High, Debug e Black. Per impostazione predefinita, viene usata Med.

Di seguito sono riportati alcuni esempi dei tipi di sfocature.

JSON di esempio:

{'version':'1.0', 'options': {'Mode': 'Combined', 'BlurType': 'High'}}

Basso

Basso

Med

Med

Alto

Alto

Debug

Debug

Nero

Nero

Elementi del file di output JSON

Il processore di contenuti multimediali per l'offuscamento offre funzionalità di rilevamento della posizione e monitoraggio dei volti ad alta precisione che possono rilevare fino a 64 volti umani in un fotogramma video. Le riprese anteriori producono risultati ottimali, mentre profili e volti di piccole dimensioni (inferiori o uguali a 24x24 pixel) presentano alcune problematiche.

Il processo genera un file di output JSON che contiene i metadati sui volti rilevati e monitorati. I metadati includono coordinate che indicano la posizione dei volti e un numero di ID volto che indica il monitoraggio della persona specifica. I codici ID del volto sono soggetti a ripristino quando le riprese non sono frontali o sono sovrapposte nel fotogramma, causando l'assegnazione di diversi ID alla stessa persona.

L'output JSON include gli attributi seguenti:

Elemento Descrizione
version Indica la versione dell'API Video.
index Solo per Azure Media Redactor. Definisce l'indice dei fotogrammi dell'evento corrente.
timescale "Scatti" al secondo del video.
offset Differenza di orario dei timestamp. Nella versione 1.0 delle API Video, questo valore è sempre 0. Negli scenari futuri supportati questo valore potrebbe cambiare.
framerate Fotogrammi al secondo del video.
fragments I metadati sono suddivisi in segmenti diversi, detti frammenti. Ogni frammento contiene un inizio, una durata, un numero di intervallo e uno o più eventi.
start L'ora di inizio del primo evento in "scatti".
duration La lunghezza del frammento in "scatti".
interval L'intervallo di ogni voce di evento all'interno del frammento in "scatti".
eventi Ogni evento contiene i volti rilevati e monitorati nel periodo specificato. È una matrice di eventi. La matrice esterna rappresenta un intervallo di tempo. La matrice interna è costituita da 0 o più eventi che si sono verificati in un determinato momento. Le parentesi quadre vuote [] indicano che non sono stati rilevati volti.
id L'ID del volto monitorato. Questo numero potrebbe cambiare inavvertitamente se un volto non viene rilevato. Una determinata persona dovrebbe avere lo stesso ID in tutto il video, ma non è possibile garantire sempre lo stesso ID a causa delle limitazioni nell'algoritmo di rilevamento (occlusione e così via)
x, y Le coordinate X e Y in alto a sinistra del riquadro del contorno del volto in una scala normalizzata da 0,0 a 1,0.
Le coordinate X e Y si riferiscono sempre all'orientamento orizzontale, pertanto se il video è in formato verticale o se è capovolto, nel caso di iOS, sarà necessario trasporre le coordinate di conseguenza.
width, height La larghezza e altezza del riquadro del contorno del volto in una scala normalizzata da 0,0 a 1,0.
facesDetected Questo valore viene riportato alla fine dei risultati del file JSON e riepiloga il numero di volti rilevati dall'algoritmo durante il video. Poiché gli ID possono essere reimpostati inavvertitamente se un volto non viene rilevato, ad esempio quando il volto esce dall'inquadratura o la persona si volta, questo numero potrebbe non corrispondere sempre al vero numero di volti del video.

Codice di esempio .NET

Il programma seguente illustra come:

  1. Creare un asset e caricare un file multimediale nell'asset.
  2. Creare un processo con un'attività di offuscamento dei volti in base a un file di configurazione contenente il set di impostazioni JSON seguente.

     {'version':'1.0', 'options': {'mode':'combined'}}
    
  3. Scaricare i file JSON di output.

Creare e configurare un progetto di Visual Studio

Configurare l'ambiente di sviluppo e popolare il file app.config con le informazioni di connessione, come descritto in Sviluppo di applicazioni di Servizi multimediali con .NET.

Esempio

using System;
using System.Configuration;
using System.IO;
using System.Linq;
using Microsoft.WindowsAzure.MediaServices.Client;
using System.Threading;
using System.Threading.Tasks;

namespace FaceRedaction
{
    class Program
    {
    // Read values from the App.config file.
    private static readonly string _AADTenantDomain =
        ConfigurationManager.AppSettings["AADTenantDomain"];
    private static readonly string _RESTAPIEndpoint =
        ConfigurationManager.AppSettings["MediaServiceRESTAPIEndpoint"];

    // Field for service context.
    private static CloudMediaContext _context = null;

    static void Main(string[] args)
    {
        var tokenCredentials = new AzureAdTokenCredentials(_AADTenantDomain, AzureEnvironments.AzureCloudEnvironment);
        var tokenProvider = new AzureAdTokenProvider(tokenCredentials);

        _context = new CloudMediaContext(new Uri(_RESTAPIEndpoint), tokenProvider);

        // Run the FaceRedaction job.
        var asset = RunFaceRedactionJob(@"C:\supportFiles\FaceRedaction\SomeFootage.mp4",
                    @"C:\supportFiles\FaceRedaction\config.json");

        // Download the job output asset.
        DownloadAsset(asset, @"C:\supportFiles\FaceRedaction\Output");
    }

    static IAsset RunFaceRedactionJob(string inputMediaFilePath, string configurationFile)
    {
        // Create an asset and upload the input media file to storage.
        IAsset asset = CreateAssetAndUploadSingleFile(inputMediaFilePath,
        "My Face Redaction Input Asset",
        AssetCreationOptions.None);

        // Declare a new job.
        IJob job = _context.Jobs.Create("My Face Redaction Job");

        // Get a reference to Azure Media Redactor.
        string MediaProcessorName = "Azure Media Redactor";

        var processor = GetLatestMediaProcessorByName(MediaProcessorName);

        // Read configuration from the specified file.
        string configuration = File.ReadAllText(configurationFile);

        // Create a task with the encoding details, using a string preset.
        ITask task = job.Tasks.AddNew("My Face Redaction Task",
        processor,
        configuration,
        TaskOptions.None);

        // Specify the input asset.
        task.InputAssets.Add(asset);

        // Add an output asset to contain the results of the job.
        task.OutputAssets.AddNew("My Face Redaction Output Asset", AssetCreationOptions.None);

        // Use the following event handler to check job progress.  
        job.StateChanged += new EventHandler<JobStateChangedEventArgs>(StateChanged);

        // Launch the job.
        job.Submit();

        // Check job execution and wait for job to finish.
        Task progressJobTask = job.GetExecutionProgressTask(CancellationToken.None);

        progressJobTask.Wait();

        // If job state is Error, the event handling
        // method for job progress should log errors.  Here we check
        // for error state and exit if needed.
        if (job.State == JobState.Error)
        {
        ErrorDetail error = job.Tasks.First().ErrorDetails.First();
        Console.WriteLine(string.Format("Error: {0}. {1}",
                        error.Code,
                        error.Message));
        return null;
        }

        return job.OutputMediaAssets[0];
    }

    static IAsset CreateAssetAndUploadSingleFile(string filePath, string assetName, AssetCreationOptions options)
    {
        IAsset asset = _context.Assets.Create(assetName, options);

        var assetFile = asset.AssetFiles.Create(Path.GetFileName(filePath));
        assetFile.Upload(filePath);

        return asset;
    }

    static void DownloadAsset(IAsset asset, string outputDirectory)
    {
        foreach (IAssetFile file in asset.AssetFiles)
        {
        file.Download(Path.Combine(outputDirectory, file.Name));
        }
    }

    static IMediaProcessor GetLatestMediaProcessorByName(string mediaProcessorName)
    {
        var processor = _context.MediaProcessors
        .Where(p => p.Name == mediaProcessorName)
        .ToList()
        .OrderBy(p => new Version(p.Version))
        .LastOrDefault();

        if (processor == null)
        throw new ArgumentException(string.Format("Unknown media processor",
                               mediaProcessorName));

        return processor;
    }

    static private void StateChanged(object sender, JobStateChangedEventArgs e)
    {
        Console.WriteLine("Job state changed event:");
        Console.WriteLine("  Previous state: " + e.PreviousState);
        Console.WriteLine("  Current state: " + e.CurrentState);

        switch (e.CurrentState)
        {
        case JobState.Finished:
            Console.WriteLine();
            Console.WriteLine("Job is finished.");
            Console.WriteLine();
            break;
        case JobState.Canceling:
        case JobState.Queued:
        case JobState.Scheduled:
        case JobState.Processing:
            Console.WriteLine("Please wait...\n");
            break;
        case JobState.Canceled:
        case JobState.Error:
            // Cast sender as a job.
            IJob job = (IJob)sender;
            // Display or log error details as needed.
            // LogJobStop(job.Id);
            break;
        default:
            break;
        }
    }
    }
}

Passaggi successivi

I percorsi di apprendimento di Servizi multimediali di Azure sono disponibili qui:

Fornire commenti e suggerimenti

Usare il forum di suggerimenti degli utenti per fornire commenti e suggerimenti su come migliorare Servizi multimediali di Azure. È anche possibile passare direttamente a una delle categorie seguenti:

Panoramica di Analisi servizi multimediali di Azure

Demo di Analisi servizi multimediali di Azure