Face Detection Algorithm

Luxand, Inc.
http://www.luxand.com
Luxand FaceSDK 3.0

Face Detection and Recognition Library
Developer’s Guide
Copyright © 2005–2010 Luxand, Inc. http://www.luxand.com 1

Table of Contents
Overview ......................................................................................................................................... 4
Requirements.................................................................................................................................. 4
Technical Specifications ............................................................................................................... 4
Face Detection................................................................................................................................................... 4
Face Matching ................................................................................................................................................... 5
Facial Feature Detection................................................................................................................................... 5
Eye Centers Detection ...................................................................................................................................... 5
Library Size ....................................................................................................................................................... 5
Installation...................................................................................................................................... 5
Windows............................................................................................................................................................. 5
Linux/Mac OS X ................................................................................................................................................ 6
Directory Structure ....................................................................................................................... 6
Sample Applications ..................................................................................................................... 6
Using FaceSDK with Programming Languages....................................................................... 7
Using with .NET (C# and VB) ........................................................................................................................... 7
Using with C/C++ .............................................................................................................................................. 8
Using with Delphi .............................................................................................................................................. 8
Using with Visual Basic 6.0 ............................................................................................................................... 8
Redistributables............................................................................................................................. 9
Using Luxand FaceSDK ............................................................................................................... 9
Library Activation ...................................................................................................................... 10
FSDK_GetHardware_ID Function ................................................................................................................... 10
FSDK_ActivateLibrary Function ..................................................................................................................... 11
FSDK_GetLicenseInfo Function ...................................................................................................................... 11
Initialization ................................................................................................................................. 12
FSDK_Initialize Function ................................................................................................................................ 12
FSDK_Finalize Function.................................................................................................................................. 12
Working with Images ................................................................................................................. 12
FSDK_LoadImageFromFile Function.............................................................................................................. 13
FSDK_SaveImageToFile Function .................................................................................................................. 13
FSDK_LoadImageFromBuffer Function ......................................................................................................... 14
FSDK_GetImageBufferSize Function.............................................................................................................. 15
FSDK_SaveImageToBuffer Function .............................................................................................................. 16
FSDK_LoadImageFromHBitmap Function ..................................................................................................... 16
FSDK_SaveImageToHBitmap Function .......................................................................................................... 17
FSDK_SetJpegCompressionQuality ................................................................................................................ 17
FSDK_GetImageWidth Function ..................................................................................................................... 18
FSDK_GetImageHeight Function .................................................................................................................... 18
FSDK_MirrorImage Function .......................................................................................................................... 19
FSDK_FreeImage Function.............................................................................................................................. 19
Face Detection .............................................................................................................................. 20
Data types ......................................................................................................................................................... 20
FSDK_DetectFace Function............................................................................................................................. 21
FSDK_DetectMultipleFaces Function ............................................................................................................. 22
FSDK_SetFaceDetectionParameters Function ................................................................................................. 23
FSDK_SetFaceDetectionThreshold Function .................................................................................................. 24

Facial Feature Detection ............................................................................................................ 25
FSDK_DetectFacialFeatures Function ............................................................................................................. 25
FSDK_DetectFacialFeaturesInRegion Function .............................................................................................. 26
FSDK_DetectEyes Function ............................................................................................................................ 27
FSDK_DetectEyesInRegion Function.............................................................................................................. 28
Face Matching ............................................................................................................................. 29
FSDK_GetFaceTemplate ................................................................................................................................. 30
FSDK_GetFaceTemplateInRegion................................................................................................................... 30
FSDK_GetFaceTemplateUsingEyes ................................................................................................................ 31
FSDK_MatchFaces .......................................................................................................................................... 32
FSDK_GetMatchingThresholdAtFAR ............................................................................................................. 33
FSDK_GetMatchingThresholdAtFRR ............................................................................................................. 33
Working with Web Cameras ..................................................................................................... 34
Data Types........................................................................................................................................................ 34
FSDK_InitializeCapturing Function................................................................................................................. 35
FSDK_FinalizeCapturing Function .................................................................................................................. 35
FSDK_SetCameraNaming Function ................................................................................................................ 36
FSDK_GetCameraList Function ...................................................................................................................... 36
FSDK_GetVideoFormatList Function ............................................................................................................. 37
FSDK_SetVideoFormat Function .................................................................................................................... 38
FSDK_OpenVideoCamera Function ................................................................................................................ 39
FSDK_GrabFrame Function ............................................................................................................................ 39
FSDK_CloseVideoCamera Function ............................................................................................................... 40
Thread Safety............................................................................................................................... 40
Migration from FaceSDK 2.0 .................................................................................................... 41
Deprecated Functions ................................................................................................................. 42
Error Codes.................................................................................................................................. 42
Detected Facial Features ............................................................................................................ 42
Library Information ................................................................................................................... 45

Overview
Luxand FaceSDK is a cross-platform face detection and recognition library that can be easily
integrated into the customer’s application. FaceSDK offers the API (Application
Programming Interface) to detect a face and facial features and to match faces. Following face
detection, the SDK provides the coordinates of 40 facial feature points for further processing.
For example, the facial feature points include eyes, eye corners, eyebrows, mouth corners and
nose tip. The library is webcam-capable, and able to retrieve frames from DirectShow-
compatible cameras.
Luxand FaceSDK is available for all 32-bit and 64-bit versions of Windows and Linux, and
64-bit MacOS X. The SDK is supplied as a dynamic link library. FaceSDK contains interface
header files and sample applications for C, Microsoft Visual C++ 6.0/2005/2008, Visual
Basic 6.0, Visual Basic .NET 2005/2008, Microsoft C# .NET 2005/2008, C++Builder 6.0 and
Borland Delphi 6.0/7.0.
Requirements
The FaceSDK library supports the following platforms:
 Windows 2000/XP/2003/Vista/2008/Seven
 Linux (RHEL 5+, CentOS 5+ and other)
 Mac OS X 10.4+ x86_64
Intel processor is recommended for better performance.
Minimum system requirements:
 1.6 GHz processor
 256 MB RAM
 150 MB free disk space
Recommended system requirements:
 2.4 GHz Intel multi-core processor
 2 GB RAM
 DirectShow-compatible webcam
Note that web camera functions are available only for Windows 32/64 platforms.
Technical Specifications
The FaceSDK library has the following technical specifications:
Face Detection
 Robust frontal face detection
 Detection of multiple faces in a photo
 Head rotation support: –30..30 degrees of in-plane rotation and –30..30 degrees out-
of-plane rotation
 Determines in-plane face rotation angle
 Detection speed: as fast as 370 frames per second*, depending on resolution
o Realtime detection: 0.0027 sec (370 FPS)* , webcam resolution, –15..15
degrees of in-plane head rotation

o Reliable detection: 0.7 sec, digicam resolution, –30..30 degrees of in-plane
head rotation
 Returned information for each detected face: (x,y) coordinates of face center, face
width and rotation angle
 Easy configuration of face detection parameters
Face Matching
 Matching of two faces at given FAR (False Acceptance Rate) and FRR (False
Rejection Rate)
 Enrollment time: 0.117 seconds (8.5 FPS)* (at webcam resoluton)
 Template Size: 16 kb
 Matching speed: 30,000 faces per second*
 Returned information: facial similarity level
Facial Feature Detection

 Detection of 40 facial feature points (eyes, eyebrows, mouth, nose, face contour)
 Detection time: 0.59 seconds* (not including face detection stage)
 Allowed head rotation: –30..30 degrees of in-plane rotation, –10..10 degrees out-of-
plane rotation
 Returned information: array of 40 (x,y) coordinates of each facial feature point
Eye Centers Detection

 Detection of eye centers only, detection time: 0.067 seconds* (not including face
detection stage)
 Returned information: two (x,y) coordinates of left eye center and right eye center
Library Size
 The size of the redistributables does not exceed 10MB for each platform.
*
Measured on Intel 2.4 Ghz Processor
Installation
Windows
To install Luxand FaceSDK, run the installation file:
Luxand_FaceSDK_Setup.exe
and follow the instructions.
FaceSDK is installed to the C:\Program Files\Luxand\FaceSDK directory by

default. FaceSDK is a copy-protected library, and must be activated with a license key before
each use (see the Library Activation chapter).

Linux/Mac OS X
Unpack the Luxand_FaceSDK.tar.bz2 archive into the desired directory.
Directory Structure
The FaceSDK directory contains the following directories and files:
bin\ FaceSDK binary files
bin\linux_x86 FaceSDK Linux 32-bit binaries
bin\linux_x86_64 FaceSDK Linux 64-bit binaries
bin\osx_x86_64 FaceSDK Mac OS X 64-bit binaries

bin\win32 FaceSDK Widows 32-bit binaries and stub library files
bin\win64 FaceSDK Windows 64-bit binaries and stub library files

demo\ Demo applications (win32)
include\ Header files
samples\ Sample applications
Sample Applications
FaceSDK is distributed with the following sample applications (they can be found in the
samples\ directory of FaceSDK):
1. LiveRecognition
This application memorizes a person from a camera and recognizes her when she
looks into a webcam. Source code is available on Microsoft C# 2005/2008, Borland
Delphi 6.0/7.0, Microsoft Visual C++ 2005/2008, Microsoft Visual Basic .NET
2005/2008 and Visual Basic 6.0.
2. FaceTracking
This application receives a picture from a webcam and highlights all detected faces
with rectangles. Source code is available on Microsoft C# 2005/2008, Borland Delphi
6.0/7.0, Microsoft Visual C++ 2005/2008, Microsoft Visual Basic .NET 2005/2008
and Visual Basic 6.0.
3. Lookalikes
This application allows the user to create a database of faces and run a search for best
matches (the most alike face from a database is shown). Source code is available on
C++, Microsoft C# 2005/2008, Borland Delphi 6.0/7.0.
4. FacialFeatures
This application opens a photograph, detects a face in a photo (only one face, the one
that can be detected best), detects face features and draws a frame around the detected

face and detected features. Source code is available on Microsoft C# 2005/2008,
Borland C++ Builder 6.0, Borland Delphi 6.0/7.0, Microsoft Visual C++ 2005/2008,
Microsoft Visual Basic .NET 2005/2008 and Visual Basic 6.0.
5. Portrait
This application is for command line. It receives a picture, detects a face and, if the
face is found, crops it and saves to file. Source code is available on C++.
6. Advanced
Source code of .NET wrapper which links facesdk.dll dynamically and samples of
using this wrapper. Refer to Using with .NET (C# and VB) for details.
Using FaceSDK with Programming Languages

To access the FaceSDK library functions, you need to use its binary file in your applications.
The specific file depends on the platform:
 Windows applications use facesdk.dll
 Windows .NET applications use facesdk.NET.dll
 Linux applications use libfsdk.so
 Mac OS X applications use libfsdk.dylib
It is usually recommended to store this file in the directory where the executable file of your
application is located. Alternatively, you may keep the file in:
 the working directory of your application
 the directory specified in the path environment variable of your system: PATH
(Windows), LD_LIBRARY_PATH (Linux), DYLD_LIBRARY_PATH (Mac OS X).
You need to include interface header files into your application project in order to use
FaceSDK.
Using with .NET (C# and VB)

For Microsoft .NET applications, you need to add the .NET component into your project.
Follow these steps to add the component in Visual Studio 2005/2008:
 Select Project – Add Reference – Browse
 For 32-bit applications, choose the file bin\win32\FaceSDK.NET.dll
 For 64-bit native applications, choose the file bin\win64\FaceSDK.NET.dll
 Add the following statement to the beginning of your application:
using Luxand
After that you may use the methods of the Luxand.FSDK namespace for general FaceSDK
functions, and Luxand.FSDKCam namespace for webcam-related functions. You may refer
just to FSDK and FSDKCam namespaces if using Luxand is specified.
Once FaceSDK.NET.dll is added to the references, it will be redistributed automatically
with your application, so no specific deployment actions are required. You do not need to
redistribute facesdk.dll with your application.

By default, the documentation refers to C/C++ declarations of FaceSDK functions. For
example, the function to detect a face is referred to as FSDK_DetectFace function. To
refer to this function in .NET, replace the FSDK_ prefix with FSDK. namespace. Thus, the
reference to this function becomes FSDK.DetectFace (note that webcam-specific
functions are located in the FSDKCam. namespace; refer to Working with Web Cameras for
details).
Note: this .NET component is available in a binary form, compatible with .NET 2.0, 3.0 and
3.5. If you need a component for a specific .NET version, you may use the source code
available in the samples\advanced\.NET wrapper directory. Note that this
component is actually a wrapper for facesdk.dll which is linked dynamically and must be
redistributed with the application that uses this wrapper.
Using with C/C++

For Microsoft Visual C++ applications, you need to include the header file
include\C\LuxandFaceSDK.h, and the stub library file facesdk.lib into your
project.
Follow these steps to add the library to your project:
 Copy include\C\LuxandFaceSDK.h into the directory of your project
 For 32-bit applications, copy bin\win32\facesdk.dll and
bin\win32\facesdk.lib into the output directory of your project
 For 64-bit applications, copy bin\win64\facesdk.dll and
bin\win64\facesdk.lib into the output directory of your project
 Choose Project Properties – Linker – Input – Additional Dependencies, and add
facesdk.lib string
 Choose Project Properties – Linker – General – Additional Library Directories
Dependencies, and add $(OutDir) string (a reference to the output directory)
 Add the following statement to the beginning of your application:
include "LuxandFaceSDK.h"
The output directory $(OutDir) typically refers to Debug\ or Release\ in the directory
of your solution. You may change it in the Configuration Properties – General of your project.
You may also choose another directory to store the .lib file, but it is recommended to keep
facesdk.dll in the directory where the executable file of your application is located.
You need to redistribute the file facesdk.dll with your application.
Using with Delphi

For Delphi applications, put facesdk.dll into the working directory and use the
include\Delphi\LuxandFaceSDK.pas unit in your project.
You need to redistribute the file facesdk.dll with your application.
Using with Visual Basic 6.0

For Visual Basic 6.0 applications, put the Visual Basic wrapper (bin\win32\FaceSDK-
VB.dll) into the project directory and add LuxandFaceSDK.bas
(include\VB6\LuxandFaceSDK.bas) module to your project (Select Project – Add

module – Existing and choose a module location). Also you need to put facesdk.dll into
the application working directory.
You need to redistribute both FaceSDK-VB.dll and facesdk.dll with your
application.
Redistributables
The following files may be redistributed with your application:
bin\win32\facesdk.dll (for 32-bit systems)

bin\win64\facesdk.dll (for 64-bit systems)
Windows bin\win32\facesdk.NET.dll (for 32-bit .NET applications)
bin\win64\facesdk.NET.dll (for 32-bit .NET applications)
bin\win32\FaceSDK-VB.dll (for Visual Basic 6.0 applications)
bin\linux_x86\libfsdk.so (for 32-bit systems)
Linux
bin\linux_x86_64\libfsdk.so (for 64-bit systems)
Mac OS X bin\osx_x86_64\libfsdk.dylib (for 64-bit systems)
Using Luxand FaceSDK

The usage level of the library depends on the functionality required from Luxand FaceSDK.
The typical scenario is:
1. Activate FaceSDK by calling up the FSDK_ActivateLibrary function with the key
sent by Luxand, Inc.
2. Initialize FaceSDK by calling up the FSDK_Initialize function.
3. Load images either from file, buffer, or the HBITMAP handle
(FSDK_LoadImageFromFile, FSDK_LoadImageFromBuffer,
FSDK_LoadFromHBitmap functions)
4. Set face detection parameters if needed (FSDK_SetFaceDetectionParameters,
FSDK_SetFaceDetectionThreshold)
5. Use FaceSDK functions:
 Detect a face (FSDK_DetectFace) or multiple faces
(FSDK_DetectMultipleFaces) in an image
 Detect facial features if needed (FSDK_DetectFacialFeatures,
FSDK_DetectFacialFeaturesInRegion)
 Extract a face template from the image (FSDK_GetFaceTemplate,
FSDK_GetFaceTemplateInRegion,
FSDK_GetFaceTemplateUsingFeatures)
 Match face templates (FSDK_MatchFaces) and acquire facial similarity
level
 To find out if a face belongs to the same person, calculate the matching
threshold at a given FAR or FRR rate
(FSDK_GetMatchingThresholdAtFAR and
FSDK_GetMatchingThresholdAtFRR functions).
6. Finalize the FaceSDK library (FSDK_Finalize function).

To work with a camera, follow these steps:
1. Initialize camera capturing (FSDK_InitializeCapturing)
2. Get list of cameras available in the system (FSDK_GetCameraList)
3. Get list of video formats supported by the camera (FSDK_GetVideoFormatList)
4. Set the desired video format for the chosen camera (FSDK_SetVideoFormat)
5. Open video camera (FSDK_OpenVideoCamera)
6. Grab frames (FSDK_GrabFrame) in a loop, displaying them and detecting/recognizing
faces
7. Close video camera (FSDK_CloseVideoCamera).
8. Finalize capturing (FSDK_FinalizeCapturing).
Library Activation
FaceSDK is a copy-protected library, and must be activated with a license key before its use.
You need to pass the license key received from Luxand, Inc. to the FSDK_ActivateLibrary
function before initializing Luxand FaceSDK. Almost all FaceSDK functions will return the
FSDKE_NOT_ACTIVATED error code in case the library is not activated. To retrieve your
license information, call FSDK_GetLicenseInfo. This function returns the name the library is
licensed to. You may need to use the FSDK_GetHardware_ID function to obtain your
hardware ID if your license is restricted to one machine only. Additionally, you can find out
hardware ID by running the hardwareid program (ShowHardwareID.exe for Windows), which
is located in the bin directory.
To get a temporary evaluation key from Luxand, Inc., run License Key Wizard from the Start
– Luxand – FaceSDK menu. You may also request this key at
http://luxand.com/facesdk/requestkey/.
FSDK_GetHardware_ID Function
Generates a Hardware ID code.
C++ Syntax:
int FSDK_GetHardware_ID(char* HardwareID);
Delphi Syntax:
function FSDK_GetHardware_ID(HardwareID: PChar): integer;
C# Syntax:
int FSDK.GetHardwareID(out string HardwareID);
VB Syntax:
Function FSDKVB_GetHardwareID(ByRef HardwareID As Byte) As
Long
Parameters:
HardwareID – address of the null-terminated string for receiving the Hardware ID code.
Return Value:
Returns FSDKE_OK if successful.

FSDK_ActivateLibrary Function
Activates the FaceSDK library.
C++ Syntax:
int FSDK_ActivateLibrary(char* LicenseKey);
Delphi Syntax:
function FSDK_ActivateLibrary(LicenseKey: PChar): integer;
C# Syntax:
int FSDK.Activate(out string LicenseKey);
VB Syntax:
Function FSDKVB_Activate(ByVal LicenseKey As String) As Long
Parameters:
LicenseKey – License key you received from Luxand, Inc.
Return Value:
Returns FSDKE_OK if the registration key is valid and not expired.
FSDK_GetLicenseInfo Function
Retrieves license information.
C++ Syntax:
int FSDK_GetLicenseInfo(char* LicenseInfo);
Delphi Syntax:
function FSDK_GetLicenseInfo(LicenseInfo: PChar): integer;
C# Syntax:
int FSDK.GetLicenseInfo(out string LicenseInfo);
VB Syntax:
Function FSDKVB_GetLicenseInfo(ByRef LicenseInfo As Byte) As
Long
Parameters:
LicenseInfo – address of the null-terminated string for receiving the license
information. This variable should be allocated no less than 256 bytes of memory.
Return Value:

Initialization
FSDK_Initialize Function
Initializes the FaceSDK library. Should be called before using of any face detection functions.
C++ Syntax:
int FSDK_Initialize(char* DataFilesPath);
Delphi Syntax:
function FSDK_Initialize(DataFilesPath: PChar): integer;
C# Syntax:
int FSDK.Initialize(string DataFilesPath);
VB Syntax:
Function FSDKVB_Initialize(ByRef DataFilesPath As Byte) As
Long
Parameters:
DataFilesPath – pointer to the null-terminated string specifying the path where
facesdk.dll is stored. An empty string means the current directory. (Note: the parameter is not
used since version 1.8; an empty string might be passed as this parameter.)
Return Value:
Returns FSDKE_OK if successful or FSDK_IO_ERROR if an I/O error occurs.
FSDK_Finalize Function
Finalizes the FaceSDK library. Should be called when the application is exited.
C++ Syntax:
int FSDK_Finalize();
Delphi Syntax:
function FSDK_Finalize: integer;
C# Syntax:
int FSDK.Finalize();
VB Syntax:
Function FSDKVB_Finalize() As Long
Return Value:
Working with Images

Images are represented as the HImage data type.

C++ Declaration:
typedef int HImage;
C# Declaration:
UInt32 Image
Delphi Declaration:
HImage = integer;
PHImage = ^HImage;
FaceSDK provides a number of functions to load images to the internal representation from
files, buffers or HBITMAP handles and to save images from the internal representation to
files, buffers and HBITMAP handles. Each FSDK_LoadImageFromXXXX function creates a
new HImage handle, which can be deleted using the FSDK_FreeImage function.
FSDK_LoadImageFromFile Function
Loads the image from a file and provides the internal handle of this image.
C++ Syntax:
int FSDK_LoadImageFromFile(HImage* Image, char* FileName);
Delphi Syntax:
function FSDK_LoadImageFromFile(Image: PHImage; FileName:
PChar): integer;
C# Syntax:
int FSDK.LoadImageFromFile(ref UInt32 Image, string FileName)
VB Syntax:
Function FSDKVB_LoadImageFromFile(ByRef Image As Long, ByVal
FileName As String) As Long
Parameters:
Image – pointer to HImage for receiving the loaded image handle.
FileName – filename of the image to be loaded. FaceSDK supports the JPG, PNG and BMP
file formats.
Return Value:
FSDK_SaveImageToFile Function
Saves an image to a file. When saving to .jpg files, you can set the quality of JPEG
compression using the FSDK_SetJpegCompressionQuality function.
C++ Syntax:
int FSDK_SaveImageToFile(HImage Image, char* FileName);

Delphi Syntax:
function FSDK_SaveImageToFile(Image: HImage; FileName: PChar):
integer;
C# Syntax:
int FSDK.SaveImageToFile(UInt32 Image, string FileName);
VB Syntax:
Function FSDKVB_SaveImageToFile(ByVal Image As Long, ByVal
FileName As String) As Long
Parameters:
Image – internal handle of an image to be saved.
FileName – name of file the image will be saved to. FaceSDK saves images in the BMP,
PNG or JPG file format. The format to use is recognized by the extension specified in the
FileName parameter.
Return Value:
Example
int img1;
FSDK_Initialize("");
FSDK_LoadImageFromFile(&img1, "test.bmp"); // load .bmp file
FSDK_SaveImageToFile(img1, "test.jpg"); // save as .jpg
FSDK_LoadImageFromBuffer Function
Loads an image from a buffer and provides the internal handle of this image. The function
suggests that the image data is organized in a top-to-bottom order, and the distance between
adjacent rows is ScanLine bytes (for example, in the 24-bit image, the ScanLine value might
be 3*Width bytes if there is no spacing between adjacent rows). The following image modes
are supported:
Mode name Meaning

FSDK_IMAGE_GRAYSCALE_8BIT 8-bit grayscale image
FSDK_IMAGE_COLOR_24BIT 24-bit color image (R, G, B order)
32-bit color image with alpha channel (R, G, B, A
FSDK_IMAGE_COLOR_32BIT
order)
The function is not available in .NET. It is suggested to use FSDK_LoadImageFromHBitmap
function instead.
C++ Syntax:
int FSDK_LoadImageFromBuffer(HImage* Image, unsigned char*
Buffer, int Width, int Height, int ScanLine, FSDK_IMAGEMODE
ImageMode);

Delphi Syntax:
function FSDK_LoadImageFromBuffer(Image: PHImage; var Buffer;
Width, Height: integer; ScanLine: integer; ImageMode:
FSDK_IMAGEMODE): integer;
VB Syntax:
Function FSDKVB_LoadImageFromBuffer(ByRef Image As Long, ByRef
Buffer As Byte, ByVal Width As Long, ByVal Height As Long,
ByVal ScanLine As Long, ByVal ImageMode As FSDK_IMAGEMODE) As
Long
Parameters:
Buffer – pointer to buffer containing image data.
Width – width of an image in pixels.
Height – height of an image in pixels.
ScanLine – distance between adjacent rows in bytes.
ImageMode – mode of an image.
Return Value:
FSDK_GetImageBufferSize Function
Returns the size of the buffer required to store an image.
C++ Syntax:
int FSDK_GetImageBufferSize(HImage Image, int * BufSize,
FSDK_IMAGEMODE ImageMode);
Delphi Syntax:
function FSDK_GetImageBufferSize(Image: HImage; BufSize:
PInteger; ImageMode: FSDK_IMAGEMODE): integer;
VB Syntax:
Function FSDKVB_GetImageBufferSize(ByVal Image As Long, ByRef
BufSize As Long, ByVal ImageMode As FSDK_IMAGEMODE) As Long
The function is not available in .NET.
Parameters:
Image – internal handle of an image.
BufSize – pointer to an integer variable to store the calculated buffer size.
ImageMode – desired image mode of a buffer.
Return Value:

FSDK_SaveImageToBuffer Function
Saves an image to a buffer in the desired image mode. Refer to the
FSDK_LoadImageFromBuffer function description to read more about image modes.
C++ Syntax:
int FSDK_SaveImageToBuffer(HImage Image, unsigned char*
Buffer, FSDK_IMAGEMODE ImageMode);
Delphi Syntax:
function FSDK_SaveImageToBuffer(Image: HImage; var Buffer;
ImageMode: FSDK_IMAGEMODE): integer;
VB Syntax:
Function FSDKVB_SaveImageToBuffer(ByVal Image As Long, ByRef
Buffer As Byte, ByVal ImageMode As FSDK_IMAGEMODE) As Long
The function is not available in .NET. It is suggested to use the FSDK_SaveImageToHBitmap
function instead.
Parameters:
Image – internal handle of an image to be saved.
Buffer – pointer to the buffer containing the image data.
ImageMode – desired mode an image will be saved in.
Return Value:
FSDK_LoadImageFromHBitmap Function
Loads the image from an HBITMAP handle and provides the internal handle of this image.
C++ Syntax:
int FSDK_LoadImageFromHBitmap(HImage* Image, HBITMAP*
BitmapHandle);
Delphi Syntax:
function FSDK_LoadImageFromHBitmap(Image: PHImage;
BitmapHandle: HBitmap): integer;
C# Syntax:
int FSDK.LoadImageFromHBitmap(ref UInt32 Image, IntPtr
BitmapHandle);
VB Syntax:
Function FSDKVB_LoadImageFromHBitmap(ByRef Image As Long,
ByVal BitmapHandle As Integer) As Long
Parameters:
BitmapHandle – handle of the image to be loaded.

Return Value:
FSDK_SaveImageToHBitmap Function
Creates an HBITMAP handle containing the image.
C++ Syntax:
int FSDK_SaveImageToHBitmap(HImage Image, HBITMAP*
BitmapHandle);
Delphi Syntax:
function FSDK_SaveImageToHBitmap(Image: HImage; BitmapHandle:
PHBitmap): integer;
C# Syntax:
int FSDK.SaveImageToHBitmap(UInt32 Image, ref IntPtr
BitmapHandle);
VB Syntax:
Function FSDKVB_SaveImageToHBitmap(ByVal Image As Long, ByRef
BitmapHandle As Integer) As Long
Parameters:
Image – internal handle of the image to be saved to HBITMAP.
BitmapHandle – pointer to HBITMAP the created HBITMAP handle will be saved to.
Return Value:
FSDK_SetJpegCompressionQuality
Sets the quality of the JPEG compression to use in the FSDK_SaveImageToFile function.
C++ Syntax:
int FSDK_SetJpegCompressionQuality(int Quality);
Delphi Syntax:
function FSDK_SetJpegCompressionQuality(Quality: integer):
integer;
C# Syntax:
int FSDK.SetJpegCompressionQuality(int Quality);
VB Syntax:
Function FSDKVB_SetJpegCompressionQuality(ByVal Quality As
Long) As Long
Parameters:
Quality – quality of JPEG compression. Varies from 0 to 100.

Return Value:
FSDK_GetImageWidth Function
Returns the width of an image.
C++ Syntax:
int FSDK_GetImageWidth(HImage SourceImage, int* Width);
Delphi Syntax:
function FSDK_GetImageWidth(SourceImage: HImage; Width:
PInteger): integer;
C# Syntax:
int FSDK.GetImageWidth(UInt32 SourceImage, ref int Width);
VB Syntax:
Function FSDKVB_GetImageWidth(ByVal SourceImage As Long, ByRef
Width As Long) As Long
Parameters:
SourceImage – internal handle of an image.
Width – pointer to an integer variable to store the width of an image.
Return Value:
FSDK_GetImageHeight Function
Returns the height of an image.
C++ Syntax:
int FSDK_GetImageHeight(HImage SourceImage, int* Height);
Delphi Syntax:
function FSDK_GetImageHeight(SourceImage: HImage; Height:
PInteger): integer;
C# Syntax:
int FSDK.GetImageHeight(UInt32 SourceImage, ref int Height);
VB Syntax:
Function FSDKVB_GetImageHeight(ByVal SourceImage As Long,
ByRef Height As Long) As Long
Parameters:
SourceImage – internal handle of an image.
Height – pointer to an integer variable to store the height of an image.

Return Value:
FSDK_MirrorImage Function
Mirrors an image. The function can mirror horizontally and vertically.
C++ Syntax:
int FSDK_MirrorImage(HImage Image, bool
UseVerticalMirroringInsteadOfHorizontal);
Delphi Syntax:
function FSDK_MirrorImage(Image: HImage;
UseVerticalMirroringInsteadOfHorizontal: boolean): integer;
C# Syntax:
int FSDK.MirrorImage(UInt32 Image, bool
UseVerticalMirroringInsteadOfHorizontal);
VB Syntax:
Function FSDKVB_MirrorImage(ByVal Image As Long, ByVal
UseVerticalMirroringInsteadOfHorizontal As Boolean) As Long
Parameters:
Image – handle of the image to be mirrored.
UseVerticalMirroringInsteadOfHorizontal – sets the mirror direction.
TRUE: left-to-right swap;
FALSE: top-to-bottom swap;
Return Value:
FSDK_FreeImage Function
Frees the internal representation of an image.
C++ Syntax:
int FSDK_FreeImage(HImage Image);
Delphi Syntax:
function FSDK_FreeImage(Image: HImage): integer;
C# Syntax:
int FSDK.FreeImage(UInt32 Image);
VB Syntax:
Function FSDKVB_FreeImage(ByVal Image As Long) As Long

Parameters:
Image – handle of the image to be freed.
Return Value:
Face Detection
You can use the FSDK_DetectFace function to detect a frontal face in an image. The function
returns the position of the face in the image. The performance and reliability of face detection
is controlled by the FSDK_SetFaceDetectionParameters and
FSDK_SetFaceDetectionThreshold functions.
Typical parameters for face detection are:
 To detect faces from a webcam in real time, call:
FSDK_SetFaceDetectionParameters(false, false, 100);
 To reliably detect faces in digital camera photos, call
FSDK_SetFaceDetectionParameters(false, false, 500);
Data types
Luxand FaceSDK introduces the TFacePosition data type that stores the information about the
position of the face. The xc and yc fields specifies the X and Y coordinates of the center of
the face, w specifies the width of the face, and angle specifies the in-plane rotation angle of
the face in degrees.
C++ Declaration:
typedef struct {
int xc, yc, w;
double angle;
} TFacePosition;
C# Declaration:
public struct TFacePosition {
public int xc, yc, w;
public double angle;
}
Delphi Declaration:
TFacePosition = record
xc, yc, w: integer;
angle: double;
end;
PFacePosition = ^TFacePosition;

VB Declaration:
Type TFacePosition
xc As Long
yc As Long
w As Long
angle As Double
End Type
FSDK_DetectFace Function
Detects a frontal face in an image and stores information about the face position into the
TFacePosition structure.
C++ Syntax:
int FSDK_DetectFace(HImage Image, TFacePosition*
FacePosition);
Delphi Syntax:
function FSDK_DetectFace(Image: HImage; FacePosition:
PFacePosition): integer;
C# Syntax:
int FSDK.DetectFace(UInt32 Image, ref FSDK.TFacePosition
FacePosition);
VB Syntax:
Function FSDKVB_DetectFace(ByVal Image As Long, ByRef
FacePosition As TFacePosition) As Long
Parameters:
Image – handle of the image to detect the face in.
FacePosition – pointer to the TFacePosition structure to store information about the face
position.
Return Value:
Returns FSDKE_OK if successful. If a face is not found, the function returns the
FSDKE_FACE_NOT_FOUND code. If the input image is too small (less than 20x20 pixels),
the functions returns FSDKE_IMAGE_TOO_SMALL.
Example
int img1;
TFacePosition FacePosition;
FSDK_LoadImageFromFile(&img1, "test.jpg");
FSDK_DetectFace(img1, &FacePosition);
printf("face position: %d %d %d", FacePosition.xc,

FacePosition.yc, FacePosition.angle);

FSDK_DetectMultipleFaces Function
Detects multiple faces in an image.
C++ Syntax:
int FSDK_DetectMultipleFaces(HImage Image, int* DetectedCount,
TFacePosition* FaceArray, int MaxSize);
Delphi Syntax:
function FSDK_DetectMultipleFaces(Image: HImage;
DetectedCount: PInteger; FaceArray: PFacePositionArray;
MaxSize: integer): integer;
C# Syntax:
int FSDK.DetectMultipleFaces(UInt32 Image, ref int
DetectedCount, FSDK.TFacePosition[] FaceArray, int MaxSize);
VB Syntax:
Function FSDKVB_DetectMultipleFaces(ByVal Image As Long, ByRef
DetectedCount As Long, ByRef FaceArray As TFacePosition, ByVal
MaxSize As Long) As Long
Parameters:
Image – handle of the image to detect faces in.
DetectedCount – count of the faces found in the image.
FaceArray – pointer to the array of TFacePosition structure to store the information about
the detected faces.
MaxSize – size of the FaceArray buffer in bytes. The function will not store more than
MaxSize bytes in the buffer.
Return Value:
Returns FSDKE_OK if successful. If no faces are found, the function returns the
FSDKE_FACE_NOT_FOUND code. If the input image is too small (less than 20x20 pixels),
the functions returns FSDKE_IMAGE_TOO_SMALL.
Example
int img1;
int DetectedCount;
TFacePosition FaceArray[50];
FSDK_DetectMultipleFaces(img1, &DetectedCount , FaceArray,
sizeof(FaceArray));
for (i = 0; i < DetectedCount; i++) {

printf("face position: %d %d %d\n", FaceArray[i].xc,
FaceArray[i].yc, FaceArray[i].angle);
}

FSDK_SetFaceDetectionParameters Function
Allows setting a number of face detection parameters to control the performance and
reliability of face detector.
The function allows configuring the following parameters: HandleArbitraryRotations,
DetermineFaceRotationAngle and InternalResizeWidth.
HandleArbitraryRotations, DetermineFaceRotationAngle can be TRUE or FALSE, while
InternalResizeWidth is an integer.
C++ Syntax:
int FSDK_SetFaceDetectionParameters(bool
HandleArbitraryRotations, bool DetermineFaceRotationAngle, int
InternalResizeWidth);
Delphi Syntax:
function
FSDK_SetFaceDetectionParameters(HandleArbitraryRotations:
boolean; DetermineFaceRotationAngle: boolean;
InternalResizeWidth: integer): integer;
C# Syntax:
int FSDK.SetFaceDetectionParameters(bool
HandleArbitraryRotations, bool DetermineFaceRotationAngle, int
InternalResizeWidth);
VB Syntax:
Function FSDKVB_SetFaceDetectionParameters(ByVal
HandleArbitraryRotations As Boolean, ByVal
DetermineFaceRotationAngle As Boolean, ByVal
InternalResizeWidth As Long) As Long
Parameters:
HandleArbitraryRotations – extends default in-plane face rotation angle from -
15..15 degrees to -30..30 degrees.
TRUE: extended in-plane rotation support is enabled at the cost of detection speed (3 times
performance hit).
FALSE: default fast detection -15..15 degrees.
DetermineFaceRotationAngle – enables or disables the detection of in-plane face
rotation angle.
TRUE: detects in-plane rotation angle when detecting faces. The angle is recorded into the
Angle field of the TFacePosition structure (TFacePosition is a structure returned by
FSDK_DetectFace and FSDK_DetectMultipleFaces).
FALSE: disables the detection of rotation angle.
Note: Enabling face rotation angle detection slows down the detection process slightly. Set
this parameter to TRUE if you are planning to call FSDK_DetectFacialFeatures or
FSDK_DetectFacialFeaturesInRegion.

InternalResizeWidth – controls the detection speed by setting the size of the image
the detection functions will work with. Choose higher value to increase detection quality, or
lower value to improve the performance.
Note: By default, all images are internally resized to the width of 384 pixels. 384 pixels are a
reasonable compromise between performance and detection quality. While large images are
down-sized, the smaller ones are up-sized to the specified Resize Width in order to maintain
constant detection speed.
Choosing the right value for InternalResizeWidth
Choosing the correct value for the InternalResizeWidth parameter is essential for the correct
operation of face detection functions of the SDK. The face detection functions can only detect
faces as small as 20x20 pixels. Even if the source image is a large 1000x1000 dots one, the
face on that image can be as small as 100x100 pixels. If you set InternalResizeWidth to 200,
then the source image will be resized to 200x200 pixels, thus the face will only occupy 20x20
pixels. This is still enough for the SDK functions to work. If, however, you set
InternalResizeWidth to 100, then the original image will become 100x100 pixels, and the face
on it will only occupy 10x10 dots, which is NOT enough for the SDK functions to work with.
Be extra careful when changing the default value of InternalResizeWidth. For example,
webcam images can be usually detected with InternalResizeWidth set to 100, while images
from multi-megapixel digital cameras require values of at least 384 or 512 pixels to work
with.
Return Value:
FSDK_SetFaceDetectionThreshold Function
Sets a threshold value for face detection. The default value is 5.
The function allows adjusting the sensitivity of the detection. If the threshold value is set to a
higher value, the detector will only recognize faces with sharp, clearly defined details, thus
reducing the number of false positive detections. Setting the threshold lower allows detecting
more faces with less clearly defined features at the expense of increased number of false
positives.
C++ Syntax:
int FSDK_SetFaceDetectionThreshold(int Threshold);
Delphi Syntax:
function FSDK_SetFaceDetectionThreshold(Threshold: integer):
integer;
C# Syntax:
int FSDK.SetFaceDetectionThreshold(int Threshold);
VB Syntax:
Function FSDKVB_SetFaceDetectionThreshold(ByVal Threshold As
Long) As Long
Parameters:
Threshold – Threshold value.

Return Value:
Facial Feature Detection

FaceSDK provides the FSDK_DetectFacialFeatures function to detect facial features in an
image and the FSDK_DetectEyes function to detect just eye centers in an image. First, these
functions detect a frontal face in an image, and then detect its facial features or only eye
centers. The FSDK_DetectFacialFeaturesInRegion and FSDK_DetectEyesInRegion functions
do not perform the face detection step and detect facial features or eye centers in a region
returned by FSDK_DetectFace or FSDK_DetectMultipleFaces.
The FSDK_DetectEyes function works much faster than FSDK_DetectFacialFeatures and is
recommended for real-time applications.
The facial features are stored in the FSDK_Features data structure. FSDK_Features is an
array data type containing FSDK_FACIAL_FEATURE_COUNT points. The list of facial
features recognized by FaceSDK is available in the Detected Facial Features chapter.
Eye centers are saved to FSDK_Features[0] and FSDK_Features[1]. The FSDK_DetectEyes
and FSDK_DetectEyesInRegion functions do not change other elements of the
FSDK_Features array.
C++ Declaration:
typedef struct { int x,y; } TPoint;
typedef TPoint FSDK_Features [FSDK_FACIAL_FEATURE_COUNT];
C# Declaration:
public struct TPoint {
public int x, y;
}
Delphi Declaration:
TPoint = record
x, y: integer;
end;
FSDK_Features = array[0..FSDK_FACIAL_FEATURE_COUNT - 1] of
TPoint;
PFSDK_Features = ^FSDK_Features;
VB Declaration:
Type TPoint
x As Long
y As Long
End Type
FSDK_DetectFacialFeatures Function
Detects a frontal face in an image and detects its facial features.

C++ Syntax:
int FSDK_DetectFacialFeatures(HImage Image, FSDK_Features*
FacialFeatures);
Delphi Syntax:
function FSDK_DetectFacialFeatures(Image: HImage;
FacialFeatures: PFSDK_Features): integer;
C# Syntax:
int FSDK.DetectFacialFeatures(UInt32 Image, FSDK.TPoint[]
FacialFeatures);
VB Syntax:
Function FSDKVB_DetectFacialFeatures(ByVal Image As Long,
ByRef FacialFeatures As TPoint) As Long
Parameters:
Image – handle of the image facial features should be detected in.
FacialFeatures – pointer to the FSDK_Features array for receiving the detected facial
features.
Return Value:
Example
int img1;
FSDK_Features Features;
FSDK_DetectFacialFeatures(img1, Features);
printf("Left eye location: (%d, %d)\n",

Features[FSDKP_LEFT_EYE].x, Features[FSDKP_LEFT_EYE].y);
printf("Right eye location: (%d, %d)\n",
Features[FSDKP_RIGHT_EYE].y, Features[FSDKP_RIGHT_EYE].y);
FSDK_DetectFacialFeaturesInRegion Function
Detects facial features in an image region returned by FSDK_DetectFace or
FSDK_DetectMultipleFaces. This function can be useful if an approximate face size is
known, or to detect facial features of a specific face returned by FSDK_DetectMultipleFaces.
C++ Syntax:
int FSDK_DetectFacialFeaturesInRegion(HImage Image,
TFacePosition* FacePosition, FSDK_Features* FacialFeatures);

Delphi Syntax:
function FSDK_DetectFacialFeaturesInRegion(Image: HImage;
FacePosition: PFacePosition; FacialFeatures: PFSDK_Features):
integer;
C# Syntax:
int FSDK.DetectFacialFeaturesInRegion(UInt32 Image, ref
FSDK.TFacePosition FacePosition, FSDK.TPoint[]
FacialFeatures);
VB Syntax:
Function FSDKVB_DetectFacialFeaturesInRegion(ByVal Image As
Long, ByRef FacePosition As TFacePosition, ByRef
FacialFeatures As TPoint) As Long
Parameters:
Image – handle of the image facial features should be detected in.
FacePosition – pointer to the face position structure.
FacialFeatures – pointer to the FSDK_Features array for receiving the detected facial
features.
Return Value:
Example
int i, DetectedCount, img1;
FSDK_Features Features;
TFacePosition FaceArray[50];
FSDK_DetectMultipleFaces(img1, &DetectedCount , FaceArray,

sizeof(FaceArray));
for (i = 0; i < DetectedCount; i++) {

FSDK_DetectFacialFeaturesInRegion(img1, FaceArray[i],
Features);
printf("Left eye location: (%d, %d)\n",
Features[FSDKP_LEFT_EYE].x, Features[FSDKP_LEFT_EYE].y);
printf("Right eye location: (%d, %d)\n",
Features[FSDKP_RIGHT_EYE].x, Features[FSDKP_RIGHT_EYE].y);
}
FSDK_DetectEyes Function
Detects a frontal face in an image and detects its eye centers.

C++ Syntax:
int FSDK_DetectEyes(HImage Image, FSDK_Features*
FacialFeatures);
Delphi Syntax:
function FSDK_DetectEyes(Image: HImage; FacialFeatures:
PFSDK_Features): integer;
C# Syntax:
int FSDK.DetectEyes(UInt32 Image, FSDK.TPoint[]
FacialFeatures);
VB Syntax:
Function FSDKVB_DetectEyes (ByVal Image As Long, ByRef
FacialFeatures As TPoint) As Long
Parameters:
Image – handle of the image eye centers should be detected in.
FacialFeatures – pointer to the FSDK_Features array for receiving the detected eye
centers.
Return Value:
FSDK_DetectEyesInRegion Function
Detects eye centers in an image region returned by FSDK_DetectFace or
FSDK_DetectMultipleFaces.
C++ Syntax:
int FSDK_DetectEyesInRegion(HImage Image, TFacePosition*
FacePosition, FSDK_Features* FacialFeatures);
Delphi Syntax:
function FSDK_DetectEyesInRegion(Image: HImage; FacePosition:
PFacePosition; FacialFeatures: PFSDK_Features): integer;
C# Syntax:
int FSDK.DetectEyesInRegion(UInt32 Image, ref
FSDK.TFacePosition FacePosition, FSDK.TPoint[]
FacialFeatures);
VB Syntax:
Function FSDKVB_DetectEyesInRegion(ByVal Image As Long, ByRef
FacePosition As TFacePosition, ByRef FacialFeatures As TPoint)
As Long
Parameters:
Image – handle of the image eye centers should be detected in.

FacialFeatures – pointer to the FSDK_Features array for receiving the detected eye
centers.
Return Value:
Face Matching
Luxand FaceSDK provides the API to extract face templates and match them. A template
extracted from a face can be stored in a database and can then be used to match faces using
the FSDK_MatchFaces function.
The FSDK_MatchFaces function returns the facial similarity level. You may consider
similarity to be equal to the probability that templates belong to one and same person.
More precisely: if the access control system provides access to a person when similarity is
higher of threshold х, the possibility of providing erroneous access to another person is 1-х.
For example, if the decision to provide access to a person is based on the code
if (similarity > 0.99)
AllowAccess();
the possibility of erroneous access to another person is 0.01, or 1%.
A facial template is non-reversible, i.e. there is no way to create the original face image using
a template. To determine if the matched templates belong to the same person (with a specified
error possibility), you can compare the facial similarity value with a threshold calculated by
the FSDK_GetMatchingThresholdAtFAR or FSDK_GetMatchingThresholdAtFRR functions.
Please note: it is also recommended to retain the original face images and their templates in
the database. This is because future versions of Luxand FaceSDK may offer an improved
template extraction algorithm, together with changes to the template format.
A face template is stored in the FSDK_FaceTemplate data structure.
In .NET, there is no specific data type for a template. Instead, it is stored in an array of bytes
of FSDK.TemplateSize length. Below is an example of retrieving facial template in C#.
C# Example:
templateData = new byte[FSDK.TemplateSize];
FSDK.GetFaceTemplate(imageHandle, out templateData);
C++ Declaration:
typedef struct {
char ftemplate [16384];
} FSDK_FaceTemplate;
Delphi Declaration:
FSDK_FaceTemplate = record
Template: array[0.. 16384-1] of byte;
end;
PFSDK_FaceTemplate = ^FSDK_FaceTemplate;

FSDK_GetFaceTemplate
This function is used to extract a template from a facial image. The function first detects a
face, then detects its eye centers and extracts the template. If there is more than one face in the
image, the template is extracted for the face with the most clearly visible details. If there is no
clearly visible face, the function returns an error code. To set the threshold determining the
accepted quality for faces, use the FSDK_SetFaceDetectionThreshold function.
If the face position or its features or eye centers are known, it is more efficient to use the
FSDK_GetFaceTemplateInRegion or FSDK_GetFaceTemplateUsingEyes functions. To
extract the template for a specific face, use the FSDK_GetFaceTemplateInRegion function.
C++ Syntax:
int FSDK_GetFaceTemplate(HImage Image, FSDK_FaceTemplate*
FaceTemplate);
Delphi Syntax:
function FSDK_GetFaceTemplate(Image: HImage; FaceTemplate:
PFSDK_FaceTemplate): integer;
C# Syntax:
int FSDK.GetFaceTemplate(UInt32 Image, byte[] FaceTemplate);
VB Syntax:
Function FSDKVB_GetFaceTemplate(ByVal Image As Long, ByRef
FaceTemplate As Byte) As Long
Parameters:
Image – handle of the image from which to extract the face template.
FaceTemplate – pointer to the FSDK_FaceTemplate structure, used to receive the face
template.
Return Value:
Returns FSDKE_OK if successful. If no faces are found, or the quality of the image is not
sufficient, the function returns the FSDKE_FACE_NOT_FOUND code.
FSDK_GetFaceTemplateInRegion
Extracts a template for a face located in a specific region returned by FSDK_DetectFace or
FSDK_DetectMultipleFaces.
The function detects eye centers in a specific region and extracts a template. The face
detection stage is not performed. This function can be useful if an approximate face size and
position is known, or to process a specific face returned by FSDK_DetectMultipleFaces. The
function produces no error if the face is not clearly visible. This is because it assumes that if
face detection functions return a detected face position, the face is of sufficient quality.
If facial features or eye centers are known, it is more efficient to use
FSDK_GetFaceTemplateUsingEyes function.

C++ Syntax:
int FSDK_GetFaceTemplateInRegion(HImage Image, TFacePosition*
FacePosition, FSDK_FaceTemplate* FaceTemplate);
Delphi Syntax:
function FSDK_DetectFacialFeatures(Image: HImage;
FacePosition: PFacePosition; FaceTemplate:
PFSDK_FaceTemplate): integer;
C# Syntax:
int FSDK.GetFaceTemplateInRegion(UInt32 Image, ref
FSDK.TFacePosition FacePosition, byte[] FaceTemplate);
VB Syntax:
Function FSDKVB_GetFaceTemplateInRegion(ByVal Image As Long,
ByRef FacePosition As TFacePosition, ByRef FaceTemplate As
Byte) As Long
Parameters:
Image – handle of the image from which to extract the face template.
FaceTemplate – pointer to the FSDK_FaceTemplate structure, used to receive the face
template.
Return Value:
FSDK_GetFaceTemplateUsingEyes
Extracts a face template using the detected eye centers.
The function receives eye centers coordinates detected by the FSDK_DetectFacialFeatures,
FSDK_DetectFacialFeaturesInRegion, FSDK_DetectEyes or FSDK_DetectEyesInRegion
functions and extracts a face template. Face detection, facial feature detection, or eye centers
detection stage is not performed. This function can be useful when facial features or eye
centers for a specific face are already detected. The function produces no error if the face is
not clearly visible, since it assumes that if the face and its facial features or eye centers are
already detected, the face is of sufficient quality.
C++ Syntax:
int FSDK_GetFaceTemplateUsingEyes(HImage Image, FSDK_Features*
eyeCoords, FSDK_FaceTemplate* FaceTemplate);
Delphi Syntax:
function FSDK_ GetFaceTemplateUsingEyes(Image: HImage;
eyeCoords: PFSDK_Features; FaceTemplate: PFSDK_FaceTemplate):
integer;

C# Syntax:
int FSDK.GetFaceTemplateUsingEyes(UInt32 Image,
FSDK.TPoint[]eyeCoords, byte[] FaceTemplate);
VB Syntax:
Function FSDKVB_GetFaceTemplateUsingEyes(ByVal Image As Long,
ByRef eyeCoords As TPoint, ByRef FaceTemplate As Byte) As Long
Parameters:
Image – handle of the image to extract the face template from.
eyeCoords – pointer to the FSDK_Features array containing eye centers coordinates.
FaceTemplate – pointer to the FSDK_FaceTemplate structure for receiving the face
template.
Return Value:
FSDK_MatchFaces
Match two face templates. The returned value determines the similarity of the faces.
C++ Syntax:
int FSDK_MatchFaces(FSDK_FaceTemplate* FaceTemplate1,
FSDK_FaceTemplate* FaceTemplate2, float* Similarity);
Delphi Syntax:
function FSDK_MatchFaces(FaceTemplate1, FaceTemplate2:
PFSDK_FaceTemplate; Similarity: PSingle): integer;
C# Syntax:
int FSDK.MatchFaces(byte[] FaceTemplate1, byte[]
FaceTemplate2, ref float Similarity);
VB Syntax:
Function FSDKVB_MatchFaces(ByRef FaceTemplate1 As Byte, ByRef
FaceTemplate2 As Byte, ByRef Similarity As Single) As Long
Parameters:
FaceTemplate1 – pointer to the FSDK_FaceTemplate structure, using the first template
for comparison.
FaceTemplate2 – pointer to the FSDK_FaceTemplate structure, using the second
template for comparison.
Similarity – pointer to an integer value, used to receive the similarity of the face
templates.
Return Value:

FSDK_GetMatchingThresholdAtFAR
This function returns the threshold value for similarity to determine if two matched templates
belong to the same person at a given FAR (False Acceptance Rate) value. The FAR
determines the acceptable error rate when two different people’s templates are mistakenly
recognized as the same person. Decreasing FAR leads to an increase in FRR – i.e. with low
FAR it becomes more probable that two templates from the same person will be determined
as belonging to different people.
C++ Syntax:
int FSDK_GetMatchingThresholdAtFAR(float FARValue, float*
Threshold);
Delphi Syntax:
function FSDK_GetMatchingThresholdAtFAR(FARValue: single; var
Threshold: single): integer;
C# Syntax:
int FSDK.GetMatchingThresholdAtFAR(float FARValue, ref float
Threshold);
VB Syntax:
Function FSDKVB_GetMatchingThresholdAtFAR(ByVal FARValue As
Single, ByRef Threshold As Single) As Long
Parameters:
FARValue – the desired FAR value. Varies from 0.0 (means 0%) to 1.0 (means 100%).
Threshold – pointer to a float variable to store the calculated Threshold value.
Return Value:
Example
FSDK_FaceTemplate template1, template2;
float MatchingThreshold, Smilarity;

FSDK_GetMatchingThresholdAtFAR(0.02, &MatchingThreshold);
FSDK_GetFaceTemplate(img1, &template1);
FSDK_GetFaceTemplate(img2, &template2);
FSDK_MatchFaces(&template1, &template2, &Similarity);
if (Similarity > MatchingThreshold)
printf("Same Person\n");
else
printf("Different Person\n");
FSDK_GetMatchingThresholdAtFRR
This function returns the threshold value for similarity to determine if two matched templates
belong to the same person at a given FRR (False Rejection Rate) value. The FRR determines

the acceptable error rate when two templates of the same person are identified as belonging to
different people. Decreasing FRR leads to an increase in FAR – i.e. with low FRR it becomes
more probable that two different people’s templates will be recognized as the same person.
C++ Syntax:
int FSDK_GetMatchingThresholdAtFRR(float FRRValue, float*
Threshold);
Delphi Syntax:
function FSDK_GetMatchingThresholdAtFRR(FRRValue: single; var
Threshold: single): integer;
C# Syntax:
int FSDK.GetMatchingThresholdAtFRR(float FRRValue, ref float
Threshold);
VB Syntax:
Function FSDKVB_GetMatchingThresholdAtFRR(ByVal FRRValue As
Single, ByRef Threshold As Single) As Long
Parameters:
FRRValue – the desired FRR value. Varies from 0.0 (means 0%) to 1.0 (means 100%).
Threshold – pointer to a float variable, used to store the calculated Threshold value.
Return Value:
Working with Web Cameras

The library offers a set of functions to work with DirectShow-compatible video cameras. The
functions allow retrieval of single frames from camera one-by-one, storing them in HImage
descriptors. The application usually grabs frames in a loop, displaying each frame in its
window and performing manipulations with images (such as face detection).
The camera functions are available only for Windows 32/64 systems.
Data Types
There are data types to store the information about video formats. Note that the names of
video cameras are stored in wide char format (each char occupies two bytes).
C++ Declaration:
typedef struct {
int Width;
int Height;
int BPP;
} FSDK_VideoFormatInfo;

Delphi Declaration:
FSDK_VideoFormatInfo = record
Width: integer;
Height: integer;
BPP: integer;
end;
PFSDK_VideoFormatInfo = ^FSDK_VideoFormatInfo;
FSDK_VideoFormatInfoArray =
array[0..255] of FSDK_VideoFormatInfo;
PFSDK_VideoFormatInfoArray = ^FSDK_VideoFormatInfoArray;
FSDK_CameraList = array[0..255] of PWideChar;
PFSDK_CameraList = ^FSDK_CameraList;
VB Declaration:
Type FSDK_VideoFormatInfo
Width As Long
Height As Long
BPP As Long
End Type
FSDK_InitializeCapturing Function
The function initializes the capturing process (but it does not open any cameras). It should be
called in a single thread that works with cameras. Note that it initializes COM in the thread.
C++ Syntax:
int FSDK_InitializeCapturing(void);
Delphi Syntax:
function FSDK_InitializeCapturing: integer;
C# Syntax:
int FSDKcam.InitializeCapturing();
VB Syntax:
Function FSDKVB_InitializeCapturing() As Long
Return Value:
FSDK_FinalizeCapturing Function
The function finalizes (also finalizing COM) the capturing process, initialized by the
FSDK_InitializeCapturing function.
C++ Syntax:
int FSDK_FinalizeCapturing(void);

Delphi Syntax:
function FSDK_FinalizeCapturing: integer;
C# Syntax:
int FSDKcam.FinalizeCapturing();
VB Syntax:
Function FSDKVB_FinalizeCapturing() As Long
Return Value:
FSDK_SetCameraNaming Function
Sets the retrieval format for the FSDK_GetCameraList function. Depending on the value of
the argument, either camera names (by default), or their unique IDs (Device Path) are
returned. The use of Device Path may be necessary if the system has several cameras of the
same manufacturer that have the same name.
C++ Syntax:
int FSDK_SetCameraNaming(bool UseDevicePathAsName);
Delphi Syntax:
function FSDK_SetCameraNaming(UseDevicePathAsName: boolean):
integer;
C# Syntax:
int FSDKcam.SetCameraNaming(bool UseDevicePathAsName)
VB Syntax:
Function FSDKVB_SetCameraNaming(ByVal UseDevicePathAsName As
Boolean) As Long
Parameters:
UseDevicePathAsName – sets a retrieval format for the FSDK_GetCameraList function.
FALSE: FSDK_GetCameraList returns the list of names for cameras installed in the system;
TRUE: FSDK_GetCameraList returns the list of unique device paths of these cameras.
Return Value:
FSDK_GetCameraList Function
The function retrieves the list of cameras available in the system. The name of each camera is
stored in wide char format (each character occupies two bytes).
C++ Syntax:
int FSDK_GetCameraList(wchar_t*** CameraList, int*
CameraCount);

Delphi Syntax:
function FSDK_GetCameraList(CameraList: PWideChar; var
CameraCount: integer): integer;
C# Syntax:
int FSDKcam.GetCameraList(out string[] CameraList, out int
CameraCount)
VB Syntax:
Function FSDKVB_GetCameraList(ByRef CameraList As Variant,
ByRef CameraCount As Long) As Long
Parameters:
CameraList – pointer to wchar_t** variable to store the camera list.
CameraCount – pointer to integer variable to store the count of cameras in the system.
Return Value:
Example
wchar_t** CameraList;
int CameraCount;
FSDK_InitializeCapturing();
if (FSDK_GetCameraList(&CameraList, &CameraCount)!=FSDKE_OK)
for (int i=0; i<CameraCount; i++)
wprintf(L"camera: %s\n", CameraList[i]);
printf("%d camera(s) found.\n", CameraCount);
FSDK_FinalizeCapturing();
FSDK_GetVideoFormatList Function
The function returns the list of video formats supported by a given camera.
C++ Syntax:
int FSDK_GetVideoFormatList(wchar_t* CameraName,
FSDK_VideoFormatInfo** VideoFormatList, int*
VideoFormatCount);
Delphi Syntax:
function FSDK_GetVideoFormatList(CameraName: PWideChar;
VideoFormatList: PFSDK_VideoFormatInfo; var VideoFormatCount:
integer): integer;
C# Syntax:
int FSDKcam.GetVideoFormatList(string CameraName, out
FSDKcam.VideoFormatInfo[] VideoFormatList, out int
VideoFormatCount)

VB Syntax:
Function FSDKVB_GetVideoFormatList(ByVal CameraName As String,
ByRef VideoFormatList As Variant, ByRef VideoFormatCount As
Long) As Long
Parameters:
CameraName – pointer to name of desired video camera.
VideoFormatList – pointer to FSDK_VideoFormatInfo* variable to store the list of
video formats.
VideoFormatCount – pointer to integer variable to store the count of video formats.
Return Value:
FSDK_SetVideoFormat Function
The function sets the format of camera output.
C++ Syntax:
int FSDK_SetVideoFormat(wchar_t* CameraName,
FSDK_VideoFormatInfo VideoFormat);
Delphi Syntax:
function FSDK_SetVideoFormat(CameraName: PWideChar;
VideoFormat: FSDK_VideoFormatInfo): integer;
C# Syntax:
int FSDKcam.SetVideoFormat(string CameraName,
FSDKcam.VideoFormatInfo VideoFormat);
VB Syntax:
Function FSDKVB_SetVideoFormat(ByVal CameraName As String,
ByRef VideoFormat As FSDK_VideoFormatInfo) As Long
Parameters:
CameraName – pointer to name of desired video camera.
VideoFormat – desired video format.
Return Value:
Example
wchar_t** CameraList;
int CameraCount;
FSDK_VideoFormatInfo* VideoFormatList;
int VideoFormatCount;
FSDK_GetCameraList(&CameraList, &CameraCount);

FSDK_GetVideoFormatList(CameraList[0], &VideoFormatList,
&VideoFormatCount);
FSDK_SetVideoFormat(CameraList[0], VideoFormatList[0]);
FSDK_OpenVideoCamera Function
The function opens the camera of a given name and returns its handle.
C++ Syntax:
int FSDK_OpenVideoCamera(wchar_t* CameraName, int*
CameraHandle);
Delphi Syntax:
function FSDK_OpenVideoCamera(CameraName: PWideChar; var
CameraHandle: integer): integer;
C# Syntax:
int FSDKcam.OpenVideoCamera(string CameraName, ref int
CameraHandle);
VB Syntax:
Function FSDKVB_OpenVideoCamera(ByVal CameraName As String,
ByRef CameraHandle As Long) As Long
Parameters:
CameraName – pointer to name of video camera to open.
CameraHandle – pointer to integer variable to store the opened camera handle.
Return Value:
FSDK_GrabFrame Function
Retrieves the current frame from a video camera and stores it in the created HImage handle. If
a camera returns an image, mirrored horizontally (it depends on camera settings), then you
can mirror it by using FSDK_MirrorImage.
C++ Syntax:
int FSDK_GrabFrame(int CameraHandle, HImage* Image);
Delphi Syntax:
function FSDK_GrabFrame(CameraHandle: integer; var Image:
PHImage): integer;
C# Syntax:
int FSDKcam.GrabFrame(int CameraHandle, ref UInt32 Image);
VB Syntax:
Function FSDKVB_GrabFrame(ByVal CameraHandle As Long, ByRef
Image As Long) As Long

Parameters:
CameraHandle – handle of the opened camera to grab frame.
Image – pointer to HImage variable to store the frame. Note that the created HImage handle
should be deleted once it is no longer needed using the FSDK_FreeImage function.
Return Value:
FSDK_CloseVideoCamera Function
The function closes the camera, opened by the FSDK_OpenVideoCamera function.
C++ Syntax:
int FSDK_CloseVideoCamera(int CameraHandle);
Delphi Syntax:
function FSDK_CloseVideoCamera(CameraHandle: integer):
integer;
C# Syntax:
int FSDKcam.CloseVideoCamera(int CameraHandle);
VB Syntax:
Function FSDKVB_CloseVideoCamera(ByVal CameraHandle As Long)
As Long
Parameters:
CameraHandle – handle of opened video camera to close.
Return Value:
Thread Safety
This chapter describes the use of FaceSDK in applications, processing multiple threads. If
your program is executed in a single thread (by default it happens in almost all environments),
you can skip this chapter.
Most of FaceSDK functions are safe for multithreaded operations except webcam-related
functions. It is strongly recommended to use these functions only within one thread. The
functions not guaranteed to be thread-safe are:
FSDK_Initialize,
FSDK_Finalize,
FSDK_ActivateLibrary,
FSDK_GetLicenseInfo,
FSDK_GetHardware_ID,
FSDK_InitializeCapturing,
FSDK_FinalizeCapturing,
FSDK_SetCameraNaming,

FSDK_GetCameraList,
FSDK_GetVideoFormatList,
FSDK_SetVideoFormat,
FSDK_OpenVideoCamera,
FSDK_CloseVideoCamera,
FSDK_GrabFrame.
The following functions set global parameters that have effect on each thread:
FSDK_SetFaceDetectionParameters,
FSDK_SetFaceDetectionThreshold,
FSDK_SetJpegCompressionQuality.
Note that HImage is safe only for multiple simultaneous reads or single write. Do not read
from (e.g. with FSDK_DetectFace) and write to (e.g. with FSDK_FreeImage) the same
HImage handle at one time.
Migration from FaceSDK 2.0

This chapter tells about changes in FaceSDK 3.0 as compared to FaceSDK 2.0. There are also
recommendations on how to migrate from version 2.0 to version 3.0.
1. As version 3.0 has introduced a new enhanced face recognition algorithm, the format
of a template changed too. Now it’s enough to detect only eye centers, rather than all
features to build a template. If your application used to detect facial features and then
created a template using detected features, now the feature detection stage can be
skipped or replaced by detection of eye centers (i.e. FSDK_DetectFacialFeatures can
be replaced by FSDK_DetectEyes). The size of a template changed too. In version 2.0,
a template was 92480 bytes, while in version 3.0, it is 16384 bytes. If your application
used a database of saved templates, you will discover that in FaceSDK 3.0 it is
necessary to recreate these templates using source images.
2. New version introduces new functions for quick detection of eye centers –
FSDK_DetectEyes and FSDK_DetectEyesInRegion. These functions are
recommended for use if it is necessary to detect eye centers in real time.
3. The meaning of similarity returned by FSDK_MatchFaces function has changed. Now
similarity is approximately equal to the probability that templates belong to one and
the same person. More information on this topic can be found in Face Matching
chapter.
4. New FSDK_SetCameraNaming function has been implemented. Using this function,
it’s possible to specify what the FSDK_GetCameraList function will return – list of
camera names available in the system, or list of unique device paths of these cameras.
(It may be required if two similar webcams of the same manufacturer are plugged to
the computer.)
5. Camera management functions are included into facesdk.dll. If you used camera
management in your applications, now you can delete facesdkcam.dll and header files
related to facesdkcam.
6. .NET wrapper does not require facesdk.dll. Besides, camera management functions
are also included into FaceSDK.NET.dll (but they are still located in class FSDKcam).
Now the wrapper is located in the directories \bin\win32\ for 32-bit applications
and \bin\win64\ for 64-bit applications.

7. The following functions have been removed from the library and will not be
supported: FSDK_LocateFace, FSDK_LocateFacialFeatures,
FSDK_ExtractFaceImage.
Deprecated Functions
The following functions are deprecated and will not be supported in the future Luxand
FaceSDK versions:
FSDK_GetFaceTemplateUsingFeatures
Error Codes
The FaceSDK library defines the following error codes:
Error Name Value

FSDKE_OK 0
FSDKE_FAILED –1
FSDKE_NOT_ACTIVATED –2
FSDKE_OUT_OF_MEMORY –3
FSDKE_INVALID_ARGUMENT –4
FSDKE_IO_ERROR –5
FSDKE_IMAGE_TOO_SMALL –6
FSDKE_FACE_NOT_FOUND –7
FSDKE_INSUFFICIENT_BUFFER_SIZE –8
FSDKE_UNSUPPORTED_IMAGE_EXTENSION –9
FSDKE_CANNOT_OPEN_FILE –10
FSDKE_CANNOT_CREATE_FILE –11
FSDKE_BAD_FILE_FORMAT –12
FSDKE_FILE_NOT_FOUND –13
Detected Facial Features

Luxand FaceSDK recognizes 40 facial feature points. These facial feature points can be
accessed by their names in the FSDK_Features array.
Facial Feature Name Value

FSDKP_LEFT_EYE 0

FSDKP_RIGHT_EYE 1
FSDKP_LEFT_EYE_INNER_CORNER 24
FSDKP_LEFT_EYE_OUTER_CORNER 23
FSDKP_RIGHT_EYE_INNER_CORNER 25
FSDKP_RIGHT_EYE_OUTER_CORNER 26
FSDKP_LEFT_EYEBROW_INNER_CORNER 17
FSDKP_LEFT_EYEBROW_MIDDLE 34
FSDKP_LEFT_EYEBROW_OUTER_CORNER 16
FSDKP_RIGHT_EYEBROW_INNER_CORNER 18
FSDKP_RIGHT_EYEBROW_MIDDLE 35
FSDKP_RIGHT_EYEBROW_OUTER_CORNER 19
FSDKP_NOSE_TIP 2
FSDKP_NOSE_BRIDGE 22
FSDKP_NOSE_LEFT_WING 27
FSDKP_NOSE_RIGHT_WING 28
FSDKP_MOUTH_RIGHT_CORNER 3
FSDKP_MOUTH_LEFT_CORNER 4
FSDKP_MOUTH_TOP 20
FSDKP_MOUTH_BOTTOM 21
FSDKP_MOUTH_LEFT_TOP 36
FSDKP_MOUTH_RIGHT_TOP 37
FSDKP_MOUTH_LEFT_BOTTOM 38
FSDKP_MOUTH_RIGHT_BOTTOM 39
FSDKP_CHIN_BOTTOM 29
FSDKP_CHIN_LEFT 14
FSDKP_CHIN_RIGHT 15
FSDKP_FACE_CONTOUR1 12


Library Information
The FaceSDK library uses libjpeg © IJG; libpng © Glenn Randers-Pehrson; easybmp © The
EasyBMP Project (http://easybmp.sourceforge.net); RSA Data Security, Inc. MD5 Message-
Digest Algorithm.

Face Detection Algorithm

Uploaded by

Document Informationclick to expand document informationFace detection

Document Informationclick to expand document information

Copyright:

Available Formats

Face Detection Algorithm

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Face Detection Algorithm

Uploaded by

Copyright:

Available Formats

Luxand, Inc.

Luxand FaceSDK 3.0

Copyright © 2005–2010 Luxand, Inc. http://www.luxand.com 1

Copyright © 2005–2010 Luxand, Inc. http://www.luxand.com 2

Copyright © 2005–2010 Luxand, Inc. http://www.luxand.com 3

Copyright © 2005–2010 Luxand, Inc. http://www.luxand.com 4

Facial Feature Detection

Eye Centers Detection

FaceSDK is installed to the C:\Program Files\Luxand\FaceSDK directory by

Copyright © 2005–2010 Luxand, Inc. http://www.luxand.com 5

bin\ FaceSDK binary files

bin\linux_x86 FaceSDK Linux 32-bit binaries

bin\linux_x86_64 FaceSDK Linux 64-bit binaries

bin\osx_x86_64 FaceSDK Mac OS X 64-bit binaries

bin\win64 FaceSDK Windows 64-bit binaries and stub library files

include\ Header files

samples\ Sample applications

Copyright © 2005–2010 Luxand, Inc. http://www.luxand.com 6

Using FaceSDK with Programming Languages

Using with .NET (C# and VB)

Copyright © 2005–2010 Luxand, Inc. http://www.luxand.com 7

Using with C/C++

Using with Delphi

Using with Visual Basic 6.0

Copyright © 2005–2010 Luxand, Inc. http://www.luxand.com 8

bin\win32\facesdk.dll (for 32-bit systems)

Using Luxand FaceSDK

Copyright © 2005–2010 Luxand, Inc. http://www.luxand.com 9

Copyright © 2005–2010 Luxand, Inc. http://www.luxand.com 10

Copyright © 2005–2010 Luxand, Inc. http://www.luxand.com 11

Working with Images

Copyright © 2005–2010 Luxand, Inc. http://www.luxand.com 12

Copyright © 2005–2010 Luxand, Inc. http://www.luxand.com 13

Mode name Meaning

Copyright © 2005–2010 Luxand, Inc. http://www.luxand.com 14

Copyright © 2005–2010 Luxand, Inc. http://www.luxand.com 15

Copyright © 2005–2010 Luxand, Inc. http://www.luxand.com 16

Copyright © 2005–2010 Luxand, Inc. http://www.luxand.com 17

Copyright © 2005–2010 Luxand, Inc. http://www.luxand.com 18

Copyright © 2005–2010 Luxand, Inc. http://www.luxand.com 19

Copyright © 2005–2010 Luxand, Inc. http://www.luxand.com 20

printf("face position: %d %d %d", FacePosition.xc,

Copyright © 2005–2010 Luxand, Inc. http://www.luxand.com 21

for (i = 0; i < DetectedCount; i++) {

Copyright © 2005–2010 Luxand, Inc. http://www.luxand.com 22

Copyright © 2005–2010 Luxand, Inc. http://www.luxand.com 23

Copyright © 2005–2010 Luxand, Inc. http://www.luxand.com 24

Facial Feature Detection

Copyright © 2005–2010 Luxand, Inc. http://www.luxand.com 25

printf("Left eye location: (%d, %d)\n",

Copyright © 2005–2010 Luxand, Inc. http://www.luxand.com 26

FSDK_DetectMultipleFaces(img1, &DetectedCount , FaceArray,

for (i = 0; i < DetectedCount; i++) {

Copyright © 2005–2010 Luxand, Inc. http://www.luxand.com 27

Copyright © 2005–2010 Luxand, Inc. http://www.luxand.com 28

Copyright © 2005–2010 Luxand, Inc. http://www.luxand.com 29

Copyright © 2005–2010 Luxand, Inc. http://www.luxand.com 30