myvtm/DevAdapter/keba/FingerPrint.keba.1.1/fingerprint.cpp

#include "fingerprint.h"
#include "CkLog.h"

//CTraceManager g_Trace;
LOG_EXTERN()
//获取当前模块所在路径
void GetModulePath(char* lpStrPath)
{
   LOG_FUNCTION();
   char szBuff[MAX_PATH];
   Dl_info path_info;
   std::string strLog = "";
   memset(&path_info, 0x00, sizeof(path_info));
   memset(szBuff, 0x00, sizeof(szBuff));

   int iRet = dladdr((const void*)GetModulePath, &path_info);
   if(!iRet)
   {
       return;
   }
   else
   {
       strcpy(szBuff, path_info.dli_fname);

       char *pLast=strrchr(szBuff, '/'); //find last '/'
       if(nullptr != pLast) *pLast = 0;  //cut

       strcat(szBuff, "/"); //

       if(nullptr != lpStrPath)
           strcpy(lpStrPath, szBuff);
   }
}

FingerPrintClassImpl::FingerPrintClassImpl():
     m_pDll(nullptr)
   ,m_bDevOpen(false)
   ,m_nPort(-1)
   ,m_strIniPath("")
   ,m_strDllPath("")

{
    LOG_FUNCTION();
    memset(m_strModulePath, 0x00, sizeof(m_strModulePath));
    GetModulePath(m_strModulePath); //获取ｓｏ所在路径

    m_strIniPath = m_strModulePath;
    m_strIniPath += "CK-VTM-E1000.INI";
    m_strDllPath = m_strModulePath;
}


FingerPrintClassImpl::~FingerPrintClassImpl()
{
    LOG_FUNCTION();
    DevClose();
    if(m_pDll != nullptr)
    {
        delete m_pDll;
    }
    m_bDevOpen = false;
}

ErrorCodeEnum FingerPrintClassImpl::GetDevCategory(DevCategoryInfo &devCategory)
{
    LOG_FUNCTION();
    LogM("FingerPrintClassImpl::Entry->FingerPrint GetDevCategory()!");
    int iRet = 0;
    char szDevInfo[128] = {0};
    char sID[1024] = {0};
    //记日志
    memset(devCategory.szType, 0, MAX_DEV_TYPE_LEN);
    memset(devCategory.szModel, 0, MAX_DEV_MODEL_LEN);
    memset(devCategory.szVendor, 0, MAX_DEV_VENDOR_LEN);
    memset(szDevInfo, 0, sizeof(szDevInfo));
    memset(sID, 0, sizeof(sID));
    iRet = m_pDll->FPIGetVersion(szDevInfo,sID);
    if(iRet == FP_ERROR_SUCCESS)
    {
        snprintf(devCategory.szType,sizeof (devCategory.szType) ,"PVER=Wellcom#MID=%s", szDevInfo);
    }
    else
    {
        memcpy(devCategory.szType, "PVER=Wellcom#MID=JZT-998APB-V20_V1.0.4.1_SC_[20150320]", strlen("PVER=Wellcom#MID=JZT-998APB-V20_V1.0.4.1_SC_[20150320]"));
        SaveErrorInfo(iRet);
    }
    memcpy(devCategory.szVendor, "keba", strlen("keba"));
    LogM("devCategory.szType = %s",devCategory.szType);
    LogM("devCategory.szVendor = %s",devCategory.szVendor);
    LogM("FingerPrintClassImpl::Leave->FingerPrint GetDevCategory() sucessfull!");
    return Error_Succeed;
}

//	Reset device.
//	Do the cleaning work and initialize device again in order to return to
//	the normal condition.
ErrorCodeEnum FingerPrintClassImpl::Reset()
{
    LOG_FUNCTION();
    LogM("FingerPrintClassImpl::Entry->FingerPrint Reset()!");
    DevClose();
    LogM("FingerPrintClassImpl::Leave->FingerPrint Reset() sucessfull!");
    return DevOpen(0, 0);
}

//
//	Close device and do the cleaning work.
//	ex. close connection,close port,release memery and so on
ErrorCodeEnum FingerPrintClassImpl::DevClose()
{
    //记日志
    LOG_FUNCTION();
    LogM("FingerPrintClassImpl::Entry->FingerPrint DevClose()!");
    if(!m_bDevOpen)
    {
        return Error_Succeed;
    }
    //CLOSEDEV();
    m_pDll->FPIDeviceClose();
    m_pDll->FreeDLL();
    m_bDevOpen = false;
    LogM("FingerPrintClassImpl::Leave->FingerPrint DevClose() sucessfull!");
    return Error_Succeed;
}
//	Get last error the device issued.
//	Error message must include explanatory memorandum ,the original error
//	code and anything in favour of location problem.
ErrorCodeEnum FingerPrintClassImpl::GetLastErr(DevErrorInfo &devErrInfo)
{
    LOG_FUNCTION();
    LogM("FingerPrintClassImpl::Entry->FingerPrint GetLastErr()!");
    devErrInfo.dwErrMsgLen = 0;
    memset(devErrInfo.szErrMsg, 0, sizeof(devErrInfo.szErrMsg));

    devErrInfo.dwErrMsgLen = (m_shErrCode << 16);
    sprintf(devErrInfo.szErrMsg, m_szErrMsg);
    devErrInfo.dwErrMsgLen += (strlen(devErrInfo.szErrMsg) & 0x0000FFFF);
    LogM("devErrInfo.szErrMsg = %s",devErrInfo.szErrMsg);
    LogM("FingerPrintClassImpl::Leave->FingerPrint GetLastErr() sucessfull!");
    return Error_Succeed;
}

ErrorCodeEnum FingerPrintClassImpl::DevOpen(DWORD dwPort, DWORD dwBaudRate)
{
    LOG_FUNCTION();
    LogM("FingerPrintClassImpl::Entry->FingerPrint DevOpen()!");
    int  iRet;
    CHAR strDllPath[256] = {0};
    char sDevInfo[64+1] = {0};
    char sID[1024] = {0};
    const char * tmpStr = "libFpDriverUSB_FGB.keba.so";
    strncat(strDllPath, "libFpDriverUSB_FGB.keba.so",strlen(tmpStr));
    m_pDll = new CDevDllLoad(strDllPath);
    if (nullptr == m_pDll)
    {
        LogM("FingerPrintClassImpl::Entry->FingerPrint DevOpen() new object CDevDllLoad failed!");
        SaveErrorInfo("对象创建失败", DEC_DEV_OBJECT_CREATE_FAILED);
        return Error_DevNotAvailable;
    }
    iRet = m_pDll->FPIDeviceInit();
    //记日志
    if(iRet != 1)
    {
        LogM("FingerPrintClassImpl::Entry->FingerPrint DevOpen()->m_pDll->FPIDeviceInit() failed! <=> iRet = %d",iRet);
        m_bDevOpen = false;
        return Error_DevNotAvailable;
    }
    LogM("FingerPrintClassImpl::Entry->FingerPrint DevOpen()->m_pDll->FPIDeviceInit() success! <=> iRet = %d",iRet);
    m_bDevOpen = true;
    memset(sDevInfo, 0, sizeof(sDevInfo));
    memset(sID, 0, sizeof(sID));
    iRet = m_pDll->FPIGetVersion(sDevInfo,sID);
    if (iRet == 1)
    {
        LogM("FingerPrintClassImpl::Leave->FingerPrint DevOpen()->m_pDll->FPIGetVersion sucessfull!");
    }
    return Error_Succeed;
}
void FingerPrintClassImpl::SaveErrorInfo(CHAR* errMsg, int errCode)
{
    LOG_FUNCTION();
    LogM("FingerPrintClassImpl::Entry->FingerPrint SaveErrorInfo(CHAR* errMsg, int errCode)! <=> errMsg = %s errCode = %d",errMsg,errCode);
    memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
    snprintf(m_szErrMsg, sizeof (m_szErrMsg),"%s[%d]", errMsg, errCode);
    LogM("FingerPrintClassImpl::Leave->FingerPrint DevOpen()->m_pDll->SaveErrorInfo(CHAR* errMsg, int errCode) sucessfull!");
}

void FingerPrintClassImpl::SaveErrorInfo(DevErrorInfo devErrorInfo)
{
    LOG_FUNCTION();
    LogM("FingerPrintClassImpl::Entry->FingerPrint SaveErrorInfo(DevErrorInfo devErrorInfo)! <=> devErrorInfo.szErrMsg = %s",devErrorInfo.szErrMsg);
    memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
    snprintf(m_szErrMsg,sizeof(m_szErrMsg), "%s",devErrorInfo.szErrMsg);
    LogM("FingerPrintClassImpl::Leave->FingerPrint DevOpen()->m_pDll->SaveErrorInfo(DevErrorInfo devErrorInfo) sucessfull!");
}
void FingerPrintClassImpl::SaveErrorInfo(int nErrorCode)
{
    LOG_FUNCTION();
    LogM("FingerPrintClassImpl::Entry->FingerPrint SaveErrorInfo(int nErrorCode)! <=> nErrorCode = %d",nErrorCode);
    ErrorCodeEnum ret;
    switch (nErrorCode)
    {
    case FP_ERROR_SUCCESS:
        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FP_ERROR_SUCCESS, "成功");
        m_shErrCode = DEC_SUCCESS;
        ret = Error_Succeed;
        break;
    case FP_ERROR_INVALID_PARAMETER:
        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FP_ERROR_INVALID_PARAMETER, "参数错误。给定函数的参数有错误。");
        m_shErrCode = DEC_INVALID_PARAMETER;
        ret = Error_Param;
        break;
    case FP_ERROR_NOT_ENOUGH_MEMORY:
        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FP_ERROR_NOT_ENOUGH_MEMORY, "内存分配失败。没有分配到足够的内存。");
        m_shErrCode = DEC_ALLOC_DENY;
        ret = Error_Param;
        break;
    case FP_ERROR_NOT_SUPPORT_FUNCTION:
        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FP_ERROR_NOT_SUPPORT_FUNCTION, "功能未开放。调用函数的功能没有实现。");
        m_shErrCode = DEC_FUNCTION_MISMATCH;
        ret = Error_Param;
        break;
    case FP_ERROR_DEVICE_NOT_FOUND:
        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
        snprintf(m_szErrMsg,sizeof(m_szErrMsg), "%d:%s",FP_ERROR_DEVICE_NOT_FOUND, "设备不存在。初始化的时候，检测到设备不存在。");
        m_shErrCode = DEC_DEV_NOT_FOUND;
        ret = Error_DevConnFailed;
        break;
    case FP_ERROR_DEVICE_NOT_INIT:
        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FP_ERROR_DEVICE_NOT_INIT, "设备未初始化。");
        m_shErrCode = DEC_DEV_NOT_OPENED;
        ret = Error_NotInit;
        break;
    case FP_ERROR_INVALIDE_CODE:
        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FP_ERROR_INVALIDE_CODE, "非法的错误号。");
        m_shErrCode = DEC_INVALID_PARAMETER;
        ret = Error_Param;
        break;
    case FP_ERROR_NO_PRIVILEGE:
        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FP_ERROR_NO_PRIVILEGE, "没有授权。");
        m_shErrCode = DEC_INVALID_PARAMETER;
        ret = Error_Param;
        break;
    case FP_ERROR_BASE64:
        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FP_ERROR_DEVICE_NOT_FOUND, "BASE64编解码失败。");
        m_shErrCode = DEC_INVALID_PARAMETER;
        ret = Error_Param;
        break;
    case FP_ERROR_EXCEPTION:
        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
        snprintf(m_szErrMsg,sizeof(m_szErrMsg), "%d:%s",FP_ERROR_EXCEPTION, "操作异常");
        m_shErrCode = DEC_INVALID_PARAMETER;
        ret = Error_Param;
        break;
    case FP_ERROR_RESERVE:
        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
        snprintf(m_szErrMsg,sizeof(m_szErrMsg), "%d:%s",FP_ERROR_RESERVE, "系统保留");
        m_shErrCode = DEC_INVALID_PARAMETER;
        ret = Error_Param;
        break;
    case FP_ERROR_MAC:
        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
        snprintf(m_szErrMsg,sizeof(m_szErrMsg), "%d:%s",FP_ERROR_MAC, "MAC错误");
        m_shErrCode = DEC_INVALID_MAC;
        ret = Error_Param;
        break;
    case FP_ERROR_ID:
        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FP_ERROR_ID, "设备ID错误");
        m_shErrCode = DEC_INVALID_PARAMETER;
        ret = Error_Param;
        break;
    case FP_ERROR_IMAGE:
        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
        snprintf(m_szErrMsg,sizeof(m_szErrMsg), "%d:%s",FP_ERROR_IMAGE, "图像错误");
        m_shErrCode = DEC_INVALID_PARAMETER;
        ret = Error_Param;
        break;
    case FP_ERROR_FILE_NO_FOUND:
        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FP_ERROR_FILE_NO_FOUND, "文件不存在");
        m_shErrCode = DEC_INVALID_PARAMETER;
        ret = Error_Param;
        break;
    case FP_ERROR_UNSUCCESS:
        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FP_ERROR_UNSUCCESS, "操作失败");
        m_shErrCode = DEC_INVALID_PARAMETER;
        ret = Error_Param;
        break;
    case FP_ERROR_UNKNOWN:
        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FP_ERROR_UNKNOWN, "未知错误");
        m_shErrCode = DEC_UNEXPECTED;
        ret = Error_Param;
        break;
    case FP_ERROR_DEVICECMD:
        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FP_ERROR_DEVICECMD, "通讯错误");
        m_shErrCode = DEC_COMMUNICATION_FAILED;
        ret = Error_DevCommFailed;
        break;
    case FP_ERROR_TIMEOUT:
        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
        snprintf(m_szErrMsg,sizeof(m_szErrMsg), "%d:%s",FP_ERROR_TIMEOUT, "操作超时");
        m_shErrCode = DEC_TIMEOUT;
        ret = Error_TimeOut;
        break;
    case FP_ERROR_CANCEL:
        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FP_ERROR_CANCEL, "操作取消");
        m_shErrCode = DEC_CANCEL;
        ret = Error_Cancel;
        break;
    case FP_ERROR_IMAGE_NOTENOUGH:
        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FP_ERROR_IMAGE_NOTENOUGH, "图像不合格");
        m_shErrCode = DEC_EXCEPTION;
        ret = Error_Param;
        break;
    case FP_ERROR_IS_BUSY:
        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FP_ERROR_IS_BUSY, "设备正忙");
        m_shErrCode = DEC_HARDWARE;
        ret = Error_Busy;
        break;
    case FP_ERROR_FINGER_VERIFY:
        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
        snprintf(m_szErrMsg,sizeof(m_szErrMsg), "%d:%s",FP_ERROR_FINGER_VERIFY, "指纹比对失败");
        m_shErrCode = DEC_INVALID_PARAMETER;
        ret = Error_MisMatched;
        break;
    case FP_ERROR_FINGER_EXTRACT:
        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
        snprintf(m_szErrMsg,sizeof(m_szErrMsg), "%d:%s",FP_ERROR_FINGER_EXTRACT, "合成特征失败");
        m_shErrCode = DEC_INVALID_PARAMETER;
        ret = Error_Param;
        break;
    case FP_ERROR_FINGER_ENROLL:
        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FP_ERROR_FINGER_ENROLL, "合成模板失败");
        m_shErrCode = DEC_INVALID_PARAMETER;
        ret = Error_Param;
        break;
    case FP_ERROR_FINGER_ILLEGAL:
        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
        snprintf(m_szErrMsg,sizeof(m_szErrMsg), "%d:%s",FP_ERROR_FINGER_ILLEGAL, "非法指纹数据");
        m_shErrCode = DEC_INVALID_DATA;
        ret = Error_Param;
        break;
    case FP_ERROR_INVALID_TEMPLATE:
        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
        snprintf(m_szErrMsg,sizeof(m_szErrMsg), "%d:%s",FP_ERROR_INVALID_TEMPLATE, "模板参数错误");
        m_shErrCode = DEC_INVALID_DATA;
        ret = Error_Param;
        break;
    case FP_ERROR_INVALID_FEATURE:
        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FP_ERROR_INVALID_FEATURE, "特征参数错误");
        m_shErrCode = DEC_INVALID_DATA;
        ret = Error_Param;
        break;
    default:
        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",nErrorCode, "其它未定义的错误");
        m_shErrCode = DEC_ERROR_CODE_UNRECOGNIZABLE;
        ret = Error_Param;
        break;
    }
    LogM("FingerPrintClassImpl::Leave->FingerPrint DevOpen()->m_pDll->SaveErrorInfo(int nErrorCode) sucessfull!");
}


ErrorCodeEnum FingerPrintClassImpl::ScanFingerAndSaveImage(const char* imageName)
{
    LOG_FUNCTION();
    LogM("FingerPrintClassImpl::Entry->FingerPrint ScanFingerAndSaveImage(const char* imageName)! <=>imageName = %s",imageName);
    int iRet =0;
    if( !m_bDevOpen )
    {
        SaveErrorInfo("ScanFingerAndSaveImage()->Dev is not open",Error_DevNotAvailable );
        //记日志
        return Error_DevNotAvailable;
    }
    iRet= m_pDll->FPIImg2Bmp(const_cast<char*>(imageName));
    if(iRet != FP_ERROR_SUCCESS)
    {
        SaveErrorInfo(iRet);
        LogM("FingerPrintClassImpl::entry->FingerPrint ScanFingerAndSaveImage()->m_pDll->FPIImg2Bmp failed!");
        return Error_DevMedia;
    }
    LogM("FingerPrintClassImpl::leave->FingerPrint ScanFingerAndSaveImage() sucessfull!");
    return Error_Succeed;
}


//计算特征值,iLength:输入代表buf最大长度,输出为特征实际长度
//Compute features
ErrorCodeEnum FingerPrintClassImpl::Image2Feature(const char* imagePath, LPBYTE lpbFeature, int &iLength)
{
    LOG_FUNCTION();
    LogM("FingerPrintClassImpl::entry FingerPrint->Image2Feature()");
    int iRet =0;
    CHAR strImgPath[256] = {0};
    snprintf(strImgPath, sizeof(strImgPath), "%s%s", m_strModulePath, imagePath); //拼装图片路径
    LogM("自己改造好的PATH=%s",strImgPath);
    if( !m_bDevOpen )
    {
        SaveErrorInfo("Image2Feature()->Dev is not open",Error_DevNotAvailable );
        LogM("FingerPrintClassImpl::entry FingerPrint->Image2Feature()->Dev is not open");
        return Error_DevNotAvailable;
    }
    if(Error_Succeed != ScanFingerAndSaveImage(strImgPath))
    {
        LogM("FingerPrintClassImpl::entry FingerPrint->Image2Feature()->ScanFingerAndSaveImage() failed");
        return Error_DevMedia;
    }
    iRet = m_pDll->FPIBmp2Feature(const_cast<char*>(strImgPath), (char*)lpbFeature, &iLength);
    if(iRet != FP_ERROR_SUCCESS)
    {
        LOG4VTM(INFO,"FingerPrintClassImpl::entry FingerPrint->Image2Feature()->m_pDll->FPIBmp2Feature failed");
        LogM("FingerPrintClassImpl::entry FingerPrint->Image2Feature()->m_pDll->FPIBmp2Feature failed");
        SaveErrorInfo(iRet);
        return Error_DevMedia;
    }
    LogM("特征值长度=%d ",iLength);
    LogM("FingerPrintClassImpl::leave FingerPrint->Image2Feature() scessfull");
    return Error_Succeed;
}

//生成特征模板（注册时使用）
//Convert image to template
ErrorCodeEnum FingerPrintClassImpl::Image2Template(const char* imagePath1, const char* imagePath2, const char* imagePath3, LPBYTE lpbTemplate, int &iLength)
{
    LOG_FUNCTION();
    LogM("FingerPrintClassImpl::entry FingerPrint->Image2Template()");
    LogM("招行传递的图片PATH1=%s ",imagePath1);
    LogM("招行传递的图片PATH2=%s ",imagePath2);
    LogM("招行传递的图片PATH3=%s ",imagePath3);
    int iRet =0;
    CHAR strImgPath1[256] = {0};
    CHAR strImgPath2[256] = {0};
    CHAR strImgPath3[256] = {0};
    memcpy(strImgPath1,imagePath1,strlen(imagePath1));
    memcpy(strImgPath2,imagePath2,strlen(imagePath2));
    memcpy(strImgPath3,imagePath3,strlen(imagePath3));

    if( !m_bDevOpen )
    {
        SaveErrorInfo("Image2Template()->Dev is not open",Error_DevNotAvailable );
        return Error_DevNotAvailable;
    }
    iRet = m_pDll->FPIBmp2Template(const_cast<char*>(imagePath1), const_cast<char*>(imagePath2), const_cast<char*>(imagePath3), (char*)lpbTemplate,&iLength);
    if(iRet != FP_ERROR_SUCCESS)
    {
        SaveErrorInfo(iRet);
        LOG4VTM(INFO,"FingerPrintClassImpl::leave FingerPrint->Image2Template() failed ");
        return Error_DevMedia;
    }
    LogM("FingerPrintClassImpl::leave FingerPrint->Image2Template() scessfull!");
    LogM("模板值长度=%d ",iLength);
    LogM("FingerPrintClassImpl::leave FingerPrint->Image2Template() scessfull!");
    return Error_Succeed;
}

ErrorCodeEnum FingerPrintClassImpl::Match(LPBYTE lpbTemplate[], int iTemplateLen[] ,int templateNum, LPBYTE lbpFeature, int &iFeatureLen ,int level)
{
   LOG_FUNCTION();
   LogM("FingerPrintClassImpl::entry FingerPrint->Match()");
   LogM("模板数组的个数=%d ",templateNum);
   LogM("特征值长度=%d ",iFeatureLen);
   int iRet =0;
   if( !m_bDevOpen )
   {
       SaveErrorInfo("Match()->Dev is not open",Error_DevNotAvailable );
       LogM("FingerPrintClassImpl::leave FingerPrint->Match() failed");
       return Error_DevNotAvailable;
   }

   for(int i=0; i<templateNum;i=i+1)
   {
       LogM("当前模板[%d]的长度=%d ",i,iTemplateLen[i]);
       iRet = m_pDll->FPIMatch((char*)(lpbTemplate[i]), (char*)(lbpFeature), level);
       if (iRet == FP_ERROR_SUCCESS)
       {
           iTemplateLen[i]=1;
       }
       else
       {
           iTemplateLen[i]=0;
       }      
       LogM("与每个模板匹配的结果iTemplateLen[%d] = %d",i,iTemplateLen[i]);
   }
   LogM("FingerPrintClassImpl::leave FingerPrint->Match() scessfull");
   return Error_Succeed;
}

//取消采集指纹图片
ErrorCodeEnum FingerPrintClassImpl::Cancel()
{
    LOG_FUNCTION();
    LogM("FingerPrintClassImpl::entry FingerPrint->Cancel()!");
    int iRet =0;
    if( !m_bDevOpen )
    {
        //SaveErrorInfo("Cancel()->Dev is not open",Error_DevNotAvailable );
        LOG4VTM(INFO,"FingerPrintClassImpl::leave FingerPrint->Cancel() failed");
        return Error_DevNotAvailable;
    }
    iRet = m_pDll->FPICancel();
    if(iRet != FP_ERROR_SUCCESS)
    {
        SaveErrorInfo(iRet);
        LOG4VTM(INFO,"FingerPrintClassImpl::leave FingerPrint->Cancel() failed");
        return Error_DevMedia;
    }
    LogM("FingerPrintClassImpl::leave FingerPrint->Cancel() scessfull");
    return Error_Succeed;
}