pftiii.h

 
#ifndef PFTIII_H_
#define PFTIII_H_
 
#include <cstddef>
#include <filesystem>
#include <memory>
#include <string>
#include <tuple>
#include <vector>
 
namespace PFTIII
{
        enum class Impression
        {
                PlainContact = 0,
                RolledContact = 1,
                LiveScanSwipe = 8,
                PlainContactlessStationary = 24,
                RolledContactlessStationary = 25,
                Unknown = 29,
                RolledContactlessMoving = 41,
                PlainContactlessMoving = 42
        };
 
        enum class FrictionRidgeCaptureTechnology
        {
                Unknown = 0,
                ScannedInkOnPaper = 2,
                OpticalTIRBright = 3,
                OpticalDirect = 5,
                Capacitive = 9,
                Electroluminescent = 11,
        };
 
        enum class FrictionRidgeGeneralizedPosition
        {
                Unknown = 0,
                RightThumb = 1,
                RightIndex = 2,
                RightMiddle = 3,
                RightRing = 4,
                RightLittle = 5,
                LeftThumb = 6,
                LeftIndex = 7,
                LeftMiddle = 8,
                LeftRing = 9,
                LeftLittle = 10,
                RightExtraDigit = 16,
                LeftExtraDigit = 17
        };
 
        struct FingerImage
        {
                FingerImage();
 
                FingerImage(
                    const uint16_t width,
                    const uint16_t height,
                    const uint16_t ppi,
                    const std::vector<std::byte> &pixels,
                    const Impression imp = Impression::Unknown,
                    const FrictionRidgeCaptureTechnology frct =
                        FrictionRidgeCaptureTechnology::Unknown,
                    const FrictionRidgeGeneralizedPosition frgp =
                        FrictionRidgeGeneralizedPosition::Unknown);
 
                uint16_t width{};
                uint16_t height{};
                uint16_t ppi{};
                std::vector<std::byte> pixels{};
                Impression imp{Impression::Unknown};
                FrictionRidgeCaptureTechnology frct{
                    FrictionRidgeCaptureTechnology::Unknown};
                FrictionRidgeGeneralizedPosition frgp{
                    FrictionRidgeGeneralizedPosition::Unknown};
        };
 
        struct FingerImageStatus
        {
                enum class Code
                {
                        Supported = 0,
                        InvalidImageData,
                        VendorDefined
                };
 
                FingerImageStatus(
                    const Code code = Code::Supported,
                    const std::string &message = "");
 
                Code code{};
                std::string message{};
        };
 
        enum class Result
        {
                Success = 0,
                Failure
        };
 
        struct CreateProprietaryTemplateResult
        {
                static CreateProprietaryTemplateResult
                success(
                     const std::vector<std::byte> &proprietaryTemplate,
                     const std::string &message = "");
 
                static CreateProprietaryTemplateResult
                failure(
                     const std::string &message = "");
 
                Result result{Result::Success};
                std::vector<std::byte> proprietaryTemplate{};
                std::string message{};
        };
 
        struct CompareProprietaryTemplatesStatus
        {
                CompareProprietaryTemplatesStatus(
                    const Result result = Result::Success,
                    const std::string &message = "");
 
                static CompareProprietaryTemplatesStatus
                success();
 
                static CompareProprietaryTemplatesStatus
                failure(
                     const std::string &message = "");
 
                Result result{};
                std::string message{};
        };
 
        struct SubmissionIdentification
        {
                SubmissionIdentification();
 
                SubmissionIdentification(
                    const uint16_t versionNumber,
                    const std::string &libraryIdentifier,
                    const std::tuple<std::string, bool>
                        &featureExtractionAlgorithmMarketingIdentifier =
                        std::make_tuple("", false),
                    const std::tuple<std::string, bool>
                        &comparisonAlgorithmMarketingIdentifier =
                        std::make_tuple("", false),
                    const std::tuple<uint16_t, bool>
                        &cbeffFeatureExtractionAlgorithmProductOwner =
                        std::make_tuple(0x0000, false),
                    const std::tuple<uint16_t, bool>
                        &cbeffFeatureExtractionAlgorithmIdentifier =
                        std::make_tuple(0x0000, false),
                    const std::tuple<uint16_t, bool>
                        &cbeffComparisoinAlgorithmProductOwner =
                        std::make_tuple(0x0000, false),
                    const std::tuple<uint16_t, bool>
                        &cbeffComparisonAlgorithmIdentifier =
                        std::make_tuple(0x0000, false));
 
                uint16_t versionNumber{};
                std::string libraryIdentifier{};
                std::tuple<std::string, bool>
                    featureExtractionAlgorithmMarketingIdentifier{"", false};
                std::tuple<std::string, bool>
                    comparisonAlgorithmMarketingIdentifier{"", false};
 
                /*
                 * CBEFF information, if registered.
                 */
 
                std::tuple<uint16_t, bool>
                    cbeffFeatureExtractionAlgorithmProductOwner{0x0000, false};
                std::tuple<uint16_t, bool>
                    cbeffFeatureExtractionAlgorithmIdentifier{0x0000, false};
 
                std::tuple<uint16_t, bool>
                    cbeffComparisonAlgorithmProductOwner{0x0000, false};
                std::tuple<uint16_t, bool> cbeffComparisonAlgorithmIdentifier{
                    0x0000, false};
        };
 
        class Interface
        {
        public:
                virtual
                SubmissionIdentification
                getIdentification()
                    const = 0;
 
                virtual
                std::tuple<FingerImageStatus, CreateProprietaryTemplateResult>
                createProprietaryTemplate(
                    const FingerImage &fingerImage) = 0;
 
                virtual
                std::tuple<CompareProprietaryTemplatesStatus, double>
                compareProprietaryTemplates(
                    const std::vector<std::byte> &probeTemplate,
                    const std::vector<std::byte> &referenceTemplate) = 0;
 
                virtual ~Interface();
 
                static
                std::shared_ptr<Interface>
                getImplementation(
                    const std::filesystem::path &configurationDirectory);
 
                Interface(const Interface&) = delete;
                Interface& operator=(const Interface&) = delete;
                Interface();
        };
 
        /*
         * API versioning.
         *
         * NIST code will extern the version number symbols. Participant code
         * shall compile them into their core library.
         */
        #ifdef NIST_EXTERN_API_VERSION
        extern uint16_t API_MAJOR_VERSION;
        extern uint16_t API_MINOR_VERSION;
        extern uint16_t API_PATCH_VERSION;
        #else /* NIST_EXTERN_API_VERSION */
        uint16_t API_MAJOR_VERSION{1};
        uint16_t API_MINOR_VERSION{1};
        uint16_t API_PATCH_VERSION{0};
        #endif /* NIST_EXTERN_API_VERSION */
 
        /*
         * Ensure that std::byte is exactly 8 bits, such that reinterpret_casts
         * may be safely used.
         */
        static_assert(std::is_same_v<std::underlying_type_t<std::byte>,
            uint8_t>, "std::byte not represented as unsigned 8 bit type");
}
 
#endif /* PFTIII_H_ */