quality.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 FRIFTE_QUALITY_H_
#define FRIFTE_QUALITY_H_
 
#include <frifte/common.h>
#include <frifte/efs.h>
#include <frifte/evaluations.h>
#include <frifte/io.h>

namespace FRIF::Evaluations::Quality
{
        LibraryIdentifier
        getLibraryIdentifier();

        enum class Component
        {
                Amputated,

                AnatomicalCluesPresent,

                Bandaged,

                ClearCoreDeltaRidgeCount,

                ComplexMatrix,

                ComplexSubstrate,

                CompressedRidges,

                Condensation,

                CorePresent,

                DeltaPresent,

                DevelopmentArtifacts,

                DistinctiveClusterPresent,

                EvenPressure,

                EvidenceOfFraud,

                ExcessiveDistortion,

                ExtremeTip,

                FocalPointsPresent,

                Ghosting,

                IsolatedRidgeClusters,

                Level3Present,

                MinutiaePresent,

                Movement,

                MultipleNonOverlappingImpressions,

                MultipleOverlappingImpressions,

                NumHighConfidenceMinutiae,

                NumMinutiae,

                OpenField,

                OrientationCertaintyLevel,

                OrientationClue,

                PatternClassification,

                PatternForceMinutiae,

                RidgeColorUncertain,

                RidgeFlowContinuity,

                RidgeValleyClarity,

                RidgeValleyUniformity,

                SpatialSamplingRatePPI,

                SpottyRidges,

                TonalReversal,

                WetRidges
        };

        class VerboseQuality
        {
        public:
                void
                setUnifiedQualityScore(
                    const EFS::QualityMeasure &uqs);

                void
                setUnifiedQualityScore(
                    const int uqs);
 
                EFS::QualityMeasure
                getUnifiedQualityScore()
                    const;

                void
                setROI(
                    const std::vector<Coordinate> &roi);
 
                std::optional<std::vector<Coordinate>>
                getROI()
                    const;

                void
                setRidgeQualityMap(
                    const std::vector<EFS::RidgeQualityRegion> &rqm);
 
                std::optional<std::vector<EFS::RidgeQualityRegion>>
                getRidgeQualityMap()
                    const;

                void
                addComponent(
                    const Component component,
                    const EFS::QualityMeasure &value);

                void
                removeComponent(
                    const Component component);
 
                std::optional<EFS::QualityMeasure>
                getComponent(
                    const Component component)
                    const;
 
                std::optional<std::unordered_map<Component,
                    EFS::QualityMeasure>>
                getComponents()
                    const;
 
                bool
                hasComponent(
                    const Component component)
                    const;
 
        private:
                EFS::QualityMeasure uqs{};
                std::optional<std::unordered_map<Component,
                    EFS::QualityMeasure>> components{};
                std::optional<std::vector<Coordinate>> roi{};
                std::optional<std::vector<EFS::RidgeQualityRegion>> rqm{};
        };

        class Interface
        {
        public:
                struct Compatibility
                {
                        bool regionOfInterest{false};

                        bool ridgeQualityMap{false};

                        bool qualityComponents{false};

                        bool palmLatent{false};
                        bool palmExemplar{false};

                        bool distalLatent{false};
                        bool distalExemplar{false};

                        bool nonDistalLatent{false};
                        bool nonDistalExemplar{false};

                        bool unknownLatent{false};
                };

                virtual
                VerboseQuality
                computeVerboseQuality(
                    const Sample &sample)
                    const = 0;

                virtual
                EFS::QualityMeasure
                computeUnifiedQualityScore(
                    const Sample &sample)
                    const = 0;
 
                /**************************************************************/

                static
                std::shared_ptr<Interface>
                getImplementation(
                    const std::filesystem::path &configurationDirectory);

                static
                std::optional<EFS::QualityMeasure::Description>
                getProductIdentifier();

                static
                Compatibility
                getCompatibility();

                Interface(const Interface&) = delete;
                Interface& operator=(const Interface&) = delete;
 
                Interface();
                virtual ~Interface();
        };
 
        /*
         * API versioning.
         *
         * NIST code will extern the version number symbols. Participant code
         * shall compile them into their core library.
         */
        #ifdef NIST_EXTERN_FRIFTE_QUALITY_API_VERSION
        extern uint16_t API_MAJOR_VERSION;
        extern uint16_t API_MINOR_VERSION;
        extern uint16_t API_PATCH_VERSION;
        #else /* NIST_EXTERN_FRIFTE_QUALITY_API_VERSION */
        inline uint16_t API_MAJOR_VERSION{0};
        inline uint16_t API_MINOR_VERSION{0};
        inline uint16_t API_PATCH_VERSION{1};
        #endif /* NIST_EXTERN_FRIFTE_QUALITY_API_VERSION */
}
 
#endif /* FRIFTE_QUALITY_H_ */