This article is written as a C# Getting Started Guide in case if you ever wish to integrate a CMITECH ES-45 Iris Recognition Terminal into your .Net application.
Table Of Contents
Background
Biometric Devices are being used extensively in many corporations through out the world these days. They are widely used in various fields like social insurance, public security, time attendance, fingerprint encryption, embedded systems and many others as a form of user authentication, verification and attendance.
The CMITECH EF-45 is a similar type of biometric device, which supports iris recognition including facial recognition.
This blog intends to help C# developers to successfully integrate an ES-45 Iris terminal into their application and provide basic guidelines on how the enrollment and verification works from a developers perspective.
Device Specifications
EF-45 is a dual iris recognition system which employs “deep learning” face detection algorithm for faster and smoother operation. The system has an extended capture range of 35-45 cm which captures high quality face images simultaneously along with iris image.
Model : CMITECH EF-45
CPU : ARM Cortex A9 quad-core processor
Memory : 8GB flash + 5GB RAM
Log Capacity : 2,000,000
Iris Capacity : 10,000
Network Interface : 10/100 Base-T Ethernet (RJ45 connector)
Optional : Wifi 802.11bgn
Iris Recognition
The iris is a flat, colored (typically blue, green or brown) area, ring-shaped membrane behind the cornea of the eye, with an adjustable circular opening (pupil) in the center. Its structure remains stable throughout life.
Due to its stability and uniqueness with each individual, it serves as a good way to establish a persons identity.
The iris recognition utilizes this unique feature of the eye as a way to identify and distinguish individuals via various advanced pattern recognition techniques based on high-resolution and distortion-free images of the irises.
Setting up the Device
The C# based SDK that comes with the EF-45 device enables a Windows PC to interacts with the device via an Ethernet cable using C# APIs.
Primary Setup
The primary setup that needs to be done in order to communicate with the device would be to simply connect with the device via an Ethernet cable and assign an IP address to the device.
The IP address can be setup from Settings ⇒ Network ⇒ TCP/IP.
Application Setup
The main library of the CSharp SDK is CMITech.UMXClient.dll.
You need to start by adding a reference to this dll in your Visual Studio .Net project . To add a reference in your project :
Right click your project in VS ⇒ Add ⇒ Reference ⇒ Browse ⇒ Select ‘CMITech.UMXClient.dll‘.
This article focuses on demonstrating how to properly use the CMITech.UMXClient.dll to interact with the device via a .Net application.
Lets start ….
The Basic Workflow
The overall work to be done via the C# SDK can be summarized into a few steps that are simplified by the following image:
Using The SDK
The implementation of the SDK has been broken down into small code snippets for a better understanding. The interfaces can be accessed by including the CMITech.UMXClient namespace which is provided by the CMITech.UMXClient.dll that we had referenced previously.
Intialize and Connect
This is the point where we try to establish a connection with the device and initialize all the necessary events.
The Client mainly requires an IP address and an optional serial number. The serial number can be made a better use of if you are working with multiple EF-45 devices and you want to recognize each device properly.
public async void Connect()
{
string ipAddress = "192.168.1.32";
string serialNumber = string.Empty;
bool checkSerialEnabled = false;
CMITech.UMXClient.Client _client = new CMITech.UMXClient.Client(ipAddress, serialNumber, checkSerialEnabled);
InitializeEvents();
// Connecting for the first time
if (_client == null && !_client.IsConnected())
{
System.Threading.Tasks.Task<bool> connectionTask = System.Threading.Tasks.Task.Run(() => _client.Connect());
bool isConnected = await connectionTask;
if (isConnected)
{
// Get Information from device
string deviceVersion = _client.GetVersion();
// You can now successfully interact with the device
// Get current devic mode
CMITech.UMXClient.Client.UMXMode mode = _client.GetMode();
}
}
}
Force Connection
In case, If the device was previously initialized and we cannot somehow connect to the device due to various factors like the device currently being in use, we might have to force a connection to the device.
public async void ForceConnect()
{
DeInitializeEvents();
// If the device was initialized, but still can`t make a connection
if (_client != null && !_client.IsConnected())
{
if (_client.StealConnect())
{
InitializeEvents();
// Get current devic mode
CMITech.UMXClient.Client.UMXMode mode = _client.GetMode();
}
}
}
The Device Events
private void InitializeEvents()
{
_client.CaptureCompleted += new Client.CaptureCompletedEventHandler(_client_CaptureCompleted);
_client.CaptureTimedOut += new Client.CaptureTimedOutEventHandler(_client_CaptureTimedOut);
_client.CaptureError += new Client.CaptureErrorEventHandler(_client_CaptureError);
_client.MatchLog += new Client.MatchLogEventHandler(_client_MatchLog);
_client.MatchData += new Client.MatchDataEventHandler(_client_MatchData);
_client.PreviewImage += new Client.PreviewImageEventHandler(_client_PreviewImage);
}
Switch Modes
The EF-45 device can be set to work in two modes –
- Slave mode / Enrollment mode
- Master mode / Recognition mode
Switching between the enrollment and recognition mode is all about setting the device modes to either Recog or Slave.
private void SwitchDeviceMode()
{
Client.UMXMode previousMode = _client.GetMode();
switch (previousMode)
{
case Client.UMXMode.Slave:
_client.SetMode(Client.UMXMode.Recog);
break;
case Client.UMXMode.Recog:
_client.SetMode(Client.UMXMode.Slave);
break;
}
ResetForNewConnection();
}
The Enroll Mode
- Start Capturing
- Acquire biometric template on Capture Complete
- Stop Capturing
- Enroll the User along with user information
private async void StartEnrollment()
{
double timeOut = 60;
bool faceMode = false;
bool glassesMode = false;
bool bothEyeMode = false;
bool eitherEyeMode = true;
bool faceFullResolution = false;
Task captureTask = Task.Run(() =>
{
_client.StartCapture(timeOut, faceMode, glassesMode, bothEyeMode, eitherEyeMode, faceFullResolution);
});
await captureTask;
}
private void _client_CaptureCompleted(CaptureCompletedEventArgs captureCompletedEventArgs)
{
if (captureCompletedEventArgs.Completed)
{
// Obtain the users template
EnrolTemplate _currentEnrolTemplate= captureCompletedEventArgs.EnrolTemplate;
}
else
{
// Capture failed
}
}
private void StopEnrollment()
{
_client.StopCapture();
}
public void AddUser()
{
string userID = "11111111";
string firstName = "John";
string lastName = "Doe";
Subject subject = new Subject();
subject.AccessAllowed = true;
subject.FirstName = firstName;
subject.LastName = lastName; // Required
subject.EnrolTemplate = _currentEnrolTemplate;
subject.SubjectUID = userID;
subject.WiegandSite = -1;
subject.WiegandFacility = -1;
subject.WiegandCode = -1;
_client.AddSubject(subject);
UserInfo userInfo = new UserInfo();
userInfo.UUID = userID;
userInfo.Card = ""; /* Card CSN : 9A 99 1F 3E ...*/
userInfo.Pin = "";
userInfo.Admin = 0;
userInfo.GroupIndex = 0;
userInfo.ByPassCard = 0;
userInfo.Indivisual = 0;
_client.AddUserInfo(userInfo);
}
Saving The Template To Database
The enroll template is a combination of the users left and right eyes biometric data in the form of bite arrays as shown below :
public class EnrolTemplate
{
public EnrolTemplate(byte[] leftEyeTemplate, byte[] rightEyeTemplate);
public byte[] LeftEyeTemplate { get; set; }
public byte[] RightEyeTemplate { get; set; }
}
Saving the template to the database, retrieve it and upload it to the device again can be quite troublesome if the biometric data is in such a form.
Here is a simple approach that I have implemented to encode and decode the template to perform back and forth transmission from the device to some other source.
public static string PreText = "UMXEF45";
public static string Splitter = "#######################";
// Encoding the template
public static string EnrollTemplateToEncodedString(EnrolTemplate enrollTemplate)
{
string data1 = Convert.ToBase64String(enrollTemplate.LeftEyeTemplate);
string data2 = Convert.ToBase64String(enrollTemplate.RightEyeTemplate);
StringBuilder sb = new StringBuilder();
sb.Append(PreText);
sb.Append(Splitter);
sb.Append(data1);
sb.Append(Splitter);
sb.Append(data2);
return sb.ToString();
}
// Decoding the template
public static EnrolTemplate EncodedStringToEnrollTemplate(string data)
{
try
{
string encodedString = data.Trim();
if (!string.IsNullOrEmpty(encodedString))
{
string splitter = Splitter;
string[] content = data.Split(new string[] { Splitter }, StringSplitOptions.None);
if (content != null)
{
if (content[0] != PreText) throw new Exception("Invalid template.");
byte[] leftEyeTemplate = Convert.FromBase64String(content[1]);
byte[] rightEyeTemplate = Convert.FromBase64String(content[2]);
return new EnrolTemplate(leftEyeTemplate, rightEyeTemplate);
}
else return null;
}
else
return null;
}
catch
{
return null;
}
}
The PreText is a unique ID to identify that the given template is an EF-45 template and not some other template like a fingerprint or facial recognition which I had in my case.
Head over to GitHub and grab a copy if you wish to explore the full code.
Here is a quick demo if you want to see if in action.
Go Beyond the frontiers of yourself. Peace !!!
can i get code for iris recognition