be_finger_incitsview.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_FINGER_INCITSVIEW_H__
#define __BE_FINGER_INCITSVIEW_H__
 
#include <tuple>
 
#include <be_view_view.h>
#include <be_feature_incitsminutiae.h>
 
namespace BiometricEvaluation 
{
        namespace Finger
        {
 
                class INCITSView : public View::View {
                public:
                        static Finger::Position
                            convertPosition(int incitsFGP);
        
                        static Finger::Impression
                            convertImpression(int incitsIMP);
        
                        Feature::INCITSMinutiae getMinutiaeData() const;
 
                        Finger::Position getPosition() const;
 
                        Finger::Impression getImpressionType() const;
 
                        uint32_t getQuality() const;
 
                        uint16_t getCaptureEquipmentID() const;
 
                        inline bool
                        isAppendixFCompliant()
                            const
                        {
                                return (this->_appendixFCompliance);
                        }
 
                        uint16_t
                        getProductIDOwner()
                            const
                        {
                                return (this->_productIDOwner);
                        }
 
                        inline uint16_t
                        getProductIDType()
                            const
                        {
                                return (this->_productIDType);
                        }
 
                        uint32_t
                        getRecordLength()
                            const;
 
                        uint8_t
                        getNumFingerViews()
                            const;
 
                        uint8_t
                        getFMRReservedByte()
                            const;
 
                        uint32_t
                        getViewNumber()
                            const;
 
                        uint16_t
                        getEDBLength()
                            const;
 
                        std::vector<uint8_t>
                        getMinutiaeReservedData()
                            const;
 
                        void
                        setMinutiaeData(
                            const Feature::INCITSMinutiae &fmd);
 
                        void
                        setMinutiaeReservedData(
                            const std::vector<uint8_t> &reservedBits);
 
                protected:
 
                        static const uint32_t FMR_BASE_FORMAT_ID = 0x464D5200;
                        /* 'F' 'M' 'R' 'nul' */
 
                        static const uint32_t ANSI2004_STANDARD = 1;
                        static const uint32_t ISO2005_STANDARD = 2;
                        static const uint32_t ANSI2007_STANDARD = 3;
 
                        INCITSView();
 
                        INCITSView(
                            const std::string &fmrFilename,
                            const std::string &firFilename,
                            const uint32_t viewNumber);
 
                        INCITSView(
                            const Memory::uint8Array &fmrBuffer,
                            const Memory::uint8Array &firBuffer,
                            const uint32_t viewNumber);
 
                        Memory::uint8Array const& getFMRData() const;
 
                        Memory::uint8Array const& getFIRData() const;
 
                        void setPosition(const Finger::Position &position);
 
                        void setImpressionType(
                            const Finger::Impression &impression);
 
                        void setQuality(uint32_t quality);
 
                        void setViewNumber(uint32_t viewNumber);
 
                        void setCaptureEquipmentID(uint16_t id);
 
                        void setCBEFFProductIDs(uint16_t owner, uint16_t type);
 
                        void setAppendixFCompliance(bool flag);
 
                        void readFMRHeader(
                            Memory::IndexedBuffer &buf,
                            const uint32_t formatStandard);
 
                        void readFVMR(
                            Memory::IndexedBuffer &buf);
 
                        virtual
                        std::tuple<Feature::MinutiaPointSet,
                        std::vector<uint8_t>>
                        readMinutiaeDataPoints(
                            Memory::IndexedBuffer &buf,
                            uint32_t count);
 
                        virtual void readExtendedDataBlock(
                            Memory::IndexedBuffer &buf);
 
                        virtual Feature::RidgeCountItemSet readRidgeCountData(
                            Memory::IndexedBuffer &buf,
                            uint32_t dataLength);
 
                        virtual void readCoreDeltaData(
                            Memory::IndexedBuffer &buf,
                                uint32_t dataLength,
                                Feature::CorePointSet &cores,
                                Feature::DeltaPointSet &deltas) = 0;
                                
                private:
                        Memory::uint8Array _fmr{};
                        Memory::uint8Array _fir{};
                        Finger::Position _position{};
                        Feature::INCITSMinutiae _minutiae{};
                        std::vector<uint8_t> _fmdReserved{};
                        Finger::Impression _impression{};
                        uint32_t _viewNumber{};
                        uint32_t _quality{};
                        bool _appendixFCompliance{};
                        uint16_t _productIDOwner{};
                        uint16_t _productIDType{};
                        uint16_t _captureEquipmentID{};
                        uint32_t _recordLength{};
                        uint8_t _numFingerViews{};
                        uint8_t _fmrReservedByte{};
                        uint16_t _edbLength{};
                };
        }
}
#endif /* __BE_FINGER_INCITSVIEW_H__ */