be_iris_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_IRIS_INCITSVIEW_H__
#define __BE_IRIS_INCITSVIEW_H__
 
#include <string>
#include <vector>
 
#include <be_iris.h>
#include <be_image.h>
#include <be_memory_indexedbuffer.h>
#include <be_view_view.h>
 
namespace BiometricEvaluation 
{
        namespace Iris
        {
                class INCITSView : public View::View {
                public:
                        typedef struct {
                                uint8_t         score;
                                uint16_t        vendorID;
                                uint16_t        algorithmID;
                        } QualitySubBlock;
                        typedef std::vector<QualitySubBlock> QualitySet;
 
                        static const uint16_t RANGE_UNASSIGNED = 0;
                        static const uint16_t RANGE_FAILED = 1;
                        static const uint16_t RANGE_OVERFLOW = 65535;
 
                        static const uint16_t ROLL_ANGLE_UNDEF = 65535;
                        static const uint16_t ROLL_UNCERTAIN_UNDEF = 65535;
                        static const uint16_t COORDINATE_UNDEF = 0;
 
                        uint8_t getCertificationFlag() const;
 
                        std::string getCaptureDateString() const;
 
                        Iris::CaptureDeviceTechnology
                            getCaptureDeviceTechnology() const;
 
                        uint16_t getCaptureDeviceVendor() const;
 
                        uint16_t getCaptureDeviceType() const;
 
                        void getQualitySet(
                            Iris::INCITSView::QualitySet &qualitySet) const;
 
                        Iris::EyeLabel getEyeLabel() const;
 
                        Iris::ImageType getImageType() const;
 
                        void getImageProperties(
                            BiometricEvaluation::Iris::Orientation
                                &horizontalOrientation,
                            BiometricEvaluation::Iris::Orientation
                                &verticalOrientation,
                            BiometricEvaluation::Iris::ImageCompression
                                &compressionHistory
                        ) const;
 
                        uint16_t getCameraRange();
 
                        void getRollAngleInfo(
                            uint16_t &rollAngle,
                            uint16_t &rollAngleUncertainty);
 
                        void getIrisCenterInfo(
                            uint16_t &irisCenterSmallestX,
                            uint16_t &irisCenterSmallestY,
                            uint16_t &irisCenterLargestX,
                            uint16_t &irisCenterLargestY,
                            uint16_t &irisDiameterSmallest,
                            uint16_t &irisDiameterLargest
                        );
 
                protected:
 
                        static const uint32_t ISO2011_STANDARD = 1;
                        static const uint32_t BASE_FORMAT_ID = 0x49495200;
                        /* 'I''I''R' 'nul' */
                        static const uint8_t CAPTURE_DATE_LENGTH = 9;
 
                        INCITSView();
 
                        INCITSView(
                            const std::string &filename,
                            const uint32_t viewNumber);
 
                        INCITSView(
                            const Memory::uint8Array &buffer,
                            const uint32_t viewNumber);
 
                        Memory::uint8Array const& getIIRData() const;
 
                        virtual void readHeader(
                            BiometricEvaluation::Memory::IndexedBuffer &buf,
                            const uint32_t formatStandard);
 
                        virtual void readIrisView(
                            Memory::IndexedBuffer &buf);
 
                private:
                        BiometricEvaluation::Memory::uint8Array _iir;
                        uint8_t _certFlag;
 
                        BiometricEvaluation::Iris::CaptureDeviceTechnology
                            _captureDeviceTechnology;
 
                        BiometricEvaluation::Iris::INCITSView::QualitySet
                            _qualitySet;
 
                        BiometricEvaluation::Iris::EyeLabel
                            _eyeLabel;
                        BiometricEvaluation::Iris::ImageType
                            _imageType;
                        Iris::Orientation _horizontalOrientation;
                        Iris::Orientation _verticalOrientation;
                        Iris::ImageCompression _compressionHistory;
                        
                        uint16_t _cameraRange;
                        uint16_t _rollAngle;
                        uint16_t _rollAngleUncertainty;
 
                        uint16_t _irisCenterSmallestX;
                        uint16_t _irisCenterSmallestY;
                        uint16_t _irisCenterLargestX;
                        uint16_t _irisCenterLargestY;
                        uint16_t _irisDiameterSmallest;
                        uint16_t _irisDiameterLargest;
 
                        uint16_t _captureDeviceVendor;
                        uint16_t _captureDeviceType;
                        uint8_t _captureDate[CAPTURE_DATE_LENGTH];
                        std::string _captureDateString;
                };
        }
}
#endif /* __BE_IRIS_INCITSVIEW_H__ */