IDescriptor.h

Go to the documentation of this file.

#pragma once

#include <fsdk/IObject.h>
#include <fsdk/IDetector.h>
#include <fsdk/FSDKError.h>
#include <fsdk/Types.h>

#include <limits>

namespace fsdk {

#ifndef DOXYGEN_SHOULD_SKIP_THIS
    DECLARE_SMARTPTR(IDescriptor);
    DECLARE_SMARTPTR(IDescriptorBatch);
    DECLARE_SMARTPTR(IDescriptorMatcher);
    DECLARE_SMARTPTR(IDescriptorExtractor);
#endif

    struct MatchingResult {
        float distance;   
        float similarity; 

        MatchingResult(void) noexcept
            : distance(std::numeric_limits<float>::infinity())
            , similarity(0.f) {
        }

        MatchingResult(float distance, float similarity) noexcept
            : distance(distance)
            , similarity(similarity) {
        }
    };

    enum DescriptorType {
        DT_FACE, 
        DT_HUMAN 
    };

    enum DescriptorVersion : uint32_t {
        DV_MIN_FACE_DESCRIPTOR_VERSION = 52,  
        DV_MIN_HUMAN_DESCRIPTOR_VERSION = 102 
    };

    enum HumanDescriptorVersion : uint32_t {
        HDV_TRACKER_HUMAN_DESCRIPTOR_VERSION = 102, 
        HDV_PRECISE_HUMAN_DESCRIPTOR_VERSION = 103, 
        HDV_REGULAR_HUMAN_DESCRIPTOR_VERSION = 104, 
        HDV_TRACKER_V2 = 105,                       
        HDV_PRECISE_V2 = 106,                       
        HDV_REGULAR_V2 = 107,                       
        HDV_TRACKER_V3 = 108,                       
        HDV_PRECISE_V3 = 109,                       
        HDV_REGULAR_V3 = 110,                       
        HDV_PRECISE_V4 = 112,                       
        HDV_REGULAR_V4 = 113                        
    };

    struct IDescriptor : IDataStorageObject {
        virtual uint32_t getModelVersion() const noexcept = 0;

        virtual DescriptorType getDescriptorType() const noexcept = 0;

        virtual uint32_t getDescriptorLength() const noexcept = 0;

        virtual bool getDescriptor(uint8_t* buffer) const noexcept = 0;

        virtual void setDescriptor(const uint8_t* buffer) noexcept = 0;
    };

    struct IDescriptorBatch : IDataStorageObject {
        enum class Error : uint32_t {
            Ok,           
            InvalidInput, 
            BatchFull,    
            Incompatible, 
            Internal,     
            IoError,      
            OutOfRange,   
        };

        virtual Result<Error> add(IDescriptor* descriptor) noexcept = 0;

        virtual Result<Error> add(IDescriptorBatch* batch, uint32_t offset = 0) noexcept = 0;

        virtual Result<Error> add(IDescriptorBatch* batch, uint32_t offset, uint32_t count) noexcept = 0;

        virtual Result<Error> removeFast(uint32_t index) noexcept = 0;

        virtual Result<Error> removeSlow(uint32_t index) noexcept = 0;

        virtual Result<MultiError<ISerializableObject::Error, Error>> loadAndAdd(IArchive* archive) = 0;

        virtual uint32_t getMaxCount() const noexcept = 0;

        virtual uint32_t getCount() const noexcept = 0;

        virtual uint32_t getModelVersion() const noexcept = 0;

        virtual DescriptorType getDescriptorType() const noexcept = 0;

        virtual uint32_t getDescriptorLength() const noexcept = 0;

        virtual ResultValue<FSDKError, IDescriptorPtr> getDescriptorSlow(uint32_t index) const noexcept = 0;

        virtual ResultValue<FSDKError, IDescriptorPtr> getDescriptorFast(uint32_t index) noexcept = 0;
    };

    template <>
    struct ErrorTraits<IDescriptorBatch::Error> {
        static bool isOk(IDescriptorBatch::Error error) noexcept {
            return error == IDescriptorBatch::Error::Ok;
        }

        static const char* toString(IDescriptorBatch::Error error) noexcept {
            switch(error) {
            case IDescriptorBatch::Error::Ok:
                return "Ok";
            case IDescriptorBatch::Error::IoError:
                return "Error during reading/writing";
            case IDescriptorBatch::Error::Internal:
                return "Internal error";
            case IDescriptorBatch::Error::BatchFull:
                return "Batch is full";
            case IDescriptorBatch::Error::OutOfRange:
                return "Descriptor out of range";
            case IDescriptorBatch::Error::Incompatible:
                return "Incompatible descriptor";
            case IDescriptorBatch::Error::InvalidInput:
                return "Invalid input";
            default:
                return "Unknown error";
            }
        }
    };

    struct IDescriptorExtractor : IRefCounted {
        virtual ResultValue<FSDKError, float>
        extractFromWarpedImage(const Image& warp, IDescriptor* descriptor) const noexcept = 0;

        virtual ResultValue<FSDKError, float> extractFromWarpedImageBatch(
            Span<const Image> warps,
            IDescriptorBatch* descriptorBatch,
            IDescriptor* aggregation,
            Span<float> garbageScoreBatch) const noexcept = 0;

        virtual Result<FSDKError> extractFromWarpedImageBatch(
            Span<const Image> warps,
            IDescriptorBatch* descriptorBatch,
            Span<float> garbageScoreBatch) const noexcept = 0;

        virtual Result<FSDKError>
        validate(Span<const Image> warps, Span<Result<FSDKError>> errors) const noexcept = 0;

        virtual uint32_t getModelVersion() const noexcept = 0;

        virtual DescriptorType getDescriptorType() const noexcept = 0;

        using FutureResult = vlc::future<float>;

        virtual FutureResult extractFromWarpedImageBatchAsync(
            Span<const Image> warps,
            IDescriptorBatch* descriptorBatch,
            IDescriptor* aggregation,
            Span<float> garbageScoreBatch) const = 0;
    };

    struct IDescriptorMatcher : IRefCounted {
        virtual ResultValue<FSDKError, MatchingResult>
        match(const IDescriptor* first, const IDescriptor* second) noexcept = 0;

        virtual Result<FSDKError> match(
            const IDescriptor* reference,
            const IDescriptorBatch* candidates,
            Span<MatchingResult> results) noexcept = 0;

        virtual uint32_t getModelVersion() const noexcept = 0;

        virtual Result<FSDKError> calcSimilarity(Span<MatchingResult> distances) const noexcept = 0;

        virtual Result<FSDKError> calcDistance(Span<MatchingResult> similarities) const noexcept = 0;
    };

} // namespace fsdk