Utilizar o atributo HeadPoseUse the HeadPose attribute

Neste guia, você verá como você pode usar o atributo HeadPose de um rosto detetado para ativar alguns cenários chave.In this guide, you'll see how you can use the HeadPose attribute of a detected face to enable some key scenarios.

Rode o retângulo facialRotate the face rectangle

O retângulo facial, devolvido com cada rosto detetado, marca a localização e o tamanho do rosto na imagem.The face rectangle, returned with every detected face, marks the location and size of the face in the image. Por predefinição, o retângulo está sempre alinhado com a imagem (os seus lados são verticais e horizontais); isto pode ser ineficiente para enquadrar rostos angulares.By default, the rectangle is always aligned with the image (its sides are vertical and horizontal); this can be inefficient for framing angled faces. Em situações em que se quer plantar rostos programáticamente numa imagem, é melhor ser capaz de rodar o retângulo para a colheita.In situations where you want to programmatically crop faces in an image, it's better to be able to rotate the rectangle to crop.

A aplicação de amostra seletiva De Serviços Cognitivos WPF utiliza o atributo HeadPose para rodar os retângulos faciais detetados.The Cognitive Services Face WPF sample app uses the HeadPose attribute to rotate its detected face rectangles.

Explore o código da amostraExplore the sample code

Pode rodar programáticamente o retângulo facial utilizando o atributo HeadPose.You can programmatically rotate the face rectangle by using the HeadPose attribute. Se especificar este atributo ao detetar rostos (ver como detetar rostos),poderá questioná-lo mais tarde.If you specify this attribute when detecting faces (see How to detect faces), you will be able to query it later. O método seguinte da aplicação Face WPF dos Serviços Cognitivos pega numa lista de objetos DetectedFace e devolve uma lista de objetos Face.The following method from the Cognitive Services Face WPF app takes a list of DetectedFace objects and returns a list of Face objects. Face aqui é uma classe personalizada que armazena dados faciais, incluindo as coordenadas retângulo atualizadas.Face here is a custom class that stores face data, including the updated rectangle coordinates. São calculados novos valores para a parte superior, esquerda, largura, altura e altura, e um novo campo FaceAngle especifica a rotação.New values are calculated for top, left, width, and height, and a new field FaceAngle specifies the rotation.

/// <summary>
/// Calculate the rendering face rectangle
/// </summary>
/// <param name="faces">Detected face from service</param>
/// <param name="maxSize">Image rendering size</param>
/// <param name="imageInfo">Image width and height</param>
/// <returns>Face structure for rendering</returns>
public static IEnumerable<Face> CalculateFaceRectangleForRendering(IList<DetectedFace> faces, int maxSize, Tuple<int, int> imageInfo)
{
    var imageWidth = imageInfo.Item1;
    var imageHeight = imageInfo.Item2;
    var ratio = (float)imageWidth / imageHeight;
    int uiWidth = 0;
    int uiHeight = 0;
    if (ratio > 1.0)
    {
        uiWidth = maxSize;
        uiHeight = (int)(maxSize / ratio);
    }
    else
    {
        uiHeight = maxSize;
        uiWidth = (int)(ratio * uiHeight);
    }

    var uiXOffset = (maxSize - uiWidth) / 2;
    var uiYOffset = (maxSize - uiHeight) / 2;
    var scale = (float)uiWidth / imageWidth;

    foreach (var face in faces)
    {
        var left = (int)(face.FaceRectangle.Left * scale + uiXOffset);
        var top = (int)(face.FaceRectangle.Top * scale + uiYOffset);

        // Angle of face rectangles, default value is 0 (not rotated).
        double faceAngle = 0;

        // If head pose attributes have been obtained, re-calculate the left & top (X & Y) positions.
        if (face.FaceAttributes?.HeadPose != null)
        {
            // Head pose's roll value acts directly as the face angle.
            faceAngle = face.FaceAttributes.HeadPose.Roll;
            var angleToPi = Math.Abs((faceAngle / 180) * Math.PI);

            // _____       | / \ |
            // |____|  =>  |/   /|
            //             | \ / |
            // Re-calculate the face rectangle's left & top (X & Y) positions.
            var newLeft = face.FaceRectangle.Left +
                face.FaceRectangle.Width / 2 -
                (face.FaceRectangle.Width * Math.Sin(angleToPi) + face.FaceRectangle.Height * Math.Cos(angleToPi)) / 2;

            var newTop = face.FaceRectangle.Top +
                face.FaceRectangle.Height / 2 -
                (face.FaceRectangle.Height * Math.Sin(angleToPi) + face.FaceRectangle.Width * Math.Cos(angleToPi)) / 2;

            left = (int)(newLeft * scale + uiXOffset);
            top = (int)(newTop * scale + uiYOffset);
        }

        yield return new Face()
        {
            FaceId = face.FaceId?.ToString(),
            Left = left,
            Top = top,
            OriginalLeft = (int)(face.FaceRectangle.Left * scale + uiXOffset),
            OriginalTop = (int)(face.FaceRectangle.Top * scale + uiYOffset),
            Height = (int)(face.FaceRectangle.Height * scale),
            Width = (int)(face.FaceRectangle.Width * scale),
            FaceAngle = faceAngle,
        };
    }
}

Mostrar o retângulo atualizadoDisplay the updated rectangle

A partir daqui, pode utilizar os objetos de face devolvidos no seu visor.From here, you can use the returned Face objects in your display. As seguintes linhas do FaceDetectionPage.xaml mostram como o novo retângulo é renderizado a partir destes dados:The following lines from FaceDetectionPage.xaml show how the new rectangle is rendered from this data:

 <DataTemplate>
    <Rectangle Width="{Binding Width}" Height="{Binding Height}" Stroke="#FF26B8F4" StrokeThickness="1">
        <Rectangle.LayoutTransform>
            <RotateTransform Angle="{Binding FaceAngle}"/>
        </Rectangle.LayoutTransform>
    </Rectangle>
</DataTemplate>

Detetar gestos de cabeçaDetect head gestures

Você pode detetar gestos de cabeça como abanar a cabeça e abanar a cabeça rastreando as mudanças de HeadPose em tempo real.You can detect head gestures like nodding and head shaking by tracking HeadPose changes in real time. Pode utilizar esta funcionalidade como detetor de vivacidade personalizado.You can use this feature as a custom liveness detector.

A deteção de vivacidade é a tarefa de determinar que um sujeito é uma pessoa real e não uma representação de imagem ou vídeo.Liveness detection is the task of determining that a subject is a real person and not an image or video representation. Um detetor de gestos na cabeça pode servir como uma forma de ajudar a verificar a vivacidade, especialmente em oposição a uma representação de imagem de uma pessoa.A head gesture detector could serve as one way to help verify liveness, especially as opposed to an image representation of a person.

Atenção

Para detetar gestos de cabeça em tempo real, terá de chamar a API facial a uma taxa elevada (mais de uma vez por segundo).To detect head gestures in real time, you'll need to call the Face API at a high rate (more than once per second). Se tiver uma subscrição de nível livre (f0), tal não será possível.If you have a free-tier (f0) subscription, this will not be possible. Se tiver uma subscrição de nível pago, certifique-se de calcular os custos de fazer chamadas rápidas de API para deteção de gestos de cabeça.If you have a paid-tier subscription, make sure you've calculated the costs of making rapid API calls for head gesture detection.

Consulte a amostra face headpose no GitHub para obter um exemplo de trabalho de deteção de gestos na cabeça.See the Face HeadPose Sample on GitHub for a working example of head gesture detection.

Passos seguintesNext steps

Consulte a aplicação Cognitive Services Face WPF no GitHub para obter um exemplo de funcionamento de retângulos faciais rotativos.See the Cognitive Services Face WPF app on GitHub for a working example of rotated face rectangles. Ou, consulte a aplicação Face HeadPose Sample, que rastreia o atributo HeadPose em tempo real para detetar movimentos da cabeça.Or, see the Face HeadPose Sample app, which tracks the HeadPose attribute in real time to detect head movements.