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 <frifte/common.h>
#include <frifte/efs.h>
 
namespace FRIF
{
        struct TemplateData
        {
                std::string identifier{};
 
                uint8_t inputIdentifier{};
 
                std::optional<EFS::Features> features{};
        };
 
        struct CreateTemplateResult
        {
                std::vector<std::byte> data{};
 
                std::optional<std::vector<TemplateData>> extractedData{};
        };
 
        struct Correspondence
        {
                std::vector<EFS::CorrespondenceRelationship> relationships{};
 
                std::optional<bool> complex{};
        };
 
        struct SubjectPositionCandidate
        {
                std::string identifier{};
                EFS::FrictionRidgeGeneralizedPosition fgp{};
 
                SubjectPositionCandidate(
                    const std::string &identifier = {},
                    const EFS::FrictionRidgeGeneralizedPosition fgp = {});
 
                auto operator<=>(const SubjectPositionCandidate&) const;
                bool operator==(const SubjectPositionCandidate&) const;
        };
 
        using SubjectCandidate = std::string;
 
        struct SubjectPositionCandidateListKeyHash
        {
                std::size_t
                operator()(
                    const FRIF::SubjectPositionCandidate &c)
                    const
                    noexcept;
        };
 
        using SubjectPositionCandidateList = std::unordered_map<
            SubjectPositionCandidate, double,
            SubjectPositionCandidateListKeyHash>;
 
        using SubjectCandidateList = std::unordered_map<std::string, double>;
 
        using SubjectPositionCandidateListCorrespondence =
            std::unordered_map<SubjectPositionCandidate, Correspondence,
            SubjectPositionCandidateListKeyHash>;
 
        using SubjectCandidateListCorrespondence =
            std::unordered_map<std::string, Correspondence>;
 
        struct ComparisonResult
        {
                bool decision{};
 
                double similarity{};
 
                std::optional<Correspondence> correspondence{};
        };
 
        struct SearchSubjectPositionResult
        {
                bool decision{};
 
                SubjectPositionCandidateList candidateList{};
 
                std::optional<SubjectPositionCandidateListCorrespondence>
                    correspondence{};
        };
 
        struct SearchSubjectResult
        {
                bool decision{};
 
                SubjectCandidateList candidateList{};
 
                std::optional<SubjectCandidateListCorrespondence>
                    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_ */