be_data_interchange_an2k.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_DATA_INTERCHANGE_AN2K__
#define __BE_DATA_INTERCHANGE_AN2K__
 
#include <map>
#include <set>
#include <string>
#include <vector>
 
#include <be_finger_an2kminutiae_data_record.h>
#include <be_finger_an2kview_fixedres.h>
#include <be_latent_an2kview.h>
#include <be_finger_an2kview_capture.h>
#include <be_io_utility.h>
#include <be_memory_autobuffer.h>
#include <be_palm_an2kview.h>
 
namespace BiometricEvaluation 
{
        namespace DataInterchange
        {
                class AN2KRecord {
                public:
                        struct DomainName {                             
                                DomainName(
                                    std::string identifier = "",
                                    std::string version = "") :
                                    identifier(identifier),
                                    version(version) {};
                                    
                                std::string identifier;
                                std::string version;
                        };
                        using DomainName = struct DomainName;
                        
                        struct CharacterSet {
                                CharacterSet(
                                    uint16_t identifier = 0,
                                    std::string commonName = "",
                                    std::string version = "") :
                                    identifier(identifier),
                                    commonName(commonName),
                                    version(version) {};
                                    
                                uint16_t identifier;
                                std::string commonName;
                                std::string version;
                        };
                        using CharacterSet = struct CharacterSet;
                        
                        
                        static std::set<int>
                        recordLocations(
                            Memory::uint8Array &buf,
                            const View::AN2KView::RecordType recordType);
                            
                        static std::set<int>
                        recordLocations(
                            const ANSI_NIST *an2k,
                            const View::AN2KView::RecordType recordType);
                            
                        AN2KRecord(
                            const std::string filename);
 
                        AN2KRecord(
                            Memory::uint8Array &buf);
 
                        std::string getVersionNumber() const;
 
                        std::string getDate() const;
 
                        std::string getDestinationAgency() const;
 
                        std::string getOriginatingAgency() const;
 
                        std::string getTransactionControlNumber() const;
 
                        std::string getNativeScanningResolution() const;
 
                        std::string getNominalTransmittingResolution() const;
 
                        uint32_t getFingerLatentCount() const;
 
                        std::vector<Latent::AN2KView>
                            getFingerLatents() const;
 
                        uint32_t getFingerCaptureCount() const;
 
                        std::vector<Finger::AN2KViewCapture>
                            getFingerCaptures() const;
 
                        uint32_t
                        getFingerFixedResolutionCaptureCount()
                            const;
 
 
                        uint32_t
                        getFingerFixedResolutionCaptureCount(
                            const View::AN2KView::RecordType type)
                            const;
 
                        std::vector<Finger::AN2KViewFixedResolution>
                        getFingerFixedResolutionCaptures()
                            const;
 
 
                        std::vector<Finger::AN2KViewFixedResolution>
                        getFingerFixedResolutionCaptures(
                            const View::AN2KView::RecordType type)
                            const;
 
                        uint32_t
                        getPalmCaptureCount()
                            const;
 
                        std::vector<Palm::AN2KView>
                        getPalmCaptures()
                            const;
 
                        std::vector<Finger::AN2KMinutiaeDataRecord>
                        getMinutiaeDataRecordSet()
                            const;
                            
                        uint8_t
                        getPriority()
                            const;
                           
                        DomainName
                        getDomainName()
                            const;
                        
                        struct tm
                        getGreenwichMeanTime()
                            const;
                        
                        std::vector<CharacterSet>
                        getDirectoryOfCharacterSets()
                            const;
 
                        static bool
                        isAN2KRecord(
                            const std::string &filename);
 
                        static bool
                        isAN2KRecord(
                            BiometricEvaluation::Memory::uint8Array &buf);
 
                protected:
                        AN2KRecord() { }
 
                private:
                        std::string _version;
                        std::string _date;
                        std::string _dai;
                        std::string _ori;
                        std::string _tcn;
                        std::string _nsr;
                        std::string _ntr;
                        uint8_t _pry;
                        std::string _tcr;
                        DomainName _domainName;
                        struct tm _gmt;
                        std::vector<CharacterSet> _dcs;
 
                        std::map<View::AN2KView::RecordType,
                            std::vector<Finger::AN2KViewFixedResolution>>
                            _fingerFixedResolutionCaptures;
                        std::vector<Latent::AN2KView> _fingerLatents;
                        std::vector<Finger::AN2KViewCapture> _fingerCaptures;
                        std::vector<Palm::AN2KView> _palmCaptures;
                        std::vector<Finger::AN2KMinutiaeDataRecord> 
                            _minutiaeDataRecordSet;
                        
                        void readAN2KRecord(Memory::uint8Array &buf);
                        void readType1Record(Memory::uint8Array &buf);
                            
                        void readMinutiaeData(Memory::uint8Array &buf);
                        void readFingerCaptures(Memory::uint8Array &buf);
                        void readFingerLatents(Memory::uint8Array &buf);
                        void readFixedResolutionCaptures(Memory::uint8Array
                            &buf);
                        void readPalmCaptures(Memory::uint8Array &buf);
                };
        }
}
#endif