chore: kickoff release

Author: phantumcode

HostApp/HostApp/Views/LivenessResultContentView+Result.swift

@@ -14,17 +14,19 @@ extension LivenessResultContentView {
         let valueTextColor: Color
         let valueBackgroundColor: Color
         let auditImage: Data?
-
+        let isLive: Bool
+        
         init(livenessResult: LivenessResult) {
             guard livenessResult.confidenceScore > 0 else {
                 text = ""
                 value = ""
                 valueTextColor = .clear
                 valueBackgroundColor = .clear
                 auditImage = nil
+                isLive = false
                 return
             }
-
+            isLive = livenessResult.isLive
             let truncated = String(format: "%.4f", livenessResult.confidenceScore)
             value = truncated
             if livenessResult.isLive {

HostApp/HostApp/Views/LivenessResultContentView.swift

@@ -17,9 +17,7 @@ struct LivenessResultContentView: View {
                 Text("Result:")
                 Text(result.text)
                     .fontWeight(.semibold)
-
             }
-            .padding(.bottom, 12)
 
             HStack {
                 Text("Liveness confidence score:")
@@ -42,6 +40,20 @@ struct LivenessResultContentView: View {
                     .frame(maxWidth: .infinity, idealHeight: 268)
                     .background(Color.secondary.opacity(0.1))
             }
+            
+            if !result.isLive {
+                steps()
+                    .padding()
+                    .background(
+                        Rectangle()
+                            .foregroundColor(
+                                .dynamicColors(
+                                    light: .hex("#ECECEC"),
+                                    dark: .darkGray
+                                )
+                            )
+                            .cornerRadius(6))
+            }
         }
         .padding(.bottom, 16)
         .onAppear {
@@ -54,6 +66,29 @@ struct LivenessResultContentView: View {
             }
         }
     }
+    
+    private func steps() -> some View {
+        func step(number: Int, text: String) -> some View {
+            HStack(alignment: .top) {
+                Text("\(number).")
+                Text(text)
+            }
+        }
+
+        return VStack(
+            alignment: .leading,
+            spacing: 8
+        ) {
+            Text("Tips to pass the video check:")
+                .fontWeight(.semibold)
+
+            step(number: 1, text: "Avoid very bright lighting conditions, such as direct sunlight.")
+                .accessibilityElement(children: .combine)
+
+            step(number: 2, text: "Remove sunglasses, mask, hat, or anything blocking your face.")
+                .accessibilityElement(children: .combine)
+        }
+    }
 }
 
 

HostApp/HostApp/Views/LivenessResultView.swift

@@ -15,7 +15,7 @@ struct LivenessResultView<Content: View>: View {
     @State var displayingCopiedNotification = false
 
     init(
-        title: String = "Liveness Check",
+        title: String = "Liveness Result",
         sessionID: String,
         onTryAgain: @escaping () -> Void,
         @ViewBuilder content: () -> Content

HostApp/README.md

@@ -29,7 +29,7 @@ cd amplify-ui-swift-livenes/HostApp
 
 7. Once signed in and authenticated, the "Create Liveness Session" is enabled.  Click the button to generate and get a session id from your backend.
 
-8. Once a session id is created, the Liveness Check screen is displayed.  Follow the instructions and click on Begin Check button to begin liveness verification.
+8. Once a session id is created, the Liveness Check screen is displayed.  Follow the instructions and click on Start video check button to begin liveness verification.
 
 ## Provision AWS Backend Resources
 

Sources/FaceLiveness/AV/CMSampleBuffer+Rotate.swift

@@ -11,15 +11,34 @@ import AVFoundation
 class LivenessCaptureSession {
     let captureDevice: LivenessCaptureDevice
     private let captureQueue = DispatchQueue(label: "com.amazonaws.faceliveness.cameracapturequeue")
-    let outputDelegate: OutputSampleBufferCapturer
+    let outputDelegate: AVCaptureVideoDataOutputSampleBufferDelegate
     var captureSession: AVCaptureSession?
+    
+    var outputSampleBufferCapturer: OutputSampleBufferCapturer? {
+        return outputDelegate as? OutputSampleBufferCapturer
+    }
 
-    init(captureDevice: LivenessCaptureDevice, outputDelegate: OutputSampleBufferCapturer) {
+    init(captureDevice: LivenessCaptureDevice, outputDelegate: AVCaptureVideoDataOutputSampleBufferDelegate) {
         self.captureDevice = captureDevice
         self.outputDelegate = outputDelegate
     }
 
     func startSession(frame: CGRect) throws -> CALayer {
+        try startSession()
+
+        guard let captureSession = captureSession else {
+            throw LivenessCaptureSessionError.captureSessionUnavailable
+        }
+        
+        let previewLayer = previewLayer(
+            frame: frame,
+            for: captureSession
+        )
+
+        return previewLayer
+    }
+    
+    func startSession() throws {
         guard let camera = captureDevice.avCaptureDevice
         else { throw LivenessCaptureSessionError.cameraUnavailable }
 
@@ -44,17 +63,10 @@ class LivenessCaptureSession {
             captureSession.startRunning()
         }
 
-        let previewLayer = previewLayer(
-            frame: frame,
-            for: captureSession
-        )
-
         videoOutput.setSampleBufferDelegate(
             outputDelegate,
             queue: captureQueue
         )
-
-        return previewLayer
     }
 
     func stopRunning() {
@@ -83,6 +95,11 @@ class LivenessCaptureSession {
         _ output: AVCaptureVideoDataOutput,
         for captureSession: AVCaptureSession
     ) throws {
+        if captureSession.canAddOutput(output) {
+            captureSession.addOutput(output)
+        } else {
+            throw LivenessCaptureSessionError.captureSessionOutputUnavailable
+        }
         output.videoSettings = [
             kCVPixelBufferPixelFormatTypeKey as String: kCVPixelFormatType_32BGRA
         ]
@@ -92,12 +109,6 @@ class LivenessCaptureSession {
             .forEach {
                 $0.videoOrientation = .portrait
         }
-
-        if captureSession.canAddOutput(output) {
-            captureSession.addOutput(output)
-        } else {
-            throw LivenessCaptureSessionError.captureSessionOutputUnavailable
-        }
     }
 
     private func previewLayer(

Sources/FaceLiveness/AV/LivenessCaptureSession.swift

@@ -24,7 +24,7 @@ class OutputSampleBufferCapturer: NSObject, AVCaptureVideoDataOutputSampleBuffer
     ) {
         videoChunker.consume(sampleBuffer)
 
-        guard let imageBuffer = sampleBuffer.rotateRightUpMirrored()
+        guard let imageBuffer = sampleBuffer.imageBuffer
         else { return }
 
         faceDetector.detectFaces(from: imageBuffer)

Sources/FaceLiveness/AV/OutputSampleBufferCapturer.swift

@@ -34,9 +34,9 @@ final class VideoChunker {
 
     func start() {
         guard state == .pending else { return }
-        state = .writing
         assetWriter.startWriting()
         assetWriter.startSession(atSourceTime: .zero)
+        state = .writing
     }
 
     func finish(singleFrame: @escaping (UIImage) -> Void) {
@@ -49,8 +49,8 @@ final class VideoChunker {
 
     func consume(_ buffer: CMSampleBuffer) {
         if state == .awaitingSingleFrame {
-            guard let rotated = buffer.rotateRightUpMirrored() else { return }
-            let singleFrame = singleFrame(from: rotated)
+            guard let imageBuffer = buffer.imageBuffer else { return }
+            let singleFrame = singleFrame(from: imageBuffer)
             provideSingleFrame?(singleFrame)
             state = .complete
         }
@@ -66,10 +66,10 @@ final class VideoChunker {
         if assetWriterInput.isReadyForMoreMediaData {
             let timestamp = CMSampleBufferGetPresentationTimeStamp(buffer).seconds
             let presentationTime = CMTime(seconds: timestamp - startTimeSeconds, preferredTimescale: 600)
-            guard let rotated = buffer.rotateRightUpMirrored() else { return }
+            guard let imageBuffer = buffer.imageBuffer else { return }
 
             pixelBufferAdaptor.append(
-                rotated,
+                imageBuffer,
                 withPresentationTime: presentationTime
             )
         }

Sources/FaceLiveness/AV/VideoChunker.swift

@@ -14,53 +14,79 @@ struct DetectedFace {
     let rightEye: CGPoint
     let nose: CGPoint
     let mouth: CGPoint
+    let rightEar: CGPoint
+    let leftEar: CGPoint
 
     let confidence: Float
 
-    func boundingBoxFromLandmarks() -> CGRect {
-        let eyeCenterX = (leftEye.x + rightEye.x) / 2
-        let eyeCenterY = (leftEye.y + rightEye.y) / 2
-
-        let cx = (nose.x + eyeCenterX) / 2
-        let cy = (nose.y + eyeCenterY) / 2
-
-        let ow = sqrt(pow((leftEye.x - rightEye.x), 2) + pow((leftEye.y - rightEye.y), 2)) * 2
-        let oh = 1.618 * ow
-        let minX = cx - ow / 2
-        let minY = cy - oh / 2
-
-        let rect = CGRect(x: minX, y: minY, width: ow, height: oh)
+    func boundingBoxFromLandmarks(ovalRect: CGRect) -> CGRect {
+        let alpha = 2.0
+        let gamma = 1.8
+        let ow = (alpha * pupilDistance + gamma * faceHeight) / 2
+        var cx = (eyeCenterX + nose.x) / 2
+        
+        if ovalRect != CGRect.zero {
+            let ovalTop = ovalRect.minY
+            let ovalHeight = ovalRect.maxY - ovalRect.minY
+            if eyeCenterY > (ovalTop + ovalHeight) / 2 {
+                cx = eyeCenterX
+            }
+        }
+        
+        let faceWidth = ow
+        let faceHeight = 1.618 * faceWidth
+        let faceBoxBottom = boundingBox.maxY
+        let faceBoxTop = faceBoxBottom - faceHeight
+        let faceBoxLeft = min(cx - ow / 2, rightEar.x)
+        let faceBoxRight = max(cx + ow / 2, leftEar.x)
+        let width = faceBoxRight - faceBoxLeft
+        let height = faceBoxBottom - faceBoxTop
+        let rect = CGRect(x: faceBoxLeft, y: faceBoxTop, width: width, height: height)
         return rect
     }
 
     var faceDistance: CGFloat {
         sqrt(pow(rightEye.x - leftEye.x, 2) + pow(rightEye.y - leftEye.y, 2))
     }
+    
+    var pupilDistance: CGFloat {
+        sqrt(pow(leftEye.x - rightEye.x, 2) + pow(leftEye.y - rightEye.y, 2))
+    }
+    
+    var eyeCenterX: CGFloat {
+        (leftEye.x + rightEye.x) / 2
+    }
+    
+    var eyeCenterY: CGFloat {
+        (leftEye.y + rightEye.y) / 2
+    }
+    
+    var faceHeight: CGFloat {
+        sqrt(pow(eyeCenterX - mouth.x, 2) + pow(eyeCenterY - mouth.y, 2))
+    }
 
     func normalize(width: CGFloat, height: CGFloat) -> DetectedFace {
-        .init(
-            boundingBox: .init(
-                x: boundingBox.minX * width,
-                y: boundingBox.minY * height,
-                width: boundingBox.width * width,
-                height: boundingBox.height * height
-            ),
-            leftEye: .init(
-                x: leftEye.x * width,
-                y: leftEye.y * height
-            ),
-            rightEye: .init(
-                x: rightEye.x * width,
-                y: rightEye.y * height
-            ),
-            nose: .init(
-                x: nose.x * width,
-                y: nose.y * height
-            ),
-            mouth: .init(
-                x: mouth.x * width,
-                y: mouth.y * height
-            ),
+        let boundingBox = CGRect(
+            x: boundingBox.minX * width,
+            y: boundingBox.minY * height,
+            width: boundingBox.width * width,
+            height: boundingBox.height * height
+        )
+        let leftEye = CGPoint(x: leftEye.x * width, y: leftEye.y * height)
+        let rightEye = CGPoint(x: rightEye.x * width, y: rightEye.y * height)
+        let nose = CGPoint(x: nose.x * width, y: nose.y * height)
+        let mouth = CGPoint(x: mouth.x * width, y: mouth.y * height)
+        let rightEar = CGPoint(x: rightEar.x * width, y: rightEar.y * height)
+        let leftEar = CGPoint(x: leftEar.x * width, y: leftEar.y * height)
+        
+        return DetectedFace(
+            boundingBox: boundingBox,
+            leftEye: leftEye,
+            rightEye: rightEye,
+            nose: nose,
+            mouth: mouth,
+            rightEar: rightEar,
+            leftEar: leftEar,
             confidence: confidence
         )
     }