io.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 FRIF_IO_H_
#define FRIF_IO_H_
 
#include <cstdint>
#include <filesystem>
#include <optional>
#include <string>
#include <unordered_map>
#include <vector>
 
#include <frif/common.h>
#include <frif/efs.h>
 
namespace FRIF
{
        struct TemplateData
        {
                std::string candidateIdentifier{};
 
                uint8_t inputIdentifier{};
 
                std::optional<EFS::Features> features{};
 
                std::optional<uint8_t> imageQuality{};
        };
 
        struct CreateTemplateResult
        {
                std::vector<std::byte> data{};
 
                std::optional<std::vector<TemplateData>> extractedData{};
        };
 
        struct Correspondence
        {
                std::vector<EFS::CorrespondenceRelationship> correspondence{};
 
                std::optional<bool> complex{};
        };
 
        struct Candidate
        {
                std::string identifier{};
                EFS::FrictionRidgeGeneralizedPosition fgp{};
 
                Candidate(
                    const std::string &identifier = {},
                    const EFS::FrictionRidgeGeneralizedPosition fgp = {});
 
                auto operator<=>(const Candidate&) const;
                bool operator==(const Candidate&) const;
        };
 
        struct CandidateListKeyHash
        {
                std::size_t
                operator()(
                    const FRIF::Candidate &c)
                    const
                    noexcept;
        };
 
        using CandidateList = std::unordered_map<Candidate, double,
            CandidateListKeyHash>;
 
        using CandidateListCorrespondence = std::unordered_map<Candidate,
            std::vector<Correspondence>, CandidateListKeyHash>;
 
        struct ComparisonResult
        {
                bool decision{};
 
                double similarity{};
 
                std::optional<Correspondence> correspondence{};
        };
 
        struct SearchResult
        {
                bool decision{};
 
                CandidateList candidateList{};
 
                std::optional<Correspondence> correspondence{};
        };
 
        struct TemplateArchive
        {
                std::filesystem::path archive{};
                std::filesystem::path manifest{};
        };
 
        using Sample = std::tuple<std::optional<Image>,
            std::optional<EFS::Features>>;
 
        enum class TemplateType
        {
                Probe,
                Reference
        };
}
 
#endif /* FRIF_IO_H_ */