Face.h

Go to the documentation of this file.

 
#pragma once
 
#include "enrollment/Exception/CallbackError.h"
#include "enrollment/Face/FaceAttributes/FaceAttributes.h"
#include "enrollment/Face/FaceCapture.h"
#include "enrollment/Face/FaceCropConfiguration.h"
#include "enrollment/Face/FaceExecutor.h"
#include "enrollment/HashUtils.h"
#include "enrollment/Image/Image.h"
#include "enrollment/Image/ImageAttribute.h"
#include "enrollment/Logger/FormattingLogger.h"
#include "enrollment/Serialization/Writer.h"
#include "enrollment/SimilarityScore.h"
#include <algorithm>
#include <array>
#include <memory>
#include <mutex>
#include <optional>
#include <unordered_map>
#include <vector>
 
// cppcoreguidelines-non-private-member-variables-in-classes,misc-non-private-member-variables-in-classes: This is not
// a problem because we are using them only as read only. cppcoreguidelines-avoid-const-or-ref-data-members: We design
// te API with const member variables instead of implementing getter methods. This is nicely transformed in C# to
// properties. Usually our objects are immutable by intention to have no problem in multithreaded applications.
// NOLINTBEGIN(cppcoreguidelines-non-private-member-variables-in-classes,misc-non-private-member-variables-in-classes,cppcoreguidelines-avoid-const-or-ref-data-members)
namespace inno
{
    class Face;

     */
    class FaceExtractorConfig : public Serializable
    {
    public:
         */
        enum class Type : uint8_t
        {
            ACCURATE,
            BALANCED,
            FAST
        };
         */
        void SetExtractor(Type value)
        {
            type = value;
        }
         */
        [[nodiscard]] Type GetExtractor() const
        {
            return type;
        }

         */
        void WriteTo(Writer& writer) const final
        {
            writer.Write("t", static_cast<unsigned int>(type));
        }

         */
        static FaceExtractorConfig Default()
        {
            static const FaceExtractorConfig DefaultCfg;
            return DefaultCfg;
        }

        FaceExtractorConfig() = default;
        virtual ~FaceExtractorConfig() = default;
        FaceExtractorConfig(const FaceExtractorConfig&) = default;
        FaceExtractorConfig(FaceExtractorConfig&&) = default;
        FaceExtractorConfig& operator=(const FaceExtractorConfig&) = default;
        FaceExtractorConfig& operator=(FaceExtractorConfig&&) = default;
 
    private:
        Type type = Type::BALANCED;
    };

     */
    class FaceTemplate : public Serializable
    {
    public:
        const std::vector<uint8_t> data;

         */
        [[nodiscard]] FaceSimilarityScore SimilarWith(const FaceTemplate& gallery) const
        {
            log.LogInfo("Matching faces %v - %v", *this, gallery);
            float score = 0.0F;
 
            exec->Match(data.data(), data.size(), gallery.data.data(), gallery.data.size(), &score, ThrowOnError{});
 
            FaceSimilarityScore faceScore = static_cast<int>(score);
            log.LogInfo("Matching faces %v - %v with score %u from %f", *this, gallery, faceScore, score);
            return faceScore;
        }

         */
        [[nodiscard]] std::string GetVersion() const
        {
            int32_t quality = 0;
            uint32_t modelVersion = 0;
            uint32_t enrollmentVersion = 0;
            std::ignore = exec->GetTemplateEmbeddingInfo(
              data.data(), data.size(), &quality, &modelVersion, &enrollmentVersion, ThrowOnError{});
            std::ignore = quality;
 
            return std::to_string(modelVersion) + "." + std::to_string(enrollmentVersion);
        }

         */
        void WriteTo(Writer& writer) const override
        {
            writer.WriteArray("t", data);
        }

         */
        FaceTemplate(std::vector<uint8_t>&& templ, std::shared_ptr<FaceExecutor> executor)
          : data(std::move(templ))
          , exec(std::move(executor))
          , log(GlobalLogger::Get())
        {
            if (exec == nullptr)
            {
                throw NullArgumentException("executor can not be null");
            }
            if (data.empty())
            {
                throw InvalidTemplateException("Face template MUST have data");
            }
        }

         */
        explicit FaceTemplate(std::vector<uint8_t>&& templ)
          : data(std::move(templ))
          , exec(GlobalFaceExecutor::Get())
          , log(GlobalLogger::Get())
        {
            if (data.empty())
            {
                throw InvalidTemplateException("Face template MUST have data");
            }
        }

         */
        FaceTemplate(const std::vector<uint8_t>& templ, std::shared_ptr<FaceExecutor> executor)
          : data(templ)
          , exec(std::move(executor))
          , log(GlobalLogger::Get())
        {
            if (exec == nullptr)
            {
                throw NullArgumentException("executor can not be null");
            }
            if (data.empty())
            {
                throw InvalidTemplateException("Face template MUST have data");
            }
        }

         */
        explicit FaceTemplate(const std::vector<uint8_t>& templ)
          : data(templ)
          , exec(GlobalFaceExecutor::Get())
          , log(GlobalLogger::Get())
        {
            if (data.empty())
            {
                throw InvalidTemplateException("Face template MUST have data");
            }
        }
 
        [[nodiscard]] bool operator==(const FaceTemplate& other) const noexcept
        {
            return data == other.data;
        }
 
        [[nodiscard]] std::size_t Hash() const noexcept
        {
            return detail::HashBytes(data);
        }
 
        FaceTemplate(const FaceTemplate&) = delete;
        FaceTemplate(FaceTemplate&&) = delete;
        FaceTemplate& operator=(const FaceTemplate&) = delete;
        FaceTemplate& operator=(FaceTemplate&&) = delete;
        FaceTemplate() = delete;
        virtual ~FaceTemplate() = default;
 
    private:
        std::shared_ptr<void> faceHandler;
        std::shared_ptr<FaceExecutor> exec;
        FormattingLogger log;
    };
 
    class Face;

     */
    class ExtractedFace : public FaceTemplate
    {
    public:
        const std::shared_ptr<Face> face;

         */
        static std::vector<std::shared_ptr<FaceTemplate>> ToTemplates(
          const std::vector<std::shared_ptr<ExtractedFace>>& faces)
        {
            std::vector<std::shared_ptr<FaceTemplate>> templates(faces.size());
            std::transform(faces.begin(), faces.end(), templates.begin(), [](const auto& t) { return t; });
            return templates;
        }
        void WriteTo(Writer& writer) const final;
 
        ExtractedFace(const ExtractedFace&) = delete;
        ExtractedFace(ExtractedFace&&) = delete;
        ExtractedFace& operator=(const ExtractedFace&) = delete;
        ExtractedFace& operator=(ExtractedFace&&) = delete;
        ExtractedFace() = delete;
        virtual ~ExtractedFace() = default;
 
    private:
        std::shared_ptr<FaceExecutor> exec;
        FormattingLogger log;
        /*
         * @brief Construct a new ExtractedFace object
         *
         * @param face Face
         * @param templ template data
         * @param faceHandler face handler
         * @return ExtractedFace object
         */
        static std::shared_ptr<ExtractedFace> Create(std::shared_ptr<Face> face,
                                                     std::vector<uint8_t>&& templ,
                                                     std::shared_ptr<FaceExecutor> exec)
        {
            return std::shared_ptr<ExtractedFace>(
              new ExtractedFace(std::move(face), std::move(templ), std::move(exec)));
        }
 
        ExtractedFace(std::shared_ptr<Face> i, std::vector<uint8_t>&& t, std::shared_ptr<FaceExecutor> e)
          : FaceTemplate(std::move(t))
          , face(std::move(i))
          , exec(std::move(e))
          , log(GlobalLogger::Get())
        {
        }
 
        friend class Face;
    };

     */
    class CroppedFace
    {
    public:
         */
        [[nodiscard]] std::shared_ptr<FaceCapture> GetFaceCapture() const
        {
            if (config.GetCropMethod() == FaceCrop::FULL_NOT_ALIGNED)
            {
                auto croppedImage = originalCapture->CropFace(GetCropRectangle(), config.GetCropBackground());
                auto faceAttributes = originalCapture->faceAttributes;
                faceAttributes.SetFaceImageType(FaceImageType::BASIC);
                return FaceCapture::Create(std::move(croppedImage), faceAttributes);
            }
 
            auto imageDataAllocator = +[](void* container, size_t size)
            {
                auto& vector = *static_cast<std::vector<uint8_t>*>(container);
                vector.resize(size);
                return vector.data();
            };
            std::vector<uint8_t> imageData;
 
            ImageHeight imageHeight = 0;
            ImageWidth imageWidth = 0;
            exec->CropImage(faceItem.get(),
                            static_cast<unsigned int>(config.GetCropMethod()),
                            config.GetCropScale(),
                            config.GetCropBackground().color.red,
                            config.GetCropBackground().color.green,
                            config.GetCropBackground().color.blue,
                            &imageWidth,
                            &imageHeight,
                            imageDataAllocator,
                            &imageData,
                            ThrowOnError{});
 
            auto raw = RawImage(
              imageWidth, imageHeight, originalCapture->image->Dpi(), RawImage::Type::BGR, std::move(imageData));
            auto croppedImage = Image::DecodeRawImage(raw);
 
            auto faceAttributes = originalCapture->faceAttributes;
            switch (config.GetCropMethod())
            {
            case FaceCrop::FULL:
                faceAttributes.SetFaceImageType(FaceImageType::FULL_FRONTAL);
                break;
            case FaceCrop::TOKEN:
                faceAttributes.SetFaceImageType(FaceImageType::TOKEN_FRONTAL);
                break;
            default:
                faceAttributes.SetFaceImageType(FaceImageType::BASIC);
                break;
            }
 
            return FaceCapture::Create(std::move(croppedImage), faceAttributes);
        }

         */
        [[nodiscard]] Rectangle GetCropRectangle() const
        {
 
            auto rectangle = exec->CropRectangle(
              faceItem.get(), static_cast<unsigned int>(config.GetCropMethod()), config.GetCropScale(), ThrowOnError{});
 
            return Rectangle{ { rectangle.topLeftX, rectangle.topLeftY },
                              { rectangle.topRightX, rectangle.topRightY },
                              { rectangle.bottomRightX, rectangle.bottomRightY },
                              { rectangle.bottomLeftX, rectangle.bottomLeftY } };
        }

         */
        [[nodiscard]] bool IsCropRegionInsideImage() const
        {
            return originalCapture->IsWholeCroppedRectangleInside(GetCropRectangle());
        }

         */
        [[nodiscard]] std::shared_ptr<Image> FaceAreaMask() const
        {
            if (config.GetCropMethod() == FaceCrop::FULL_NOT_ALIGNED)
            {
                throw NotSupportedException(
                  "It is not possible to get face area mask for FULL_NOT_ALIGNED crop method");
            }
 
            unsigned int width = 0;
            unsigned int height = 0;
            size_t length = 0;
            uint8_t* data = nullptr;
            exec->FaceAreaMask(faceItem.get(),
                               &width,
                               &height,
                               &data,
                               &length,
                               static_cast<unsigned int>(config.GetCropMethod()),
                               config.GetCropScale(),
                               ThrowOnError{});
 
            std::vector<uint8_t> mask(data, std::next(data, static_cast<ptrdiff_t>(length)));
            exec->DeleteBytes(data);
            return Image::DecodeRawImage(
              RawImage(width, height, originalCapture->image->Dpi(), RawImage::Type::GRAYSCALE, std::move(mask)));
        }

         */
        [[nodiscard]] std::shared_ptr<Image> FaceAreaSegment(const RGB& color) const
        {
            if (config.GetCropMethod() == FaceCrop::FULL_NOT_ALIGNED)
            {
                throw NotSupportedException(
                  "It is not possible to get color segmentation for FULL_NOT_ALIGNED crop method");
            }
 
            unsigned int width = 0;
            unsigned int height = 0;
            size_t length = 0;
            uint8_t* data = nullptr;
            exec->FaceAreaSegmentationColor(faceItem.get(),
                                            &width,
                                            &height,
                                            &data,
                                            &length,
                                            static_cast<unsigned int>(config.GetCropMethod()),
                                            config.GetCropScale(),
                                            color.red,
                                            color.green,
                                            color.blue,
                                            ThrowOnError{});
 
            std::vector<uint8_t> mask(data, std::next(data, static_cast<ptrdiff_t>(length)));
            exec->DeleteBytes(data);
            return Image::DecodeRawImage(
              RawImage(width, height, originalCapture->image->Dpi(), RawImage::Type::BGR, std::move(mask)));
        }

         */
        [[nodiscard]] std::shared_ptr<Image> FaceAreaSegment() const
        {
            if (config.GetCropMethod() == FaceCrop::FULL_NOT_ALIGNED)
            {
                throw NotSupportedException("It is not possible to get segmentation for FULL_NOT_ALIGNED crop method");
            }
 
            unsigned int width = 0;
            unsigned int height = 0;
            size_t length = 0;
            uint8_t* data = nullptr;
            std::ignore = exec->FaceAreaSegmentation(faceItem.get(),
                                                     &width,
                                                     &height,
                                                     &data,
                                                     &length,
                                                     static_cast<unsigned int>(config.GetCropMethod()),
                                                     config.GetCropScale(),
                                                     ThrowOnError{});
 
            std::vector<uint8_t> mask(data, std::next(data, static_cast<ptrdiff_t>(length)));
            exec->DeleteBytes(data);
            return Image::DecodeRawImage(
              RawImage(width, height, originalCapture->image->Dpi(), RawImage::Type::BGRA, std::move(mask)));
        }
        CroppedFace() = delete;
        virtual ~CroppedFace() = default;
        CroppedFace(const CroppedFace&) = delete;
        CroppedFace(CroppedFace&&) = delete;
        CroppedFace& operator=(const CroppedFace&) = delete;
        CroppedFace& operator=(CroppedFace&&) = delete;
 
    private:
        std::shared_ptr<void> faceItem;
        std::shared_ptr<FaceCapture> originalCapture;
        FaceCropConfiguration config;
        std::shared_ptr<FaceExecutor> exec;
 
        CroppedFace(std::shared_ptr<void> f,
                    std::shared_ptr<FaceCapture> oc,
                    FaceCropConfiguration c,
                    std::shared_ptr<FaceExecutor> e)
          : faceItem(std::move(f))
          , originalCapture(std::move(oc))
          , config(std::move(c))
          , exec(std::move(e))
        {
        }
 
        friend class Face;
    };

     */
    class Face final
      : public Serializable
      , public std::enable_shared_from_this<Face>
    {
    public:
        class Keypoints;
         */
        class Keypoint : public Serializable
        {
        public:
             */
            [[nodiscard]] Point GetPosition() const
            {
                return pos;
            }

             */
            [[nodiscard]] float GetScore() const
            {
                return score;
            }

             */
            void WriteTo(Writer& writer) const final
            {
                writer.Write("p", GetPosition());
                writer.Write("s", GetScore());
            }
 
        private:
            Point pos;
            float score = 0.0F;
 
            Keypoint() = default;
 
            Keypoint(Point position, float reliabilityScore)
              : pos(std::move(position))
              , score(reliabilityScore)
            {
            }
 
            friend class Keypoints;
        };

         */
        class Keypoints : public Serializable
        {
        public:
             */
            Keypoint RightEyeOuterCorner()
            {
                return CalculateKeypoint(exec->GetRightEyeOuterCornerId(), "reoc");
            }

             */
            Keypoint RightEyeCentre()
            {
                return CalculateKeypoint(exec->GetRightEyeCentreId(), "rec");
            }

             */
            Keypoint RightEyeInnerCorner()
            {
                return CalculateKeypoint(exec->GetRightEyeInnerCornerId(), "reic");
            }

             */
            Keypoint LeftEyeInnerCorner()
            {
                return CalculateKeypoint(exec->GetLeftEyeInnerCornerId(), "leic");
            }

             */
            Keypoint LeftEyeCentre()
            {
                return CalculateKeypoint(exec->GetLeftEyeCentreId(), "lec");
            }

             */
            Keypoint LeftEyeOuterCorner()
            {
                return CalculateKeypoint(exec->GetLeftEyeOuterCornerId(), "leoc");
            }

             */
            Keypoint NoseRoot()
            {
                return CalculateKeypoint(exec->GetNoseRootId(), "nr");
            }

             */
            Keypoint NoseRightBottom()
            {
                return CalculateKeypoint(exec->GetNoseRightBottomId(), "nrb");
            }

             */
            Keypoint NoseTip()
            {
                return CalculateKeypoint(exec->GetNoseTipId(), "nt");
            }

             */
            Keypoint NoseLeftBottom()
            {
                return CalculateKeypoint(exec->GetNoseLeftBottomId(), "nlb");
            }

             */
            Keypoint NoseBottom()
            {
                return CalculateKeypoint(exec->GetNoseBottomId(), "nb");
            }

             */
            Keypoint MouthRightCorner()
            {
                return CalculateKeypoint(exec->GetMouthRightCornerId(), "mrc");
            }

             */
            Keypoint MouthCenter()
            {
                return CalculateKeypoint(exec->GetMouthCenterId(), "mc");
            }

             */
            Keypoint MouthLeftCorner()
            {
                return CalculateKeypoint(exec->GetMouthLeftCornerId(), "mlc");
            }

             */
            Keypoint MouthUpperEdge()
            {
                return CalculateKeypoint(exec->GetMouthUpperEdgeId(), "mue");
            }

             */
            Keypoint MouthLowerEdge()
            {
                return CalculateKeypoint(exec->GetMouthLowerEdgeId(), "mle");
            }

             */
            Keypoint RightEyebrowOuterEnd()
            {
                return CalculateKeypoint(exec->GetRightEyebrowOuterEndId(), "reoe");
            }

             */
            Keypoint RightEyebrowInnerEnd()
            {
                return CalculateKeypoint(exec->GetRightEyebrowInnerEndId(), "reie");
            }

             */
            Keypoint LeftEyebrowInnerEnd()
            {
                return CalculateKeypoint(exec->GetLeftEyebrowInnerEndId(), "leie");
            }

             */
            Keypoint LeftEyebrowOuterEnd()
            {
                return CalculateKeypoint(exec->GetLeftEyebrowOuterEndId(), "leoe");
            }

             */
            Keypoint RightEdge()
            {
                return CalculateKeypoint(exec->GetRightEdgeId(), "re");
            }

             */
            Keypoint ChinTip()
            {
                return CalculateKeypoint(exec->GetChinTipId(), "cht");
            }

             */
            Keypoint LeftEdge()
            {
                return CalculateKeypoint(exec->GetLeftEdgeId(), "le");
            }

             */
            [[nodiscard]] std::shared_ptr<Image> GetImage() const
            {
                return capture->image;
            }

             */
            void WriteTo(Writer& writer) const final
            {
                const std::scoped_lock lock(keyPointsMux);
                for (const auto& [id, serializableKeypoint] : keypoints)
                {
                    writer.Write(serializableKeypoint.serializationKey, serializableKeypoint.keypoint);
                }
            }
 
        private:
            /*
             * @brief Construct a new Keypoints object
             *
             * @param faceCapture original face image on which face was detected
             * @param face face detected on the image
             * @param executor is FaceExecutor
             * @throws NullArgumentException when image is null
             * @throws NullArgumentException when face is null
             * @throws NullArgumentException when executor is null
             */
            Keypoints(std::shared_ptr<FaceCapture> faceCapture,
                      std::shared_ptr<void> face,
                      std::shared_ptr<FaceExecutor> executor)
              : capture(std::move(faceCapture))
              , faceItem(std::move(face))
              , exec(std::move(executor))
            {
                if (capture == nullptr)
                {
                    throw NullArgumentException("Face capture can not be null");
                }
                if (faceItem == nullptr)
                {
                    throw NullArgumentException("face cannot be null");
                }
                if (exec == nullptr)
                {
                    throw NullArgumentException("executor can not be null");
                }
            }
 
            Keypoint CalculateKeypoint(unsigned int id, const char* serializationKey)
            {
                const std::scoped_lock keyPointsLock(keyPointsMux);
 
                const bool alreadyCalculated = keypoints.contains(id);
                if (!alreadyCalculated)
                {
                    float score = {};
                    float x = {};
                    float y = {};
                    exec->GetKeypoint(GlobalLogger::Get(), faceItem.get(), id, &score, &x, &y, ThrowOnError{});
 
                    keypoints.emplace(
                      id,
                      SerializableKeypoint{ serializationKey,
                                            Keypoint(Point{ static_cast<X>(x), static_cast<Y>(y) }, score) });
                }
                return keypoints[id].keypoint;
            }
 
            std::shared_ptr<FaceCapture> capture;
            std::shared_ptr<void> faceItem;
            std::shared_ptr<FaceExecutor> exec;
            struct SerializableKeypoint
            {
                const char* serializationKey = nullptr;
                Keypoint keypoint;
            };
 
            std::unordered_map<unsigned int, SerializableKeypoint> keypoints;
            mutable std::mutex keyPointsMux;
 
            friend class Face;
        };

         */
        [[nodiscard]] std::shared_ptr<Keypoints> GetKeypoints() const
        {
            return keypoints;
        }

        const std::shared_ptr<FaceCapture> capture;
        const unsigned int confidence;

         */
        [[nodiscard]] std::shared_ptr<CroppedFace> Crop(FaceCropConfiguration cfg) const
        {
            return std::shared_ptr<CroppedFace>(new CroppedFace(faceItem, capture, std::move(cfg), exec));
        }

         */
        [[nodiscard]] Rectangle DetectionRectangle() const
        {
            return boundingBox;
        }
         */
        [[nodiscard]] std::vector<uint8_t> ToIsoImage(ImageEncoder& encoder) const
        {
            auto isoEncoder = IsoImageEncoder(*this, encoder);
            return isoEncoder.Encode();
        }

         */
        std::shared_ptr<ExtractedFace> Extract(const FaceExtractorConfig& cfg)
        {
            log.LogInfo("Face extraction for %v with cfg %v ...", capture, cfg);
 
            std::vector<uint8_t> templData;
 
            exec->Extract(
              faceItem.get(),
              +[](void* container, size_t size) -> uint8_t*
              {
                  auto* data = static_cast<std::vector<uint8_t>*>(container);
                  data->resize(size);
                  return data->data();
              },
              &templData,
              static_cast<unsigned int>(cfg.GetExtractor()),
              ThrowOnError{});
 
            auto face = shared_from_this();
            auto extractedFace = ExtractedFace::Create(face, std::move(templData), exec);
 
            log.LogInfo("Face extraction result %v", extractedFace);
 
            return extractedFace;
        }

         */
        std::shared_ptr<ExtractedFace> Extract()
        {
            auto cfg = FaceExtractorConfig::Default();
            return Extract(cfg);
        }

         */
        void WriteTo(Writer& writer) const final
        {
            writer.Write("c", confidence);
            writer.Write("k", keypoints);
            writer.Write("cp", capture);
            for (auto const& attribute : attributes)
            {
                const std::scoped_lock lock(attribute.mux);
                if (attribute.value.has_value())
                {
                    writer.Write(attribute.serializationKey, attribute.value.value());
                }
            }
            {
                const std::scoped_lock lock(fastPassiveLivenessMux);
                if (fastPassiveLiveness.has_value())
                {
                    writer.Write("ulf", fastPassiveLiveness.value());
                }
            }
            {
                const std::scoped_lock lock(accuratePassiveLivenessMux);
                if (accuratePassiveLiveness.has_value())
                {
                    writer.Write("ula", accuratePassiveLiveness.value());
                }
            }
        }

         */
        bool IsSameAs(const Face& face) const
        {
            return this == &face;
        }

         */
        bool operator==(const Face& f) const
        {
            if (this == &f)
            {
                return true;
            }
 
            return *capture->image == *f.capture->image && capture->faceAttributes == f.capture->faceAttributes;
        }

         */
        bool operator!=(const Face& f) const
        {
            return !(*this == f);
        }

         */
        float Sharpness()
        {
            return CalculateAttribute(exec->GetSharpnessId(), "sr");
        }

         */
        float Brightness()
        {
            return CalculateAttribute(exec->GetBrightnessId(), "br");
        }

         */
        float Contrast()
        {
            return CalculateAttribute(exec->GetContrastId(), "ct");
        }

         */
        float UniqueIntensityLevels()
        {
            return CalculateAttribute(exec->GetUniqueIntensityLevelsId(), "uil");
        }

         */
        float Shadow()
        {
            return CalculateAttribute(exec->GetShadowId(), "sh");
        }

         */
        float NoseShadow()
        {
            return CalculateAttribute(exec->GetNoseShadowId(), "ns");
        }

         */
        float Specularity()
        {
            return CalculateAttribute(exec->GetSpecularityId(), "sp");
        }

         */
        float EyeGaze()
        {
            return CalculateAttribute(exec->GetEyeGazeId(), "eg");
        }

         */
        float RightEyeStatus()
        {
            return CalculateAttribute(exec->GetEyeStatusRId(), "esr");
        }

         */
        float LeftEyeStatus()
        {
            return CalculateAttribute(exec->GetEyeStatusLId(), "esl");
        }

         */
        float GlassStatus()
        {
            return CalculateAttribute(exec->GetGlassStatusId(), "gs");
        }

         */
        float HeavyFrame()
        {
            return CalculateAttribute(exec->GetHeavyFrameId(), "hf");
        }

         */
        float MouthStatus()
        {
            return CalculateAttribute(exec->GetMouthStatusId(), "ms");
        }

         */
        float BackgroundUniformity(uint8_t minimalBackgroundRatio)
        {
            static constexpr uint8_t MaxBackgroundRatio = 100;
            if (minimalBackgroundRatio > MaxBackgroundRatio)
            {
                throw EnrollmentInvalidArgumentException(
                  "The minimal background ratio for face background uniformity MUST be in range <0,100>");
            }
            AttributeConfiguration config;
            config.emplace_back(inno_FaceParams::BackgroundUniformityMinRatioName,
                                std::to_string(minimalBackgroundRatio));
            return CalculateAttribute(exec->GetBackgroundUniformityId(), "bu", std::move(config));
        }

         */
        float BackgroundUniformity()
        {
            static constexpr uint8_t DefaultMinimalBackgroundRatio = 5;
            return BackgroundUniformity(DefaultMinimalBackgroundRatio);
        }

         */
        enum class AgeEstimationMode : uint8_t
        {
            BALANCED = 1,
            ACCURATE = 2
        };

         */
        float Age()
        {
            return Age(AgeEstimationMode::BALANCED);
        }

         */
        float Age(AgeEstimationMode mode)
        {
            AttributeConfiguration config;
            config.emplace_back(inno_FaceParams::AgeGenderMode, ToString(mode));
            return CalculateAttribute(exec->GetAgeId(), "age", std::move(config));
        }

         */
        float RightRedEye()
        {
            return CalculateAttribute(exec->GetRedEyeRId(), "rer");
        }

         */
        float LeftRedEye()
        {
            return CalculateAttribute(exec->GetRedEyeLId(), "rel");
        }

         */
        enum class GenderEstimationMode : uint8_t
        {
            BALANCED = 1,
            ACCURATE = 2
        };

         */
        float Gender()
        {
            return Gender(GenderEstimationMode::BALANCED);
        }

         */
        float Gender(GenderEstimationMode mode)
        {
            AttributeConfiguration config;
            config.emplace_back(inno_FaceParams::AgeGenderMode, ToString(mode));
            return CalculateAttribute(exec->GetGenderId(), "gen", std::move(config));
        }

         */
        float EyeDistance()
        {
            return CalculateAttribute(exec->GetEyeDistanceId(), "ed");
        }

         */
        float RollAngle()
        {
            return CalculateAttribute(exec->GetRollAngleId(), "ra");
        }

         */
        float PitchAngle()
        {
            return CalculateAttribute(exec->GetPitchAngleId(), "pa");
        }

         */
        float YawAngle()
        {
            return CalculateAttribute(exec->GetYawAngleId(), "ya");
        }

         */
        float FaceSize()
        {
            return CalculateAttribute(exec->GetFaceSizeId(), "fs");
        }

         */
        float FaceRelativeArea()
        {
            return CalculateAttribute(exec->GetFaceRelativeAreaId(), "fra");
        }

         */
        float FaceRelativeAreaInImage()
        {
            return CalculateAttribute(exec->GetFaceRelativeAreaInImageId(), "fri");
        }

         */
        float TintedGlasses()
        {
            return CalculateAttribute(exec->GetTintedGlassesId(), "tg");
        }

         */
        float WidthHeightRatio() const
        {
            return CalculateWidthHeightRatio();
        }

        /// Mode of passive liveness calculation
        enum class PassiveLivenessMode : uint8_t
        {
            FAST,
            ACCURATE
        };
         */
        float PassiveLiveness()
        {
            return PassiveLiveness(PassiveLivenessMode::ACCURATE);
        }
         */
        float PassiveLiveness(PassiveLivenessMode mode)
        {
            if (mode == PassiveLivenessMode::FAST)
            {
                return CalculateFastPassiveLiveness();
            }
 
            return CalculateAccuratePassiveLiveness();
        }

        /// Face attributes IDs
        enum class AttributeID : uint8_t
        {
            CONFIDENCE,
            SHARPNESS,
            BRIGHTNESS,
            CONTRAST,
            UNIQUE_INTENSITY_LEVELS,
            SHADOW,
            NOSE_SHADOW,
            SPECULARITY,
            EYE_GAZE,
            RIGHT_EYE_STATUS,
            LEFT_EYE_STATUS,
            GLASS_STATUS,
            HEAVY_FRAME,
            MOUTH_STATUS,
            BACKGROUND_UNIFORMITY,
            AGE,
            RIGHT_RED_EYE,
            LEFT_RED_EYE,
            GENDER,
            EYE_DISTANCE,
            ROLL_ANGLE,
            PITCH_ANGLE,
            YAW_ANGLE,
            FACE_SIZE,
            FACE_RELATIVE_AREA,
            FACE_RELATIVE_AREA_IN_IMAGE,
            TINTED_GLASSES,
            WIDTH_HEIGHT_RATIO,
        };
 
        Face(const Face&) = delete;
        Face(Face&&) = delete;
        Face& operator=(const Face&) = delete;
        Face& operator=(Face&&) = delete;
        virtual ~Face() = default;
        Face() = delete;
 
    private:
        using AttributeConfiguration = std::vector<std::tuple<const char*, std::string>>;
        class Attribute
        {
        public:
            const char* serializationKey = nullptr;
            std::optional<float> value;
            AttributeConfiguration config;
            mutable std::mutex mux;
 
            Attribute() = default;
            ~Attribute() = default;
            Attribute(const Attribute&) = delete;
            Attribute(Attribute&&) = delete;
            Attribute& operator=(const Attribute&) = delete;
            Attribute& operator=(Attribute&&) = delete;
        };
 
        std::vector<Attribute> attributes;
        std::optional<float> fastPassiveLiveness;
        mutable std::mutex fastPassiveLivenessMux;
        std::optional<float> accuratePassiveLiveness;
        mutable std::mutex accuratePassiveLivenessMux;
        FormattingLogger log;

        static std::shared_ptr<Face> Create(std::shared_ptr<FaceCapture> capture,
                                            std::shared_ptr<void> faceItem,
                                            Rectangle bb,
                                            unsigned int confidence,
                                            std::shared_ptr<FaceExecutor> exec = GlobalFaceExecutor::Get())
        {
            return std::shared_ptr<Face>(
              new Face(std::move(capture), std::move(bb), confidence, std::move(faceItem), std::move(exec)));
        }
 
        Face(std::shared_ptr<FaceCapture> capt,
             Rectangle bb,
             unsigned int conf,
             std::shared_ptr<void> fi,
             std::shared_ptr<FaceExecutor> e)
          : capture(std::move(capt))
          , confidence(conf)
          , attributes(e->GetMaxId())
          , log(GlobalLogger::Get())
          , faceItem(std::move(fi))
          , boundingBox(std::move(bb))
          , exec(std::move(e))
          , keypoints(new Keypoints(capture, faceItem, exec))
        {
            if (exec == nullptr)
            {
                throw NullArgumentException("Could not create Face due to executor can not be null");
            }
 
            if (capture == nullptr)
            {
                throw NullArgumentException("Could not create Face due to the face original capture can not be null");
            }
        }
 
        float CalculateAttribute(unsigned int id, const char* serializationKey)
        {
            AttributeConfiguration config;
            return CalculateAttribute(id, serializationKey, std::move(config));
        }
        float CalculateAttribute(unsigned int id, const char* serializationKey, AttributeConfiguration&& config)
        {
            const std::scoped_lock attributesLock(attributes[id].mux);
            auto& attribute = attributes[id];
 
            if (attribute.value.has_value() && config == attribute.config)
            {
                return attribute.value.value();
            }
 
            std::vector<inno_FaceParams> params(config.size());
            std::transform(config.begin(),
                           config.end(),
                           params.begin(),
                           [](const auto& c) { return inno_FaceParams{ std::get<0>(c), std::get<1>(c).c_str() }; });
 
            float value =
              exec->GetAttribute(GlobalLogger::Get(), faceItem.get(), id, params.data(), params.size(), ThrowOnError{});
 
            attribute.value = value;
            attribute.serializationKey = serializationKey;
            attribute.config = std::move(config);
 
            return value;
        }
 
        float CalculateAccuratePassiveLiveness()
        {
            const std::scoped_lock attributesLock(accuratePassiveLivenessMux);
 
            if (accuratePassiveLiveness.has_value())
            {
                return accuratePassiveLiveness.value();
            }
 
            float value = exec->GetPassiveLivenessAccurate(GlobalLogger::Get(), faceItem.get(), ThrowOnError{});
 
            accuratePassiveLiveness = value;
 
            return value;
        }
 
        float CalculateFastPassiveLiveness()
        {
            const std::scoped_lock attributesLock(fastPassiveLivenessMux);
 
            if (fastPassiveLiveness.has_value())
            {
                return fastPassiveLiveness.value();
            }
 
            float value = exec->GetPassiveLivenessFast(GlobalLogger::Get(), faceItem.get(), ThrowOnError{});
 
            fastPassiveLiveness = value;
 
            return value;
        }
 
        float CalculateWidthHeightRatio() const
        {
            auto width = capture->image->Width();
            auto height = capture->image->Height();
            if (width == 0 || height == 0)
            {
                return 0.F;
            }
            const float ratio = static_cast<float>(width) / static_cast<float>(height);
            return ratio;
        }
 
        static std::string ToString(AgeEstimationMode mode)
        {
            switch (mode)
            {
            case AgeEstimationMode::BALANCED:
                return "balanced";
            case AgeEstimationMode::ACCURATE:
                return "accurate";
            }
 
            throw EnrollmentInvalidArgumentException("Incorrect AgeEstimationMode '" +
                                                     std::to_string(static_cast<uint8_t>(mode)) + "'");
        }
 
        static std::string ToString(GenderEstimationMode mode)
        {
            switch (mode)
            {
            case GenderEstimationMode::BALANCED:
                return "balanced";
            case GenderEstimationMode::ACCURATE:
                return "accurate";
            }
 
            throw EnrollmentInvalidArgumentException("Incorrect GenderEstimationMode '" +
                                                     std::to_string(static_cast<uint8_t>(mode)) + "'");
        }
 
        class IsoImage
        {
        public:
            explicit IsoImage(const Face& f)
              : face(f)
            {
            }
            IsoImage() = delete;
            ~IsoImage() = default;
            IsoImage(const IsoImage&) = delete;
            IsoImage(IsoImage&&) = delete;
            IsoImage& operator=(const IsoImage&) = delete;
            IsoImage& operator=(IsoImage&&) = delete;
 
            void SetCompressionType(uint8_t ct)
            {
                compressionType = ct;
            }
 
            std::vector<uint8_t> FillIsoImage(const std::vector<uint8_t>& encodedImage)
            {
                // General header contains 17 bytes.
                static constexpr size_t GeneralHeaderLength = 17;
 
                // Quality Blocks are not used optional fields.
                static constexpr size_t NumberOfQualityBlocks = 0;
 
                // Quality Block contains 5 bytes.
                static constexpr size_t SizeOfQualityBlock = 5;
 
                // Landmark Points are not used optional fields.
                static constexpr size_t NumberOfLandmarkPoints = 0;
 
                // Landmark Points contain 8 bytes.
                static constexpr size_t SizeOfLandmarkPoints = 8;
 
                // Representation header contains 47 bytes + size of optional fields.
                static constexpr size_t RepresentationHeaderLength =
                  47 + NumberOfQualityBlocks * SizeOfQualityBlock + NumberOfLandmarkPoints * SizeOfLandmarkPoints;
 
                // Length of Image Data Block contains 4 bytes.
                static constexpr size_t ImageDataBlockLength = 4;
 
                // Length of encoded image.
                auto imageLength = encodedImage.size();
 
                // Representation length including the representation header length.
                auto representationLength = RepresentationHeaderLength + imageLength + ImageDataBlockLength;
 
                // Record length with image data.
                auto recordLength = GeneralHeaderLength + representationLength;
 
                std::vector<uint8_t> isoImage;
                isoImage.resize(recordLength);
 
                FillGeneralHeader(isoImage, recordLength);
                FillRepresentationHeader(isoImage, representationLength);
                FillRepresentationBody(isoImage, encodedImage, imageLength);
 
                return isoImage;
            }
 
        private:
            static void ThrowWhenValueCannotFitInto4Bytes(size_t recordLength)
            {
                if (recordLength > static_cast<size_t>(std::numeric_limits<uint32_t>::max()))
                {
                    throw EnrollmentRuntimeException("Invalid conversion size");
                }
            }

            void FillGeneralHeader(std::vector<uint8_t>& isoImage, const size_t recordLength)
            {
                FillFormatIdentifier(isoImage);
                FillVersionNumber(isoImage);
                FillLengthOfRecord(isoImage, recordLength);
                FillNumberOfRepresentations(isoImage);
                FillCertificationFlag(isoImage);
                FilTemporalSemantics(isoImage);
            }

            void FillFormatIdentifier(std::vector<uint8_t>& isoImage)
            {
                // Mandatory fields.
                isoImage[writeIndex++] = 'F';
                isoImage[writeIndex++] = 'A';
                isoImage[writeIndex++] = 'C';
                isoImage[writeIndex++] = '\0';
            }

            void FillVersionNumber(std::vector<uint8_t>& isoImage)
            {
                // Mandatory fields.
                isoImage[writeIndex++] = '0';
                isoImage[writeIndex++] = '3';
                isoImage[writeIndex++] = '0';
                isoImage[writeIndex++] = '\0';
            }

            void FillLengthOfRecord(std::vector<uint8_t>& isoImage, const size_t recordLength)
            {
                ThrowWhenValueCannotFitInto4Bytes(recordLength);
 
                // Mandatory fields.
                isoImage[writeIndex++] = static_cast<uint8_t>(recordLength >> ThreeBytesBitsCount);
                isoImage[writeIndex++] = static_cast<uint8_t>((recordLength >> TwoBytesBitsCount) & ByteMask);
                isoImage[writeIndex++] = static_cast<uint8_t>((recordLength >> OneByteBitsCount) & ByteMask);
                isoImage[writeIndex++] = static_cast<uint8_t>(recordLength & ByteMask);
            }

            void FillNumberOfRepresentations(std::vector<uint8_t>& isoImage)
            {
                // Mandatory fields.
                isoImage[writeIndex++] = 0x00;
                isoImage[writeIndex++] = 0x01;
            }

            void FillCertificationFlag(std::vector<uint8_t>& isoImage)
            {
                isoImage[writeIndex++] = 0x00; // Mandatory field.
            }

            void FilTemporalSemantics(std::vector<uint8_t>& isoImage)
            {
                // Mandatory fields.
                isoImage[writeIndex++] = 0x00;
                isoImage[writeIndex++] = 0x00;
            }

            void FillRepresentationHeader(std::vector<uint8_t>& isoImage, size_t representationLength)
            {
                FillRepresentationLength(isoImage, representationLength);
                FillCaptureDateTime(isoImage);
                FillCaptureDeviceTechnologyIdentifier(isoImage);
                FillCaptureDeviceVendorIdentifier(isoImage);
                FillCaptureDeviceTypeIdentifier(isoImage);
                FillNumberOfQualityBlocks(isoImage);
                FillFacialInformation(isoImage);
                FillImageInformation(isoImage);
            }

            void FillRepresentationLength(std::vector<uint8_t>& isoImage, size_t representationLength)
            {
                ThrowWhenValueCannotFitInto4Bytes(representationLength);
 
                // Mandatory fields.
                isoImage[writeIndex++] = static_cast<uint8_t>(representationLength >> ThreeBytesBitsCount);
                isoImage[writeIndex++] = static_cast<uint8_t>((representationLength >> TwoBytesBitsCount) & ByteMask);
                isoImage[writeIndex++] = static_cast<uint8_t>((representationLength >> OneByteBitsCount) & ByteMask);
                isoImage[writeIndex++] = static_cast<uint8_t>(representationLength & ByteMask);
            }

            void FillCaptureDateTime(std::vector<uint8_t>& isoImage)
            {
                // Mandatory fields.
                static constexpr uint8_t DummyValue = 0xff;
                isoImage[writeIndex++] = DummyValue; // year
                isoImage[writeIndex++] = DummyValue; // year
                isoImage[writeIndex++] = DummyValue; // month
                isoImage[writeIndex++] = DummyValue; // day
                isoImage[writeIndex++] = DummyValue; // hour
                isoImage[writeIndex++] = DummyValue; // minute
                isoImage[writeIndex++] = DummyValue; // second
                isoImage[writeIndex++] = DummyValue; // millisecond
                isoImage[writeIndex++] = DummyValue; // millisecond
            }

            void FillCaptureDeviceTechnologyIdentifier(std::vector<uint8_t>& isoImage)
            {
                const FaceCaptureDeviceTechnology& technology =
                  face.capture->faceAttributes.GetCaptureDeviceTechnology();
                isoImage[writeIndex++] =
                  static_cast<uint8_t>(FaceToIsoCaptureDeviceTechnology(technology)); // Mandatory field.
            }

            void FillCaptureDeviceVendorIdentifier(std::vector<uint8_t>& isoImage)
            {
                // Mandatory fields.
                const FaceCaptureDeviceVendorID& vendor = face.capture->faceAttributes.GetCaptureDeviceVendorID();
                isoImage[writeIndex++] = static_cast<uint8_t>(static_cast<unsigned int>(vendor) >> OneByteBitsCount);
                isoImage[writeIndex++] = static_cast<uint8_t>(static_cast<unsigned int>(vendor) & ByteMask);
            }

            void FillCaptureDeviceTypeIdentifier(std::vector<uint8_t>& isoImage)
            {
                // Mandatory fields.
                const FaceCaptureDeviceTypeID type = face.capture->faceAttributes.GetCaptureDeviceTypeID();
                isoImage[writeIndex++] = static_cast<uint8_t>(static_cast<unsigned int>(type) >> OneByteBitsCount);
                isoImage[writeIndex++] = static_cast<uint8_t>(static_cast<unsigned int>(type) & ByteMask);
            }

            void FillNumberOfQualityBlocks(std::vector<uint8_t>& isoImage)
            {
                isoImage[writeIndex++] = 0x00; // Not used
            }

            void FillQualityBlockData(std::vector<uint8_t>& isoImage)
            {
                // Optional fields.
                FillQualityScore(isoImage);
                FillQualityAlgorithmVendorId(isoImage);
                FillQualityAlgorithmId(isoImage);
            }

            void FillQualityScore(std::vector<uint8_t>& isoImage)
            {
                isoImage[writeIndex++] = 0x00; // Optional field.
            }

            void FillQualityAlgorithmVendorId(std::vector<uint8_t>& isoImage)
            {
                // Optional fields.
                isoImage[writeIndex++] = 0x00;
                isoImage[writeIndex++] = 0x00;
            }

            void FillQualityAlgorithmId(std::vector<uint8_t>& isoImage)
            {
                // Optional fields.
                isoImage[writeIndex++] = 0x00;
                isoImage[writeIndex++] = 0x00;
            }

            void FillFacialInformation(std::vector<uint8_t>& isoImage)
            {
                FillNumberOfLandmarkPoints(isoImage);
                FillGender(isoImage);
                FillEyeColour(isoImage);
                FillHairColour(isoImage);
                FillSubjectHeight(isoImage);
                FillPropertyMask(isoImage);
                FillExpressionMask(isoImage);
                FillPoseAngle(isoImage);
                FillPoseAngleUncertainty(isoImage);
            }

            void FillNumberOfLandmarkPoints(std::vector<uint8_t>& isoImage)
            {
                // Not used
                isoImage[writeIndex++] = 0x00;
                isoImage[writeIndex++] = 0x00;
            }

            void FillGender(std::vector<uint8_t>& isoImage)
            {
                isoImage[writeIndex++] = 0x00; // Mandatory field.
            }

            void FillEyeColour(std::vector<uint8_t>& isoImage)
            {
                isoImage[writeIndex++] = 0x00; // Mandatory field.
            }

            void FillHairColour(std::vector<uint8_t>& isoImage)
            {
                isoImage[writeIndex++] = 0x00; // Mandatory field.
            }

            void FillSubjectHeight(std::vector<uint8_t>& isoImage)
            {
                isoImage[writeIndex++] = 0x00; // Mandatory field.
            }

            void FillPropertyMask(std::vector<uint8_t>& isoImage)
            {
                // Mandatory fields.
                isoImage[writeIndex++] = 0x00;
                isoImage[writeIndex++] = 0x00;
                isoImage[writeIndex++] = 0x00;
            }

            void FillExpressionMask(std::vector<uint8_t>& isoImage)
            {
                // Mandatory fields.
                isoImage[writeIndex++] = 0x00;
                isoImage[writeIndex++] = 0x00;
            }

            void FillPoseAngle(std::vector<uint8_t>& isoImage)
            {
                // Mandatory fields.
                isoImage[writeIndex++] = 0x00;
                isoImage[writeIndex++] = 0x00;
                isoImage[writeIndex++] = 0x00;
            }

            void FillPoseAngleUncertainty(std::vector<uint8_t>& isoImage)
            {
                // Mandatory fields.
                isoImage[writeIndex++] = 0x00;
                isoImage[writeIndex++] = 0x00;
                isoImage[writeIndex++] = 0x00;
            }

            void Fill2D3DLandmarkPoints(std::vector<uint8_t>& isoImage)
            {
                FillLandmarkPointType(isoImage);
                FillLandmarkPointCode(isoImage);
                FillLandmarkXCoordinate(isoImage);
                FillLandmarkYCoordinate(isoImage);
                FillLandmarkZCoordinate(isoImage);
            }

            void FillLandmarkPointType(std::vector<uint8_t>& isoImage)
            {
                isoImage[writeIndex++] = 0x00;
            }

            void FillLandmarkPointCode(std::vector<uint8_t>& isoImage)
            {
                isoImage[writeIndex++] = 0x00;
            }

            void FillLandmarkXCoordinate(std::vector<uint8_t>& isoImage)
            {
                isoImage[writeIndex++] = 0x00;
                isoImage[writeIndex++] = 0x00;
            }

            void FillLandmarkYCoordinate(std::vector<uint8_t>& isoImage)
            {
                isoImage[writeIndex++] = 0x00;
                isoImage[writeIndex++] = 0x00;
            }

            void FillLandmarkZCoordinate(std::vector<uint8_t>& isoImage)
            {
                isoImage[writeIndex++] = 0x00;
                isoImage[writeIndex++] = 0x00;
            }

            void FillImageInformation(std::vector<uint8_t>& isoImage)
            {
                FaceImageType(isoImage);
                ImageDataType(isoImage);
                ImageWidth(isoImage);
                ImageHeight(isoImage);
                SpatialSamplingRateLevel(isoImage);
                PostAcquisitionProcessing(isoImage);
                CrossReference(isoImage);
                ImageColourSpace(isoImage);
            }

            void FaceImageType(std::vector<uint8_t>& isoImage)
            {
                isoImage[writeIndex++] = static_cast<uint8_t>(
                  FaceToIsoImageType(face.capture->faceAttributes.GetFaceImageType())); // Mandatory field.
            }

            void ImageDataType(std::vector<uint8_t>& isoImage)
            {
                isoImage[writeIndex++] = compressionType; // Mandatory field.
            }

            void ImageWidth(std::vector<uint8_t>& isoImage)
            {
                // Mandatory fields.
                isoImage[writeIndex++] = static_cast<uint8_t>(face.capture->image->Width() >> OneByteBitsCount);
                isoImage[writeIndex++] = static_cast<uint8_t>(face.capture->image->Width() & ByteMask);
            }

            void ImageHeight(std::vector<uint8_t>& isoImage)
            {
                // Mandatory fields.
                isoImage[writeIndex++] = static_cast<uint8_t>(face.capture->image->Height() >> OneByteBitsCount);
                isoImage[writeIndex++] = static_cast<uint8_t>(face.capture->image->Height() & ByteMask);
            }

            void SpatialSamplingRateLevel(std::vector<uint8_t>& isoImage)
            {
                isoImage[writeIndex++] = 0x00; // Mandatory field.
            }

            void PostAcquisitionProcessing(std::vector<uint8_t>& isoImage)
            {
                // Mandatory fields.
                isoImage[writeIndex++] = 0x00;
                isoImage[writeIndex++] = 0x00;
            }

            void CrossReference(std::vector<uint8_t>& isoImage)
            {
                isoImage[writeIndex++] = 0x00; // Mandatory field.
            }

            void ImageColourSpace(std::vector<uint8_t>& isoImage)
            {
                isoImage[writeIndex++] = 0x00; // Mandatory field.
            }

            void FillRepresentationBody(std::vector<uint8_t>& isoImage,
                                        const std::vector<uint8_t>& encodedImage,
                                        size_t imageLength)
            {
                FillImageDataLength(isoImage, imageLength);
                FillImageData(isoImage, encodedImage);
            }

            void FillImageDataLength(std::vector<uint8_t>& isoImage, size_t imageLength)
            {
                ThrowWhenValueCannotFitInto4Bytes(imageLength);
                // Mandatory fields.
                isoImage[writeIndex++] = static_cast<uint8_t>(imageLength >> ThreeBytesBitsCount);
                isoImage[writeIndex++] = static_cast<uint8_t>((imageLength >> TwoBytesBitsCount) & ByteMask);
                isoImage[writeIndex++] = static_cast<uint8_t>((imageLength >> OneByteBitsCount) & ByteMask);
                isoImage[writeIndex++] = static_cast<uint8_t>(imageLength & ByteMask);
            }

            void FillImageData(std::vector<uint8_t>& isoImage, const std::vector<uint8_t>& encodedImage)
            {
                std::copy(encodedImage.begin(),
                          encodedImage.end(),
                          std::next(isoImage.begin(), static_cast<ptrdiff_t>(writeIndex))); // Mandatory field.
                writeIndex += encodedImage.size();
            }
 
            size_t writeIndex = 0U;
            const Face& face;
            static constexpr uint8_t NoCompressionType = 255;
            uint8_t compressionType = NoCompressionType;
            static constexpr unsigned int OneByteBitsCount = 8U;
            static constexpr unsigned int TwoBytesBitsCount = 16U;
            static constexpr unsigned int ThreeBytesBitsCount = 24U;
            static constexpr unsigned int ByteMask = 0xffU;
        };
 
        class IsoImageEncoder : public ImageEncoderVisitor
        {
        public:
            std::vector<uint8_t> Encode()
            {
                // Get necessary image data for creating iso image.
                encoder.Accept(*this);
 
                // Get image data in requested format.
                auto encodedImage = face.capture->image->EncodeIn(encoder);
 
                return isoImage.FillIsoImage(encodedImage);
            }
 
            void Visit(const WsqImageEncoder& /* encoder */) final
            {
                throw EnrollmentInvalidArgumentException("Could not create ISO image for WSQ image format");
            }
 
            void Visit(const JpgImageEncoder& /* encoder */) final
            {
                throw EnrollmentInvalidArgumentException("Could not create ISO image for JPG image format");
            }
 
            void Visit(const Jp2ImageEncoder& jp2Encoder) final
            {
                if (jp2Encoder.IsLossy())
                {
                    // According to table of image data type codes, JPEG 2000 lossy has compression code 1.
                    isoImage.SetCompressionType(1);
                }
                else
                {
                    // According to table of image data type codes, JPEG 2000 lossless has compression code 2.
                    isoImage.SetCompressionType(2);
                }
            }
 
            void Visit(const PngImageEncoder& /* encoder */) final
            {
                // According to table of image data type codes, PNG has compression code 3.
                isoImage.SetCompressionType(3);
            }
 
            void Visit(const IRawImageEncoder& /* encoder */) final
            {
                throw EnrollmentInvalidArgumentException("Could not create ISO image for IRAW image format");
            }
 
            void Visit(const BmpImageEncoder& /* encoder */) final
            {
                throw EnrollmentInvalidArgumentException("Could not create ISO image for BMP image format");
            }
 
            void Visit(const TiffImageEncoder& /* encoder */) final
            {
                throw EnrollmentInvalidArgumentException("Could not create ISO image for TIFF image format");
            }
 
            void Visit(const WebpImageEncoder& /* encoder */) final
            {
                throw EnrollmentInvalidArgumentException("Could not create ISO image for WEBP image format");
            }
 
            // We can use references because this is inner class of Print and we always know the usage.
            // The references will be valid in whole class lifetime.
            IsoImageEncoder(const Face& f, ImageEncoder& e)
              : face(f)
              , encoder(e)
              , isoImage(IsoImage(f))
            {
            }
            IsoImageEncoder() = delete;
            virtual ~IsoImageEncoder() = default;
            IsoImageEncoder(const IsoImageEncoder&) = delete;
            IsoImageEncoder(IsoImageEncoder&&) = delete;
            IsoImageEncoder& operator=(const IsoImageEncoder&) = delete;
            IsoImageEncoder& operator=(IsoImageEncoder&&) = delete;
 
        private:
            const Face& face;
            ImageEncoder& encoder;
            IsoImage isoImage;
        };
 
        std::shared_ptr<void> faceItem;
        Rectangle boundingBox;
        std::shared_ptr<FaceExecutor> exec;
        std::shared_ptr<Keypoints> keypoints;
 
        friend class FaceDetector;
    };
 
    inline void ExtractedFace::WriteTo(Writer& writer) const
    {
        writer.Write("f", face);
        FaceTemplate::WriteTo(writer);
    }
 
    inline std::ostream& operator<<(std::ostream& os, Face::AttributeID a)
    {
        switch (a)
        {
        case Face::AttributeID::CONFIDENCE:
            os << "CONFIDENCE";
            break;
        case Face::AttributeID::SHARPNESS:
            os << "SHARPNESS";
            break;
        case Face::AttributeID::BRIGHTNESS:
            os << "BRIGHTNESS";
            break;
        case Face::AttributeID::CONTRAST:
            os << "CONTRAST";
            break;
        case Face::AttributeID::UNIQUE_INTENSITY_LEVELS:
            os << "UNIQUE_INTENSITY_LEVELS";
            break;
        case Face::AttributeID::SHADOW:
            os << "SHADOW";
            break;
        case Face::AttributeID::NOSE_SHADOW:
            os << "NOSE_SHADOW";
            break;
        case Face::AttributeID::SPECULARITY:
            os << "SPECULARITY";
            break;
        case Face::AttributeID::EYE_GAZE:
            os << "EYE_GAZE";
            break;
        case Face::AttributeID::RIGHT_EYE_STATUS:
            os << "RIGHT_EYE_STATUS";
            break;
        case Face::AttributeID::LEFT_EYE_STATUS:
            os << "LEFT_EYE_STATUS";
            break;
        case Face::AttributeID::GLASS_STATUS:
            os << "GLASS_STATUS";
            break;
        case Face::AttributeID::HEAVY_FRAME:
            os << "HEAVY_FRAME";
            break;
        case Face::AttributeID::MOUTH_STATUS:
            os << "MOUTH_STATUS";
            break;
        case Face::AttributeID::BACKGROUND_UNIFORMITY:
            os << "BACKGROUND_UNIFORMITY";
            break;
        case Face::AttributeID::AGE:
            os << "AGE";
            break;
        case Face::AttributeID::RIGHT_RED_EYE:
            os << "RIGHT_RED_EYE";
            break;
        case Face::AttributeID::LEFT_RED_EYE:
            os << "LEFT_RED_EYE";
            break;
        case Face::AttributeID::GENDER:
            os << "GENDER";
            break;
        case Face::AttributeID::EYE_DISTANCE:
            os << "EYE_DISTANCE";
            break;
        case Face::AttributeID::ROLL_ANGLE:
            os << "ROLL_ANGLE";
            break;
        case Face::AttributeID::PITCH_ANGLE:
            os << "PITCH_ANGLE";
            break;
        case Face::AttributeID::YAW_ANGLE:
            os << "YAW_ANGLE";
            break;
        case Face::AttributeID::FACE_SIZE:
            os << "FACE_SIZE";
            break;
        case Face::AttributeID::FACE_RELATIVE_AREA:
            os << "FACE_RELATIVE_AREA";
            break;
        case Face::AttributeID::FACE_RELATIVE_AREA_IN_IMAGE:
            os << "FACE_RELATIVE_AREA_IN_IMAGE";
            break;
        case Face::AttributeID::TINTED_GLASSES:
            os << "TINTED_GLASSES";
            break;
        case Face::AttributeID::WIDTH_HEIGHT_RATIO:
            os << "WIDTH_HEIGHT_RATIO";
            break;
        }
        return os;
    }
 
} // namespace inno
 
namespace inno
{
    inline Rectangle FaceCapture::BoundingBoxesShape::GetFaceDetectionBox(const std::shared_ptr<Face>& face)
    {
        return face->DetectionRectangle();
    }
} // namespace inno
// NOLINTEND(cppcoreguidelines-non-private-member-variables-in-classes,misc-non-private-member-variables-in-classes,cppcoreguidelines-avoid-const-or-ref-data-members)