Megosztás a következőn keresztül:

A HeadPose attribútum használata

  • Cikk

Ebben az útmutatóban megtudhatja, hogyan használhatja az észlelt arc HeadPose attribútumát néhány kulcsfontosságú forgatókönyv engedélyezéséhez.

Fontos

Az arcattribútumok előrejelzése statisztikai algoritmusok használatával történik. Lehet, hogy nem mindig pontosak. Körültekintően járjon el, ha attribútumadatokon alapuló döntéseket hoz. Ne használja ezeket az attribútumokat a hamisítás elleni hamisításhoz. Ehelyett a Face Liveness detektálását javasoljuk. További információkért tekintse meg a következő oktatóanyagot: Élőség észlelése az arcokban.

Az arc téglalapjának elforgatása

Az arc téglalapja, amelyet minden észlelt arcmal visszaadott, az arc helyét és méretét jelöli a képen. Alapértelmezés szerint a téglalap mindig a képhez igazodik (oldalai függőlegesek és vízszintesek); ez nem lehet hatékony a szögletes arcok kialakításához. Olyan helyzetekben, amikor programozott módon szeretné körülvágott arcokat egy képen, jobb, ha elforgatja a téglalapot a körülvágáshoz.

Az Azure AI Face WPF (Windows megjelenítési alaprendszer) mintaalkalmazás a HeadPose attribútummal elforgatja az észlelt arc téglalapjait.

A mintakód megismerése

Az arc téglalapja programozott módon elforgatható a HeadPose attribútummal. Ha ezt az attribútumot az arcok észlelésekor adja meg (lásd : Az észlelési API meghívása), később le tudja kérdezni. Az Azure AI Face WPF-alkalmazás következő metódusa a DetectedFace objektumok listáját veszi fel, és visszaadja a Face-objektumok listáját. A Face here egy egyéni osztály, amely arcadatokat tárol, beleértve a frissített téglalap koordinátáit is. A rendszer új értékeket számít ki a felső, bal oldali, szélességi és magassági értékekhez, és egy új mező, a FaceAngle határozza meg a forgatást.

/// <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,
        };
    }
}

A frissített téglalap megjelenítése

Innen használhatja a visszaadott Face objektumokat a kijelzőn. A FaceDetectionPage.xaml alábbi sorai bemutatják, hogyan jelenik meg az új téglalap az adatokból:

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

Következő lépések