DOT iOS Face library

v8.4.0

Introduction

DOT iOS Face as a part of the DOT iOS libraries family provides components for the digital onboarding process using the latest Innovatrics IFace image processing library. It wraps the core functionality of IFace library to a higher-level module which is easy to integrate into an iOS application.

Requirements

DOT iOS Face has the following requirements:

Xcode 15.1+
iOS 12.0+
Swift or Objective-C
CocoaPods or Swift Package Manager

Distribution

Modularization

DOT iOS Face is divided into core module and optional feature modules. This enables you to reduce the size of the library and include only modules that are actually used in your use case.

DOT iOS Face is divided into following modules:

dot-face-core (Required) - provides API for all the features and functionalities.
dot-face-detection-fast (Optional) - enables the fast face detection feature.
dot-face-detection-balanced (Optional) - enables the balanced face detection feature.
dot-face-verification (Optional) - enables template extraction and verification feature.
dot-face-eye-gaze-liveness (Optional) - enables the eye gaze liveness feature.
dot-face-passive-liveness (Optional) - enables the passive liveness feature.
dot-face-background-uniformity (Optional) - enables the background uniformity evaluation feature.
dot-face-expression-neutral (Optional) - enables the face expression evaluation feature.

Each feature module can have other modules as their dependency and cannot be used without it, see the table below. Modules dot-face-detection-fast and dot-face-detection-balanced belong to one category, therefore only one of them can be activated.

Table 1. Module dependencies
Module	Dependency
`dot-face-detection-fast`	`dot-face-core`
`dot-face-detection-balanced`	`dot-face-core`
`dot-face-verification`	`dot-face-detection-*`
`dot-face-eye-gaze-liveness`	`dot-face-detection-*`
`dot-face-passive-liveness`	`dot-face-detection-*`
`dot-face-background-uniformity`	`dot-face-detection-*`
`dot-face-expression-neutral`	`dot-face-detection-*`

dot-face-detection-* stands for either dot-face-detection-fast or dot-face-detection-balanced.

For example, if you want to use Eye Gaze Liveness you will have to use these three modules: dot-face-eye-gaze-liveness, dot-face-detection-*(required by dot-face-eye-gaze-liveness) and dot-face-core(always required).

Swift Package Manager

DOT iOS Face can be easily integrated into Xcode project in: Project → Package Dependencies.

Use https://github.com/innovatrics/dot-ios-sdk-spm.git repository and choose the version you want to use. There you can select set of DotFace* packages you want to use. All the required dependencies will be downloaded with the selected package set.

Cocoapods

In order to integrate DOT iOS Face into your project, the first step is to insert the following line of code on top of your Podfile.

Podfile

source 'https://github.com/innovatrics/innovatrics-podspecs'

Then, add the module(s) which you want to use to your Podfile. You also need to add dependencies of the module(s) you want to use. Following Podfile shows how to use all modules:

Podfile

source 'https://github.com/innovatrics/innovatrics-podspecs'

use_frameworks!

target 'YOUR_TARGET' do

pod `dot-face-core`
pod `dot-face-detection-fast`
pod 'dot-face-verification'
pod 'dot-face-eye-gaze-liveness'
pod 'dot-face-passive-liveness'
pod `dot-face-background-uniformity`
pod `dot-face-expression-neutral`

end

Following Podfile shows how to use only dot-face-detection-fast module:

Podfile

source 'https://github.com/innovatrics/innovatrics-podspecs'

use_frameworks!

target 'YOUR_TARGET' do

pod `dot-face-core`
pod 'dot-face-detection-fast'

end

If a CocoaPods problem with pod install occurs, try to clone the private pod repository manually.

pod repo remove innovatrics
pod repo add innovatrics https://github.com/innovatrics/innovatrics-podspecs

Supported Architectures

DOT iOS Face provides all supported architectures in the distributed XCFramework package. Device binary contains: arm64. Simulator binary contains: x86_64, arm64.

Licensing

In order to use DotSdk in your iOS application, it must be licensed. The license can be compiled into the application as it is bound to Bundle Identifier specified in the General tab in Xcode.

The Bundle ID can be also retrieved in runtime by calling DotSdk.shared.bundleId.

In order to obtain the license, please contact your Innovatrics’ representative specifying Bundle ID. After you have obtained your license file, add it to your Xcode project and use it during the DotSdk initialization, as shown below.

Permissions

Set the following permission in Info.plist:

Info.plist

<key>NSCameraUsageDescription</key>
	<string>Your usage description</string>

Basic Setup

Initialization

Before using any of the components, you need to initialize DOT SDK with the license, DotFaceLibrary object and list of feature modules you want to use. Each module can be accessed by its singleton *Module class. DOT iOS Face is distributed as a set of XCFramework packages. Each module is distributed as a single XCFramework package, see the table below.

Table 2. XCFramework packages
Module	Class	XCFramework
`dot-face-detection-fast`	DotFaceDetectionFastModule	DotFaceDetectionFast.xcframework
`dot-face-detection-balanced`	DotFaceDetectionBalancedModule	DotFaceDetectionBalanced.xcframework
`dot-face-verification`	DotFaceVerificationModule	DotFaceVerification.xcframework
`dot-face-eye-gaze-liveness`	DotFaceEyeGazeLivenessModule	DotFaceEyeGazeLiveness.xcframework
`dot-face-passive-liveness`	DotFacePassiveLivenessModule	DotFacePassiveLiveness.xcframework
`dot-face-background-uniformity`	DotFaceBackgroundUniformityModule	DotFaceBackgroundUniformity.xcframework
`dot-face-expression-neutral`	DotFaceExpressionNeutralModule	DotFaceExpressionNeutral.xcframework

DOT SDK Sample shows how to initialize DOT SDK with DotFaceLibrary and all feature modules. DotSdk.shared.initialize() method should be called on background thread.

After you have successfully finished initialization, you can use all added features by importing only DotFaceCore Swift module in your source files. Keep in mind that if you try to use any feature which was not added during initialization DOT SDK will generate fatal error. DOT iOS Face requires small amount of disk space in the Caches directory for the initialization (approximately 10KB), if there is not enough disk space the initialization will fail.

Deinitialization

When you have finished using the DOT iOS Face, it is usually a good practice to deinitialize it in order to free the memory. You can deinitialize DOT iOS Face only after the complete process is finished and not within the life cycle of individual components. This can be performed using the DotSdk.shared.deinitialize() method. If you want to use the DOT iOS Face components again, you need to call DotSdk.shared.initialize() again.

Logging

DOT iOS Face supports logging using a global Logger class. You can set the log level as follows:

import DotFaceCore

Logger.logLevel = .debug

Log levels:

debug
info
warning
error
none

Each log message contains DotFace tag. Keep in mind that logging should be used just for debugging purposes.

Components

Overview

DOT iOS Face provides both non-UI and UI components. Non-UI components are aimed to be used by developers who want to build their own UI using the DOT iOS Face functionality. UI components are build on top of non-UI components. Components having UI are available as UIViewController classes and can be embedded into the application’s existing UI or presented using the standard methods.

List of Non-UI Components

FACE DETECTOR: A component for performing face detection on an image, creating templates and evaluating face attributes.
TEMPLATE MATCHER: A component for performing template matching.
FACE MATCHER: A component for performing face matching.

List of UI Components

FACE AUTO CAPTURE: A visual component for capturing good quality face images and creating templates suitable for matching.
FACE SIMPLE CAPTURE (Deprecated): A visual component for capturing face images and creating templates suitable for matching without considering image quality requirements.
EYE GAZE LIVENESS: A visual component which performs the liveness check based on object tracking. An object is shown on the screen and the user is instructed to follow the movement of this object with her/his eyes.
SMILE LIVENESS: A visual component which performs the liveness check based on the changes in the face expression.
MAGNIFEYE LIVENESS: A visual component for capturing images suitable for MagnifEye liveness evaluation.

Non-UI Components

Face Detector

The FaceDetector class provides the face detection functionality. Face detection stops when maximumFaces is reached. This component requires dot-face-detection-* module.

Create FaceDetector:

let faceDetector = FaceDetector()

To perform detection, call the following method on the background thread:

let detectedFaces = try faceDetector.detect(faceImage: faceImage, query: .init(), limit: 10)

Template Matcher

In order to match face templates (1:1), use the TemplateMatcher class. The recommended approach is to create face templates using FaceDetector or Face Auto Capture component and use only templates for matching. This component requires dot-face-verification module.

Create TemplateMatcher:

let templateMatcher = TemplateMatcher()

To perform matching, call the following method on the background thread:

let result = try? matcher.match(referenceTemplate: referenceTemplate, probeTemplate: probeTemplate)

Face Matcher

In order to match face images (1:1), use the FaceMatcher class. It is also possible to match a face image against a template, which is a recommended approach if you already have an available reference template. This component requires dot-face-verification module.

Create FaceMatcher:

let faceMatcher = FaceMatcher()

To perform matching, call one of the following methods on the background thread:

let result = try? faceMatcher.match(referenceFaceImage: referenceImage, probeFaceImage: probeImage)
let result = try? faceMatcher.match(referenceTemplate: referenceTemplate, probeFaceImage: probeImage)

UI Components

Camera handling

Camera lifecycle

DOT iOS Face view controller will start the camera in viewWillAppear(:) lifecycle method. DOT iOS Face view controller will stop the camera in viewDidDisappear(:) lifecycle method.

Camera permission

DOT iOS Face view controller will check the camera permission right before the camera is started. If the camera permission is granted the view controller will start the camera. If the camera permission is denied the view controller will call *ViewControllerNoCameraPermission(:) callback. Implement this callback in order to navigate the user further in your app workflow. If the camera permission is not determined the view controller will use iOS API - AVCaptureDevice.requestAccess(for: .video) method to request the camera permission. This method will present the system dialog to the user of the app. The user of the app can grant or deny the camera permission and then the view controller will proceed the same way as it does during the camera permission check as was explained at the beginning of this section.

View Controller Configuration

Components containing UI are embedded into the application as view controllers. All view controllers can be embedded into your own view controller or presented directly. Each view controller can be configured using its *Configuration class and each view controller can have its appearance customized using its *Style class.

To present view controller:

let viewController = FaceAutoCaptureViewController.create(configuration: .init(), style: .init())
viewController.delegate = self
self.present(viewController, animated: true, completion: nil)

To embed view controller into your view controller:

override func viewDidLoad() {
    super.viewDidLoad()

    addChild(viewController)
    view.addSubview(viewController.view)
    viewController.view.translatesAutoresizingMaskIntoConstraints = false
    viewController.didMove(toParent: self)

    NSLayoutConstraint.activate([
        viewController.view.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor),
        viewController.view.leadingAnchor.constraint(equalTo: view.safeAreaLayoutGuide.leadingAnchor),
        viewController.view.bottomAnchor.constraint(equalTo: view.safeAreaLayoutGuide.bottomAnchor),
        viewController.view.trailingAnchor.constraint(equalTo: view.safeAreaLayoutGuide.trailingAnchor)
    ])
}

Safe Area

DOT iOS Face view controllers ignore safe area layout guide when they layout their subviews. Therefore, for example if you push DOT iOS Face view controller using UINavigationController, you will get incorrect layout. If you want to respect safe area layout guide, you should embed DOT iOS Face view controller in a container view controller and setup the layout constraints accordingly.

Face size ratio interval

If a face present in an image has the face size out of the face size ratio interval, it won’t be detected. Please note that a wider interval results in a lower performance (detection FPS).

Face Auto Capture

The view controller with instructions for obtaining quality face images suitable for further processing. This component requires dot-face-detection-* module. If you want to evaluate background uniformity during the face auto capture process, you will also need dot-face-background-uniformity module. If you want to evaluate face mask during the face auto capture process, you will need dot-face-detection-balanced module.

In order to configure the behaviour of FaceAutoCaptureViewController use FaceAutoCaptureViewController.Configuration. For face verification scenarios, a convenient preset configuration simple is available within FaceAutoCaptureViewController.Configuration.Presets.

In order to customize the appearance of FaceAutoCaptureViewController use FaceAutoCaptureViewController.Style. You can handle the FaceAutoCaptureViewController events using its delegate FaceAutoCaptureViewControllerDelegate.

Start the face auto capture process:

Check whether DOT iOS Face is initialized.
If DOT iOS Face is initialized, you can call the start() method immediately. If not, you need to initialize DOT iOS Face and call start() in the DotFaceLibraryDelegate.dotFaceLibraryInitializationFinished() callback.

In case you want to handle detection data, implement faceAutoCaptureViewController(:processed:) delegate callback. This callback is called with each processed camera frame. When the face auto capture process finishes successfully, the result will be returned via the faceAutoCaptureViewController(:captured:) callback.

In case you want to force the capture event, call the requestCapture() method. The most recent image will be returned via the faceAutoCaptureViewController(:captured:) callback asynchronously.

Call start() method in order to start over the face auto capture process. You can also call start() method to stop and start over ongoing process.

In case you want to stop the face auto capture process prematurely, call the stopAsync() method. The callback in the method argument indicates that the processing is over.

Once the face auto capture process has started, it is not safe to deinitialize the DOT iOS Face until one of these callbacks is called:

faceAutoCaptureViewController(:captured:)
callback argument of stopAsync() method

Quality Attributes of the Output Image

You may adjust quality requirements for the output image. To perform this, you can use pre-defined builders - QualityAttributeThresholds.Builder - from QualityAttributeThresholdPresets with recommended thresholds and pass it to FaceAutoCaptureViewController.Configuration by setting the qualityAttributeThresholds. You can also create your own instance of QualityAttributeThresholds from scratch or based on pre-defined builders according to your needs.

Possible ways how to create QualityAttributeThresholds:

// The standard preset
let standard = FaceAutoCaptureViewController.Configuration.QualityAttributeThresholdPresets.standard.build()

// Modified thresholds based on the standard preset
let modified = try FaceAutoCaptureViewController.Configuration.QualityAttributeThresholdPresets.standard
        .minConfidence(minConfidence)
        .minSharpness(nil)
        .build()

// Custom thresholds
let custom = try FaceAutoCaptureViewController.Configuration.QualityAttributeThresholds.Builder()
        .minConfidence(minConfidence)
        .minSharpness(minSharpness)
        .build()

Available presets (pre-defined builders with thresholds) in QualityAttributeThresholdPresets:

standard - The resulting image suitable for matching. See the thresholds.
passiveLiveness - The resulting image suitable for evaluation of the passive liveness. See the thresholds.
icao - The resulting image passing ICAO checks. See the thresholds.

Face Simple Capture (Deprecated)

The view controller for obtaining images for matching without considering any image quality requirements. This component requires dot-face-detection-* module.

In order to configure the behaviour of FaceSimpleCaptureViewController use FaceSimpleCaptureViewController.Configuration. In order to customize the appearance of FaceSimpleCaptureViewController use FaceSimpleCaptureViewController.Style. You can handle the FaceSimpleCaptureViewController events using its delegate FaceSimpleCaptureViewControllerDelegate.

Start the face simple capture process:

Check whether DOT iOS Face is initialized.
If DOT iOS Face is initialized, you can call the start() method immediately. If not, you need to initialize DOT iOS Face and call start() in the DotFaceLibraryDelegate.dotFaceLibraryInitializationFinished() callback.

You need to call requestCapture() method in order to request a capture. The component will capture a face as soon as it is detected. The result will be returned via the faceSimpleCaptureViewController(:captured:) callback.

In case you want to stop the face simple capture process prematurely, call the stopAsync() method. The callback in the method argument indicates that the processing is over.

Once the face simple capture process has started, it is not safe to deinitialize the DOT iOS Face until one of these callbacks is called:

callback argument of stopAsync() method

Eye Gaze Liveness

The view controller with a moving or fading object on the screen. This component requires dot-face-eye-gaze-liveness module.

In order to configure the behaviour of EyeGazeLivenessViewController use EyeGazeLivenessConfiguration. In order to customize the appearance of EyeGazeLivenessViewController use EyeGazeLivenessStyle. You can handle the EyeGazeLivenessViewController events using its delegate EyeGazeLivenessViewControllerDelegate.

You can customize the color of the default objectImage or you can replace the default objectImage with custom image.

Start the eye gaze liveness process:

Check whether DOT iOS Face is initialized.
If DOT iOS Face is initialized, you can call the start() method immediately. If not, you need to initialize DOT iOS Face and call start() in the DotFaceLibraryDelegate.dotFaceLibraryInitializationFinished() callback.

The liveness check follows corners: [WrappedEyeGazeLivenessCorner] and renders an object in the specified corners of the screen.

For a better user experience, it is recommended to provide the user more attempts, therefore the size of corners: [WrappedEyeGazeLivenessCorner] should be greater than four. However, this should be limited, as it is better to terminate the process if the user is failing in many corners. The recommended way to generate corners is to use a RandomEyeGazeLivenessCornersGenerator.

In case you want to handle detection data, implement eyeGazeLivenessViewController(:processed:) callback. This callback is called with each processed camera frame. The process is automatically finished as soon as there are four valid images in corner positions. After that, eyeGazeLivenessViewController(:finished:) callback is called.

If the face can’t be detected anytime during the process or if the eyes can’t be detected in the first corner, the process will be terminated with the eyeGazeLivenessViewControllerCriticalFacePresenceLost() callback.

The process fails with the eyeGazeLivenessViewControllerAllCornersUsed(:) callback when all the corners were displayed but it wasn’t possible to collect four valid images in corner positions.

In case you want to stop the eye gaze liveness process prematurely, call the stopAsync() method. The callback in the method argument indicates that the processing is over.

Once the eye gaze liveness process has started, it is not safe to deinitialize the DOT iOS Face until one of these callbacks is called:

eyeGazeLivenessViewController(:finished:)
eyeGazeLivenessViewControllerCriticalFacePresenceLost()
eyeGazeLivenessViewControllerAllCornersUsed()
callback argument of stopAsync() method

Server-side evaluation

If you want to perform a server side validation of the eye gaze liveness, please follow this recommended approach. The object movement is generated by DIS and then rendered on the device using corners. When the process is finished successfully, the EyeGazeLivenessResult.content is transferred to DIS for evaluation.

Smile Liveness

The view controller which performs the liveness check based on the changes in the face expression. This component requires dot-face-expression-neutral module.

In order to configure the behaviour of SmileLivenessViewController, use SmileLivenessViewController.Configuration. In order to customize the appearance of SmileLivenessViewController, use SmileLivenessViewController.Style. You can handle the SmileLivenessViewController events using its delegate SmileLivenessViewControllerDelegate.

Start the smile liveness process:

Check whether DOT iOS Face is initialized.
If DOT iOS Face is initialized, you can call the start() method immediately. If not, you need to initialize DOT iOS Face and call start() in the DotFaceLibraryDelegate.dotFaceLibraryInitializationFinished() callback.

In case you want to handle detection data, implement smileLivenessViewController(:processed:) delegate callback. This callback is called with each processed camera frame. The process is automatically finished when both the neutral and the smile face expression images are captured. After that, smileLivenessViewController(:finished:) callback is called and the passive liveness and face matching can be evaluated.

If the face presence is lost after the neutral face expression image is captured, smileLivenessViewControllerCriticalFacePresenceLost(:) callback is called. If the face presence between the neutral and the smile face expression images is required, call start() method to restart the process. Otherwise the callback can be ignored.

Call start() method in order to start over the smile liveness process. You can also call start() method to stop and start over ongoing process.

In case you want to stop the smile liveness process prematurely, call the stopAsync() method. The callback in the method argument indicates that the processing is over.

Once the smile liveness process has started, it is not safe to deinitialize the DOT iOS Face until one of these callbacks is called:

smileLivenessViewController(:finished:)
callback argument of stopAsync() method

MagnifEye Liveness

The view controller with instructions for obtaining face data suitable for MagnifEye liveness evaluation. This component requires dot-face-detection-* module.

In order to configure the behaviour of MagnifEyeLivenessViewController, use MagnifEyeLivenessViewController.Configuration. In order to customize the appearance of MagnifEyeLivenessViewController, use MagnifEyeLivenessViewController.Style. You can handle the MagnifEyeLivenessViewController events using its delegate MagnifEyeLivenessViewControllerDelegate.

Start the MagnifEye liveness process:

Check whether DOT iOS Face is initialized.
If DOT iOS Face is initialized, you can call the start() method immediately. If not, you need to initialize DOT iOS Face and call start() in the DotFaceLibraryDelegate.dotFaceLibraryInitializationFinished() callback.

In case you want to handle detection data, implement magnifEyeLivenessViewController(:processed:) callback. This callback is called with each processed camera frame. When the MagnifEye liveness process finishes successfully, the result will be returned via the magnifEyeLivenessViewController(:finished:) callback.

Call start() method in order to start over the MagnifEye liveness process. You can also call start() method to stop and start over ongoing process.

In case you want to stop the MagnifEye liveness process prematurely, call the stopAsync() method. The callback in the method argument indicates that the processing is over.

Once the MagnifEye liveness process has started, it is not safe to deinitialize the DOT iOS Face until one of these callbacks is called:

magnifEyeLivenessViewController(:finished:)
callback argument of stopAsync() method

Customization of UI Components

Localization

String resources can be overridden in your application and alternative strings for supported languages can be provided following these two steps:

Add your own Localizable.strings file to your project using standard iOS localization mechanism. To change a specific text override corresponding key in this Localizable.strings file.
Set the localization bundle to the bundle of your application (preferably during the application launch in your AppDelegate).

Use this setup if you want to use standard iOS localization mechanism, which means your iOS application uses system defined locale.

import DotFaceCore

Localization.bundle = .main

Custom Localization

You can override standard iOS localization mechanism by providing your own translation dictionary and setting the Localization.useLocalizationDictionary flag to true. Use this setup if you do not want to use standard iOS localization mechanism, which means your iOS application ignores system defined locale and uses its own custom locale.

import DotFaceCore

guard let localizableUrl = Bundle.main.url(forResource: "Localizable", withExtension: "strings", subdirectory: nil, localization: "de"),
      let dictionary = NSDictionary(contentsOf: localizableUrl) as? [String: String]
else { return }

Localization.useLocalizationDictionary = true
Localization.localizationDictionary = dictionary

Localizable.strings

"dot_face.face_auto_capture.instruction.face_not_detected" = "Position your face into the circle";
"dot_face.face_auto_capture.instruction.face_out_of_bounds" = "Center your face";
"dot_face.face_auto_capture.instruction.size_too_large" = "Move back";
"dot_face.face_auto_capture.instruction.size_too_small" = "Move closer";
"dot_face.face_auto_capture.instruction.brightness_too_high" = "Turn towards light";
"dot_face.face_auto_capture.instruction.brightness_too_low" = "Turn towards light";
"dot_face.face_auto_capture.instruction.contrast_too_high" = "Turn towards light";
"dot_face.face_auto_capture.instruction.contrast_too_low" = "Turn towards light";
"dot_face.face_auto_capture.instruction.shadow_too_high" = "Turn towards light";
"dot_face.face_auto_capture.instruction.sharpness_too_low" = "Turn towards light";
"dot_face.face_auto_capture.instruction.unique_intensity_levels_too_low" = "Turn towards light";
"dot_face.face_auto_capture.instruction.glasses_present" = "Remove glasses";
"dot_face.face_auto_capture.instruction.background_nonuniform" = "Plain background required";
"dot_face.face_auto_capture.instruction.expression_neutral_too_high" = "Smile :)";
"dot_face.face_auto_capture.instruction.expression_neutral_too_low" = "Keep neutral expression";
"dot_face.face_auto_capture.instruction.pitch_too_high" = "Lower your chin";
"dot_face.face_auto_capture.instruction.pitch_too_low" = "Lift your chin";
"dot_face.face_auto_capture.instruction.yaw_too_right" = "Look left";
"dot_face.face_auto_capture.instruction.yaw_too_left" = "Look right";
"dot_face.face_auto_capture.instruction.eyes_too_closed" = "Open your eyes";
"dot_face.face_auto_capture.instruction.mouth_too_open" = "Close your mouth";
"dot_face.face_auto_capture.instruction.mask_present" = "Remove mask";
"dot_face.face_auto_capture.instruction.candidate_selection" = "Stay still...";
"dot_face.face_auto_capture.instruction.device_pitch_too_high" = "Hold your phone at eye level";

"dot_face.eye_gaze_liveness.instruction.initial_state" = "Watch the object";
"dot_face.eye_gaze_liveness.instruction.device_pitch_too_high" = "Hold your phone at eye level";
"dot_face.eye_gaze_liveness.instruction.shadow_too_high" = "Turn towards light";
"dot_face.eye_gaze_liveness.instruction.face_not_detected" = "Look straight";
"dot_face.eye_gaze_liveness.instruction.size_too_large" = "Move back";
"dot_face.eye_gaze_liveness.instruction.size_too_small" = "Move closer";

"dot_face.magnifeye_liveness.instruction.eye_centering" = "Fit your eye into square";

Common Classes

`ImageSize`

Class which represents a size of an image. To create an instance:

let imageSize = ImageSize(width: 100, height: 100)

`BgrRawImage`

Class which represents an image.

To create an instance from CGImage:

let bgrRawImage = BgrRawImageFactory.create(cgImage: cgImage)

To create CGImage from BgrRawImage:

let cgImage = CGImageFactory.create(bgrRawImage: bgrRawImage)

`FaceImage`

Class which represents a face image and can be used for face detection and matching. To create an instance:

let faceSizeRatioInterval = try IntervalDouble(min: 0.05, max: 0.5)
let faceImage = try FaceImage(bgrRawImage: bgrRawImage, faceSizeRatioInterval: faceSizeRatioInterval)

minFaceSizeRatio and maxFaceSizeRatio, or commonly face size ratio, must be equal or greater than minimum valid face size ratio.

Security guidelines

The effectiveness of our video injection prevention feature can be strengthened if the application that implements it includes security recommendations from Apple: App integrity. Which ensure its authenticity that it was downloaded only from the App Store and the transmission of its sensitive data cannot be modified.

OWASP Mobile Application Security

We also strongly recommend following the OWASP Mobile Application Security guidelines. The OWASP Mobile Application Security (MAS) flagship project provides a security standard for mobile apps (OWASP MASVS) and a comprehensive testing guide (OWASP MASTG) that covers the processes, techniques, and tools used during a mobile app security test, as well as an exhaustive set of test cases that enables testers to deliver consistent and complete results.

Technical release. No changes.

8.3.2 - 2024-08-16

Fixed

Unnecessary deprecated warnings.

8.3.1 - 2024-08-15

Technical release. No changes.

8.3.0 - 2024-08-08

Added

Property EyeGazeLivenessViewController.Configuration.minValidSamplesCount.

8.2.1 - 2024-07-31

Fixed

EyeGazeLivenessViewController could crash when presented multiple times.
Default value for argument isFacePresenceRequired in method FaceAutoCaptureViewController.requestCapture().

8.2.0 - 2024-07-30

Added

Nested enumerator Error to all public components. It groups all possible errors that might be thrown by a component.
Enum CaptureMode.
Property FaceAutoCaptureViewController.Configuration.captureMode.
Property FaceAutoCaptureViewController.Configuration.isPlaceholderVisible.
Class FaceAutoCaptureViewController.Configuration.Presets.
Method argument isFacePresenceRequired to method FaceAutoCaptureViewController.requestCapture().

DOT iOS Face library

v8.4.0#

v8.4.0