identification.h

/* Copyright 2021 ID R&D Inc. All Rights Reserved. */
 
#pragma once
 
#include <string>
#include <vector>
#include <memory>
 
#include <voicesdk/verify/verify.h>
 
namespace voicesdk {
namespace ident {
 
struct IdentificationResult {
    std::vector<size_t> GetIndexesOfMatchedTemplates() const {
        std::vector<size_t> indexes;
 
        for (size_t i = 0; i < scores.size(); ++i) {
            if (scores[i] >= threshold) {
                indexes.push_back(i);
            }
        }
 
        return indexes;
    }
 
    bool IsMatched() const {
        for (const auto& score : scores) {
            if (score >= threshold) {
                return true;
            }
        }
        return false;
    }
 
    VOICE_SDK_API
    friend std::ostream& operator<<(std::ostream& os, const IdentificationResult& obj) {
        os << "IdentificationList["
           << "scores: { ";
 
        for (const auto& s : obj.scores) {
            os << s << ", ";
        }
 
        os << "}, ";
        os << "threshold: " << obj.threshold << "]";
 
        return os;
    }
 
    std::vector<float> scores;
 
    float threshold;
};
 
struct VOICE_SDK_API IdentificationList {
    using Ptr = std::shared_ptr<IdentificationList>;
 
    virtual void Serialize(std::ostream& stream) const = 0;
 
    static IdentificationList::Ptr Deserialize(std::istream& stream);
 
    virtual ~IdentificationList() = default;
};
 
class VOICE_SDK_API IdentificationEngine {
public:
    using Ptr = std::shared_ptr<IdentificationEngine>;
 
    static Ptr Create(const std::string& initDataPath);
 
    virtual IdentificationList::Ptr CreateIdentificationList(
            const std::vector<voicesdk::VoiceTemplate::Ptr>& voice_templates) = 0;
 
    virtual IdentificationResult Identify(const voicesdk::VoiceTemplate::Ptr& voice_template,
                                          const IdentificationList::Ptr& identification_list,
                                          const float acceptance_level = -2.0f) = 0;
 
    virtual void EnrichIdentificationList(const IdentificationList::Ptr& identification_list,
                                          const std::vector<voicesdk::VoiceTemplate::Ptr>& voice_templates) = 0;
 
    virtual ~IdentificationEngine() = default;
};
 
}  // namespace ident
}  // namespace voicesdk