Face SDK
Face identification for stand-alone or Web applications
VeriLook facial identification technology is designed for biometric systems developers and integrators. The technology assures system performance and reliability with live face detection, simultaneous multiple face recognition and fast face matching in 1-to-1 and 1-to-many modes.
Available as a software development kit that allows development of stand-alone and Web-based solutions on Microsoft Windows, Linux, macOS, iOS and Android platforms.
VeriLook SDK is based on VeriLook face recognition technology and is intended for biometric systems developers and integrators. The SDK allows rapid development of biometric applications using functions from the VeriLook algorithm that ensure fast and reliable face identification. VeriLook can be easily integrated into the customer's security system. The integrator has complete control over SDK data input and output.
VeriLook SDK includes the Device Manager library that allows to perform simultaneous capture from multiple cameras. Integrators can write plug-ins to support their cameras or other devices using the plug-in framework provided with the Device Manager.
License Activation Options
The components are copy-protected. The following license activation options are available:
- Activation by serial number is not suitable for ARM-Linux, except BeagleBone Black and Raspberry Pi 3 devices.
- Activation by serial number is not suitable for virtual environments.
- Activating single computer licenses – An installation license for a VeriLook component will be activated for use on a particular computer. The number of available licenses in the license manager will be decreased by the number of activated licenses.
- Managing single computer licenses via a LAN or the Internet – The license manager allows the management of installation licenses for VeriLook components across multiple computers or mobile/embedded devices in a LAN or over the Internet. The number of managed licenses is limited by the number of licenses in the license manager. No license activation is required and the license quantity is not decreased. Once issued, the license is assigned to a specific computer or device on the network.
- Using license manager as a dongle – A volume license manager containing at least one license for a VeriLook component may be used as a dongle, allowing the VeriLook component to run on the particular computer where the dongle is attached.
Additional VeriLook component licenses for the license manager may be purchased at any time.
Licenses Validity
All SDK and component licenses are perpetual and do not have expiration. There are no annual fee or any other fees except license purchasing fee. It is possible to move licenses from one computer or device to another. Neurotechnology provides a way to renew the license if the computer undergoes changes due to technical maintenance.
The table below compares VeriLook 12.1 Standard SDK and VeriLook 12.1 Extended SDK. The list can be narrowed with filtering by certain requirements based on the target biometric system.
| VeriLook SDK components and licenses | ||
|---|---|---|
| Component types | VeriLook 12.1 Standard SDK |
VeriLook 12.1 Extended SDK |
| Face component licenses included with a specific SDK: | ||
| Face Extractor | 1 single computer license | 1 single computer license |
| Face Matcher | 1 single computer license | 1 single computer license |
| Face Client | 3 single computer licenses | |
| Mobile Face Extractor | 1 single computer license | 1 single computer license |
| Mobile Face Matcher | 1 single computer license | 1 single computer license |
| Mobile Face Client | 3 single computer licenses | |
| Matching Server | + | |
VeriLook 12.1 SDK includes programming samples and tutorials that show how to use the components of the SDK to perform face template extraction or matching against other templates. The samples and tutorials are available for these programming languages and platforms:
| Windows 32 & 64 bit | Linux 32 & 64 bit | macOS | Android | iOS | |
|---|---|---|---|---|---|
| Programming samples | |||||
| C/C++ | + | + | + | ||
| Objective-C | + | ||||
| C# | + | ||||
| Visual Basic .NET | + | ||||
| Java | + | + | + | + | |
| Programming tutorials | |||||
| C | + | + | + | ||
| C++ | + | + | + | ||
| C# | + | ||||
| Visual Basic .NET | + | ||||
| Java | + | + | + | + | |
There are specific requirements for each platform which will run VeriLook-based applications.
Microsoft Windows Platform Requirements
- 2 GHz or better processor is recommended.
- x86 (32-bit) processors can still be used, but the algorithm will not provide the specified performance.
- AVX2 support is highly recommended. Processors that do not support AVX2 will still run the VeriLook algorithms, but in a mode, which will not provide the specified performance. Most modern processors support this instruction set, but please check if a particular processor model supports it.
- Any webcam or camera that is accessible using DirectShow, Windows Media or Media Foundation interfaces.
-
Any IP camera, that supports RTSP (Real Time
Streaming Protocol):
- Only RTP over UDP is supported.
- H.264/MPEG-4 AVC or Motion JPEG should be used for encoding the video stream.
-
These advanced cameras are supported:
- CMITech EMX-30 – face & iris camera (Microsoft Windows only)
- Iris ID iCAM R100 and iCAM TD100 – face & iris cameras (Microsoft Windows only)
- VistaFA2 / VistaFA2E / VistaEY2 face & iris cameras (Microsoft Windows only)
-
These models of still cameras are supported:
- Canon EOS family still cameras (the supported camera models are EOS M50, EOS 2000D, EOS 4000D, EOS M100, EOS 6D Mark II, EOS 200D, EOS 77D, EOS 800D, EOS M6, EOS M5, EOS 5D Mark IV, EOS-1D X Mark II, EOS 80D, EOS 1300D, EOS M10, EOS 5DS, EOS 5DS R, EOS 760D, EOS 750D, EOS 7D Mark II)
- Nikon DSLR still cameras (a specific camera model should support video capture and should be listed there)
- Fujifilm X-T2 still camera
- Cameras, which can operate in near-infrared spectrum, can be used for image capture. VeriLook algorithm is able to match faces, captured in near-infrared spectrum, against faces, captured in visible light.
- Integrators can also write a plug-in to support their cameras using the plug-in framework provided with the Device Manager from the VeriLook SDK.
- Microsoft SQL Server;
- MySQL;
- Oracle;
- PostgreSQL;
- SQLite.
- Microsoft Visual Studio 2012 or newer (for application development under C/C++, C#, Visual Basic .Net)
- Java SE JDK 8 or newer
Android Platform Requirements
- If you have a custom Android-based device or development board, contact us to find out if it is supported.
- Java SE JDK 8 (or higher)
- AndroidStudio 4.0 IDE
- AndroidSDK 21+ API level
- Gradle 6.1.1 build automation system or newer
- Android Gradle Plugin 4.0.0
- Internet connection for activating VerFinger component licenses
iOS Platform Requirements
- iPhone 5S or newer iPhone.
- iPad Air or newer iPad models.
- a Mac running macOS 10.12.6 or newer.
- Xcode 9.x or newer.
macOS Platform Requirements
- 2 GHz or better processor is recommended.
- AVX2 support is highly recommended. Processors that do not support AVX2 will still run the VeriLook algorithms, but in a mode, which will not provide the specified performance. Most modern processors support this instruction set, but please check if a particular processor model supports it.
- Any webcam or camera which is accessible using GStreamer interface.
-
Any IP camera, that supports RTSP (Real Time
Streaming Protocol):
- Only RTP over UDP is supported.
- H.264/MPEG-4 AVC or Motion JPEG should be used for encoding the video stream.
- XCode 6.x or newer
- GStreamer 1.10.x or newer with gst-plugin-base and gst-plugin-good is required for face capture using camera/webcam or rtsp video.
- GNU Make 3.81 or newer (to build samples and tutorials development)
- Java SE JDK 8 or newer
Linux x86-64 Platform Requirements
- 2 GHz or better processor is recommended.
- x86 (32-bit) processors can still be used, but the algorithm will not provide the specified performance.
- AVX2 support is highly recommended. Processors that do not support AVX2 will still run the VeriLook algorithms, but in a mode, which will not provide the specified performance. Most modern processors support this instruction set, but please check if a particular processor model supports it.
- Any webcam or camera which is accessible using GStreamer interface.
-
Any IP camera, that supports RTSP (Real Time
Streaming Protocol):
- Only RTP over UDP is supported.
- H.264/MPEG-4 AVC or Motion JPEG should be used for encoding the video stream.
- Cameras, which can operate in near-infrared spectrum, can be used for image capture. VeriLook algorithm is able to match faces, captured in near-infrared spectrum, against faces, captured in visible light.
- Integrators can also write a plug-in to support their cameras using the plug-in framework provided with the Device Manager from the VeriLook SDK.
- MySQL;
- Oracle;
- PostgreSQL;
- SQLite.
- gcc 4.8 or newer
- GNU Make 3.81 or newer
- Java SE JDK 8 or newer
ARM Linux Platform Requirements
- ARMHF architecture (EABI 32-bit hard-float ARMv7) is required.
- Lower clock-rate processors may be also used, but the fingerprint processing will take longer time.
- Any webcam or camera which is accessible using GStreamer interface.
-
Any IP camera, that supports RTSP (Real Time
Streaming Protocol):
- Only RTP over UDP is supported.
- H.264/MPEG-4 AVC or Motion JPEG should be used for encoding the video stream.
- Cameras, which can operate in near-infrared spectrum, can be used for image capture. VeriLook algorithm is able to match faces, captured in near-infrared spectrum, against faces, captured in visible light.
- gcc 4.8 or newer
- GNU Make 3.81 or newer
- Java SE JDK 8 or newer
- Face recognition accuracy of the MegaMatcher algorithm heavily depends on the quality of a face image. Image quality during enrollment is important, as it influences the quality of the face template.
- 32 pixels is the recommended minimal distance between eyes for a face on image or video stream to perform face template extraction reliably. 64 pixels or more recommended for better face recognition results. Note that this distance should be native, not achieved by resizing an image.
- Several images during enrollment are recommended for better facial template quality which results in improvement of recognition quality and reliability.
- Additional enrollments may be needed when facial hair style changes, especially when beard or mustache is grown or shaved off.
- Persons wearing face masks or respirators can be recognized without separate enrollment. Face quality check should be disabled for this scenario.
-
head roll (tilt) – ±180 degrees (configurable);
- ±15 degrees default value is the fastest setting which is usually sufficient for most near-frontal face images.
-
head pitch (nod) – ±15 degrees from frontal
position.
- The head pitch tolerance can be increased up to ±25 degrees if several views of the same face that covered different pitch angles were used during enrollment.
-
head yaw (bobble) – ±90 degrees from frontal
position (default value).
- Smaller yaw tolerance values are not recommended to be used except if the target system does not meet the system requirements.
- Several views of the same face can be enrolled to the database to cover the whole ±90 degrees yaw range from frontal position.
- A stream of consecutive images (usually a video stream from a camera) is required for the live face detection.
- When the liveness check is enabled, it is performed by the face engine before feature extraction. If the face in the stream fails to qualify as "live", the features are not extracted.
- Only one face should be visible in these frames.
-
Users can enable these liveness check modes:
- Active – the engine requests the user to perform certain actions like blinking or moving one's head. All requested actions should be performed to pass the liveness check. This mode can work with both colored and grayscale images. 5 frames per second or better frame rate required.
- Passive – the engine analyzes certain facial features while the user stays still in front of the camera for a short period of time. Colored images are required for this mode. 10 frames per second or better frame rate is required. Better score is achieved when users do not move at all.
- Passive then active – the engine first tries the passive liveness check, and if it fails, tries the active check. This mode requires colored images.
- Simple – the engine requires user to turn head from side to side while looking at camera. This mode can work with both colored and grayscale images. 5 frames per second or better frame rate recommended.
VeriLook 12.1 face detection algorithm can run in maximal speed or maximal accuracy modes. The face detection times in the table below are provided for 640 x 480 pixels images as ranges, where the smallest time corresponds to the maximal speed mode, and the largest time – to the maximal accuracy. The head pitch tolerance in the table below is always ±15°. The head yaw tolerance in the table below is always ±90°. The face detection times are specified for a PC with Intel Core i7-8700K processor.
| VeriLook 12.1 face detection algorithm performance for all faces in a frame on PC-based systems | ||
|---|---|---|
| Roll tolerance | Time (milliseconds) | |
| ±15° | 37 | |
| ±45° | 38 | |
| ±180° | 56 | |
VeriLook biometric template extraction and matching algorithm is designed to run on multi-core processors allowing to reach maximum possible performance on the used hardware. Face template extraction is performed after all faces are detected in a frame. The template extraction time does not depend on image size.
| VeriLook 12.1 face engine specifications | ||||
|---|---|---|---|---|
| Embedded / mobile (1) platform |
PC-based (2) platform |
|||
| Template extraction components | Mobile Face Extractor |
Mobile Face Client |
Face Extractor |
Face Client |
| Template extraction time (seconds) | 1.34 | 1.20 | 1.34 | 0.60 |
| Template matching components | Mobile Face Matcher | Face Matcher | ||
| Template matching speed (faces per second) | 3,000 | 40,000 | ||
| Single face record size in a template (bytes) | 194 or 322 (configurable) |
|||
Notes:
(1) Requires to be run on iOS devices or Android
devices based on at least Snapdragon S4 system-on-chip with
Krait 300 processor (4 cores, 1.51 GHz).
(2) Requires to be run on PC or laptop with at least Intel Core
i7-8700K processor.
We present the testing results to show the VeriLook 12.1 algorithm face recognition reliability evaluations. The following public datasets were used:
- All full-profile face images from the dataset were removed because they are not supported by VeriLook SDK. This resulted in 1,216 images of 518 persons.
- According to the original protocol, only 6,000 pairs (3,000 genuine and 3,000 impostor) should be used to report the results. But recent algorithms are "very close to the maximum achievable by a perfect classifier" [source]. Instead, as Neurotechnology algorithms were not trained on any image from this dataset, verification results on matching each pair of all 13,233 face images of 5,729 persons were chosen to be reported.
- All identity mistakes, which had been mentioned on the LFW website, were fixed. Also, several not mentioned issues were fixed.
- Some images from the LFW dataset contained multiple faces. The correct faces for assigned identities were chosen manually to solve these ambiguities.
- The dataset contains face images, which were captured in visible light (VIS) and near-infrared (NIR) spectrums. According to the original protocol, VeriLook algorithm testing used VIS images as gallery, and NIR images as probe.
- According to the original protocol, the dataset is split into two parts – View1 intended for algorithm development and View2 for performance evaluation. Neurotechnology algorithms were not trained on any image from this dataset. Only View2 part with 12,393 NIR images and 2,564 VIS images was used for face verification evaluation.
- The non-cropped images (640 x 480 pixels) from the dataset were used for VeriLook algorithm testing.
Two experiments were performed with each dataset:
- Experiment 1 maximized matching accuracy. VeriLook 12.1 algorithm reliability in this test is shown on the ROC charts as blue curves.
- Experiment 2 maximized matching speed. VeriLook 12.1 algorithm reliability in this test is shown on the ROC charts as red curves.
Receiver operation characteristic (ROC) curves are usually used to demonstrate the recognition quality of an algorithm. ROC curves show the dependence of false rejection rate (FRR) on the false acceptance rate (FAR). Equal error rate (EER) is the rate at which both FAR and FRR are equal.
MEDS-II dataset
Click to zoom |
LFW dataset
Click to zoom |
NIR-VIS 2.0 dataset
Click to zoom |
| VeriLook 12.1 algorithm testing results with face images from public datasets | ||||||
|---|---|---|---|---|---|---|
| MEDS-II | LFW | NIR-VIS 2.0 | ||||
| Exp. 1 | Exp. 2 | Exp. 1 | Exp. 2 | Exp. 1 | Exp. 2 | |
| Image count | 1216 | 13233 | 14957 | |||
| Subject count | 518 | 5729 | 725 | |||
| Session count | 1 - 18 | 1 - 530 | 4 | |||
| Image size (pixels) | variable | 250 x 250 | 480 x 640 | |||
| Template size (bytes) | 322 | 322 | 322 | 322 | 322 | 322 |
| EER | 0.0228 % | 0.0234 % | 0.0080 % | 0.0147 % | 0.0375 % | 0.0629 % |
| FRR at 0.1 % FAR | 0.0000 % | 0.0000 % | 0.0029 % | 0.0041 % | 0.0081 % | 0.0549 % |
| FRR at 0.01 % FAR | 0.0000 % | 0.0000 % | 0.0078 % | 0.0194 % | 0.1291 % | 0.1581 % |
| FRR at 0.001 % FAR | 0.0000 % | 0.1361 % | 0.0281 % | 0.0454 % | 0.7649 % | 0.8020 % |