n2n.h

 
#ifndef N2N_H_
#define N2N_H_
 
#include <cstdint>
#include <string>
#include <memory>
#include <vector>
 
#include <be_finger.h>
#include <be_image_raw.h>
#include <be_io_recordstore.h>
#include <be_memory_autoarray.h>
 
namespace N2N
{
        struct FingerImage
        {
                FingerImage() = default;
 
                FingerImage(
                    const BiometricEvaluation::Finger::Position &fgp,
                    const BiometricEvaluation::Finger::Impression &imp,
                    const uint8_t nfiq2,
                    const std::shared_ptr<BiometricEvaluation::Image::Raw>
                    &rawImage) :
                    fgp{fgp},
                    imp{imp},
                    nfiq2{nfiq2},
                    rawImage{rawImage} {}
 
                BiometricEvaluation::Finger::Position fgp{
                    BiometricEvaluation::Finger::Position::Unknown};
                BiometricEvaluation::Finger::Impression imp{
                    BiometricEvaluation::Finger::Impression::Unknown};
                uint8_t nfiq2{254};
                std::shared_ptr<BiometricEvaluation::Image::Raw> rawImage{};
        };
        using FingerImage = struct FingerImage;
 
        struct Candidate
        {
                Candidate() = default;
 
                Candidate(
                    const std::string &templateID,
                    double similarity) :
                    templateID{templateID},
                    similarity{similarity} {}
 
                std::string templateID{};
                double similarity{-1};
        };
        using Candidate = struct Candidate;
 
        enum class StatusCode
        {
                Success = 0,
                ImageSizeNotSupported = 1,
                TemplateTypeNotSupported = 2,
                FailedToExtract = 3,
                FailedToSearch = 4,
                FailedToParseInput = 5,
                InsufficientResources = 6,
                Vendor = 7
        };
 
        inline std::ostream&
        operator<<(
            std::ostream &s,
            const StatusCode &sc)
        {
                switch (sc) {
                case StatusCode::Success:
                        return (s << "Success");
                case StatusCode::ImageSizeNotSupported:
                        return (s << "Image size not supported");
                case StatusCode::TemplateTypeNotSupported:
                        return (s << "Template type not supported");
                case StatusCode::FailedToExtract:
                        return (s << "Failed to extract");
                case StatusCode::FailedToSearch:
                        return (s << "Failed to search");
                case StatusCode::FailedToParseInput:
                        return (s << "Failed to parse input");
                case StatusCode::InsufficientResources:
                        return (s << "Insufficient resources");
                case StatusCode::Vendor:
                        return (s << "Vendor-defined");
                }
        }
 
        struct ReturnStatus
        {
                ReturnStatus() = default;
 
                ReturnStatus(
                    const StatusCode code,
                    const std::string info) :
                    code{code},
                    info{info} {}
 
                StatusCode code{StatusCode::Success};
                std::string info{};
        };
        using ReturnStatus = struct ReturnStatus;
 
        inline std::ostream&
        operator<<(
            std::ostream &s,
            const ReturnStatus &rs)
        {
                return (s << "Code: " << rs.code << " Info: '" << rs.info <<
                    '"');
        }
 
        enum class InputType
        {
                Capture,
                Latent
        };
 
        class Interface;
        class Interface
        {
        public:
                virtual void
                getIDs(
                    std::string &identifier,
                    uint32_t &revision,
                    std::string &email) = 0;
 
                virtual ReturnStatus
                initMakeEnrollmentTemplate(
                    const std::string &configurationDirectory) = 0;
 
                virtual ReturnStatus
                makeEnrollmentTemplate(
                    const std::vector<FingerImage> &standardImages,
                    const std::vector<BiometricEvaluation::Memory::uint8Array>
                    &proprietaryImages,
                    BiometricEvaluation::Memory::uint8Array
                    &enrollmentTemplate) = 0;
 
                virtual ReturnStatus
                finalizeEnrollment(
                    const std::string &configurationDirectory,
                    const std::string &enrollmentDirectory,
                    const uint8_t nodeCount,
                    const uint64_t nodeMemory,
                    BiometricEvaluation::IO::RecordStore
                    &enrollmentTemplates) = 0;
 
                virtual ReturnStatus
                initMakeSearchTemplate(
                    const std::string &configurationDirectory,
                    const InputType &inputType) = 0;
 
                virtual ReturnStatus
                makeSearchTemplate(
                    const std::vector<FingerImage> &standardImages,
                    const std::vector<BiometricEvaluation::Memory::uint8Array>
                    &proprietaryImages,
                    BiometricEvaluation::Memory::uint8Array
                    &searchTemplate) = 0;
 
                virtual ReturnStatus
                initIdentificationStageOne(
                    const std::string &configurationDirectory,
                    const std::string &enrollmentDirectory,
                    const InputType &inputType,
                    const uint8_t nodeNumber) = 0;
 
                virtual ReturnStatus
                identifyTemplateStageOne(
                    const std::string &searchID,
                    const BiometricEvaluation::Memory::uint8Array
                    &searchTemplate,
                    const std::string &stageOneDataDirectory) = 0;
 
                virtual ReturnStatus
                initIdentificationStageTwo(
                    const std::string &configurationDirectory,
                    const std::string &enrollmentDirectory,
                    const InputType &inputType) = 0;
 
                virtual ReturnStatus
                identifyTemplateStageTwo(
                    const std::string &searchID,
                    const std::string &stageOneDataDirectory,
                    std::vector<Candidate> &candidates) = 0;
 
                static std::shared_ptr<Interface>
                getImplementation();
 
                virtual ~Interface() = default;
        };
}
 
#endif  /*  N2N_H_ */