Kurz: Detekce živého života v tvářích

Zjistěte, jak integrovat detekci živé tváře do pracovního postupu pomocí logiky na straně serveru a doprovodných klientských aplikací front-endu.

Návod

Obecné informace o detekci živé tváře najdete v koncepční příručce.

V tomto kurzu se dozvíte, jak spustit front-endovou aplikaci s aplikačním serverem, aby bylo možné provádět detekci aktivity. Můžete také přidat ověřování tváře napříč různými platformami a jazyky.

Důležité

Klientské sady SDK pro detekci živosti obličeje jsou funkce s omezeným přístupem. Musíte požádat o přístup k funkci živosti vyplněním formuláře pro příjem žádosti o rozpoznávání tváře. Po udělení přístupu k předplatnému Azure si můžete stáhnout sadu SDK pro rozpoznávání tváře.

Požadavky

• Předplatné Azure: Můžete si ho vytvořit zdarma.
• Váš účet Azure musí mít přiřazenou roli Přispěvatel služeb Cognitive Services , abyste mohli souhlasit s zodpovědnými podmínkami umělé inteligence a vytvořit prostředek. Pokud chcete tuto roli přiřadit k vašemu účtu, postupujte podle pokynů v dokumentaci k přiřazování rolí nebo se obraťte na správce.
• Jakmile budete mít předplatné Azure, v Azure portálu, aby získali klíč a koncový bod. Jakmile je nasazení dokončeno, zvolte Přejít k prostředku.
  • K připojení aplikace ke službě Rozpoznávání tváře potřebujete klíč a koncový bod z prostředku, který vytvoříte.
• Přístup k chráněným artefaktům potřebným pro Azure Vision v Foundry Tools Face Client SDK pro mobilní zařízení (iOS a Android) a web.
  • Abyste mohli začít, musíte požádat o funkce omezeného přístupu k rozpoznávání tváře pro získání přístupu k chráněným artefaktům. Další informace najdete na stránce Face Limited Access.
• Znalost funkce detekce živosti tváře. Podívejte se na koncepční příručku.

Návod

Po splnění předpokladů můžete vyzkoušet živý zážitek na následujících platformách:

• iOS: iOS App Store – klepnutím na obrazovku aplikace 10krát po instalaci povolte vývojářský režim.
  
• Android: Google Play Store – klepnutím na obrazovku aplikace 10krát po instalaci povolte vývojářský režim.
  
• Web: Vyzkoušejte ho přímo v nástroji Vision Studio.
  

Kompletní ukázku front-endu (iOS, Android nebo Web) můžete také sestavit a spustit v části Ukázky .

Příprava front-endové aplikace

Sady SDK poskytujeme ve více jazycích, abychom zjednodušili integraci s front-endovou aplikací. Pokud chcete integrovat uživatelské rozhraní i požadovaný kód, projděte si soubor README pro zvolenou sadu SDK v následujících částech.

Důležité

Každá front-endová sada SDK vyžaduje přístup k chráněnému prostředku, aby se úspěšně zkompiloval. Pokud chcete nastavit tento přístup, přečtěte si následující pokyny.

Pro Swift iOS:

• Artefakty: Azure AI Face UI SDK pro iOS
• Referenční informace k rozhraní API: Referenční dokumentace k AzureAIVisionFaceUI
• Ukázka: Ukázka pro iOS

Pro Kotlin/Java Android:

• Artefakty: Maven Central: com.azure:azure-ai-vision-face-ui
• Referenční informace k rozhraní API: azure-ai-vision-face-ui Reference
• Ukázka: Ukázka systému Android

Pro javascriptový web:

• Artefakty: @azure/ai-vision-face-ui - npm
• Referenční informace k rozhraní API: Referenční dokumentace k AzureAIVisionFaceUI
• Ukázka: Webová ukázka
• Podpora architektury: Funguje s oblíbenými architekturami, jako je React (včetně Next.js), Vue.jsa Angular.

Jakmile je sada SDK integrovaná do front-endové aplikace, kameru zapne, nasměruje uživatele k úpravě své pozice, sestaví datový balíček pro ověření živosti a odešle jej do služby Azure AI Face ke zpracování.

Sledujte sekci Vydání repozitáře pro nové aktualizace verzí SDK a povolte upozornění na automatické aktualizace závislostí, jako je GitHub Dependabot (pro repozitáře GitHub) nebo Renovate (GitHub, GitLab, Bitbucket a Azure Repos).

Detekce živosti

Následující kroky popisují proces orchestrace aktivity:

1. Front-endová aplikace spustí kontrolu aktivity a upozorní aplikační server.

2. Aplikační server vytvoří novou relaci živé aktivity se službou Azure AI Face Service. Služba vytvoří živou relaci a odpoví autorizačním tokenem relace. Další informace o každém parametru požadavku, který je součástí vytváření relace liveness, naleznete v tématu Liveness Create Session Operation.

   C#

   var endpoint = new Uri(System.Environment.GetEnvironmentVariable("FACE_ENDPOINT"));
   var key = new AzureKeyCredential(System.Environment.GetEnvironmentVariable("FACE_APIKEY"));
   
   var body = JsonSerializer.Serialize(new
   {
       livenessOperationMode = "PassiveActive",
       deviceCorrelationId = "723d6d03-ef33-40a8-9682-23a1feb7bccd",
       enableSessionImage = true
   });
   
   using var client = new HttpClient();
   client.DefaultRequestHeaders.Add("Ocp-Apim-Subscription-Key", key);
   
   var response = await client.PostAsync(
       $"{endpoint}/face/v1.2/detectLiveness-sessions",
       new StringContent(body, Encoding.UTF8, "application/json"));
   
   response.EnsureSuccessStatusCode();
   
   using var doc  = JsonDocument.Parse(await response.Content.ReadAsStringAsync());
   var root       = doc.RootElement;
   
   Console.WriteLine("Session created");
   Console.WriteLine($"sessionId : {root.GetProperty("sessionId").GetString()}");
   Console.WriteLine($"authToken : {root.GetProperty("authToken").GetString()}");
   

   Java

   String endpoint = System.getenv("FACE_ENDPOINT");
   String key = System.getenv("FACE_APIKEY");
   
   String body = """
   {
       "livenessOperationMode": "PassiveActive",
       "deviceCorrelationId": "723d6d03-ef33-40a8-9682-23a1feb7bccd",
       "enableSessionImage": true,
   }
   """;
   
   HttpRequest req = HttpRequest.newBuilder()
           .uri(URI.create(endpoint + "/face/v1.2/detectLiveness-sessions"))
           .header("Content-Type", "application/json")
           .header("Ocp-Apim-Subscription-Key", key)
           .POST(HttpRequest.BodyPublishers.ofString(body))
           .build();
   
   HttpResponse<String> res = HttpClient.newHttpClient()
           .send(req, HttpResponse.BodyHandlers.ofString());
   
   if (res.statusCode() != 200) throw new RuntimeException("HTTP error: " + res.statusCode());
   
   JsonNode json = new ObjectMapper().readTree(res.body());
   System.out.println("Session created");
   System.out.println("sessionId : " + json.get("sessionId").asText());
   System.out.println("authToken : " + json.get("authToken").asText());
   

   Python

   endpoint = os.environ["FACE_ENDPOINT"]
   key = os.environ["FACE_APIKEY"]
   
   url  = f"{endpoint}/face/v1.2/detectLiveness-sessions"
   body = {
       "livenessOperationMode": "PassiveActive",
       "deviceCorrelationId":  "723d6d03-ef33-40a8-9682-23a1feb7bccd",
       "enableSessionImage":   True
   }
   
   headers = {
       "Ocp-Apim-Subscription-Key": key,
       "Content-Type": "application/json"
   }
   
   res = requests.post(url, headers=headers, data=json.dumps(body))
   res.raise_for_status()
   
   data = res.json()
   print("Session created")
   print("sessionId :", data["sessionId"])
   print("authToken :", data["authToken"])
   

   JavaScript

   const endpoint = process.env['FACE_ENDPOINT'];
   const apikey = process.env['FACE_APIKEY'];
   
   const url  = `${endpoint}/face/v1.2/detectLiveness-sessions`;
   const body = {
       livenessOperationMode: "PassiveActive",
       deviceCorrelationId:  "723d6d03-ef33-40a8-9682-23a1feb7bccd",
       enableSessionImage:   true
   };
   
   const headers = {
       "Ocp-Apim-Subscription-Key": key,
       "Content-Type": "application/json"
   };
   
   async function createLivenessSession() {
       const res = await fetch(url, {
           method: "POST",
           headers,
           body: JSON.stringify(body)
       });
   
       if (!res.ok) {
           throw new Error(`${res.status} ${await res.text()}`);
       }
   
       const data = await res.json();
       console.log("Session created");
       console.log("sessionId :", data.sessionId);
       console.log("authToken :", data.authToken);
   }
   

   REST API (Windows)

   curl --request POST --location "%FACE_ENDPOINT%/face/v1.2/detectLiveness-sessions" ^
   --header "Ocp-Apim-Subscription-Key: %FACE_APIKEY%" ^
   --header "Content-Type: application/json" ^
   --data ^
   "{ ^
       ""livenessOperationMode"": ""passiveactive"", ^
       ""deviceCorrelationId"": ""723d6d03-ef33-40a8-9682-23a1feb7bccd"", ^
       ""enableSessionImage"": ""true"" ^
   }"
   

   REST API (Linux)

   curl --request POST --location "${FACE_ENDPOINT}/face/v1.2/detectLivenesswithVerify-sessions" \
   --header "Ocp-Apim-Subscription-Key: ${FACE_APIKEY}" \
   --header "Content-Type: application/json" \
   --data \
   '{
       "livenessOperationMode": "passiveactive",
       "deviceCorrelationId": "723d6d03-ef33-40a8-9682-23a1feb7bccd",
       "enableSessionImage": "true"
   }'
   

   Příklad textu odpovědi:

   {
       "sessionId": "a6e7193e-b638-42e9-903f-eaf60d2b40a5",
       "authToken": "<session-authorization-token>",
       "status": "NotStarted",
       "modelVersion": "2025-05-20",
       "results": {
           "attempts": []
       }
   }
   

3. Aplikační server poskytuje autorizační token relace zpět do front-endové aplikace.

4. Frontendová aplikace používá autorizační token relace ke spuštění detektoru živosti obličeje, který zahájí proces ověřování živosti.

   Android

       FaceLivenessDetector(
           sessionAuthorizationToken = FaceSessionToken.sessionToken,
           verifyImageFileContent = FaceSessionToken.sessionSetInClientVerifyImage,
           deviceCorrelationId = "null",
           onSuccess = viewModel::onSuccess,
           onError = viewModel::onError
       )
   

   Ios

   struct HostView: View {
      @State var livenessDetectionResult: LivenessDetectionResult? = nil
      var token: String
      var body: some View {
          if livenessDetectionResult == nil {
              FaceLivenessDetectorView(result: $livenessDetectionResult,
                                       sessionAuthorizationToken: token)
          } else if let result = livenessDetectionResult {
              VStack {
                  switch result { 
                      case .success(let success):
                      /// <#show success#>
                      case .failure(let error):
                      /// <#show failure#>
                  }
              }
          }
      }
   }
   

   Web

   faceLivenessDetector = document.createElement("azure-ai-vision-face-ui");
   document.getElementById("container").appendChild(faceLivenessDetector);
   faceLivenessDetector.start(session.authToken)
   

5. SDK spustí kameru, nasměruje uživatele, aby správně umístil zařízení, a následně připraví datovou část pro volání koncového bodu služby detekce živosti.

6. Sada SDK volá službu Azure Vision Face pro detekci živosti. Jakmile služba odpoví, sada SDK oznámí frontendové aplikaci, že je kontrola živosti dokončená. Poznámka: Odpověď služby neobsahuje rozhodnutí o živém stavu. Tyto informace musíte dotazovat ze serveru aplikace.

7. Front-endová aplikace předá dokončení kontroly aktivity na aplikační server.

8. Aplikační server se dotazuje na výsledek detekce živé aktivity ze služby Azure Vision Face.

   C#

   using var client = new HttpClient();
   client.DefaultRequestHeaders.Add("Ocp-Apim-Subscription-Key", key);
   
   var response = await client.GetAsync(
       $"{endpoint}/face/v1.2/livenessSessions/{sessionId}/result");
   
   response.EnsureSuccessStatusCode();
   
   using var doc = JsonDocument.Parse(await response.Content.ReadAsStringAsync());
   var root = doc.RootElement;
   var attempts = root.GetProperty("results").GetProperty("attempts");
   var latestAttempt = attempts[attempts.GetArrayLength() - 1];
   var attemptStatus = latestAttempt.GetProperty("attemptStatus").GetString();
   
   Console.WriteLine($"Session id: {root.GetProperty("sessionId").GetString()}");
   Console.WriteLine($"Session status: {root.GetProperty("status").GetString()}");
   Console.WriteLine($"Latest attempt status: {attemptStatus}");
   
   if (attemptStatus == "Succeeded")
       Console.WriteLine($"Liveness detection decision: {latestAttempt.GetProperty("result").GetProperty("livenessDecision").GetString()}");
   else
   {
       var error = latestAttempt.GetProperty("error");
       Console.WriteLine($"Error: {error.GetProperty("code").GetString()} - {error.GetProperty("message").GetString()}");
   }
   

   Java

   HttpRequest req = HttpRequest.newBuilder()
       .uri(URI.create(endpoint + "/face/v1.2/livenessSessions/" + sessionId + "/result"))
       .header("Ocp-Apim-Subscription-Key", key)
       .GET()
       .build();
   
   HttpResponse<String> res = HttpClient.newHttpClient()
       .send(req, HttpResponse.BodyHandlers.ofString());
   
   if (res.statusCode() != 200) throw new RuntimeException("HTTP error: " + res.statusCode());
   
   JsonNode root = new ObjectMapper().readTree(res.body());
   JsonNode attempts = root.path("results").path("attempts");
   JsonNode latestAttempt = attempts.get(attempts.size() - 1);
   
   String attemptStatus = latestAttempt.path("attemptStatus").asText();
   
   System.out.println("Session id: " + root.path("sessionId").asText());
   System.out.println("Session status: " + root.path("status").asText());
   System.out.println("Latest attempt status: " + attemptStatus);
   
   if ("Succeeded".equals(attemptStatus)) {
       System.out.println("Liveness detection decision: " +
           latestAttempt.path("result").path("livenessDecision").asText());
   } else {
       JsonNode error = latestAttempt.path("error");
       System.out.println("Error: " + error.path("code").asText() + " - " +
           error.path("message").asText());
   }
   

   Python

   url = f"{endpoint}/face/v1.2/livenessSessions/{sessionId}/result"
   headers = { "Ocp-Apim-Subscription-Key": key }
   
   res = requests.get(url, headers=headers)
   res.raise_for_status()
   
   data = res.json()
   attempts = data["results"]["attempts"]
   latest_attempt = attempts[-1]
   attempt_status = latest_attempt.get("attemptStatus")
   
   print(f"Session id: {data['sessionId']}")
   print(f"Session status: {data['status']}")
   print(f"Latest attempt status: {attempt_status}")
   
   if attempt_status == "Succeeded":
       print(f"Liveness detection decision: {latest_attempt['result']['livenessDecision']}")
   else:
       err = latest_attempt.get("error", {})
       print(f"Error: {err.get('code')} - {err.get('message')}")
   

   JavaScript

   const url = `${endpoint}/face/v1.2/livenessSessions/${sessionId}/result`;
   const headers = {
       "Ocp-Apim-Subscription-Key": apikey
   };
   
   async function getLivenessSessionResult() {
       const res = await fetch(url, { method: "GET", headers });
       if (!res.ok) {
           throw new Error(`${res.status} ${await res.text()}`);
       }
   
       const data = await res.json();
       const attempts = data.results.attempts;
       const latestAttempt = attempts[attempts.length - 1];
       const attemptStatus = latestAttempt.attemptStatus;
   
       console.log("Session id :", data.sessionId);
       console.log("Session status :", data.status);
       console.log("Latest attempt status :", attemptStatus);
   
       if (attemptStatus === "Succeeded") {
           console.log("Liveness detection decision :", latestAttempt.result.livenessDecision);
       } else {
               const err = latestAttempt.error || {};
               console.log(`Error: ${err.code} - ${err.message}`);
       }
   }
   

   REST API (Windows)

   curl --request GET --location "%FACE_ENDPOINT%/face/v1.2/detectLiveness-sessions/<session-id>" ^
   --header "Ocp-Apim-Subscription-Key: %FACE_APIKEY%"
   

   REST API (Linux)

   curl --request GET --location "${FACE_ENDPOINT}/face/v1.2/detectLiveness-sessions/<session-id>" \
   --header "Ocp-Apim-Subscription-Key: ${FACE_APIKEY}"
   

   Příklad textu odpovědi:

   {
       "sessionId": "b12e033e-bda7-4b83-a211-e721c661f30e",
       "authToken": "eyJhbGciOiJFUzI1NiIsIm",
       "status": "NotStarted",
       "modelVersion": "2024-11-15",
       "results": {
           "attempts": [
               {
                   "attemptId": 2,
                   "attemptStatus": "Succeeded",
                   "result": {
                   "livenessDecision": "realface",
                   "targets": {
                       "color": {
                       "faceRectangle": {
                               "top": 669,
                               "left": 203,
                               "width": 646,
                               "height": 724
                           }
                       }
                   },
                   "digest": "B0A803BB7B26F3C8F29CD36030F8E63ED3FAF955FEEF8E01C88AB8FD89CCF761",
                   "sessionImageId": "Ae3PVWlXAmVAnXgkAFt1QSjGUWONKzWiSr2iPh9p9G4I"
                   }
               },
               {
                   "attemptId": 1,
                   "attemptStatus": "Failed",
                   "error": {
                   "code": "FaceWithMaskDetected",
                   "message": "Mask detected on face image.",
                   "targets": {
                           "color": {
                           "faceRectangle": {
                               "top": 669,
                               "left": 203,
                               "width": 646,
                               "height": 724
                           }
                           }
                       }
                   }
               }
           ]
       }
   }
   

9. Aplikační server odstraní relaci poté, co dotáže všechny výsledky relace.

   C#

   using var client = new HttpClient();
   client.DefaultRequestHeaders.Add("Ocp-Apim-Subscription-Key", key);
   
   await client.DeleteAsync($"{endpoint}/face/v1.2/livenessSessions/{sessionId}");
   Console.WriteLine($"Session deleted: {sessionId}");
   

   Java

   HttpRequest req = HttpRequest.newBuilder()
       .uri(URI.create(endpoint + "/face/v1.2/livenessSessions/" + sessionId))
       .header("Ocp-Apim-Subscription-Key", key)
       .DELETE()
       .build();
   
   HttpClient.newHttpClient().send(req, HttpResponse.BodyHandlers.ofString());
   System.out.println("Session deleted: " + sessionId);
   

   Python

   headers = { "Ocp-Apim-Subscription-Key": key }
   requests.delete(f"{endpoint}/face/v1.2/livenessSessions/{sessionId}", headers=headers)
   print(f"Session deleted: {sessionId}")
   

   JavaScript

   const headers = { "Ocp-Apim-Subscription-Key": apikey };
   await fetch(`${endpoint}/face/v1.2/livenessSessions/${sessionId}`, { method: "DELETE", headers });
   console.log(`Session deleted: ${sessionId}`);
   

   REST API (Windows)

   curl --request DELETE --location "%FACE_ENDPOINT%/face/v1.2/detectLiveness-sessions/<session-id>" ^
   --header "Ocp-Apim-Subscription-Key: %FACE_APIKEY%"
   

   REST API (Linux)

   curl --request DELETE --location "${FACE_ENDPOINT}/face/v1.2/detectLiveness-sessions/<session-id>" \
   --header "Ocp-Apim-Subscription-Key: ${FACE_APIKEY}"
   

Detekce živosti s ověřením obličeje

Kombinace ověřování tváře s detekcí živé aktivity umožňuje biometrické ověřování konkrétní osoby, která má zájem, s přidanou zárukou, že osoba je fyzicky přítomná v systému.

Integrace detekce živosti s ověřením zahrnuje dvě části:

Krok 1 – výběr referenčního obrázku

Pokud chcete získat nejpřesnější výsledky rozpoznávání, postupujte podle tipů uvedených v požadavcích na složení pro scénáře ověřování ID.

Krok 2 : Nastavení orchestrace živé aktivity s ověřením

Následující základní kroky ukazují, jak orchestrovat živě s ověřováním:

1. Pomocí jedné z následujících dvou metod zadejte referenční obrázek ověření:

   • Aplikační server poskytuje referenční obrázek při vytváření relace ověřování živosti. Další informace o každém parametru požadavku, který je součástí vytváření relace aktivity s ověřením, naleznete v tématu Liveness With Verify Create Session Operation.

     C#

     var endpoint = new Uri(System.Environment.GetEnvironmentVariable("FACE_ENDPOINT"));
     var key      = System.Environment.GetEnvironmentVariable("FACE_APIKEY");
     
     // Create the JSON part
     var jsonPart = new StringContent(
         JsonSerializer.Serialize(new
         {
             livenessOperationMode = "PassiveActive",
             deviceCorrelationId = "723d6d03-ef33-40a8-9682-23a1feb7bcc",
             enableSessionImage = true
         }),
         Encoding.UTF8,
         "application/json"
     );
     jsonPart.Headers.ContentDisposition = new ContentDispositionHeaderValue("form-data")
     {
         Name = "CreateLivenessWithVerifySessionRequest"
     };
     
     // Create the file part
     using var fileStream = File.OpenRead("test.png");
     var filePart = new StreamContent(fileStream);
     filePart.Headers.ContentType = new MediaTypeHeaderValue("image/png");
     filePart.Headers.ContentDisposition = new ContentDispositionHeaderValue("form-data")
     {
         Name = "VerifyImage",
         FileName = "test.png"
     };
     
     // Build multipart form data
     using var formData = new MultipartFormDataContent();
     formData.Add(jsonPart);
     formData.Add(filePart);
     
     using var client = new HttpClient();
     client.DefaultRequestHeaders.Add("Ocp-Apim-Subscription-Key", key);
     
     var response = await client.PostAsync($"{endpoint}/face/v1.2/createLivenessWithVerifySession", formData);
     response.EnsureSuccessStatusCode();
     
     using var doc = JsonDocument.Parse(await response.Content.ReadAsStringAsync());
     var root = doc.RootElement;
     
     Console.WriteLine("Session created.");
     Console.WriteLine($"Session id: {root.GetProperty("sessionId").GetString()}");
     Console.WriteLine($"Auth token: {root.GetProperty("authToken").GetString()}");
     

     Java

     String endpoint = System.getenv("FACE_ENDPOINT");
     String key      = System.getenv("FACE_APIKEY");
     
     String json = """
     {
     "livenessOperationMode": "PassiveActive",
     "deviceCorrelationId": "723d6d03-ef33-40a8-9682-23a1feb7bcc",
     "enableSessionImage": true
     }
     """;
     
     byte[] img = Files.readAllBytes(Path.of("test.png"));
     String boundary = "----faceBoundary" + java.util.UUID.randomUUID();
     
     var head =
         "--" + boundary + "\r\n" +
         "Content-Disposition: form-data; name=\"CreateLivenessWithVerifySessionRequest\"\r\n" +
         "Content-Type: application/json\r\n\r\n" +
         json + "\r\n" +
         "--" + boundary + "\r\n" +
         "Content-Disposition: form-data; name=\"VerifyImage\"; filename=\"test.png\"\r\n" +
         "Content-Type: image/png\r\n\r\n";
     
     var tail = "\r\n--" + boundary + "--\r\n";
     
     byte[] body = java.nio.ByteBuffer
         .allocate(head.getBytes(StandardCharsets.UTF_8).length + img.length + tail.getBytes(StandardCharsets.UTF_8).length)
         .put(head.getBytes(StandardCharsets.UTF_8))
         .put(img)
         .put(tail.getBytes(StandardCharsets.UTF_8))
         .array();
     
     HttpRequest req = HttpRequest.newBuilder()
         .uri(URI.create(endpoint + "/face/v1.2/createLivenessWithVerifySession"))
         .header("Ocp-Apim-Subscription-Key", key)
         .header("Content-Type", "multipart/form-data; boundary=" + boundary)
         .POST(HttpRequest.BodyPublishers.ofByteArray(body))
         .build();
     
     HttpResponse<String> res = HttpClient.newHttpClient().send(req, HttpResponse.BodyHandlers.ofString());
     if (res.statusCode() != 200) throw new RuntimeException("HTTP error: " + res.statusCode());
     
     JsonNode root = new ObjectMapper().readTree(res.body());
     System.out.println("Session created.");
     System.out.println("Session id: " + root.get("sessionId").asText());
     System.out.println("Auth token: " + root.get("authToken").asText());
     

     Python

     endpoint = os.environ["FACE_ENDPOINT"]
     key      = os.environ["FACE_APIKEY"]
     
     url = f"{endpoint}/face/v1.2/createLivenessWithVerifySession"
     files = {
         "CreateLivenessWithVerifySessionRequest": (
             "request.json",
             json.dumps({
                 "livenessOperationMode": "PassiveActive",
                 "deviceCorrelationId": "723d6d03-ef33-40a8-9682-23a1feb7bcc",
                 "enableSessionImage": True
             }),
             "application/json"
         ),
         "VerifyImage": ("test.png", open("test.png", "rb"), "image/png")
     }
     headers = { "Ocp-Apim-Subscription-Key": key }
     
     res = requests.post(url, headers=headers, files=files)
     res.raise_for_status()
     
     data = res.json()
     print("Session created.")
     print("Session id:", data["sessionId"])
     print("Auth token:", data["authToken"])
     

     JavaScript

     const endpoint = process.env["FACE_ENDPOINT"];
     const apikey   = process.env["FACE_APIKEY"];
     
     const form = new FormData();
     form.append(
         "CreateLivenessWithVerifySessionRequest",
         new Blob([JSON.stringify({
             livenessOperationMode: "PassiveActive",
             deviceCorrelationId: "723d6d03-ef33-40a8-9682-23a1feb7bcc",
             enableSessionImage: true
         })], { type: "application/json" }),
         "request.json"
     );
     // If your runtime doesn't support Blob here, you can use fs.createReadStream instead.
     form.append("VerifyImage", new Blob([fs.readFileSync("test.png")], { type: "image/png" }), "test.png");
     
     const res = await fetch(`${endpoint}/face/v1.2/createLivenessWithVerifySession`, {
         method: "POST",
         headers: { "Ocp-Apim-Subscription-Key": apikey },
         body: form
     });
     if (!res.ok) {
         throw new Error(`${res.status} ${await res.text()}`);
     }
     
     const data = await res.json();
     console.log("Session created.");
     console.log("Session id:", data.sessionId);
     console.log("Auth token:", data.authToken);
     

     REST API (Windows)

     curl --request POST --location "%FACE_ENDPOINT%/face/v1.2/detectLivenesswithVerify-sessions" ^
     --header "Ocp-Apim-Subscription-Key: %FACE_APIKEY%" ^
     --form "Parameters=""{\\\""livenessOperationMode\\\"": \\\""passiveactive\\\"", \\\""deviceCorrelationId\\\"": \\\""723d6d03-ef33-40a8-9682-23a1feb7bccd\\\"", ""enableSessionImage"": ""true""}""" ^
     --form "VerifyImage=@""test.png"""
     

     REST API (Linux)

     curl --request POST --location "${FACE_ENDPOINT}/face/v1.2/detectLivenesswithVerify-sessions" \
     --header "Ocp-Apim-Subscription-Key: ${FACE_APIKEY}" \
     --form 'Parameters="{
         \"livenessOperationMode\": \"passiveactive\",
         \"deviceCorrelationId\": \"723d6d03-ef33-40a8-9682-23a1feb7bccd\"
     }"' \
     --form 'VerifyImage=@"test.png"'
     

     Příklad textu odpovědi:

     {
         "sessionId": "3847ffd3-4657-4e6c-870c-8e20de52f567",
         "authToken": "<session-authorization-token>",
         "status": "NotStarted",
         "modelVersion": "2024-11-15",
         "results": {
             "attempts": [],
             "verifyReferences": [
             {
                 "referenceType": "image",
                 "faceRectangle": {
                 "top": 98,
                 "left": 131,
                 "width": 233,
                 "height": 300
                 },
                 "qualityForRecognition": "high"
             }
             ]
         }
     }
     

   • Frontendová aplikace poskytuje referenční obraz při inicializaci mobilních SDK. Tento scénář není ve webovém řešení podporovaný.

     Android

         FaceLivenessDetector(
             sessionAuthorizationToken = FaceSessionToken.sessionToken,
             verifyImageFileContent = FaceSessionToken.sessionSetInClientVerifyImage,
             deviceCorrelationId = "null",
             onSuccess = viewModel::onSuccess,
             onError = viewModel::onError
         )
     

     Ios

     struct HostView: View {
         @State var livenessDetectionResult: LivenessDetectionResult? = nil
         var token: String
         var body: some View {
             if livenessDetectionResult == nil {
                 FaceLivenessDetectorView(result: $livenessDetectionResult,
                                             sessionAuthorizationToken: token)
             } else if let result = livenessDetectionResult {
                 VStack {
                     switch result { 
                         case .success(let success):
                         /// <#show success#>
                         case .failure(let error):
                         /// <#show failure#>
                     }
                 }
             }
         }
     }
     

     Web

     Not supported.
     

2. Aplikační server teď může kromě výsledku ověření živosti zadat dotaz na výsledek ověření.

   C#

   using var client = new HttpClient();
   client.DefaultRequestHeaders.Add("Ocp-Apim-Subscription-Key", key);
   
   var response = await client.GetAsync($"{endpoint}/face/v1.2/livenessSessions/{sessionId}/result");
   response.EnsureSuccessStatusCode();
   
   using var doc = JsonDocument.Parse(await response.Content.ReadAsStringAsync());
   var root = doc.RootElement;
   
   var attempts = root.GetProperty("results").GetProperty("attempts");
   var latestAttempt = attempts[attempts.GetArrayLength() - 1];
   var attemptStatus = latestAttempt.GetProperty("attemptStatus").GetString();
   
   Console.WriteLine($"Session id: {root.GetProperty("sessionId").GetString()}");
   Console.WriteLine($"Session status: {root.GetProperty("status").GetString()}");
   Console.WriteLine($"Latest attempt status: {attemptStatus}");
   
   if (attemptStatus == "Succeeded")
   {
       var decision = latestAttempt.GetProperty("result").GetProperty("livenessDecision").GetString();
       var verify   = latestAttempt.GetProperty("verifyResult");
       Console.WriteLine($"Liveness detection decision: {decision}");
       Console.WriteLine($"Verify isIdentical: {verify.GetProperty("isIdentical").GetBoolean()}");
       Console.WriteLine($"Verify matchConfidence: {verify.GetProperty("matchConfidence").GetDouble()}");
   }
   else
   {
       var err = latestAttempt.GetProperty("error");
       Console.WriteLine($"Error: {err.GetProperty("code").GetString()} - {err.GetProperty("message").GetString()}");
   }
   

   Java

   HttpRequest req = HttpRequest.newBuilder()
       .uri(URI.create(endpoint + "/face/v1.2/livenessSessions/" + sessionId + "/result"))
       .header("Ocp-Apim-Subscription-Key", key)
       .GET()
       .build();
   
   HttpResponse<String> res = HttpClient.newHttpClient().send(req, HttpResponse.BodyHandlers.ofString());
   if (res.statusCode() != 200) throw new RuntimeException("HTTP error: " + res.statusCode());
   
   ObjectMapper om = new ObjectMapper();
   JsonNode root = om.readTree(res.body());
   
   JsonNode attempts = root.path("results").path("attempts");
   JsonNode latest   = attempts.get(attempts.size() - 1);
   String attemptStatus = latest.path("attemptStatus").asText();
   
   System.out.println("Session id: " + root.path("sessionId").asText());
   System.out.println("Session status: " + root.path("status").asText());
   System.out.println("Latest attempt status: " + attemptStatus);
   
   if ("Succeeded".equals(attemptStatus)) {
       String decision = latest.path("result").path("livenessDecision").asText();
       JsonNode verify = latest.path("verifyResult");
       System.out.println("Liveness detection decision: " + decision);
       System.out.println("Verify isIdentical: " + verify.path("isIdentical").asBoolean());
       System.out.println("Verify matchConfidence: " + verify.path("matchConfidence").asDouble());
   } else {
       JsonNode err = latest.path("error");
       System.out.println("Error: " + err.path("code").asText() + " - " + err.path("message").asText());
   }
   

   Python

   url = f"{endpoint}/face/v1.2/livenessSessions/{sessionId}/result"
   headers = {"Ocp-Apim-Subscription-Key": key}
   
   res = requests.get(url, headers=headers)
   res.raise_for_status()
   
   data = res.json()
   attempts = data["results"]["attempts"]
   latest = attempts[-1]
   attempt_status = latest.get("attemptStatus")
   
   print(f"Session id: {data['sessionId']}")
   print(f"Session status: {data['status']}")
   print(f"Latest attempt status: {attempt_status}")
   
   if attempt_status == "Succeeded":
       decision = latest["result"]["livenessDecision"]
       verify   = latest.get("verifyResult", {})
       print(f"Liveness detection decision: {decision}")
       print(f"Verify isIdentical: {verify.get('isIdentical')}")
       print(f"Verify matchConfidence: {verify.get('matchConfidence')}")
   else:
       err = latest.get("error", {})
       print(f"Error: {err.get('code')} - {err.get('message')}")
   

   JavaScript

   const url = `${endpoint}/face/v1.2/livenessSessions/${sessionId}/result`;
   const headers = { "Ocp-Apim-Subscription-Key": apikey };
   
   async function getLivenessWithVerifyResult() {
   const res = await fetch(url, { method: "GET", headers });
   if (!res.ok) throw new Error(`${res.status} ${await res.text()}`);
   
   const data = await res.json();
   const attempts = data.results.attempts;
   const latest = attempts[attempts.length - 1];
   const attemptStatus = latest.attemptStatus;
   
   console.log("Session id:", data.sessionId);
   console.log("Session status:", data.status);
   console.log("Latest attempt status:", attemptStatus);
   
   if (attemptStatus === "Succeeded") {
       console.log("Liveness detection decision:", latest.result.livenessDecision);
       console.log("Verify isIdentical:", latest.verifyResult?.isIdentical);
       console.log("Verify matchConfidence:", latest.verifyResult?.matchConfidence);
   } else {
       const err = latest.error || {};
       console.log(`Error: ${err.code} - ${err.message}`);
   }
   }
   

   REST API (Windows)

   curl --request GET --location "%FACE_ENDPOINT%/face/v1.2/detectLivenesswithVerify-sessions/<session-id>" ^
   --header "Ocp-Apim-Subscription-Key: %FACE_APIKEY%"
   

   REST API (Linux)

   curl --request GET --location "${FACE_ENDPOINT}/face/v1.2/detectLivenesswithVerify-sessions/<session-id>" \
   --header "Ocp-Apim-Subscription-Key: ${FACE_APIKEY}"
   

   Příklad textu odpovědi:

   {
       "sessionId": "b12e033e-bda7-4b83-a211-e721c661f30e",
       "authToken": "eyJhbGciOiJFUzI1NiIsIm",
       "status": "NotStarted",
       "modelVersion": "2024-11-15",
       "results": {
           "attempts": [
           {
               "attemptId": 2,
               "attemptStatus": "Succeeded",
               "result": {
               "livenessDecision": "realface",
               "targets": {
                   "color": {
                   "faceRectangle": {
                       "top": 669,
                       "left": 203,
                       "width": 646,
                       "height": 724
                   }
                   }
               },
               "verifyResult": {
                   "matchConfidence": 0.08871888,
                   "isIdentical": false
               },
               "digest": "B0A803BB7B26F3C8F29CD36030F8E63ED3FAF955FEEF8E01C88AB8FD89CCF761",
               "sessionImageId": "Ae3PVWlXAmVAnXgkAFt1QSjGUWONKzWiSr2iPh9p9G4I",
               "verifyImageHash": "43B7D8E8769533C3290DBD37A84D821B2C28CB4381DF9C6784DBC4AAF7E45018"
               }
           },
           {
               "attemptId": 1,
               "attemptStatus": "Failed",
               "error": {
                   "code": "FaceWithMaskDetected",
                   "message": "Mask detected on face image.",
                   "targets": {
                       "color": {
                       "faceRectangle": {
                               "top": 669,
                               "left": 203,
                               "width": 646,
                               "height": 724
                           }
                       }
                   }
               }
           }
           ],
           "verifyReferences": [
               {
                   "referenceType": "image",
                   "faceRectangle": {
                   "top": 316,
                   "left": 131,
                   "width": 498,
                   "height": 677
                   },
                   "qualityForRecognition": "high"
               }
           ]
           }
       }
   

3. Pokud už výsledek nepotřebujete, může aplikační server relaci odstranit.

   C#

   using var client = new HttpClient();
   client.DefaultRequestHeaders.Add("Ocp-Apim-Subscription-Key", key);
   
   await client.DeleteAsync($"{endpoint}/face/v1.2/livenessWithVerifySessions/{sessionId}");
   Console.WriteLine($"Liveness-with-Verify session deleted: {sessionId}");
   

   Java

   HttpRequest req = HttpRequest.newBuilder()
       .uri(URI.create(endpoint + "/face/v1.2/livenessWithVerifySessions/" + sessionId))
       .header("Ocp-Apim-Subscription-Key", key)
       .DELETE()
       .build();
   
   HttpClient.newHttpClient().send(req, HttpResponse.BodyHandlers.ofString());
   System.out.println("Liveness-with-Verify session deleted: " + sessionId);
   

   Python

   headers = { "Ocp-Apim-Subscription-Key": key }
   requests.delete(f"{endpoint}/face/v1.2/livenessWithVerifySessions/{sessionId}", headers=headers)
   print(f"Liveness-with-Verify session deleted: {sessionId}")
   

   JavaScript

   const headers = { "Ocp-Apim-Subscription-Key": apikey };
   await fetch(`${endpoint}/face/v1.2/livenessWithVerifySessions/${sessionId}`, { method: "DELETE", headers });
   console.log(`Liveness-with-Verify session deleted: ${sessionId}`);
   

   REST API (Windows)

   curl --request DELETE --location "%FACE_ENDPOINT%/face/v1.2/detectLivenesswithVerify-sessions/<session-id>" ^
   --header "Ocp-Apim-Subscription-Key: %FACE_APIKEY%"
   

   REST API (Linux)

   curl --request DELETE --location "${FACE_ENDPOINT}/face/v1.2/detectLivenesswithVerify-sessions/<session-id>" \
   --header "Ocp-Apim-Subscription-Key: ${FACE_APIKEY}"
   

Provádění dalších operací s tvářemi po detekci živosti

Volitelně můžete provádět další operace s tváří po ověření živosti, jako je analýza tváře (pro získání atributů obličeje) a operace identity obličeje.

1. Nastavte parametr enableSessionImage na true během kroku Session-Creation.
2. Extrahujte sessionImageId z kroku Session-Get-Result.
3. Stáhněte si obrázek relace (odkazovaný v rozhraní API operace Liveness Get Session Image) nebo zadejte sessionImageId v rámci operace rozhraní API pro detekci z ID obrázku relace, abyste mohli pokračovat s další analýzou obličeje nebo operacemi identity obličeje. Další informace o těchto operacích najdete v tématu Koncepty detekce tváří a koncepty rozpoznávání tváře.

Možnosti podpory

Kromě využití hlavních nástrojů podpory Foundry můžete také zadávat své dotazy v sekci problémy v repozitáři SDK.

Související obsah

Informace o integraci řešení živé aktivity do existující aplikace najdete v referenčních informacích k sadě Azure Vision SDK.

• Kotlin (Android)
• Swift (iOS)
• JavaScript (web)

Pro více informací o funkcích dostupných pro orchestraci řešení živosti, podívejte se na referenci k Session REST API.

• Operace relace živosti