IHumanAttributeEstimator.h

#pragma once

#include <fsdk/IObject.h>
#include <fsdk/FSDKError.h>
#include <fsdk/Optional.h>

#include <fsdk/Types/Image.h>
#include <fsdk/Types/Result.h>
#include <fsdk/Types/Span.h>

namespace fsdk {

#ifndef DOXYGEN_SHOULD_SKIP_THIS
    DECLARE_SMARTPTR(IHumanAttributeEstimator);
#endif

    struct HumanAttributeResult {

        enum class Color {
            Black,
            Blue,
            Green,
            Grey,
            Orange,
            Purple,
            Red,
            White,
            Yellow,
            Pink,
            Brown,
            Beige,
            Khaki,
            Multicolored,
            Count
        };

        struct OutwearColorEstimation {
            bool isBlack;                                 
            bool isBlue;                                  
            bool isGreen;                                 
            bool isGrey;                                  
            bool isOrange;                                
            bool isPurple;                                
            bool isRed;                                   
            bool isWhite;                                 
            bool isYellow;                                
            bool isPink;                                  
            bool isBrown;                                 
            bool isBeige;                                 
            bool isKhaki;                                 
            bool isMulticolored;                          
            float scores[static_cast<int>(Color::Count)]; 

            inline float getScore(Color color) const;
        };

        enum class ApparentColor {
            Black,
            White,
            Other,
            Unknown,
            Count
        };

        struct ApparentColorEstimation {
            bool isBlack;                                         
            bool isWhite;                                         
            bool isOther;                                         
            bool isUnknown;                                       
            float scores[static_cast<int>(ApparentColor::Count)]; 

            inline float getScore(ApparentColor color) const;
        };

        enum class Gender {
            Female, 
            Male,   
            Unknown 
        };

        struct GenderEstimation {
            Gender result; 
            float female;  
            float male;    
            float unknown; 
        };

        enum class SleeveSize {
            Short,  
            Long,   
            Unknown 
        };

        struct SleeveSizeEstimation {
            SleeveSize result; 
            float shortSize;   
            float longSize;    
            float unknown;     
        };

        enum class Hat {
            No,     //< there is no headwear
            Yes,    //< there is a headwear
            Unknown //< headwear state is unknown
        };

        struct HatEstimation {
            Hat result;    
            float noHat;   
            float hat;     
            float unknown; 

            ApparentColorEstimation hatColor; 
        };

        enum class Backpack {
            No,     //< there is no backpack
            Yes,    //< there is a backpack
            Unknown //< backpack state is unknown
        };

        struct BackpackEstimation {
            Backpack result;  
            float noBackpack; 
            float backpack;   
            float unknown;    
        };

        enum class LowerBodyClothing {
            Pants,  //< there is pants
            Shorts, //< there is shorts
            Skirt,  //< there is skirt
            Unknown //< lower body clothing state is unknown
        };

        struct LowerBodyClothingEstimation {
            LowerBodyClothing result;

            float pants;

            float shorts;

            float skirt;

            float unknown;

            OutwearColorEstimation lowerBodyClothingColor;
        };

        Optional<float> age;

        Optional<GenderEstimation> gender;

        Optional<SleeveSizeEstimation> sleeve;

        Optional<HatEstimation> headwear;

        Optional<BackpackEstimation> backpack;

        Optional<OutwearColorEstimation> outwearColor;

        Optional<LowerBodyClothingEstimation> lowerBodyClothing;

        Optional<ApparentColorEstimation> shoeColor;
    };

    enum class HumanAttributeRequest {
        EstimateAge = 1 << 0,               
        EstimateGender = 1 << 1,            
        EstimateSleeveSize = 1 << 2,        
        EstimateBackpack = 1 << 3,          
        EstimateOutwearColor = 1 << 4,      
        EstimateHeadwear = 1 << 5,          
        EstimateLowerBodyClothing = 1 << 7, 
        EstimateShoeColor = 1 << 8,         
        EstimateAll = 0xffff                
    };

    struct IHumanAttributeEstimator : IRefCounted {

        virtual Result<FSDKError> estimate(
            const Image& humanWarp,
            HumanAttributeRequest request,
            HumanAttributeResult& result) const noexcept = 0;

        virtual Result<FSDKError> estimate(
            Span<const Image> humanWarps,
            HumanAttributeRequest request,
            Span<HumanAttributeResult> results) const noexcept = 0;

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


        virtual Result<FSDKError> aggregate(
            Span<const HumanAttributeResult> estimations,
            HumanAttributeRequest request,
            HumanAttributeResult& result) const noexcept = 0;
    };

    /*
        Implementation details.
    */
    float HumanAttributeResult::OutwearColorEstimation::getScore(HumanAttributeResult::Color color) const {
        switch(color) {
        case Color::Black:
        case Color::Blue:
        case Color::Green:
        case Color::Grey:
        case Color::Orange:
        case Color::Purple:
        case Color::Red:
        case Color::White:
        case Color::Yellow:
        case Color::Pink:
        case Color::Brown:
        case Color::Beige:
        case Color::Khaki:
        case Color::Multicolored:
            return scores[static_cast<int>(color)];
        default:
            return -1.0f;
        }
    }

    /*
        Implementation details.
    */
    float
    HumanAttributeResult::ApparentColorEstimation::getScore(HumanAttributeResult::ApparentColor color) const {
        switch(color) {
        case ApparentColor::Black:
        case ApparentColor::White:
        case ApparentColor::Other:
        case ApparentColor::Unknown:
            return scores[static_cast<int>(color)];
        default:
            return -1.0f;
        }
    }

    /*
        Implementation details.
    */
    inline HumanAttributeRequest operator|(HumanAttributeRequest lhs, HumanAttributeRequest rhs) {
        return static_cast<HumanAttributeRequest>(static_cast<int>(lhs) | static_cast<int>(rhs));
    }

    /*
        Implementation details.
    */
    inline bool operator&(HumanAttributeRequest lhs, HumanAttributeRequest rhs) {
        return static_cast<int>(lhs) & static_cast<int>(rhs);
    }

} // namespace fsdk