be_feature_an2k11efs.h

Go to the documentation of this file.

/*
 * This software was developed at the National Institute of Standards and
 * Technology (NIST) by employees of the Federal Government in the course
 * of their official duties. Pursuant to title 17 Section 105 of the
 * United States Code, this software is not subject to copyright protection
 * and is in the public domain. NIST assumes no responsibility whatsoever for
 * its use by other parties, and makes no guarantees, expressed or implied,
 * about its quality, reliability, or any other characteristic.
 */
 
#ifndef __BE_FEATURE_AN2K11EFS_H__
#define __BE_FEATURE_AN2K11EFS_H__
 
#include <be_image.h>
#include <be_finger.h>
#include <be_palm.h>
#include <be_plantar.h>
#include <be_feature.h>
#include <be_feature_minutiae.h>
#include <be_framework_enumeration.h>
#include <be_memory_autoarray.h>
 
namespace BiometricEvaluation 
{
        namespace Feature {
        namespace AN2K11EFS {
 
                struct Orientation {
                        enum class EncodingMethod {
                                Default,
                                Indeterminate,
                                UserDefined
                        };
 
                        static const int        EODDefault = 0;
                        static const int        EUCDefault = 15;
                        static const int        EUCIndeterminate = 180;
 
                        EncodingMethod encodingMethod;
 
                        int     eod;
                        bool    has_euc;
                        int     euc;
                };
                std::ostream& operator<< (std::ostream&, const Orientation&);
 
                enum class FingerprintSegment {
                        PRX = 0,
                        DST,
                        MED,
                        UNK
                };
 
                enum class OffCenterFingerPosition {
                        T = 0,
                        R,
                        L
                };
                using OCF = OffCenterFingerPosition;
 
                struct FPPPosition {
                        Feature::FGP                    fgp;
 
                        bool                            has_fsm;
                        FingerprintSegment              fsm;
 
                        bool                            has_ocf;
                        OffCenterFingerPosition         ocf;
 
                        bool                            has_sgp;
                        BiometricEvaluation::Image::CoordinateSet sgp;
                        
                };
                std::ostream& operator<< (std::ostream&, const FPPPosition&);
 
                enum class TonalReversal {
                        N = 0,
                        P,
                        U
                };
 
                enum class LateralReversal {
                        L = 0,
                        U
                };
 
                struct ImageInfo {
                        BiometricEvaluation::Image::ROI roi;
 
                        FPPPosition                     fpp;
 
                        Orientation                     ort;
 
                        bool                            has_trv;
                        TonalReversal                   trv;
 
                        bool                            has_plr;
                        LateralReversal                 plr;
                };
                std::ostream& operator<< (std::ostream&,
                    const ImageInfo&);
 
                struct MinutiaPoint : public Feature::MinutiaPoint {
                        bool    has_mru;
                        int     mru;
                        bool    has_mdu;
                        int     mdu;
                };
                std::ostream& operator<< (std::ostream&,
                    const MinutiaPoint&);
                using MinutiaPointSet = std::vector<MinutiaPoint>;
 
                struct MinutiaeRidgeCount {
                        int     mia;
                        int     mib;
                        int     mir;
                        bool    has_mrn;
                        int     mrn;
                        bool    has_mrs;
                        int     mrs;
                };
                std::ostream& operator<< (std::ostream&,
                    const MinutiaeRidgeCount&);
                using MinutiaeRidgeCountSet =
                    std::vector<MinutiaeRidgeCount>;
 
                enum class MethodOfRidgeCounting {
                        A = 0,
                        T,
                        M
                };
                using MORC = MethodOfRidgeCounting;
 
                struct MinutiaeRidgeCountConfidence {
                        Image::Coordinate       pointA;
                        Image::Coordinate       pointB;
                        MethodOfRidgeCounting   morc;
                        int                     mcv;
                };
                using MRCC = struct MinutiaeRidgeCountConfidence;
                std::ostream& operator<< (std::ostream&,
                    const MinutiaeRidgeCountConfidence&);
                using MinutiaeRidgeCountConfidenceSet =
                    std::vector<MinutiaeRidgeCountConfidence>;
 
                enum class MinutiaeRidgeCountAlgorithm {
                        OCTANT = 0,
                        EFTS7,
                        QUADRANT
                };
                using MRA = MinutiaeRidgeCountAlgorithm;
 
                struct MinutiaeRidgeCountInfo {
                        bool                            has_mra;
                        MinutiaeRidgeCountAlgorithm     mra;
                        bool                            has_mrcs;
                        MinutiaeRidgeCountSet           mrcs;
                        bool                            has_rccs;
                        MinutiaeRidgeCountConfidenceSet rccs;
                };
                std::ostream& operator<< (std::ostream&,
                    const MinutiaeRidgeCountInfo&);
 
                 /*
                 * @brief
                 * Representation of an extended feature set core.
                 */
                struct CorePoint {
                        Image::Coordinate       location;
                        bool                    has_cdi;
                        int                     cdi;
                        bool                    has_rpu;
                        int                     rpu;
                        bool                    has_duy;
                        int                     duy;
                };
                std::ostream& operator<< (std::ostream&, const CorePoint&);
                using CorePointSet = std::vector<CorePoint>;
 
                enum class DeltaType {
                        L,
                        R,
                        I00,
                        I02,
                        I03,
                        I04,
                        I05,
                        I07,
                        I08,
                        I09,
                        I10,
                        I16,
                        I17,
                        C,
                        Other
                };
 
                struct DeltaPoint {
                        Image::Coordinate       location;
                        bool            has_dup;
                        int             dup;
                        bool            has_dlf;
                        int             dlf;
                        bool            has_drt;
                        int             drt;
                        bool            has_dtp;
                        DeltaType       dtp;
                        bool            has_rpu;
                        int             rpu;
                        bool            has_duu;
                        int             duu;
                        bool            has_dul;
                        int             dul;
                        bool            has_dur;
                        int             dur;
                };
                using DeltaPointSet = std::vector<DeltaPoint>;
                std::ostream& operator<< (std::ostream&, const DeltaPoint&);
 
                struct NoFeaturesPresent {
                        bool    cores;
                        bool    deltas;
                        bool    minutiae;
                };
                std::ostream& operator<< (
                     std::ostream&, const NoFeaturesPresent&);
 
                enum class LatentProcessingMethod
                {
                        I12,
                        ADX,
                        ALS,
                        AMB,
                        AY7,
                        BAR,
                        BLE,
                        BLP,
                        BPA,
                        BRY,
                        CBB,
                        CDS,
                        COG,
                        DAB,
                        DFO,
                        FLP,
                        GEN,
                        GRP,
                        GTV,
                        HCA,
                        IOD,
                        ISR,
                        LAS,
                        LCV,
                        LIQ,
                        LQD,
                        MBD,
                        MBP,
                        MGP,
                        MPD,
                        MRM,
                        NIN,
                        OTH,
                        PDV,
                        R6G,
                        RAM,
                        RUV,
                        SAO,
                        SDB,
                        SGF,
                        SPR,
                        SSP,
                        SVN,
                        TEC,
                        TID,
                        VIS,
                        WHP,
                        ZIC
                };
                using LPM = LatentProcessingMethod;
 
                enum class ValueAssessmentCode
                {
                        Value,
                        ValueForIndividualization = Value,
                        VID = Value,
                        Limited,
                        ValueForExclusionOnly = Limited,
                        VEO = Limited,
                        NoValue,
                        NV = NoValue,
                        NonPrint
                };
 
                struct ExaminerAnalysisAssessment
                {
                        bool present{false};
 
                        ValueAssessmentCode aav;
                        std::string aln;
                        std::string afn;
                        std::string aaf;
                        std::string amt;
                        std::string acm{};
                        bool has_cxf{false};
                        bool cxf{};
                };
                std::ostream&
                operator<<(
                     std::ostream&,
                     const ExaminerAnalysisAssessment&);
 
                enum class SubstrateCode
                {
                        Paper,
                        Cardboard,
                        UnfinishedWood,
                        OtherOrUnknownPorous,
 
                        Plastic,
                        Glass,
                        PaintedMetal,
                        UnpaintedMetal,
                        GlossyPaintedSurface,
                        AdhesiveSideTape,
                        NonAdhesiveSideTape,
                        AluminumFoil,
                        OtherOrUnknownNonporous,
 
                        Rubber,
                        Leather,
                        EmulsionSidePhotograph,
                        PaperSidePhotograph,
                        GlossyOrSemiglossyPaperOrCardboard,
                        SatinOrFlatFinishedPaintedSurface,
                        OtherOrUnknownSemiporous,
 
                        Other,
                        Unknown
                };
 
                struct Substrate
                {
                        bool present{false};
 
                        SubstrateCode cls{SubstrateCode::Unknown};
                        std::string osd{};
                };
                std::ostream&
                operator<<(
                     std::ostream&,
                     const Substrate&);
 
                struct Pattern
                {
                        enum class GeneralClassification
                        {
                                Arch,
                                Whorl,
                                RightSlantLoop,
                                LeftSlantLoop,
                                Amputation,
                                TemporarilyUnavailable,
                                Unclassifiable,
                                Scar,
                                DissociatedRidges
                        };
 
                        /* Details subclassification for arches */
                        enum class ArchSubclassification
                        {
                                Plain,
                                Tented
                        };
 
                        /* Details subclassification for whorls */
                        enum class WhorlSubclassification
                        {
                                Plain,
                                CentralPocketLoop,
                                DoubleLoop,
                                Accidental
                        };
 
                        enum class WhorlDeltaRelationship
                        {
                                Inner,
                                Outer,
                                Meeting
                        };
 
                        bool present{false};
 
                        GeneralClassification general;
 
                        bool hasSubclass{false};
                        union
                        {
                                ArchSubclassification arch;
                                WhorlSubclassification whorl;
                        } subclass;
 
                        bool hasWhorlDeltaRelationship{false};
                        WhorlDeltaRelationship whorlDeltaRelationship;
                };
                std::ostream&
                operator<<(
                     std::ostream&,
                     const Pattern&);
 
                class ExtendedFeatureSet {
                public:
                        ExtendedFeatureSet(
                            const std::string &filename,
                            int recordNumber);
 
                        ExtendedFeatureSet(
                            Memory::uint8Array &buf,
                            int recordNumber);
 
                        ImageInfo
                        getImageInfo()
                            const;
 
                        BiometricEvaluation::Feature::AN2K11EFS::MinutiaPointSet
                        getMPS()
                            const;
 
                        BiometricEvaluation::Feature::AN2K11EFS::MinutiaeRidgeCountInfo
                        getMRCI()
                            const;
 
                        BiometricEvaluation::Feature::AN2K11EFS::CorePointSet
                        getCPS()
                            const;
 
                        BiometricEvaluation::Feature::AN2K11EFS::DeltaPointSet
                        getDPS()
                            const;
 
                        std::vector<LatentProcessingMethod>
                        getLPM()
                            const;
 
                        BiometricEvaluation::Feature::AN2K11EFS::NoFeaturesPresent
                        getNFP()
                            const;
 
                        ExaminerAnalysisAssessment
                        getEAA()
                            const;
 
                        Substrate
                        getLSB()
                            const;
 
                        std::vector<Pattern>
                        getPAT()
                            const;
 
                        ~ExtendedFeatureSet();
 
                private:
                        class Impl;
                        std::unique_ptr<ExtendedFeatureSet::Impl> pimpl;
                };
        } /* Namespace AN2K11EFS */
        } /* Namespace Feature */
}
 
BE_FRAMEWORK_ENUMERATION_DECLARATIONS(
    BiometricEvaluation::Feature::AN2K11EFS::Orientation::EncodingMethod,
    BE_Feature_AN2K11EFS_Orientation_EncodingMethod_EnumToStringMap);
 
BE_FRAMEWORK_ENUMERATION_DECLARATIONS(
    BiometricEvaluation::Feature::AN2K11EFS::FingerprintSegment,
    BE_Feature_AN2K11EFS_FingerprintSegment_EnumToStringMap);
 
BE_FRAMEWORK_ENUMERATION_DECLARATIONS(
    BiometricEvaluation::Feature::AN2K11EFS::OCF,
    BE_Feature_AN2K11EFS_OCF_EnumToStringMap);
 
BE_FRAMEWORK_ENUMERATION_DECLARATIONS(
    BiometricEvaluation::Feature::AN2K11EFS::TonalReversal,
    BE_Feature_AN2K11EFS_TonalReversal_EnumToStringMap);
 
BE_FRAMEWORK_ENUMERATION_DECLARATIONS(
    BiometricEvaluation::Feature::AN2K11EFS::LateralReversal,
    BE_Feature_AN2K11EFS_LateralReversal_EnumToStringMap);
 
BE_FRAMEWORK_ENUMERATION_DECLARATIONS(
    BiometricEvaluation::Feature::AN2K11EFS::MethodOfRidgeCounting,
    BE_Feature_AN2K11EFS_MethodOfRidgeCounting_EnumToStringMap);
 
BE_FRAMEWORK_ENUMERATION_DECLARATIONS(
    BiometricEvaluation::Feature::AN2K11EFS::MRA,
    BE_Feature_AN2K11EFS_MRA_EnumToStringMap);
 
BE_FRAMEWORK_ENUMERATION_DECLARATIONS(
    BiometricEvaluation::Feature::AN2K11EFS::DeltaType,
    BE_Feature_AN2K11EFS_DeltaType_EnumToStringMap);
 
BE_FRAMEWORK_ENUMERATION_DECLARATIONS(
    BiometricEvaluation::Feature::AN2K11EFS::LatentProcessingMethod,
    BE_Feature_AN2K11EFS_LatentProcessingMethod_EnumToStringMap);
 
BE_FRAMEWORK_ENUMERATION_DECLARATIONS(
    BiometricEvaluation::Feature::AN2K11EFS::ValueAssessmentCode,
    BE_Feature_AN2K11EFS_ValueAssessmentCode_EnumToStringMap);
 
BE_FRAMEWORK_ENUMERATION_DECLARATIONS(
    BiometricEvaluation::Feature::AN2K11EFS::SubstrateCode,
    BE_Feature_AN2K11EFS_SubstrateCode_EnumToStringMap);
 
BE_FRAMEWORK_ENUMERATION_DECLARATIONS(
    BiometricEvaluation::Feature::AN2K11EFS::Pattern::GeneralClassification,
    BE_Feature_AN2K11EFS_Pattern_GeneralClassification_EnumToStringMap);
 
BE_FRAMEWORK_ENUMERATION_DECLARATIONS(
    BiometricEvaluation::Feature::AN2K11EFS::Pattern::ArchSubclassification,
    BE_Feature_AN2K11EFS_Pattern_ArchSubclassification_EnumToStringMap);
 
BE_FRAMEWORK_ENUMERATION_DECLARATIONS(
    BiometricEvaluation::Feature::AN2K11EFS::Pattern::WhorlSubclassification,
    BE_Feature_AN2K11EFS_Pattern_WhorlSubclassification_EnumToStringMap);
 
BE_FRAMEWORK_ENUMERATION_DECLARATIONS(
    BiometricEvaluation::Feature::AN2K11EFS::Pattern::WhorlDeltaRelationship,
    BE_Feature_AN2K11EFS_Pattern_WhorlDeltaRelationship_EnumToStringMap);
 
#endif /* __BE_FEATURE_AN2K11EFS_H__ */