OFIQFace.h

Go to the documentation of this file.

 
#pragma once
 
#include "enrollment/Exception/CallbackError.h"
#include "enrollment/Exception/EnrollmentException.h"
#include "enrollment/Face/Face.h"
#include "enrollment/Face/FaceCapture.h"
#include "enrollment/Face/FaceExecutor.h"
#include "enrollment/Image/Image.h"
#include "enrollment/Image/ImageAttribute.h"
#include "enrollment/Logger/Logger.h"
#include "enrollment/Serialization/Writer.h"
#include <cstdint>
#include <enrollment/Export.h>
#include <memory>
#include <vector>
 
namespace inno
{
    extern "C"
    {
        INNO_ENROLLMENT_API void inno_ofiq_get_bounding_box(void* impl,
                                                            int* topLeftX,
                                                            int* topLeftY,
                                                            size_t* width,
                                                            size_t* height,
                                                            ErrorCallbacks error);
        INNO_ENROLLMENT_API uint8_t inno_ofiq_get_sharpness(void* impl, ErrorCallbacks error);
        INNO_ENROLLMENT_API uint8_t inno_ofiq_get_unified_quality_score(void* impl, ErrorCallbacks error);
        INNO_ENROLLMENT_API uint8_t inno_ofiq_get_background_uniformity(void* impl, ErrorCallbacks error);
        INNO_ENROLLMENT_API uint8_t inno_ofiq_get_illumination_uniformity(void* impl, ErrorCallbacks error);
        INNO_ENROLLMENT_API uint8_t inno_ofiq_get_luminance_mean(void* impl, ErrorCallbacks error);
        INNO_ENROLLMENT_API uint8_t inno_ofiq_get_luminance_variance(void* impl, ErrorCallbacks error);
        INNO_ENROLLMENT_API uint8_t inno_ofiq_get_under_exposure_prevention(void* impl, ErrorCallbacks error);
        INNO_ENROLLMENT_API uint8_t inno_ofiq_get_over_exposure_prevention(void* impl, ErrorCallbacks error);
        INNO_ENROLLMENT_API uint8_t inno_ofiq_get_dynamic_range(void* impl, ErrorCallbacks error);
        INNO_ENROLLMENT_API uint8_t inno_ofiq_get_compression_artifacts(void* impl, ErrorCallbacks error);
        INNO_ENROLLMENT_API uint8_t inno_ofiq_get_natural_colour(void* impl, ErrorCallbacks error);
        INNO_ENROLLMENT_API uint8_t inno_ofiq_get_single_face_present(void* impl, ErrorCallbacks error);
        INNO_ENROLLMENT_API uint8_t inno_ofiq_get_eyes_open(void* impl, ErrorCallbacks error);
        INNO_ENROLLMENT_API uint8_t inno_ofiq_get_mouth_closed(void* impl, ErrorCallbacks error);
        INNO_ENROLLMENT_API uint8_t inno_ofiq_get_eyes_visible(void* impl, ErrorCallbacks error);
        INNO_ENROLLMENT_API uint8_t inno_ofiq_get_mouth_occlusion_prevention(void* impl, ErrorCallbacks error);
        INNO_ENROLLMENT_API uint8_t inno_ofiq_get_face_occlusion_prevention(void* impl, ErrorCallbacks error);
        INNO_ENROLLMENT_API uint8_t inno_ofiq_get_inter_eye_distance(void* impl, ErrorCallbacks error);
        INNO_ENROLLMENT_API uint8_t inno_ofiq_get_head_size(void* impl, ErrorCallbacks error);
        INNO_ENROLLMENT_API uint8_t inno_ofiq_get_leftward_crop_of_the_face_image(void* impl, ErrorCallbacks error);
        INNO_ENROLLMENT_API uint8_t inno_ofiq_get_rightward_crop_of_the_face_image(void* impl, ErrorCallbacks error);
        INNO_ENROLLMENT_API uint8_t inno_ofiq_get_margin_above_of_the_face_image(void* impl, ErrorCallbacks error);
        INNO_ENROLLMENT_API uint8_t inno_ofiq_get_margin_below_of_the_face_image(void* impl, ErrorCallbacks error);
        INNO_ENROLLMENT_API uint8_t inno_ofiq_get_head_pose_yaw(void* impl, ErrorCallbacks error);
        INNO_ENROLLMENT_API uint8_t inno_ofiq_get_head_pose_pitch(void* impl, ErrorCallbacks error);
        INNO_ENROLLMENT_API uint8_t inno_ofiq_get_head_pose_roll(void* impl, ErrorCallbacks error);
        INNO_ENROLLMENT_API uint8_t inno_ofiq_get_expression_neutrality(void* impl, ErrorCallbacks error);
        INNO_ENROLLMENT_API uint8_t inno_ofiq_get_no_head_coverings(void* impl, ErrorCallbacks error);
    }

     */
    class OFIQFace : public Serializable
    {
    public:
         */
        static std::shared_ptr<OFIQFace> Create(const std::shared_ptr<FaceCapture>& capture,
                                                const std::shared_ptr<FaceExecutor>& executor)
        {
            if (capture == nullptr)
            {
                throw NullArgumentException("capture cannot be null");
            }
            if (executor == nullptr)
            {
                throw NullArgumentException("executor cannot be null");
            }
 
            auto bgr = capture->image->AsRawBGR();
            FaceDestroyer deleter = nullptr;
            void* ptr = executor->CreateOFIQFace(GlobalLogger::Get(),
                                                 bgr.Data().data(),
                                                 bgr.width,
                                                 bgr.height,
                                                 static_cast<unsigned int>(bgr.dpi),
                                                 bgr.Data().size(),
                                                 &deleter,
                                                 ThrowOnError{});
 
            auto pimpl = std::unique_ptr<void, FaceDestroyer>(ptr, deleter);
            return std::shared_ptr<OFIQFace>(new OFIQFace(std::move(pimpl)));
        }

         */
        static std::shared_ptr<OFIQFace> Create(const std::shared_ptr<FaceCapture>& capture)
        {
            return Create(capture, GlobalFaceExecutor::Get());
        }

         */
        void WriteTo(Writer& writer) const final
        {
            auto writeOnSuccess = [&writer](const char* name, auto&& func)
            {
                try
                {
                    auto value = func();
                    writer.Write(name, value);
                }
                catch (...) // NOLINT(bugprone-empty-catch) - skip writing this field on error
                {
                }
            };
            writer.Write("bb", GetBoundingBox());
            writeOnSuccess("sh", [this]() { return GetSharpness(); });
            writeOnSuccess("uqs", [this]() { return GetUnifiedQualityScore(); });
            writeOnSuccess("bu", [this]() { return GetBackgroundUniformity(); });
            writeOnSuccess("iu", [this]() { return GetIlluminationUniformity(); });
            writeOnSuccess("lmn", [this]() { return GetLuminanceMean(); });
            writeOnSuccess("lmv", [this]() { return GetLuminanceVariance(); });
            writeOnSuccess("uep", [this]() { return GetUnderExposurePrevention(); });
            writeOnSuccess("oep", [this]() { return GetOverExposurePrevention(); });
            writeOnSuccess("dr", [this]() { return GetDynamicRange(); });
            writeOnSuccess("ca", [this]() { return GetCompressionArtifacts(); });
            writeOnSuccess("nc", [this]() { return GetNaturalColour(); });
            writeOnSuccess("sfp", [this]() { return GetSingleFacePresent(); });
            writeOnSuccess("eo", [this]() { return GetEyesOpen(); });
            writeOnSuccess("mc", [this]() { return GetMouthClosed(); });
            writeOnSuccess("ev", [this]() { return GetEyesVisible(); });
            writeOnSuccess("mop", [this]() { return GetMouthOcclusionPrevention(); });
            writeOnSuccess("fop", [this]() { return GetFaceOcclusionPrevention(); });
            writeOnSuccess("ied", [this]() { return GetInterEyeDistance(); });
            writeOnSuccess("hs", [this]() { return GetHeadSize(); });
            writeOnSuccess("lco", [this]() { return GetLeftwardCropOfTheFaceImage(); });
            writeOnSuccess("rco", [this]() { return GetRightwardCropOfTheFaceImage(); });
            writeOnSuccess("mao", [this]() { return GetMarginAboveOfTheFaceImage(); });
            writeOnSuccess("mbo", [this]() { return GetMarginBelowOfTheFaceImage(); });
            writeOnSuccess("hpy", [this]() { return GetHeadPoseYaw(); });
            writeOnSuccess("hpp", [this]() { return GetHeadPosePitch(); });
            writeOnSuccess("hpr", [this]() { return GetHeadPoseRoll(); });
            writeOnSuccess("en", [this]() { return GetExpressionNeutrality(); });
            writeOnSuccess("nhc", [this]() { return GetNoHeadCoverings(); });
        }

         */
        [[nodiscard]] Rectangle GetBoundingBox() const
        {
            int topLeftX = 0;
            int topLeftY = 0;
            size_t width = 0UL;
            size_t height = 0UL;
            inno_ofiq_get_bounding_box(impl.get(), &topLeftX, &topLeftY, &width, &height, ThrowOnError{});
            return { { topLeftX, topLeftY },
                     { static_cast<X>(topLeftX + width), topLeftY },
                     { static_cast<X>(topLeftX + width), static_cast<Y>(topLeftY + height) },
                     { topLeftX, static_cast<Y>(topLeftY + height) } };
        }
         */
        [[nodiscard]] uint8_t GetSharpness() const
        {
            return inno_ofiq_get_sharpness(impl.get(), ThrowOnError{});
        }
         */
        [[nodiscard]] uint8_t GetUnifiedQualityScore() const
        {
            return inno_ofiq_get_unified_quality_score(impl.get(), ThrowOnError{});
        }
         */
        [[nodiscard]] uint8_t GetBackgroundUniformity() const
        {
            return inno_ofiq_get_background_uniformity(impl.get(), ThrowOnError{});
        }
         */
        [[nodiscard]] uint8_t GetIlluminationUniformity() const
        {
            return inno_ofiq_get_illumination_uniformity(impl.get(), ThrowOnError{});
        }
         */
        [[nodiscard]] uint8_t GetLuminanceMean() const
        {
            return inno_ofiq_get_luminance_mean(impl.get(), ThrowOnError{});
        }
         */
        [[nodiscard]] uint8_t GetLuminanceVariance() const
        {
            return inno_ofiq_get_luminance_variance(impl.get(), ThrowOnError{});
        }
         */
        [[nodiscard]] uint8_t GetUnderExposurePrevention() const
        {
            return inno_ofiq_get_under_exposure_prevention(impl.get(), ThrowOnError{});
        }
         */
        [[nodiscard]] uint8_t GetOverExposurePrevention() const
        {
            return inno_ofiq_get_over_exposure_prevention(impl.get(), ThrowOnError{});
        }
         */
        [[nodiscard]] uint8_t GetDynamicRange() const
        {
            return inno_ofiq_get_dynamic_range(impl.get(), ThrowOnError{});
        }
         */
        [[nodiscard]] uint8_t GetCompressionArtifacts() const
        {
            return inno_ofiq_get_compression_artifacts(impl.get(), ThrowOnError{});
        }
         */
        [[nodiscard]] uint8_t GetNaturalColour() const
        {
            return inno_ofiq_get_natural_colour(impl.get(), ThrowOnError{});
        }
         */
        [[nodiscard]] uint8_t GetSingleFacePresent() const
        {
            return inno_ofiq_get_single_face_present(impl.get(), ThrowOnError{});
        }
         */
        [[nodiscard]] uint8_t GetEyesOpen() const
        {
            return inno_ofiq_get_eyes_open(impl.get(), ThrowOnError{});
        }
         */
        [[nodiscard]] uint8_t GetMouthClosed() const
        {
            return inno_ofiq_get_mouth_closed(impl.get(), ThrowOnError{});
        }
         */
        [[nodiscard]] uint8_t GetEyesVisible() const
        {
            return inno_ofiq_get_eyes_visible(impl.get(), ThrowOnError{});
        }
         */
        [[nodiscard]] uint8_t GetMouthOcclusionPrevention() const
        {
            return inno_ofiq_get_mouth_occlusion_prevention(impl.get(), ThrowOnError{});
        }
         */
        [[nodiscard]] uint8_t GetFaceOcclusionPrevention() const
        {
            return inno_ofiq_get_face_occlusion_prevention(impl.get(), ThrowOnError{});
        }
         */
        [[nodiscard]] uint8_t GetInterEyeDistance() const
        {
            return inno_ofiq_get_inter_eye_distance(impl.get(), ThrowOnError{});
        }
         */
        [[nodiscard]] uint8_t GetHeadSize() const
        {
            return inno_ofiq_get_head_size(impl.get(), ThrowOnError{});
        }
         */
        [[nodiscard]] uint8_t GetLeftwardCropOfTheFaceImage() const
        {
            return inno_ofiq_get_leftward_crop_of_the_face_image(impl.get(), ThrowOnError{});
        }
         */
        [[nodiscard]] uint8_t GetRightwardCropOfTheFaceImage() const
        {
            return inno_ofiq_get_rightward_crop_of_the_face_image(impl.get(), ThrowOnError{});
        }
         */
        [[nodiscard]] uint8_t GetMarginAboveOfTheFaceImage() const
        {
            return inno_ofiq_get_margin_above_of_the_face_image(impl.get(), ThrowOnError{});
        }
         */
        [[nodiscard]] uint8_t GetMarginBelowOfTheFaceImage() const
        {
            return inno_ofiq_get_margin_below_of_the_face_image(impl.get(), ThrowOnError{});
        }
         */
        [[nodiscard]] uint8_t GetHeadPoseYaw() const
        {
            return inno_ofiq_get_head_pose_yaw(impl.get(), ThrowOnError{});
        }
         */
        [[nodiscard]] uint8_t GetHeadPosePitch() const
        {
            return inno_ofiq_get_head_pose_pitch(impl.get(), ThrowOnError{});
        }
         */
        [[nodiscard]] uint8_t GetHeadPoseRoll() const
        {
            return inno_ofiq_get_head_pose_roll(impl.get(), ThrowOnError{});
        }
         */
        [[nodiscard]] uint8_t GetExpressionNeutrality() const
        {
            return inno_ofiq_get_expression_neutrality(impl.get(), ThrowOnError{});
        }
         */
        [[nodiscard]] uint8_t GetNoHeadCoverings() const
        {
            return inno_ofiq_get_no_head_coverings(impl.get(), ThrowOnError{});
        }
 
        OFIQFace() = delete;
        virtual ~OFIQFace() = default;
        OFIQFace(const OFIQFace&) = delete;
        OFIQFace(OFIQFace&&) = delete;
        OFIQFace& operator=(const OFIQFace&) = delete;
        OFIQFace& operator=(OFIQFace&&) = delete;
 
    private:
        explicit OFIQFace(std::unique_ptr<void, FaceDestroyer> pimpl)
          : impl(std::move(pimpl))
        {
        }
 
        std::unique_ptr<void, FaceDestroyer> impl;
    };
} // namespace inno