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