Recognizer.h

#ifndef __PBIO_API__PBIO__RECOGNIZER_H_
#define __PBIO_API__PBIO__RECOGNIZER_H_


#include <istream>
#include <sstream>
#include <vector>

#include "ComplexObject.h"
#include "Error.h"
#include "RawSample.h"
#include "SmartPtr.h"
#include "Template.h"
#include "TemplatesIndex.h"
#include "stl_wraps_impls/WrapIStreamBufferImpl.h"
#include "stl_wraps_impls/WrapIStreamImpl.h"
#include "stl_wraps_impls/WrapOStreamImpl.h"

namespace pbio
{

class FacerecService;

class Recognizer : public ComplexObject
{
public:

    typedef LightSmartPtr<Recognizer>::tPtr Ptr;

    struct MatchResult
    {
        double distance;

        double fa_r;

        double fr_r;

        double score;
    };

    struct SearchResult
    {
        size_t i;

        MatchResult match_result;
    };

    enum SearchAccelerationType
    {
        NO_SEARCH_ACCELERATION = 0,

        SEARCH_ACCELERATION_1 = 1,
    };


    std::string getMethodName() const;


    MatchResult getROCCurvePointByDistanceThreshold(const double distance_threshold) const;


    MatchResult getROCCurvePointByFAR(const double desired_far) const;


    MatchResult getROCCurvePointByFRR(const double desired_frr) const;


    MatchResult getROCCurvePointByScoreThreshold(const double score_threshold) const;


    Template::Ptr processing(const RawSample &sample) const;


    Template::Ptr loadTemplate(std::istream &binary_stream) const;

    Template::Ptr loadTemplate(pbio::stl_wraps::WrapIStream &binary_stream) const;


    Template::Ptr loadTemplate(
        const void* const data,
        const int size) const;


    MatchResult verifyMatch(
        const Template &template1,
        const Template &template2) const;


    TemplatesIndex::Ptr createIndex(
        const std::vector<pbio::Template::Ptr> &templates,
        const int search_threads_count = 1,
        const int reserve_queries_count = 0) const;


    TemplatesIndex::Ptr createResizableIndex(
        const uint64_t templates_count,
        const int search_threads_count = 1,
        const int reserve_queries_count = 0) const;


    std::vector<SearchResult> search(
        const pbio::Template &query_template,
        const pbio::TemplatesIndex &templates_index,
        const size_t k,
        const SearchAccelerationType acceleration = SEARCH_ACCELERATION_1) const;


    std::vector<std::vector<SearchResult> > search(
        const std::vector<pbio::Template::Ptr> &queries_templates,
        const pbio::TemplatesIndex &templates_index,
        const size_t k,
        const SearchAccelerationType acceleration = SEARCH_ACCELERATION_1) const;


    std::vector<size_t> chooseRepresentativeTemplatesSet(
        const size_t set_size,
        const std::vector<pbio::Template::Ptr> &templates,
        const std::vector<size_t> &inviolable_templates_indexes = std::vector<size_t>());

private:

    Recognizer(
        const DHPtr &dll_handle,
        void* impl);

    friend class FacerecService;
    friend class object_with_ref_counter<Recognizer>;
};

}  // pbio namespace




namespace pbio
{

inline
Recognizer::Recognizer(
    const DHPtr &dll_handle,
    void* impl):
ComplexObject(dll_handle, impl)
{
    // nothing else
}


inline
std::string Recognizer::getMethodName() const
{
    std::ostringstream name_stream;
    pbio::stl_wraps::WrapOStreamImpl name_stream_wrap(name_stream);

    void* exception = NULL;

    _dll_handle->Recognizer_getMethodName(
        _impl,
        &name_stream_wrap,
        pbio::stl_wraps::WrapOStream::write_func,
        &exception);

    checkException(exception, *_dll_handle);

    return name_stream.str();
}


inline
Template::Ptr Recognizer::processing(
    const RawSample &sample) const
{
    void* exception = NULL;

    void* const result_impl = _dll_handle->Recognizer_processing(
        _impl,
        (const pbio::facerec::RawSampleImpl*) sample._impl,
        &exception);

    checkException(exception, *_dll_handle);

    return Template::Ptr::make(_dll_handle, result_impl);
}


inline
Template::Ptr Recognizer::loadTemplate(std::istream &binary_stream) const
{
    pbio::stl_wraps::WrapIStreamImpl binary_stream_wrap(binary_stream);

    return loadTemplate(binary_stream_wrap);
}

inline
Template::Ptr Recognizer::loadTemplate(pbio::stl_wraps::WrapIStream &binary_stream) const
{
    void* exception = NULL;

    void* const result_impl = _dll_handle->Recognizer_loadTemplate(
        _impl,
        &binary_stream,
        pbio::stl_wraps::WrapIStream::read_func,
        &exception);

    checkException(exception, *_dll_handle);

    return Template::Ptr::make(_dll_handle, result_impl);
}


inline
Template::Ptr Recognizer::loadTemplate(
    const void* const data,
    const int size) const
{
    void* exception = NULL;

    pbio::stl_wraps::WrapIStreamBufferImpl input_stream((const char*) data, size);

    void* const result_impl = _dll_handle->Recognizer_loadTemplate(
        _impl,
        &input_stream,
        pbio::stl_wraps::WrapIStream::read_func,
        &exception);

    checkException(exception, *_dll_handle);

    return Template::Ptr::make(_dll_handle, result_impl);
}


inline
Recognizer::MatchResult Recognizer::verifyMatch(
    const Template &template1,
    const Template &template2) const
{
    MatchResult result;

    void* exception = NULL;

    _dll_handle->Recognizer_verifyMatch_v2(
        _impl,
        (const pbio::facerec::TemplateImpl*) template1._impl,
        (const pbio::facerec::TemplateImpl*) template2._impl,
        &result.distance,
        &result.fa_r,
        &result.fr_r,
        &result.score,
        &exception);

    checkException(exception, *_dll_handle);

    return result;
}

inline
TemplatesIndex::Ptr Recognizer::createIndex(
    const std::vector<pbio::Template::Ptr> &templates,
    const int search_threads_count,
    const int reserve_queries_count) const
{
    std::vector<const pbio::facerec::TemplateImpl*> templates_impls(templates.size());

    for(size_t i = 0; i < templates.size(); ++i)
        templates_impls[i] = (const pbio::facerec::TemplateImpl*) templates[i]->_impl;

    void* exception = NULL;

    void* const result_impl =
        _dll_handle->Recognizer_createIndex(
            _impl,
            templates.size(),
            &templates_impls[0],
            search_threads_count,
            &exception);

    checkException(exception, *_dll_handle);

    const TemplatesIndex::Ptr result = TemplatesIndex::Ptr::make(_dll_handle, result_impl);

    result->reserveSearchMemory(reserve_queries_count);

    return result;
}


inline TemplatesIndex::Ptr Recognizer::createResizableIndex(
        const uint64_t templates_count,
        const int search_threads_count,
        const int reserve_queries_count) const
{
    void* exception = NULL;

    void* const result_impl =
        _dll_handle->Recognizer_createResizableIndex(
            _impl,
            templates_count,
            search_threads_count,
            &exception);

    checkException(exception, *_dll_handle);

    const TemplatesIndex::Ptr result = TemplatesIndex::Ptr::make(_dll_handle, result_impl);

    result->reserveSearchMemory(reserve_queries_count);

    return result;
}


inline
std::vector<Recognizer::SearchResult> Recognizer::search(
    const pbio::Template &query_template,
    const pbio::TemplatesIndex &templates_index,
    const size_t k,
    const SearchAccelerationType acceleration) const
{
    std::vector<int64_t> result_i(k);
    std::vector<float> result_distance(k);
    std::vector<float> result_far(k);
    std::vector<float> result_frr(k);
    std::vector<float> result_score(k);

    void* exception = NULL;

    _dll_handle->Recognizer_search_v2(
        _impl,
        acceleration,
        1,  // queries_count
        (const pbio::facerec::TemplateImpl* const*) &query_template._impl,
        (const pbio::facerec::TemplatesIndexImpl*) templates_index._impl,
        k,
        &result_i[0],
        &result_distance[0],
        &result_far[0],
        &result_frr[0],
        &result_score[0],
        &exception);

    checkException(exception, *_dll_handle);

    std::vector<SearchResult> result(k);
    result.reserve(k);

    for(size_t i = 0; i < k; ++i)
    {
        if(result_i[i] < 0)
        {
            result.resize(i);
            break;
        }

        result[i].i = result_i[i];
        result[i].match_result.distance = result_distance[i];
        result[i].match_result.fa_r = result_far[i];
        result[i].match_result.fr_r = result_frr[i];
        result[i].match_result.score = result_score[i];
    }

    return result;
}


inline
std::vector<std::vector<Recognizer::SearchResult> > Recognizer::search(
    const std::vector<pbio::Template::Ptr> &queries_templates,
    const pbio::TemplatesIndex &templates_index,
    const size_t k,
    const SearchAccelerationType acceleration) const
{
    const size_t queries_count = queries_templates.size();

    std::vector<const pbio::facerec::TemplateImpl*> queries_impls(queries_count);

    for(size_t i = 0; i < queries_count; ++i)
    {
        queries_impls[i] = (const pbio::facerec::TemplateImpl*) queries_templates[i]->_impl;
    }

    std::vector<int64_t> result_i(k * queries_count);
    std::vector<float> result_distance(k * queries_count);
    std::vector<float> result_far(k * queries_count);
    std::vector<float> result_frr(k * queries_count);
    std::vector<float> result_score(k * queries_count);

    void* exception = NULL;

    _dll_handle->Recognizer_search_v2(
        _impl,
        acceleration,
        queries_count,
        &queries_impls[0],
        (const pbio::facerec::TemplatesIndexImpl*) templates_index._impl,
        k,
        &result_i[0],
        &result_distance[0],
        &result_far[0],
        &result_frr[0],
        &result_score[0],
        &exception);

    checkException(exception, *_dll_handle);

    std::vector<std::vector<SearchResult> > result(
        queries_count,
        std::vector<SearchResult>(k));

    for(size_t i = 0; i < queries_count; ++i)
    {
        for(size_t j = 0; j < k; ++j)
        {
            const size_t h = i * k + j;

            if(result_i[h] < 0)
            {
                result[i].resize(j);
                break;
            }

            result[i][j].i = result_i[h];
            result[i][j].match_result.distance = result_distance[h];
            result[i][j].match_result.fa_r = result_far[h];
            result[i][j].match_result.fr_r = result_frr[h];
            result[i][j].match_result.score = result_score[h];
        }
    }

    return result;
}





inline
Recognizer::MatchResult Recognizer::getROCCurvePointByDistanceThreshold(
    const double distance_threshold) const
{
    MatchResult result;

    void* exception = NULL;

    _dll_handle->Recognizer_getROCCurvePointByDistanceThreshold_v2(
        _impl,
        distance_threshold,
        &result.distance,
        &result.fa_r,
        &result.fr_r,
        &result.score,
        &exception);

    checkException(exception, *_dll_handle);

    return result;
}

inline
Recognizer::MatchResult Recognizer::getROCCurvePointByFAR(
    const double desired_far) const
{
    MatchResult result;

    void* exception = NULL;

    _dll_handle->Recognizer_getROCCurvePointByFAR_v2(
        _impl,
        desired_far,
        &result.distance,
        &result.fa_r,
        &result.fr_r,
        &result.score,
        &exception);

    checkException(exception, *_dll_handle);

    return result;
}

inline
Recognizer::MatchResult Recognizer::getROCCurvePointByFRR(
    const double desired_frr) const
{
    MatchResult result;

    void* exception = NULL;

    _dll_handle->Recognizer_getROCCurvePointByFRR_v2(
        _impl,
        desired_frr,
        &result.distance,
        &result.fa_r,
        &result.fr_r,
        &result.score,
        &exception);

    checkException(exception, *_dll_handle);

    return result;
}


inline
Recognizer::MatchResult Recognizer::getROCCurvePointByScoreThreshold(
    const double score_threshold) const
{
    MatchResult result;

    void* exception = NULL;

    _dll_handle->Recognizer_getROCCurvePointByScoreThreshold(
        _impl,
        score_threshold,
        &result.distance,
        &result.fa_r,
        &result.fr_r,
        &result.score,
        &exception);

    checkException(exception, *_dll_handle);

    return result;
}

inline
std::vector<size_t> Recognizer::chooseRepresentativeTemplatesSet(
    const size_t set_size,
    const std::vector<pbio::Template::Ptr> &templates,
    const std::vector<size_t> &inviolable_templates_indexes)
{
    std::vector<pbio::facerec::TemplateImpl const*> template_impls(templates.size());

    for(size_t i = 0; i < templates.size(); ++i)
        template_impls[i] = (pbio::facerec::TemplateImpl const*) templates[i]->_impl;

    std::vector<int8_t> inv_flags_8(templates.size(), 0);

    for(size_t i = 0; i < inviolable_templates_indexes.size(); ++i)
    {
        const size_t j = inviolable_templates_indexes[i];

        if(j >= templates.size())
            throw pbio::Error(
                0x63156958,
                "Error: bad index in chooseRepresentativeTemplatesSet, error code: 0x63156958");

        inv_flags_8[j] = 1;
    }

    std::vector<int32_t> result(set_size);

    void* exception = NULL;

    _dll_handle->Recognizer_chooseRepresentativeTemplatesSet(
        _impl,
        template_impls.empty() ? NULL : template_impls.data(),
        inv_flags_8.empty() ? NULL : inv_flags_8.data(),
        templates.size(),
        result.empty() ? NULL : result.data(),
        set_size,
        &exception);

    checkException(exception, *_dll_handle);

    return std::vector<size_t>(result.begin(), result.end());
}


}  // pbio namespace


#endif  // __PBIO_API__PBIO__RECOGNIZER_H_