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 = {});
 
                std::strong_ordering
                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_ */