Tech5_GalleryMatcher_ServerE.h

#ifndef TECH5_GALLERY_MATCHER_SERVER_E_H
#define TECH5_GALLERY_MATCHER_SERVER_E_H
 
#include <vector>
#include <string>
 
#include "coreSdk.h"
 
 
#ifdef _WINDOWS
    #ifdef TECH5_FINGER_SDK_BUILD_dll
        #define TECH5_FINGER_EXPORT __declspec(dllexport)
    #else
        #define TECH5_FINGER_EXPORT __declspec(dllimport)
    #endif
#elif defined (__linux__)
    #define TECH5_FINGER_EXPORT __attribute__((visibility("default")))
#else
    #define TECH5_FINGER_EXPORT __attribute__((visibility("default")))
#endif
 
 
 
namespace Tech5Finger {
    
 
    const static uint32_t 
        
        SUCCESS = 0,
        LICENSE_FILE_NAME_INVALID = 1,
        LOW_MEMORY = 2,
        IMAGE_TOO_BIG = 3,
        NO_IMAGE = 4,
        IMAGE_PROCESSING_FAILED = 5,
        WRONG_FINGER_POS = 6,
        WSQ_INIT_FAILED = 7,
        WRONG_WSQ_IMAGE = 8,
        WSQ_FAILED = 9,
        VERIFICATION_FAILED = 10,
        WRONG_TEMPLATE = 11,
        NO_SAME_FINGERS = 12,
        WRONG_PARAMETRS = 13,
        UNPACK_INIT_FAILED = 14,
        ACCEL_CORRUPT = 15,
        NOT_SUPPORT_SSSE3 = 16,
        ACCEL_CALC_ERR = 17,
        NO_FINGERS_GOOD_FOR_ACCEL = 18,
        ACCEL_MATCHING_FAILED = 19,
        DOUBLE_ID = 20,
        IDENTIFICATION_FAILED = 21,
        NO_LICENSE = 22,
        MAX_GALLERY_SIZE_REACHED = 23,
        NO_SUCH_RECORD = 24,
        NOT_SUPPORT_SSE4_2 = 25,
        WRONG_IDENTIFY_MODE = 26,
        NO_TEMPLATE = 27,
        WRONG_IMAGE_TYPE = 28,
        CONVERT_FAILED = 29,
        WRONG_IMAGE    = 30,
        WRONG_IMAGE_DPI = 31,
        TOO_LITTLE_MINUTIAE = 32,
        MATCH_FAILED        = 33,
        NULL_TEMPLATE       = 34,
        INSERT_ERR          = 35,   
       FINAL_MATCH_INIT_FAILED = 36,
       FINAL_MATCH_FAILED = 37,
       UPLOAD_DB_OVERFLOW = 38,
         UNKNOWN_EXCEPTION = 100;     
    
       // end of ErrorGroup Error codes
 
 
 
   TECH5_FINGER_EXPORT const char * getVersion();
   
   struct candidates_string
   {
       std::string uid;    
      union
      {
         FINGERS  finger;
         PalmPart palmPart;
      };
       float score;
      float logFAR;
      candidates_string()
      {
         finger = FINGERS::FINGPOS_UK;
         score  = 0         ;       
         logFAR = 0;
      }
   };
 
   class TECH5_FINGER_EXPORT TemplateCreator
   {
   public:
      static TemplateCreator*   create();              
      static void cancel(TemplateCreator *&templateCreator);    
      static uint32_t  get_max_template_size (char imageType);
      virtual ~TemplateCreator() {}
 
      virtual bool init_license(const char *licensePath, void* env = nullptr ) = 0;
      virtual uint32_t createTemplate (ImageData &image, uint8_t *fpTemplate, uint32_t &templateSize, 
                                       uint8_t* skeleton, uint32_t& skeletonSize, uint8_t& quality, char imageType,
                                       bool doSegmentation) = 0;
   };  // TemplateCreator
 
   class TECH5_FINGER_EXPORT FpTemplateChecker
   {
   public:
      static FpTemplateChecker* create();                        
      
      static void cancel(FpTemplateChecker *&checker);  
      virtual ~FpTemplateChecker() {}
      virtual bool check (uint8_t *fpTemplate) = 0;
   }; // FpTemplateChecker
 
   
   #define MATCHING_SPEED_DEF  NORMAL_MATCH_SPEED
 
   struct MatchingParameters
   {
      MATCH_SPEED  searchSpeed;
      unsigned int   maxAngle;     
      unsigned int   maxAngleThumbs;     
      MATCHING_MODE  matchingMode;                 
 
      MatchingParameters()
      {
         searchSpeed                   = MATCH_SPEED::MATCHING_SPEED_DEF ;
         maxAngle                      = MAX_ANGLE_DEF      ;
         maxAngleThumbs                = MAX_ANGLE_DEF      ;
         matchingMode                  = MATCHING_MODE::NORMAL_MATCHING_MODE;
      }
   }; // MatchingParameters
   enum IDENTIFY_MODE
   {
      FAST_IDENTIFY   = 0,           
      SLOW_IDENTIFY  = 1,             
   };
 
 
   class TECH5_FINGER_EXPORT Matcher
   {
   public:
      static Matcher*   create(IDENTIFY_MODE identify_mode, bool check_doubles);                        
      static void cancel(Matcher *&matcher);    
      virtual ~Matcher() {}
 
      static uint32_t  get_max_template_size ();
      virtual bool init_license(const char *licensePath) = 0;  
        virtual uint32_t verify_record(MatchingParameters &matchingParameters, TpTemplate &tpTemplate1, TpTemplate &tpTemplate2, double &score, double& logFAR) = 0;
 
      virtual uint32_t insert_record (const std::string &id, TpTemplate &tpTemplate, PersonalData *personalData) = 0;
      virtual uint32_t delete_record (const std::string &id) = 0;
      virtual uint64_t get_final_gallery_size() const = 0;
      virtual bool isRecordExist(const std::string &id) = 0;
 
 
/******************************************************************************************************************
   Identify in 'FAST_IDENTIFY' mode (1 step identification)
******************************************************************************************************************/
      virtual uint32_t identify_record   (MatchingParameters             &matchingParameters    , 
                                          TpTemplate                     &probe                 , 
                                          PersonalData                   *probePersonalData     ,
                                          const uint32_t                  numberOfThreads       , 
                                          const uint32_t                  candidate_list_length , 
                                          std::vector<candidates_string> &candidate_list         ) = 0;
/******************************************************************************************************************
   Identify in 'SLOW_IDENTIFY' mode (2 steps identification)
   NOTE: whole cicle of matching:
   -call identify_record_1st
   - call clean_gallery_2nd
   - multiple call insert_record_2nd
   - call identify_record_2nd
 
   should be performed before another identification will be started.
******************************************************************************************************************/
      virtual uint32_t identify_record_1st(MatchingParameters             &matchingParameters    , 
                                           TpTemplate                     &probe                 , 
                                           PersonalData                   *probePersonalData     ,
                                           const uint32_t                  numberOfThreads       ,
                                           const uint32_t                  candidate_list_length , 
                                           std::vector<string>            &candidate_list_id      ) = 0;
      virtual void clean_gallery_2nd () = 0;
      virtual uint32_t insert_record_2nd (const std::string &id, TpTemplate &tpTemplate) = 0;
 
      virtual uint32_t identify_record_2nd( MatchingParameters             &matchingParameters   , 
                                           TpTemplate                     &probe                 , 
                                           const uint32_t                  numberOfThreads       , 
                                           const uint32_t                  candidate_list_length , 
                                           std::vector<candidates_string> &candidate_list         ) = 0;
}; // Matcher
 
 
class TECH5_FINGER_EXPORT LT_Matcher
{
public:
   static LT_Matcher* create(IDENTIFY_MODE identify_mode, bool check_doubles);
   static void cancel(LT_Matcher*& matcher);
   virtual ~LT_Matcher() {}
 
   static uint32_t  get_max_template_size();
   virtual bool init_license(const char* licensePath) = 0;
   virtual uint32_t verify_latent(MatchingParameters& matchingParameters, uint8_t *latent_template, uint8_t *finger_template, double& score, double &logFAR) = 0;
   virtual uint32_t insert_record(std::string& id, TpTemplate& tpTemplate) = 0;
   virtual uint32_t delete_record(std::string& id) = 0;
   virtual uint64_t get_final_gallery_size() const = 0;
   virtual bool isRecordExist(std::string& id) = 0;
 
 
   /******************************************************************************************************************
      Identify in 'FAST_IDENTIFY' mode (1 step identification)
   ******************************************************************************************************************/
   virtual uint32_t identify_LT(MatchingParameters             &matchingParameters   ,
                                uint8_t                        *latent_template      ,
                                uint8_t                         fingerMask[10]       ,
                                const uint32_t                  number_threads       ,
                                const uint32_t                  candidate_list_length,
                                std::vector<candidates_string> &candidate_list        ) = 0;
 
}; // LT_Matcher
 
class TECH5_FINGER_EXPORT Latent_Matcher
{
public:
   static Latent_Matcher* create(IDENTIFY_MODE identify_mode, bool check_doubles);
   static void cancel(Latent_Matcher*& matcher);
   virtual ~Latent_Matcher() {}
 
   static uint32_t  get_max_template_size();
   virtual bool init_license(const char* licensePath) = 0;
   virtual uint32_t verify_latent(MatchingParameters &matchingParameters, 
                                  uint8_t            *latent_template, 
                                  uint8_t            *finger_template, 
                                  double             &score,
                                  double             &logFAR) = 0;
   
   virtual uint32_t insert_latent(std::string& id, uint8_t *latent) = 0;
 
   virtual uint32_t delete_record(std::string& id) = 0;
   virtual uint64_t get_final_gallery_size() const = 0;
   virtual bool isRecordExist(std::string& id) = 0;
 
 
   /******************************************************************************************************************
      Identify in 'FAST_IDENTIFY' mode (1 step identification)
   ******************************************************************************************************************/
   virtual uint32_t identify_TL(MatchingParameters             &matchingParameters,
                                TpTemplate                     &probeTpTemplate,
                                const uint32_t                  number_threads,
                                const uint32_t                  candidate_list_length,
                                std::vector<candidates_string> &candidate_list) = 0;
                                
   virtual uint32_t identify_LL( MatchingParameters             &matchingParameters,
                                 uint8_t                        *latent_template,
                                 const uint32_t                  number_threads,
                                 const uint32_t                  candidate_list_length,
                                 std::vector<candidates_string> &candidate_list) = 0;
}; // Latent_Matcher
 
class TECH5_FINGER_EXPORT Palm_Matcher
{
public:
   static Palm_Matcher* create(IDENTIFY_MODE identify_mode, bool check_doubles);
   
   static void cancel(Palm_Matcher*& matcher);
   
   virtual ~Palm_Matcher() {}
 
   static uint32_t  get_max_template_size();
   
   virtual bool init_license(const char* licensePath) = 0;
   
   virtual uint32_t verify_palm(MatchingParameters &matchingParameters, 
                                uint8_t            *probe_palm_template, 
                                uint8_t            *gallery_palm_template, 
                                double             &score,
                                double             &logFAR) = 0;
   
   virtual uint32_t insert_record(std::string& id, TpTemplate& palmTemplate) = 0;
   
   virtual uint32_t delete_record(std::string& id) = 0;
   
   virtual uint64_t get_final_gallery_size() const = 0;
   
   virtual bool isRecordExist(std::string& id) = 0;
 
 
   /******************************************************************************************************************
      Identify in 'FAST_IDENTIFY' mode (1 step identification)
   ******************************************************************************************************************/
   virtual uint32_t identify_PP(MatchingParameters             &matchingParameters,
                                TpTemplate                      probe_palm_template,
                                const uint32_t                  number_threads,
                                const uint32_t                  candidate_list_length,
                                std::vector<candidates_string> &candidate_list) = 0;
 
   virtual uint32_t identify_LPP(MatchingParameters             &matchingParameters,
                                 uint8_t                        *probe_palm_template,
                                 uint8_t                         palmPartMask[NUM_PALM_PARTS],
                                 const uint32_t                  number_threads,
                                 const uint32_t                  candidate_list_length,
                                 std::vector<candidates_string>& candidate_list) = 0;
}; // Palm_Matcher
 
class TECH5_FINGER_EXPORT Latent_Palm_Matcher
{
public:
   static Latent_Palm_Matcher* create(IDENTIFY_MODE identify_mode, bool check_doubles);
 
   static void cancel(Latent_Palm_Matcher*& matcher);
 
   virtual ~Latent_Palm_Matcher() {}
 
   static uint32_t  get_max_template_size();
 
   virtual bool init_license(const char* licensePath) = 0;
 
   virtual uint32_t verify_palm(MatchingParameters& matchingParameters,
                                 uint8_t *probe_palm_template,
                                 uint8_t *gallery_palm_template,
                                 double  &score,
                                 double  &logFAR) = 0;
 
   virtual uint32_t insert_record(std::string& id, uint8_t *palmTemplate) = 0;
 
   virtual uint32_t delete_record(std::string& id) = 0;
 
   virtual uint64_t get_final_gallery_size() const = 0;
 
   virtual bool isRecordExist(std::string& id) = 0;
 
 
   /******************************************************************************************************************
      Identify in 'FAST_IDENTIFY' mode (1 step identification)
   ******************************************************************************************************************/
   virtual uint32_t identify_PLP(MatchingParameters& matchingParameters,
                                 TpTemplate                      probe_palm_template,
                                 const uint32_t                  number_threads,
                                 const uint32_t                  candidate_list_length,
                                 std::vector<candidates_string>& candidate_list) = 0;
 
   virtual uint32_t identify_LPLP(MatchingParameters& matchingParameters,
                                  uint8_t                        *probe_palm_template,
                                  const uint32_t                  number_threads,
                                  const uint32_t                  candidate_list_length,
                                  std::vector<candidates_string>& candidate_list) = 0;
}; // Latent_Palm_Matcher
 
 
} // namespace Tech5Finger {
 // end of Gallery Matcher ServerE
 
#endif // TECH5_GALLERY_MATCHER_SERVER_E_H