coreSdk.h

/*****************************************************************************
    coreSdk.h - the common header file for all components of Core Matching SDKs
 
    The Core Matching SDKs is the high-level tools, intended for easy creating
    of your own scalable biometric applications that use the person's fingerprint for 
    identification or verification purpose. 
        
*******************************************************************************/
 
#ifndef CORE_SDK_H__
#define CORE_SDK_H__
 
 
#ifdef __cplusplus
   #include <set>
   #include <string>
#include <functional>
   using namespace std;
#endif
 
#include "assert.h"
 
#include "common.h"
 
 
#ifdef __cplusplus
   extern "C"{
#endif
 
 
/******************************************************************
          THE CONSTANRS
*****************************************************************/
#pragma pack(push, _CORE_PACKING)
 
ENUM_DECLARATION MATCHING_MODE
{
   NORMAL_MATCHING_MODE             = 0,  
   CHECK_MIX_FINGER_MATCHING_MODE   = 1,  
   CHECK_MIX_SLAP_MATCHING_MODE     = 2,  
   CHECK_MIX_HAND_MATCHING_MODE     = 3,  
};
 
ENUM_DECLARATION FUSION_MODE
{
    OPTIMAL_FUSION_MODE     = 0,    
    LOW_BINNING_FUSION_MODE = 1,    
    HIGH_BINNING_FUSION_MODE = 2, 
};
 
ENUM_DECLARATION SINGULAR_TYPE
{
   WHORL = 1,  
   LOOP  = 2,
   DELTA = 8
};
 
 
ENUM_DECLARATION PATTERN_TYPE
{
   ARCHSC   =   0x01,                   
   ARCHSU   =   0x02,                   
   LOOPRC   =   0x04,                   
   LOOPRU   =   0x08,                   
   LOOPLC   =   0x10,                   
   LOOPLU   =   0x20,               
   WHORLC   =   0x40,               
   WHORLU   =   0x80                    
};
 
ENUM_DECLARATION FP_TYPE
{
   UNKNOWN    = 0,
   ROLLED     = 1,       
   FLAT       = 2,    
   // latent
   LATENT     = 3,          
};
 
 
#define MAX_PROTECT_LEN       512     // maximum lenght of protect buffer
 
#define MAX_SINGULAR            16    // maximum number of singularity
 
#define MIN_RESOLUTION         250    // minimum supported image resolution
#define MAX_RESOLUTION         1000   // maximum supported image resolution
// if source image dpi is different from 500 dpi more than DPI_TOL then image will be stretched 
// before image processing
#define DPI_TOL                5
 
 
#define MAX_SENSOR_NAME        50     // maximum length of sensor name
#define MAX_SENSORS            50     // maximum number of supported sensors
#define ENDLESSLY              -1     // the special value for unlimited timeout
 
#define MIN_REL_POINTS         32     // minimum number of reliable points
#define MAX_SCORE              10000  // maximum value for score  
 
// default parameters
#define SEARCH_SPEED_DEF       LOWEST_MATCH_SPEED
#define MAX_ANGLE_DEF          180
#define MAX_DISP_DEF           400
#define LOW_THRESHOLD_DEF      0
#define HIGH_THRESHOLD_DEF     MAX_SCORE
#define MIN_MATCH_DEF          1
#define MAX_MATCH_DEF          10
 
#define DEF_MAX_FRAMES         8
 
 
 
 
 
struct TemplateData
{
    enum FINGERS numFinger;     
    uint8_t        *fpTemplate;    
 
#ifdef __cplusplus
   TemplateData()
   {
      numFinger  = FINGERS::FINGPOS_UK;
      fpTemplate = 0;
   }
#endif
};
 
struct CaptureData
{
    enum FINGERS  numFinger;   
    uint8_t         *dib;         
                              
};
 
#pragma pack (push, _CORE_TIGHT)
struct P_PACKED_1 TemplHeader
{
   uint32_t       size;              
   int8_t           specialFields[7];  
   uint16_t points;            
   uint8_t           relPoints;         
   uint8_t           quality;           
   uint8_t           reserved[5];
   uint8_t           version;
#ifdef __cplusplus
   TemplHeader()
   {
      memset (this, 0, sizeof(TemplHeader));
   }
#endif
};
 
 
struct P_PACKED_1 Frame
{
    int32_t left;
    int32_t right;
    int32_t top;
    int32_t bottom;
 
#ifdef __cplusplus
   Frame()
   {
      left = right = top = bottom = 0;
   }
 
   Frame& operator= (Frame &frame)
   {
      left      = frame.left;
      right     = frame.right;
      top       = frame.top;
      bottom    = frame.bottom;
      return *this;
   }
 
   Frame(const Frame& frame)
   {
       this->left = frame.left;
       this->right = frame.right;
       this->top = frame.top;
       this->bottom = frame.bottom;
   }
#endif
};
#pragma pack (pop)
 
#ifdef __cplusplus
struct Singular : public ::Feature
{
   SINGULAR_TYPE  type;         
};
#else
struct Singular
{
   int32_t                    x;                
   int32_t                    y;                
   uint8_t              prob;           
   int32_t                  angle;      
   uint8_t              density;  
   enum SINGULAR_TYPE   type;           
};
#endif
 
ENUM_DECLARATION Sex
{
   SEX_X = 0,
   SEX_M = 1,
   SEX_F = 2,
   SEX_G = 3,
   SEX_N = 4,
   SEX_Y = 5,
   SEX_Z = 6,
};
 
 
struct SearchParam
{
   enum MATCH_SPEED  searchSpeed;  
   uint32_t      maxAngle;     
   uint32_t      maxAngleThumbs;     
   uint32_t      maxDisp;      
   int32_t              lowThreshold;
   int32_t              highThreshold;
   uint32_t      minMatch;
   uint32_t      maxMatch;
   enum MATCHING_MODE     matchingMode;  
   enum FUSION_MODE       fusionMode;  
 
#ifdef __cplusplus
   SearchParam()
   {
      searchSpeed    = MATCH_SPEED::SEARCH_SPEED_DEF;
      maxAngle       = MAX_ANGLE_DEF;
      maxAngleThumbs = MAX_ANGLE_DEF;
      maxDisp        = MAX_DISP_DEF;
      lowThreshold   = LOW_THRESHOLD_DEF;
      highThreshold  = HIGH_THRESHOLD_DEF;
      minMatch       = MIN_MATCH_DEF;
      maxMatch       = MAX_MATCH_DEF;
      matchingMode   = MATCHING_MODE::NORMAL_MATCHING_MODE;
      fusionMode     = FUSION_MODE::OPTIMAL_FUSION_MODE;
   }
#endif
};
 
 
struct  ProcessParam
{
   bool doSegmentation;                
   bool allowsIncreaseFrame;
   bool ISO_compatible;
   uint32_t maxWidth;     
   uint32_t maxHeight;
   bool isLatent;
 
#ifdef __cplusplus
   ProcessParam()
   {
      doSegmentation          = true;
      allowsIncreaseFrame     = true;
      isLatent                = false;
      ISO_compatible          = false;
      maxWidth                = MAX_WIDTH;
      maxHeight               = MAX_HEIGHT;
   }
   
   ProcessParam& operator= (ProcessParam &param)
   {
      memcpy(this, &param, sizeof(ProcessParam));
      return *this;
   }
 
   ProcessParam(const ProcessParam& param)
   {
       this->doSegmentation = param.doSegmentation;
       this->allowsIncreaseFrame = param.allowsIncreaseFrame;
       this->isLatent = param.isLatent;
       this->ISO_compatible = param.ISO_compatible;
       this->maxWidth = param.maxWidth;
       this->maxHeight = param.maxHeight;
   }
#endif
};
 
struct MatchResultTT
{
   int32_t          fusionScore;     
   int32_t          score[10];       
   int8_t         galleryPair[10]; 
   uint32_t      numMatched;      
 
#ifdef __cplusplus   
   MatchResultTT()
   {
      clear();
   }
   void clear()
   {
      fusionScore = 0;
      numMatched  = 0;
      clearScore();
   }
   void clearScore()
   {
      for(int32_t pos = 0; pos < 10; pos++)
      {
         score      [pos]  =  0;
         galleryPair[pos]  = -1;
      }
   }
#endif
};
 
ENUM_DECLARATION PalmPart
{
   UNKNOWN_PALM             = 0,
   RIGHT_LOWER_PALM         = 1 ,
   RIGHT_UPPER_PALM         = 2 ,
   RIGHT_WRITER_PALM        = 3 ,
   RIGHT_THENAR_PALM        = 4 ,
   RIGHT_HYPOTHENAR_PALM    = 5 ,
   RIGHT_INTERDIGITAL_PALM  = 6 ,
   LEFT_LOWER_PALM          = 7 ,
   LEFT_UPPER_PALM          = 8 ,
   LEFT_WRITER_PALM         = 9 ,
   LEFT_THENAR_PALM         = 10 ,
   LEFT_HYPOTHENAR_PALM     = 11,
   LEFT_INTERDIGITAL_PALM   = 12
};
static const uint32_t NUM_PALM_PARTS = 12;
 
static const int8_t* getPalmPartName(int32_t palmPartPos)
{
   switch (palmPartPos)
   {
   case 0:
      return (int8_t*)"unknown palm";
      break;
   case 1:
      return (int8_t*)"right lower palm";
      break;
   case 2:
      return (int8_t*)"right upper palm";
      break;
   case 3:
      return (int8_t*)"right writer's palm";
      break;
   case 4:
      return (int8_t*)"right thenar palm";
      break;
   case 5:
      return (int8_t*)"right hypothenar palm";
      break;
   case 6:
      return (int8_t*)"right interdigital palm";
      break;
   case 7:
      return (int8_t*)"left lower palm";
      break;
   case 8:
      return (int8_t*)"left upper palm";
      break;
   case 9:
      return (int8_t*)"left writer's palm";
      break;
   case 10:
      return (int8_t*)"left thenar palm";
      break;
   case 11:
      return (int8_t*)"left hypothenar palm";
      break;
   case 12:
      return (int8_t*)"left interdigital palm";
      break;
   default:
      assert(false);
   }
   return 0;
}
 
static const int8_t* getFingerName(enum FINGERS fingerPos)
{
   switch (fingerPos)
   {
#ifdef __cplusplus
   case FINGERS::FINGPOS_RT :
      return (int8_t*)"right thumb";
      break;
   case FINGERS::FINGPOS_RI :
      return (int8_t*)"right index";
      break;
   case FINGERS::FINGPOS_RM :
      return (int8_t*)"right middle";
      break;
   case FINGERS::FINGPOS_RR :
      return (int8_t*)"right ring";
      break;
   case FINGERS::FINGPOS_RL :
      return (int8_t*)"right lettle";
      break;
   case FINGERS::FINGPOS_LT :
      return (int8_t*)"left thumb";
      break;
   case FINGERS::FINGPOS_LI :
      return (int8_t*)"left index";
      break;
   case FINGERS::FINGPOS_LM :
      return (int8_t*)"left middle";
      break;
   case FINGERS::FINGPOS_LR :
      return (int8_t*)"left ring";
      break;
   case FINGERS::FINGPOS_LL :
      return (int8_t*)"left lettle";
      break;
#else
       case FINGPOS_RT :
          return (int8_t*)"right thumb";
          break;
       case FINGPOS_RI :
          return (int8_t*)"right index";
          break;
       case FINGPOS_RM :
          return (int8_t*)"right middle";
          break;
       case FINGPOS_RR :
          return (int8_t*)"right ring";
          break;
       case FINGPOS_RL :
          return (int8_t*)"right lettle";
          break;
       case FINGPOS_LT :
          return (int8_t*)"left thumb";
          break;
       case FINGPOS_LI :
          return (int8_t*)"left index";
          break;
       case FINGPOS_LM :
          return (int8_t*)"left middle";
          break;
       case FINGPOS_LR :
          return (int8_t*)"left ring";
          break;
       case FINGPOS_LL :
          return (int8_t*)"left lettle";
          break;
#endif
   default:
      assert(false);
   }
   return 0;
}
 
 
struct TpTemplate
{
   uint8_t *m_templ[20];
 
#ifdef __cplusplus
   TpTemplate()
   {
      memset(this, 0, sizeof(TpTemplate));
   }
   TpTemplate& operator= (const TpTemplate& tp)
   {
      for(uint32_t i = 0; i < 20; i++)
         this->m_templ[i] = tp.m_templ[i];
      return *this;
   }
   TpTemplate(const TpTemplate& tp)
   {
      *this = tp;
   }
   void clear()
   {
      for(uint32_t i = 0; i < 20; i++)
         m_templ[i] = NULL;
   }
#endif
};
 
struct RL                       
{
   uint64_t regNum;                  
   int32_t  finger;                  
   int32_t  score;                  
};
 
#ifdef __cplusplus
struct RLex : public RL
{
   RLex()
   {
      this->regNum = 0;
      this->finger = 0;
      this->score = 0;
   }
   RLex(int64_t regNum, int32_t finger, int32_t score)
   {
      this->regNum = regNum;
      this->finger = finger;
      this->score  = score ;
   }
   bool operator< (const RLex &rl) const
   {
      return this->score < rl.score;
   }
   operator int32_t () const
   {
      return this->score;
   }
};
typedef std::multiset <RLex, std::greater<int32_t> > RL_SET;
 
 
struct Base_GalleryItem
{
   std::string m_id;
   Base_GalleryItem()
   {
   }
   Base_GalleryItem(std::string id)
   {
      m_id = id;
   }
   ~Base_GalleryItem() { }
   Base_GalleryItem& operator= (const Base_GalleryItem& item)
   {
      m_id = item.m_id;
      return *this;
   }
   Base_GalleryItem(const Base_GalleryItem& item)
   {
      *this = item;
   }
};
 
/******************************************************************
          FUNCTION TYPEDEF
******************************************************************/
typedef bool (*ON_PRE_PROCESS)(const LPVOID pContext, FINGERS  finger, ::Frame &frame);
 
typedef bool (*ON_GET_QUALITY)(const LPVOID pContext, FINGERS finger, int quality);
 
typedef bool (*ON_PROCESS_1)(
                       const LPVOID         pContext, 
                             FINGERS        finger, 
                             unsigned int   pattern, 
                             unsigned int   numSingularity,
                             const Singular singular[MAX_SINGULAR]);
 
typedef bool (*ON_SKELETON)(const LPVOID pContext, FINGERS finger, uint8_t *skeleton, int skeletonSize);
 
 
#endif //#ifdef __cplusplus
 
#pragma pack(pop)
#ifdef __cplusplus
   } // extern "C"{
#endif
 
#endif // CORE_SDK_H__