private bool ExtractTemplate(byte[] Template, out int TemplateSize)
{
UFS_STATUS ufs_res;
int EnrollQuality;
m_Scanner.ClearCaptureImageBuffer();
//tbxMessage.AppendText("Place Finger\r\n");
TemplateSize = 0;
while (true)
{
ufs_res = m_Scanner.CaptureSingleImage();
if (ufs_res != UFS_STATUS.OK)
{
UFScanner.GetErrorString(ufs_res, out m_strError);
//tbxMessage.AppendText("UFScanner CaptureSingleImage: " + m_strError + "\r\n");
return(false);
}
ufs_res = m_Scanner.Extract(Template, out TemplateSize, out EnrollQuality);
if (ufs_res == UFS_STATUS.OK)
{
//tbxMessage="UFScanner Extract: OK\r\n");
break;
}
else
{
UFScanner.GetErrorString(ufs_res, out m_strError);
// tbxMessage="UFScanner Extract: " + m_strError + "\r\n");
}
}
return(true);
}
private void btnUninit_Click(object sender, EventArgs e)
{
//=========================================================================//
// Uninit Scanners
//=========================================================================//
UFS_STATUS ufs_res;
Cursor.Current = Cursors.WaitCursor;
ufs_res = m_ScannerManager.Uninit();
Cursor.Current = this.Cursor;
if (ufs_res == UFS_STATUS.OK)
{
tbxMessage.AppendText("UFScanner Uninit: OK\r\n");
m_ScannerManager.ScannerEvent -= ScannerEvent;
lbScannerList.Items.Clear();
}
else
{
UFScanner.GetErrorString(ufs_res, out m_strError);
tbxMessage.AppendText("UFScanner Uninit: " + m_strError + "\r\n");
}
pbImageFrame.Image = null;
//=========================================================================//
}
private void Init()
{
//=========================================================================//
// Inicializa algoritmo
//=========================================================================//
UFS_STATUS ufs_res;
int nScannerNumber;
Cursor.Current = Cursors.WaitCursor;
ufs_res = m_ScannerManager.Init();
Cursor.Current = this.Cursor;
if (ufs_res == UFS_STATUS.OK)
{
lbMensagem.Text = "Inicialização de algoritmo: OK";
}
else
{
UFScanner.GetErrorString(ufs_res, out m_strError);
lbMensagem.Text = m_strError;
return;
}
//m_ScannerManager.ScannerEvent += new UFS_SCANNER_PROC(ScannerEvent);
nScannerNumber = m_ScannerManager.Scanners.Count;
m_template1 = null;
m_template2 = null;
m_template3 = null;
}
public void InicializaBiometria()
{
groupBox2.Enabled = true;
//=========================================================================//
// Inicializa algoritmo
//=========================================================================//
UFS_STATUS ufs_res;
int nScannerNumber;
Cursor.Current = Cursors.WaitCursor;
ufs_res = m_ScannerManager.Init();
Cursor.Current = this.Cursor;
if (ufs_res == UFS_STATUS.OK)
{
toolStripStatusLabel1.Text = "Inicialização de algoritmo: OK";
}
else
{
UFScanner.GetErrorString(ufs_res, out m_strError);
toolStripStatusLabel1.Text = m_strError;
return;
}
m_ScannerManager.ScannerEvent += new UFS_SCANNER_PROC(ScannerEvent);
nScannerNumber = m_ScannerManager.Scanners.Count;
toolStripStatusLabel1.Text = "Algoritmo inicializado";
groupBox2.Enabled = true;
m_template1 = null;
m_template2 = null;
m_template3 = null;
}
private void btnCaptureSingle_Click(object sender, EventArgs e)
{
UFScanner Scanner;
UFS_STATUS ufs_res;
if (!GetGetCurrentScanner(out Scanner))
{
return;
}
Cursor.Current = Cursors.WaitCursor;
ufs_res = Scanner.CaptureSingleImage();
Cursor.Current = this.Cursor;
if (ufs_res == UFS_STATUS.OK)
{
tbxMessage.AppendText("UFScanner CaptureSingleImage: OK\r\n");
DrawCapturedImage(Scanner);
}
else
{
UFScanner.GetErrorString(ufs_res, out m_strError);
tbxMessage.AppendText("UFScanner CaptureSingleImage: " + m_strError + "\r\n");
}
}
private void btnExtract_Click(object sender, EventArgs e)
{
UFScanner Scanner;
UFS_STATUS ufs_res;
if (!GetGetCurrentScanner(out Scanner))
{
return;
}
Scanner.TemplateSize = MAX_TEMPLATE_SIZE;
Scanner.DetectCore = cbDetectCore.Checked;
byte[] Template = new byte[MAX_TEMPLATE_SIZE];
int TemplateSize;
int EnrollQuality;
Cursor.Current = Cursors.WaitCursor;
ufs_res = Scanner.Extract(Template, out TemplateSize, out EnrollQuality);
Cursor.Current = this.Cursor;
if (ufs_res == UFS_STATUS.OK)
{
tbxMessage.AppendText("UFScanner Extract: OK\r\n");
}
else
{
UFScanner.GetErrorString(ufs_res, out m_strError);
tbxMessage.AppendText("UFScanner Extract: " + m_strError + "\r\n");
}
}
private void CaptureTemplate(object sender, RoutedEventArgs e)
{
try
{
UFScanner scanner = GetSelectedScanner();
if (scanner == null)
{
return;
}
this.Cursor = Cursors.Wait;
scanner.ClearCaptureImageBuffer();
UFS_STATUS ufsRes = scanner.CaptureSingleImage();
if (ufsRes == UFS_STATUS.OK)
{
UFS_STATUS capturingStatus = ExtractTemplate(scanner);
}
else
{
string error = string.Empty;
UFScanner.GetErrorString(ufsRes, out error);
WriteLog(error, false);
}
}
catch (Exception exc)
{
WriteLog(exc.Message, true);
}
this.Cursor = Cursors.Arrow;
}
private void InitializeScanners()
{
try
{
WriteLog("Initializing scanners");
UFS_STATUS ufsRes = _scannerManager.Init();
if (ufsRes == UFS_STATUS.OK)
{
}
else
{
string error = string.Empty;
UFScanner.GetErrorString(ufsRes, out error);
WriteLog(error, false);
//init failed probably problem with license
btnCapture.IsEnabled = false;
return;
}
btnCapture.IsEnabled = UpdateScannersList() > 0;
}
catch (Exception ex)
{
WriteLog(ex.Message, true);
}
}
private void btnInit_Click(object sender, EventArgs e)
{
//=========================================================================//
// Initilize scanners
//=========================================================================//
UFS_STATUS ufs_res;
int nScannerNumber;
Cursor.Current = Cursors.WaitCursor;
ufs_res = m_ScannerManager.Init();
if (ufs_res == UFS_STATUS.OK)
{
tbxMessage.AppendText("UFScanner Init: OK\r\n");
}
else
{
UFScanner.GetErrorString(ufs_res, out m_strError);
tbxMessage.AppendText("UFScanner Init: " + m_strError + "\r\n");
Cursor.Current = this.Cursor;
return;
}
m_ScannerManager.ScannerEvent += new UFS_SCANNER_PROC(ScannerEvent);
nScannerNumber = m_ScannerManager.Scanners.Count;
tbxMessage.AppendText("UFScanner GetScannerNumber: " + nScannerNumber + "\r\n");
UpdateScannerList();
if (cbScanTemplateType.SelectedIndex == -1)
{
cbScanTemplateType.SelectedIndex = 1;
m_nType = 1;
}
//=========================================================================//
//=========================================================================//
// Create matcher
//=========================================================================//
m_Matcher = new UFMatcher();
if (m_Matcher.InitResult == UFM_STATUS.OK)
{
tbxMessage.AppendText("UFMatcher Init: OK\r\n");
}
else
{
UFMatcher.GetErrorString(m_Matcher.InitResult, out m_strError);
tbxMessage.AppendText("UFMatcher Init: " + m_strError + "\r\n");
}
GetMatcherSettings(m_Matcher);
//=========================================================================//
Cursor.Current = this.Cursor;
}
public string Initializescanner()
{
//=========================================================================//
// Initilize scanners
//=========================================================================//
UFS_STATUS ufs_res;
int nScannerNumber;
string tbxMessage = "";
Cursor.Current = Cursors.WaitCursor;
ufs_res = m_ScannerManager.Init();
// Cursor.Current = this.Cursor;
if (ufs_res == UFS_STATUS.OK)
{
tbxMessage = "UFScanner Init: OK\r\n";
}
else
{
UFScanner.GetErrorString(ufs_res, out m_strError);
tbxMessage = "UFScanner Init: " + m_strError + "\r\n";
return(tbxMessage);
}
nScannerNumber = m_ScannerManager.Scanners.Count;
tbxMessage = "UFScanner GetScannerNumber: " + nScannerNumber + "\r\n";
if (nScannerNumber == 0)
{
tbxMessage = "There's no available scanner\r\n";
return(tbxMessage);
}
else
{
tbxMessage = "First scanner will be used\r\n";
}
m_Scanner = m_ScannerManager.Scanners[0];
m_Scanner.Timeout = 5000;
//=========================================================================//
// UpdateDatabaseList();
//=========================================================================//
//=========================================================================//
// Create matcher
//=========================================================================//
m_Matcher = new UFMatcher();
return("");
//=========================================================================//
}
//public bool IsInitializescanner()
//{
// UFS_STATUS ufs_res;
// int nScannerNumber;
// string tbxMessage = "";
// Cursor.Current = Cursors.WaitCursor;
// // ufs_res = m_ScannerManager.Init();
// if (ufs_res.in == UFS_STATUS.OK)
// {
// return true;
// }
//}
public string Uninit()
{
//=========================================================================//
// Uninit scanner module
//=========================================================================//
UFS_STATUS ufs_res;
Cursor.Current = Cursors.WaitCursor;
ufs_res = m_ScannerManager.Uninit();
// Cursor.Current = this.Cursor;
if (ufs_res == UFS_STATUS.OK)
{
tbxMessage = "UFScanner Uninit: OK\r\n";
}
else
{
UFScanner.GetErrorString(ufs_res, out m_strError);
tbxMessage = "UFScanner Uninit: " + m_strError + "\r\n";
}
//=========================================================================//
//=========================================================================//
// Close database
//=========================================================================//
//UFD_STATUS ufd_res;
//if (m_Database != null)
//{
// ufd_res = m_Database.Close();
// if (ufd_res == UFD_STATUS.OK)
// {
// tbxMessage="UFDatabase Close: OK\r\n";
// }
// else
// {
// UFDatabase.GetErrorString(ufd_res, out m_strError);
// tbxMessage="UFDatabase Close: " + m_strError + "\r\n";
// }
//}
// lvDatabaseList.Items.Clear();
return(tbxMessage);
//=========================================================================//
}
private void UFE30_Enroll_Load(object sender, EventArgs e)
{
UFS_STATUS ufs_res;
string strError;
m_extract_num = 0;
m_try_extract = true;
m_bFingerCheck = false;
int i;
m_EnrollTemplate_input = new byte[MAX_TEMPLATE_INPUT_NUM][];
m_EnrollTemplateSize_input = new int[MAX_TEMPLATE_INPUT_NUM];
for (i = 0; i < MAX_TEMPLATE_INPUT_NUM; i++)
{
m_EnrollTemplate_input[i] = new byte[MAX_TEMPLATE_SIZE];
m_EnrollTemplateSize_input[i] = 0;
}
m_EnrollTemplate_output = new byte[m_output_num][];
m_EnrollTemplateSize_output = new int[m_output_num];
for (i = 0; i < m_output_num; i++)
{
m_EnrollTemplate_output[i] = new byte[MAX_TEMPLATE_SIZE];
m_EnrollTemplateSize_output[i] = 0;
}
tbxMessage.AppendText("Advanced Enroll is started. Place your finger\r\n");
m_Scanner.ClearCaptureImageBuffer();
m_Scanner.Timeout = 0;
m_Scanner.CaptureEvent += new UFS_CAPTURE_PROC(EnrollEvent);
ufs_res = m_Scanner.StartCapturing();
if (ufs_res == UFS_STATUS.OK)
{
tbxMessage.AppendText("UFScanner StartCapturing: OK\r\n");
}
else
{
UFScanner.GetErrorString(ufs_res, out strError);
tbxMessage.AppendText("UFScanner StartCapturing: " + strError + "\r\n");
}
}
public void FinalizaBiometria()
{
//=========================================================================//
// Finaliza algoritmo
//=========================================================================//
UFS_STATUS ufs_res;
Cursor.Current = Cursors.WaitCursor;
ufs_res = m_ScannerManager.Uninit();
Cursor.Current = this.Cursor;
if (ufs_res != UFS_STATUS.OK)
{
UFScanner.GetErrorString(ufs_res, out m_strError);
lbMensagem.Text = m_strError;
}
pictureBox1.Image = null;
}
private void btnUpdate_Click(object sender, EventArgs e)
{
UFS_STATUS ufs_res;
Cursor.Current = Cursors.WaitCursor;
ufs_res = m_ScannerManager.Update();
Cursor.Current = this.Cursor;
if (ufs_res == UFS_STATUS.OK)
{
tbxMessage.AppendText("UFScanner Update: OK\r\n");
UpdateScannerList();
}
else
{
UFScanner.GetErrorString(ufs_res, out m_strError);
tbxMessage.AppendText("UFScanner Update: " + m_strError + "\r\n");
}
}
private void btnUninit_Click(object sender, EventArgs e)
{
//=========================================================================//
// Uninit scanner module
//=========================================================================//
UFS_STATUS ufs_res;
Cursor.Current = Cursors.WaitCursor;
ufs_res = m_ScannerManager.Uninit();
Cursor.Current = this.Cursor;
if (ufs_res == UFS_STATUS.OK)
{
tbxMessage.AppendText("UFScanner Uninit: OK\r\n");
}
else
{
UFScanner.GetErrorString(ufs_res, out m_strError);
tbxMessage.AppendText("UFScanner Uninit: " + m_strError + "\r\n");
}
//=========================================================================//
//=========================================================================//
// Close database
//=========================================================================//
UFD_STATUS ufd_res;
if (m_Database != null)
{
ufd_res = m_Database.Close();
if (ufd_res == UFD_STATUS.OK)
{
tbxMessage.AppendText("UFDatabase Close: OK\r\n");
}
else
{
UFDatabase.GetErrorString(ufd_res, out m_strError);
tbxMessage.AppendText("UFDatabase Close: " + m_strError + "\r\n");
}
}
lvDatabaseList.Items.Clear();
//=========================================================================//
}
private void btnAbortCapturing_Click(object sender, EventArgs e)
{
UFScanner Scanner;
UFS_STATUS ufs_res;
if (!GetGetCurrentScanner(out Scanner))
{
return;
}
ufs_res = Scanner.AbortCapturing();
if (ufs_res == UFS_STATUS.OK)
{
tbxMessage.AppendText("UFScanner AbortCapturing: OK\r\n");
}
else
{
UFScanner.GetErrorString(ufs_res, out m_strError);
tbxMessage.AppendText("UFScanner AbortCapturing: " + m_strError + "\r\n");
}
}
private void btnAutoCapture_Click(object sender, EventArgs e)
{
UFScanner Scanner;
UFS_STATUS ufs_res;
if (!GetGetCurrentScanner(out Scanner))
{
return;
}
Scanner.CaptureEvent += new UFS_CAPTURE_PROC(CaptureEvent);
ufs_res = Scanner.StartAutoCapture();
if (ufs_res == UFS_STATUS.OK)
{
tbxMessage.AppendText("UFScanner StartAutoCapture: OK\r\n");
}
else
{
UFScanner.GetErrorString(ufs_res, out m_strError);
tbxMessage.AppendText("UFScanner StartAutoCapture: " + m_strError + "\r\n");
}
}
public void FinalizaBiometria()
{
groupBox2.Enabled = false;
//=========================================================================//
// Finaliza algoritmo
//=========================================================================//
UFS_STATUS ufs_res;
Cursor.Current = Cursors.WaitCursor;
ufs_res = m_ScannerManager.Uninit();
Cursor.Current = this.Cursor;
if (ufs_res == UFS_STATUS.OK)
{
toolStripStatusLabel1.Text = "Algoritmo finalizado";
m_ScannerManager.ScannerEvent -= ScannerEvent;
}
else
{
UFScanner.GetErrorString(ufs_res, out m_strError);
toolStripStatusLabel1.Text = m_strError;
}
pictureBox1.Image = null;
}
private UFS_STATUS ExtractTemplate(UFScanner scanner)
{
try
{
byte[] template = new byte[TemplateBufferSize];
int enrollQuality = 0;
UFS_STATUS ufsRes = scanner.Extract(template, out _templateSize, out enrollQuality);
if (ufsRes == UFS_STATUS.OK)
{
if (template.Length != TemplateBufferSize)
{
//WriteLog(true, "Invalid template size, try again");
//return UFS_STATUS.ERR_NOT_GOOD_IMAGE;
byte[] tmp = new byte[TemplateBufferSize];
for (int i = template.Length - 1; i < tmp.Length; i++)
{
tmp[i] = 0;
}
template = tmp;
}
WriteLog("Template capturing completed");
WriteLog(string.Format("Template quality is {0}", enrollQuality));
if (enrollQuality < Settings.MinimalTemplateQualityPercent)
{
MessageBoxResult result = MessageBox.Show("The quality of captured template is too low for using it, Would you like to retry template capturing?",
"Poor template quality", MessageBoxButton.YesNo, MessageBoxImage.Information);
if (result == MessageBoxResult.Yes)
{
CaptureTemplate(this, null);
}
}
else
{
_template = Encoding.ASCII.GetString(TemplateConverter.ConvertToSynelTemplateFormat(template));
System.Drawing.Bitmap bitm = null;
int resolution = 0;
scanner.GetCaptureImageBuffer(out bitm, out resolution);
fingerImage.Source = loadBitmap(bitm);
}
}
else
{
string error = string.Empty;
UFScanner.GetErrorString(ufsRes, out error);
WriteLog(error, false);
}
return(ufsRes);
}
catch (Exception exc)
{
WriteLog(exc.Message, true);
}
return(UFS_STATUS.ERROR);
}
public int EnrollEvent(object sender, UFScannerCaptureEventArgs e)
{
byte[] Template;
int TemplateSize;
int nEnrollQuality;
UFS_STATUS ufs_res;
string strError;
Template = new byte[MAX_TEMPLATE_SIZE];
if (!m_try_extract)
{
if (!e.FingerOn)
{
m_try_extract = true;
m_bFingerCheck = false;
SetTextMessage("Place your finger\r\n");
}
else
{
if (!m_bFingerCheck)
{
SetTextMessage("Remove your fingerprint from scanner\r\n");
m_bFingerCheck = true;
}
}
UpdatePictureBox(pbImageFrame, e.ImageFrame);
return(1);
}
if (e.FingerOn && m_try_extract)
{
ufs_res = m_Scanner.ExtractEx(MAX_TEMPLATE_SIZE, Template, out TemplateSize, out nEnrollQuality);
if (ufs_res == UFS_STATUS.OK)
{
if (nEnrollQuality < m_quality)
{
SetTextMessage("Template Quality is too low\r\n");
}
else
{
System.Array.Copy(Template, 0, m_EnrollTemplate_input[m_extract_num], 0, TemplateSize);
m_EnrollTemplateSize_input[m_extract_num] = TemplateSize;
m_extract_num++;
SetTextMessage("UFS_Extract: OK (" + m_extract_num + "/4)\r\n");
m_try_extract = false;
if (m_extract_num == MAX_TEMPLATE_INPUT_NUM)
{
ufs_res = m_Scanner.SelectTemplateEx(MAX_TEMPLATE_SIZE, m_EnrollTemplate_input, m_EnrollTemplateSize_input, 4, m_EnrollTemplate_output, m_EnrollTemplateSize_output, m_output_num);
if (ufs_res == UFS_STATUS.OK)
{
SetTextMessage("Extraction process is succeed\r\n");
if (m_output_num == 1)
{
// output template number is 1
}
else if (m_output_num == 2)
{
// output template number is 2
}
else
{
SetTextMessage("template output number is not correct\r\n");
}
}
else
{
SetTextMessage("Extraction process is faild\r\n");
}
UpdatePictureBox(pbImageFrame, e.ImageFrame);
return(0);
}
}
}
else
{
UFScanner.GetErrorString(ufs_res, out strError);
SetTextMessage("UFS_Extract:" + strError + "\r\n");
}
}
UpdatePictureBox(pbImageFrame, e.ImageFrame);
return(1);
}
private void btnIdentify_Click(object sender, EventArgs e)
{
UFScanner Scanner;
UFS_STATUS ufs_res;
UFM_STATUS ufm_res;
byte[] Template = new byte[MAX_TEMPLATE_SIZE];
int TemplateSize;
int EnrollQuality;
int MatchIndex;
if (!GetGetCurrentScanner(out Scanner))
{
return;
}
Scanner.ClearCaptureImageBuffer();
tbxMessage.AppendText("Place Finger\r\n");
ufs_res = Scanner.CaptureSingleImage();
if (ufs_res != UFS_STATUS.OK)
{
UFScanner.GetErrorString(ufs_res, out m_strError);
tbxMessage.AppendText("UFScanner CaptureSingleImage: " + m_strError + "\r\n");
return;
}
switch (this.cbScanTemplateType.SelectedIndex)
{
case 0:
Scanner.nTemplateType = 2001;
break;
case 1:
Scanner.nTemplateType = 2002;
break;
case 2:
Scanner.nTemplateType = 2003;
break;
}
ufs_res = Scanner.Extract(Template, out TemplateSize, out EnrollQuality);
if (ufs_res == UFS_STATUS.OK)
{
DrawCapturedImage(Scanner);
}
else
{
UFScanner.GetErrorString(ufs_res, out m_strError);
tbxMessage.AppendText("UFScanner Extract: " + m_strError + "\r\n");
return;
}
switch (this.cbMatchTemplateType.SelectedIndex)
{
case 0:
m_Matcher.nTemplateType = 2001;
break;
case 1:
m_Matcher.nTemplateType = 2002;
break;
case 2:
m_Matcher.nTemplateType = 2003;
break;
}
Cursor.Current = Cursors.WaitCursor;
//*
ufm_res = m_Matcher.Identify(Template, TemplateSize, m_template, m_template_size, m_template_num, 5000, out MatchIndex);
//ufm_res = m_Matcher.IdentifyMT(Template, TemplateSize, m_template, m_template_size, m_template_num, 5000, out MatchIndex);
/*/
* {
* byte[,] Template2 = new byte[m_template_num, MAX_TEMPLATE_SIZE];
* int i, j;
* for (j = 0; j < m_template_num; j++) {
* for (i = 0; i < m_template_size[j]; i++) {
* Template2[j,i] = m_template[j][i];
* }
* }
* ufm_res = m_Matcher.Identify(Template, TemplateSize, m_template, m_template_size, m_template_num, 5000, out MatchIndex);
* }
* //*/
Cursor.Current = this.Cursor;
if (ufm_res != UFM_STATUS.OK)
{
UFMatcher.GetErrorString(ufm_res, out m_strError);
tbxMessage.AppendText("UFMatcher Identify: " + m_strError + "\r\n");
return;
}
if (MatchIndex != -1)
{
tbxMessage.AppendText("Identification succeed (No." + (MatchIndex + 1) + ")\r\n");
}
else
{
tbxMessage.AppendText("Identification failed\r\n");
}
}
private void btnVerify_Click(object sender, EventArgs e)
{
UFScanner Scanner;
UFS_STATUS ufs_res;
UFM_STATUS ufm_res;
byte[] Template = new byte[MAX_TEMPLATE_SIZE];
int TemplateSize;
int EnrollQuality;
bool VerifySucceed;
int SelectID;
SelectID = cbID.SelectedIndex;
if (SelectID == -1)
{
tbxMessage.AppendText("Select Enroll ID\r\n");
return;
}
if (!GetGetCurrentScanner(out Scanner))
{
return;
}
Scanner.ClearCaptureImageBuffer();
tbxMessage.AppendText("Place Finger\r\n");
ufs_res = Scanner.CaptureSingleImage();
if (ufs_res != UFS_STATUS.OK)
{
UFScanner.GetErrorString(ufs_res, out m_strError);
tbxMessage.AppendText("UFScanner CaptureSingleImage: " + m_strError + "\r\n");
return;
}
switch (this.cbScanTemplateType.SelectedIndex)
{
case 0:
Scanner.nTemplateType = 2001;
break;
case 1:
Scanner.nTemplateType = 2002;
break;
case 2:
Scanner.nTemplateType = 2003;
break;
}
ufs_res = Scanner.Extract(Template, out TemplateSize, out EnrollQuality);
if (ufs_res == UFS_STATUS.OK)
{
DrawCapturedImage(Scanner);
}
else
{
UFScanner.GetErrorString(ufs_res, out m_strError);
tbxMessage.AppendText("UFScanner Extract: " + m_strError + "\r\n");
return;
}
switch (this.cbMatchTemplateType.SelectedIndex)
{
case 0:
m_Matcher.nTemplateType = 2001;
break;
case 1:
m_Matcher.nTemplateType = 2002;
break;
case 2:
m_Matcher.nTemplateType = 2003;
break;
}
ufm_res = m_Matcher.Verify(Template, TemplateSize, m_template[SelectID], m_template_size[SelectID], out VerifySucceed);
if (ufm_res != UFM_STATUS.OK)
{
UFMatcher.GetErrorString(ufm_res, out m_strError);
tbxMessage.AppendText("UFMatcher Verify: " + m_strError + "\r\n");
return;
}
if (VerifySucceed)
{
tbxMessage.AppendText("Verification succeed (No." + (SelectID + 1) + ")\r\n");
}
else
{
tbxMessage.AppendText("Verification failed\r\n");
}
}
private void btnEnroll_Click(object sender, EventArgs e)
{
UFScanner Scanner;
UFS_STATUS ufs_res;
int EnrollQuality;
if (!GetGetCurrentScanner(out Scanner))
{
return;
}
Scanner.ClearCaptureImageBuffer();
tbxMessage.AppendText("Place Finger\r\n");
while (true)
{
ufs_res = Scanner.CaptureSingleImage();
if (ufs_res != UFS_STATUS.OK)
{
UFScanner.GetErrorString(ufs_res, out m_strError);
tbxMessage.AppendText("UFScanner CaptureSingleImage: " + m_strError + "\r\n");
return;
}
switch (this.cbScanTemplateType.SelectedIndex)
{
case 0:
Scanner.nTemplateType = 2001;
break;
case 1:
Scanner.nTemplateType = 2002;
break;
case 2:
Scanner.nTemplateType = 2003;
break;
}
ufs_res = Scanner.Extract(m_template[m_template_num], out m_template_size[m_template_num], out EnrollQuality);
if (ufs_res == UFS_STATUS.OK)
{
tbxMessage.AppendText("UFScanner Extract: OK\r\n");
DrawCapturedImage(Scanner);
break;
}
else
{
UFScanner.GetErrorString(ufs_res, out m_strError);
tbxMessage.AppendText("UFScanner Extract: " + m_strError + "\r\n");
}
}
if (EnrollQuality < cbEnrollQuality.SelectedIndex * 10 + 30)
{
tbxMessage.AppendText("Too low quality [Q:" + EnrollQuality + "]\r\n");
return;
}
tbxMessage.AppendText("Enrollment success (No." + (m_template_num + 1) + ") [Q:" + EnrollQuality + "]\r\n");
cbID.Items.Add(m_template_num + 1);
if (m_template_num + 1 == MAX_TEMPLATE_NUM)
{
tbxMessage.AppendText("Template memory is full\r\n");
}
else
{
m_template_num++;
}
}
private void button1_Click(object sender, EventArgs e)
{
UFScanner Scanner;
UFS_STATUS ufs_res;
int EnrollQuality = 0;
if (!GetCurrentScanner(out Scanner))
{
return;
}
Scanner.ClearCaptureImageBuffer();
toolStripStatusLabel1.Text = "Posicione o dedo";
pictureBox1.Image = null;
digitalCapturada = false;
while (true)
{
Application.DoEvents();
ufs_res = Scanner.CaptureSingleImage();
if (ufs_res != UFS_STATUS.OK)
{
UFScanner.GetErrorString(ufs_res, out m_strError);
toolStripStatusLabel1.Text = m_strError;
return;
}
// Configura o tipo de template pra Suprema (2001)
Scanner.nTemplateType = 2001;
switch (numDigital)
{
case 1:
m_template1 = new byte[MAX_TEMPLATE_SIZE];
ufs_res = Scanner.Extract(m_template1, out m_template_size, out EnrollQuality);
break;
case 2:
m_template2 = new byte[MAX_TEMPLATE_SIZE];
ufs_res = Scanner.Extract(m_template2, out m_template_size, out EnrollQuality);
break;
case 3:
m_template3 = new byte[MAX_TEMPLATE_SIZE];
ufs_res = Scanner.Extract(m_template3, out m_template_size, out EnrollQuality);
break;
}
if (ufs_res == UFS_STATUS.OK)
{
toolStripStatusLabel1.Text = "Digital capturada [Q:" + EnrollQuality + "/100]";
statusLabel.Text = "Digital capturada";
statusLabel.ForeColor = Color.Green;
DrawCapturedImage(Scanner);
digitalCapturada = true;
break;
}
else
{
UFScanner.GetErrorString(ufs_res, out m_strError);
toolStripStatusLabel1.Text = m_strError;
digitalCapturada = false;
}
}
if (EnrollQuality < 50)
{
toolStripStatusLabel1.Text = "Qualidade da digital muito baixa [Q:" + EnrollQuality + "/100]";
digitalCapturada = false;
return;
}
}
//=========================================================================//
//=========================================================================//
private void btnInit_Click(object sender, EventArgs e)
{
//=========================================================================//
// Initilize scanners
//=========================================================================//
UFS_STATUS ufs_res;
int nScannerNumber;
Cursor.Current = Cursors.WaitCursor;
ufs_res = m_ScannerManager.Init();
Cursor.Current = this.Cursor;
if (ufs_res == UFS_STATUS.OK)
{
tbxMessage.AppendText("UFScanner Init: OK\r\n");
}
else
{
UFScanner.GetErrorString(ufs_res, out m_strError);
tbxMessage.AppendText("UFScanner Init: " + m_strError + "\r\n");
return;
}
nScannerNumber = m_ScannerManager.Scanners.Count;
tbxMessage.AppendText("UFScanner GetScannerNumber: " + nScannerNumber + "\r\n");
if (nScannerNumber == 0)
{
tbxMessage.AppendText("There's no available scanner\r\n");
return;
}
else
{
tbxMessage.AppendText("First scanner will be used\r\n");
}
m_Scanner = m_ScannerManager.Scanners[0];
//=========================================================================//
//=========================================================================//
// Open database
//=========================================================================//
UFD_STATUS ufd_res;
m_Database = new UFDatabase();
// Generate connection string
string szDataSource;
string szConnection;
/*
* szDataSource = "UFDatabase.mdb";
* /*/
tbxMessage.AppendText("Select a database file\r\n");
OpenFileDialog dlg = new OpenFileDialog();
dlg.FileName = "UFDatabase.mdb";
dlg.Filter = "Database Files (*.mdb)|*.mdb";
dlg.DefaultExt = "mdb";
DialogResult res = dlg.ShowDialog();
if (res != DialogResult.OK)
{
return;
}
szDataSource = dlg.FileName;
//*/
szConnection = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" + szDataSource + ";";
ufd_res = m_Database.Open(szConnection, null, null);
if (ufd_res == UFD_STATUS.OK)
{
tbxMessage.AppendText("UFDatabase Open: OK\r\n");
}
else
{
UFDatabase.GetErrorString(ufd_res, out m_strError);
tbxMessage.AppendText("UFDatabase Open: " + m_strError + "\r\n");
return;
}
UpdateDatabaseList();
//=========================================================================//
//=========================================================================//
// Create matcher
//=========================================================================//
m_Matcher = new UFMatcher();
if (m_Matcher.InitResult == UFM_STATUS.OK)
{
tbxMessage.AppendText("UFMatcher Init: OK\r\n");
}
else
{
UFMatcher.GetErrorString(m_Matcher.InitResult, out m_strError);
tbxMessage.AppendText("UFMatcher Init: " + m_strError + "\r\n");
}
//=========================================================================//
cbScanTemplateType.SelectedIndex = 0;
}
private void btnIdentify_Click(object sender, EventArgs e)
{
UFScanner Scanner;
UFS_STATUS ufs_res;
UFM_STATUS ufm_res;
byte[] Template = new byte[MAX_TEMPLATE_SIZE];
int TemplateSize;
int EnrollQuality;
int MatchIndex;
byte[][] template_all;
int[] templateSize_all;
int[] nindex;
int i, j = 0, nMaxTemplateNum = 0;
template_all = new byte[MAX_TEMPLATE_NUM * 2][];
templateSize_all = new int[MAX_TEMPLATE_NUM * 2];
nindex = new int[MAX_TEMPLATE_NUM * 2];
for (i = 0; i < m_template_num * 2; i++)
{
template_all[i] = new byte[MAX_TEMPLATE_SIZE];
templateSize_all[i] = 0;
}
for (i = 0; i < m_template_num * 2; i++)
{
if (i < m_template_num)
{
if (m_template_size1[i] != 0)
{
System.Array.Copy(m_template1[i], 0, template_all[j], 0, m_template_size1[i]);
templateSize_all[j] = m_template_size1[i];
nindex[j] = i;
j++;
}
}
else
{
if (m_template_size2[i - m_template_num] != 0)
{
System.Array.Copy(m_template2[i - m_template_num], 0, template_all[j], 0, m_template_size2[i - m_template_num]);
templateSize_all[j] = m_template_size2[i - m_template_num];
nindex[j] = i - m_template_num;
j++;
}
}
}
nMaxTemplateNum = j;
if (!GetGetCurrentScanner(out Scanner))
{
return;
}
Scanner.ClearCaptureImageBuffer();
tbxMessage.AppendText("Place Finger\r\n");
ufs_res = Scanner.CaptureSingleImage();
if (ufs_res != UFS_STATUS.OK)
{
UFScanner.GetErrorString(ufs_res, out m_strError);
tbxMessage.AppendText("UFScanner CaptureSingleImage: " + m_strError + "\r\n");
return;
}
switch (this.cbScanTemplateType.SelectedIndex)
{
case 0:
Scanner.nTemplateType = 2001;
break;
case 1:
Scanner.nTemplateType = 2002;
break;
case 2:
Scanner.nTemplateType = 2003;
break;
}
ufs_res = Scanner.ExtractEx(MAX_TEMPLATE_SIZE, Template, out TemplateSize, out EnrollQuality);
if (ufs_res == UFS_STATUS.OK)
{
DrawCapturedImage(Scanner);
}
else
{
UFScanner.GetErrorString(ufs_res, out m_strError);
tbxMessage.AppendText("UFScanner ExtractEx: " + m_strError + "\r\n");
return;
}
switch (this.cbScanTemplateType.SelectedIndex)
{
case 0:
m_Matcher.nTemplateType = 2001;
break;
case 1:
m_Matcher.nTemplateType = 2002;
break;
case 2:
m_Matcher.nTemplateType = 2003;
break;
}
Cursor.Current = Cursors.WaitCursor;
//*
ufm_res = m_Matcher.Identify(Template, TemplateSize, template_all, templateSize_all, nMaxTemplateNum, 5000, out MatchIndex);
//ufm_res = m_Matcher.IdentifyMT(Template, TemplateSize, template_all, templateSize_all, nMaxTemplateNum, 5000, out MatchIndex);
/*/
* {
* byte[,] Template2 = new byte[m_template_num, MAX_TEMPLATE_SIZE];
* int i, j;
* for (j = 0; j < m_template_num; j++) {
* for (i = 0; i < m_template_size[j]; i++) {
* Template2[j,i] = m_template[j][i];
* }
* }
* ufm_res = m_Matcher.Identify(Template, TemplateSize, m_template, m_template_size, m_template_num, 5000, out MatchIndex);
* }
* //*/
Cursor.Current = this.Cursor;
if (ufm_res != UFM_STATUS.OK)
{
UFMatcher.GetErrorString(ufm_res, out m_strError);
tbxMessage.AppendText("UFMatcher Identify: " + m_strError + "\r\n");
return;
}
if (MatchIndex != -1)
{
tbxMessage.AppendText("Identification succeed (Match Index." + MatchIndex + ") (Match Serial." + nindex[MatchIndex] % nMaxTemplateNum + ") (ID." + m_UserID[nindex[MatchIndex]] + ")\r\n");
}
else
{
tbxMessage.AppendText("Identification failed\r\n");
}
}
private void btnVerify_Click(object sender, EventArgs e)
{
UFScanner Scanner;
UFS_STATUS ufs_res;
UFM_STATUS ufm_res;
byte[] Template = new byte[MAX_TEMPLATE_SIZE];
int TemplateSize;
int EnrollQuality;
bool VerifySucceed;
int Serial;
if (lvFingerDataList.SelectedIndices.Count == 0)
{
tbxMessage.AppendText("Select data\r\n");
return;
}
else
{
Serial = Convert.ToInt32(lvFingerDataList.SelectedItems[0].SubItems[FINGERDATA_COL_SERIAL].Text);
}
if (!GetGetCurrentScanner(out Scanner))
{
return;
}
tbxMessage.AppendText("Verify with serial: " + Serial + "\r\n");
Scanner.ClearCaptureImageBuffer();
tbxMessage.AppendText("Place Finger\r\n");
ufs_res = Scanner.CaptureSingleImage();
if (ufs_res != UFS_STATUS.OK)
{
UFScanner.GetErrorString(ufs_res, out m_strError);
tbxMessage.AppendText("UFScanner CaptureSingleImage: " + m_strError + "\r\n");
return;
}
switch (this.cbScanTemplateType.SelectedIndex)
{
case 0:
Scanner.nTemplateType = 2001;
break;
case 1:
Scanner.nTemplateType = 2002;
break;
case 2:
Scanner.nTemplateType = 2003;
break;
}
ufs_res = Scanner.ExtractEx(MAX_TEMPLATE_SIZE, Template, out TemplateSize, out EnrollQuality);
if (ufs_res == UFS_STATUS.OK)
{
DrawCapturedImage(Scanner);
}
else
{
UFScanner.GetErrorString(ufs_res, out m_strError);
tbxMessage.AppendText("UFScanner ExtractEx: " + m_strError + "\r\n");
return;
}
switch (this.cbScanTemplateType.SelectedIndex)
{
case 0:
m_Matcher.nTemplateType = 2001;
break;
case 1:
m_Matcher.nTemplateType = 2002;
break;
case 2:
m_Matcher.nTemplateType = 2003;
break;
}
ufm_res = m_Matcher.Verify(Template, TemplateSize, m_template1[Serial], m_template_size1[Serial], out VerifySucceed);
if (ufm_res != UFM_STATUS.OK)
{
UFMatcher.GetErrorString(ufm_res, out m_strError);
tbxMessage.AppendText("UFMatcher Verify: " + m_strError + "\r\n");
return;
}
if (VerifySucceed)
{
tbxMessage.AppendText("Verification succeed (Serial." + Serial + ") (ID." + m_UserID[Serial] + ")\r\n");
}
else
{
if (m_template_size2[Serial] != 0)
{
ufm_res = m_Matcher.Verify(Template, TemplateSize, m_template2[Serial], m_template_size2[Serial], out VerifySucceed);
if (ufm_res != UFM_STATUS.OK)
{
UFMatcher.GetErrorString(ufm_res, out m_strError);
tbxMessage.AppendText("UFMatcher Verify: " + m_strError + "\r\n");
return;
}
if (VerifySucceed)
{
tbxMessage.AppendText("Verification succeed (Serial." + Serial + ") (ID." + m_UserID[Serial] + ")\r\n");
}
else
{
tbxMessage.AppendText("Verification failed\r\n");
}
}
else
{
tbxMessage.AppendText("Verification failed\r\n");
}
}
}
private void btnEnroll_Click(object sender, EventArgs e)
{
UFScanner Scanner;
UFS_STATUS ufs_res;
int EnrollQuality;
int EnrollMode;
int template_enrolled = 0;
bool fingeron;
if (!GetGetCurrentScanner(out Scanner))
{
return;
}
switch (this.cbScanTemplateType.SelectedIndex)
{
case 0:
Scanner.nTemplateType = 2001;
break;
case 1:
Scanner.nTemplateType = 2002;
break;
case 2:
Scanner.nTemplateType = 2003;
break;
}
EnrollMode = rbtnOneTemplateAdvanced.Checked ? 1 : 2;
UFE30_UserInfo udlg = new UFE30_UserInfo();
tbxMessage.AppendText("Input user data\r\n");
if (udlg.ShowDialog(this) != DialogResult.OK)
{
tbxMessage.AppendText("User data input is cancelled by user\r\n");
return;
}
Refresh();
//Enroll Template with Non-Advanced-Extraction
if (rbtnOneTemplateNormal.Checked == true || rbtnOneTemplateNormal2.Checked == true)
{
Scanner.ClearCaptureImageBuffer();
tbxMessage.AppendText("Place Finger\r\n");
while (true)
{
ufs_res = Scanner.CaptureSingleImage();
if (ufs_res != UFS_STATUS.OK)
{
UFScanner.GetErrorString(ufs_res, out m_strError);
tbxMessage.AppendText("UFScanner CaptureSingleImage: " + m_strError + "\r\n");
return;
}
if (m_template_num + 1 == MAX_TEMPLATE_NUM)
{
tbxMessage.AppendText("Template memory is full\r\n");
return;
}
if (template_enrolled == 0)
{
ufs_res = Scanner.ExtractEx(MAX_TEMPLATE_SIZE, m_template1[m_template_num], out m_template_size1[m_template_num], out EnrollQuality);
}
else
{
ufs_res = Scanner.ExtractEx(MAX_TEMPLATE_SIZE, m_template2[m_template_num], out m_template_size2[m_template_num], out EnrollQuality);
}
DrawCapturedImage(Scanner);
if (ufs_res == UFS_STATUS.OK)
{
if (EnrollQuality < m_quality)
{
tbxMessage.AppendText("Too low quality [Q:" + EnrollQuality + "]\r\n");
}
else
{
m_UserID[m_template_num] = udlg.UserID;
template_enrolled++;
tbxMessage.AppendText("Enrollment success (No." + m_template_num + ") [Q:" + EnrollQuality + "]\r\n");
if (rbtnOneTemplateNormal.Checked == true)
{
m_template_num++;
UpdateFingerDataList();
break;
}
else if (rbtnOneTemplateNormal2.Checked == true && template_enrolled == 2)
{
m_template_num++;
UpdateFingerDataList();
break;
}
else
{
tbxMessage.AppendText("Remove finger\r\n");
while (true)
{
fingeron = Scanner.IsFingerOn;
if (fingeron == false)
{
tbxMessage.AppendText("Place a finger\r\n");
break;
}
}
}
}
}
else
{
UFScanner.GetErrorString(ufs_res, out m_strError);
tbxMessage.AppendText("UFScanner Extract: " + m_strError + "\r\n");
}
}
}
//Enroll with Advanced-Extraction
else
{
UFE30_Enroll dlg = new UFE30_Enroll();
dlg.hScanner = Scanner;
dlg.UserID = udlg.UserID;
dlg.OutputNum = EnrollMode;
dlg.Quality = m_quality;
if (dlg.ShowDialog(this) != DialogResult.OK)
{
tbxMessage.AppendText("Fingerprint enrollment is cancelled by user\r\n");
return;
}
if (dlg.EnrollTemplateOutputSize[0] != 0)
{
if (m_template_num + 1 == MAX_TEMPLATE_NUM)
{
tbxMessage.AppendText("Template memory is full\r\n");
}
else
{
//Enroll 1-Template
if (EnrollMode == 1)
{
System.Array.Copy(dlg.EnrollTemplateOutput[0], 0, m_template1[m_template_num], 0, dlg.EnrollTemplateOutputSize[0]);
m_template_size1[m_template_num] = dlg.EnrollTemplateOutputSize[0];
m_UserID[m_template_num] = udlg.UserID;
}
//Enroll 2-Template
else
{
System.Array.Copy(dlg.EnrollTemplateOutput[0], 0, m_template1[m_template_num], 0, dlg.EnrollTemplateOutputSize[0]);
m_template_size1[m_template_num] = dlg.EnrollTemplateOutputSize[0];
System.Array.Copy(dlg.EnrollTemplateOutput[1], 0, m_template2[m_template_num], 0, dlg.EnrollTemplateOutputSize[1]);
m_template_size2[m_template_num] = dlg.EnrollTemplateOutputSize[1];
m_UserID[m_template_num] = udlg.UserID;
}
tbxMessage.AppendText("Enrollment is succeed (No." + m_template_num + ")\r\n");
m_template_num++;
}
UpdateFingerDataList();
}
else
{
tbxMessage.AppendText("Enrollment is failed\r\n");
}
Scanner.Timeout = cbTimeout.SelectedIndex * 1000;
}
}
private void btnUpdateTemplate_Click(object sender, EventArgs e)
{
UFScanner Scanner;
UFS_STATUS ufs_res;
byte[] Template = new byte[MAX_TEMPLATE_SIZE];
int TemplateSize;
int EnrollQuality;
int EnrollMode;
int Serial;
int template_enrolled = 0;
bool fingeron;
if (lvFingerDataList.SelectedIndices.Count == 0)
{
tbxMessage.AppendText("Select data\r\n");
return;
}
else
{
Serial = Convert.ToInt32(lvFingerDataList.SelectedItems[0].SubItems[FINGERDATA_COL_SERIAL].Text);
}
if (!GetGetCurrentScanner(out Scanner))
{
return;
}
switch (this.cbScanTemplateType.SelectedIndex)
{
case 0:
Scanner.nTemplateType = 2001;
break;
case 1:
Scanner.nTemplateType = 2002;
break;
case 2:
Scanner.nTemplateType = 2003;
break;
}
EnrollMode = rbtnOneTemplateAdvanced.Checked ? 1 : 2;
//Update Template with Non-Advanced-Extraction
if (rbtnOneTemplateNormal.Checked == true || rbtnOneTemplateNormal2.Checked == true)
{
Scanner.ClearCaptureImageBuffer();
tbxMessage.AppendText("Place Finger\r\n");
while (true)
{
ufs_res = Scanner.CaptureSingleImage();
if (ufs_res != UFS_STATUS.OK)
{
UFScanner.GetErrorString(ufs_res, out m_strError);
tbxMessage.AppendText("UFScanner CaptureSingleImage: " + m_strError + "\r\n");
return;
}
ufs_res = Scanner.ExtractEx(MAX_TEMPLATE_SIZE, Template, out TemplateSize, out EnrollQuality);
DrawCapturedImage(Scanner);
if (ufs_res == UFS_STATUS.OK)
{
if (EnrollQuality < m_quality)
{
tbxMessage.AppendText("Too low quality [Q:" + EnrollQuality + "]\r\n");
}
else
{
if (rbtnOneTemplateNormal.Checked == true)
{
System.Array.Clear(m_template2[Serial], 0, MAX_TEMPLATE_SIZE);
m_template_size2[Serial] = 0;
System.Array.Clear(m_template1[Serial], 0, MAX_TEMPLATE_SIZE);
System.Array.Copy(Template, 0, m_template1[Serial], 0, TemplateSize);
m_template_size1[Serial] = TemplateSize;
tbxMessage.AppendText("Update success (Serial." + Serial + ") [Q:" + EnrollQuality + "]\r\n");
UpdateFingerDataList();
break;
}
else if (rbtnOneTemplateNormal2.Checked == true && template_enrolled == 1)
{
System.Array.Clear(m_template2[Serial], 0, MAX_TEMPLATE_SIZE);
System.Array.Copy(Template, 0, m_template2[Serial], 0, TemplateSize);
m_template_size2[Serial] = TemplateSize;
tbxMessage.AppendText("Second template update success (Serial." + Serial + ") [Q:" + EnrollQuality + "]\r\n");
UpdateFingerDataList();
break;
}
else
{
template_enrolled++;
System.Array.Clear(m_template1[Serial], 0, MAX_TEMPLATE_SIZE);
System.Array.Copy(Template, 0, m_template1[Serial], 0, TemplateSize);
m_template_size1[Serial] = TemplateSize;
tbxMessage.AppendText("First template update success (Serial." + Serial + ") [Q:" + EnrollQuality + "]\r\n");
tbxMessage.AppendText("Remove finger\r\n");
while (true)
{
fingeron = Scanner.IsFingerOn;
if (fingeron == false)
{
tbxMessage.AppendText("Place a finger\r\n");
break;
}
}
}
}
}
else
{
UFScanner.GetErrorString(ufs_res, out m_strError);
tbxMessage.AppendText("UFScanner Extract: " + m_strError + "\r\n");
}
}
}
//Update with Advanced-Extraction
else
{
UFE30_Enroll dlg = new UFE30_Enroll();
dlg.hScanner = Scanner;
dlg.UserID = m_UserID[Serial];
dlg.OutputNum = EnrollMode;
dlg.Quality = m_quality;
if (dlg.ShowDialog(this) != DialogResult.OK)
{
tbxMessage.AppendText("Fingerprint update is cancelled by user\r\n");
return;
}
if (dlg.EnrollTemplateOutputSize[0] != 0)
{
//Update 1-Template
if (EnrollMode == 1)
{
System.Array.Clear(m_template2[Serial], 0, MAX_TEMPLATE_SIZE);
m_template_size2[Serial] = 0;
System.Array.Clear(m_template1[Serial], 0, MAX_TEMPLATE_SIZE);
System.Array.Copy(dlg.EnrollTemplateOutput[0], 0, m_template1[Serial], 0, dlg.EnrollTemplateOutputSize[0]);
m_template_size1[Serial] = dlg.EnrollTemplateOutputSize[0];
}
//Update 2-Template
else
{
System.Array.Clear(m_template1[Serial], 0, MAX_TEMPLATE_SIZE);
System.Array.Copy(dlg.EnrollTemplateOutput[0], 0, m_template1[Serial], 0, dlg.EnrollTemplateOutputSize[0]);
m_template_size1[Serial] = dlg.EnrollTemplateOutputSize[0];
System.Array.Clear(m_template2[Serial], 0, MAX_TEMPLATE_SIZE);
System.Array.Copy(dlg.EnrollTemplateOutput[1], 0, m_template2[Serial], 0, dlg.EnrollTemplateOutputSize[1]);
m_template_size2[Serial] = dlg.EnrollTemplateOutputSize[1];
}
tbxMessage.AppendText("Fingerprint update is succeed (Serial." + Serial + ")\r\n");
UpdateFingerDataList();
}
else
{
tbxMessage.AppendText("Fingerprint update is failed\r\n");
}
Scanner.Timeout = cbTimeout.SelectedIndex * 1000;
}
}
