FaceCapture.h

Go to the documentation of this file.

 
#pragma once
 
#include "enrollment/Export.h"
#include "enrollment/Face/FaceAttributes/FaceAttributes.h"
#include "enrollment/Face/FaceCropConfiguration.h"
#include "enrollment/Image/Image.h"
#include "enrollment/Image/ImageAttribute.h"
#include "enrollment/Logger/FormattingLogger.h"
#include <algorithm>
#include <memory>
#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 Logger;
    class FaceCapture;
    class Face;
 
    // Internal interface to overcome cyclic includes between this header and FaceDetector.
    // It is introduced to be possible to add convenient function FaceCapture::DetectWith(().
    class FaceCaptureSegmentation
    {
    public:
        virtual std::vector<std::shared_ptr<Face>> Detect(std::shared_ptr<FaceCapture> capture) = 0;
 
        FaceCaptureSegmentation() = default;
        virtual ~FaceCaptureSegmentation() = default;
        FaceCaptureSegmentation(const FaceCaptureSegmentation&) = delete;
        FaceCaptureSegmentation(FaceCaptureSegmentation&&) = delete;
        FaceCaptureSegmentation& operator=(const FaceCaptureSegmentation&) = delete;
        FaceCaptureSegmentation& operator=(FaceCaptureSegmentation&&) = delete;
    };

     */
    class FaceCapture
      : public Serializable
      , public std::enable_shared_from_this<FaceCapture>
    {
    public:
        const std::shared_ptr<Image> image;
        const FaceAttributes faceAttributes;

         */
        [[nodiscard]] static std::shared_ptr<FaceCapture> Create(std::shared_ptr<Image> img,
                                                                 const FaceAttributes& fa = FaceAttributes())
        {
            if (img == nullptr)
            {
                throw NullArgumentException("Could not create FaceCapture due to image can not be null");
            }
            return std::shared_ptr<FaceCapture>(new FaceCapture(std::move(img), fa));
        }

         */
        void WriteTo(Writer& writer) const final
        {
            writer.Write("i", image);
            writer.Write("a", faceAttributes);
        }

         */
        [[nodiscard]] static std::shared_ptr<FaceCapture> FromIsoImage(const std::vector<uint8_t>& isoImage)
        {
            static constexpr size_t SizeOfIdentifier = 4UL;
            static constexpr size_t SizeOfVersion = 4UL;
            if (isoImage.size() < SizeOfIdentifier + SizeOfVersion)
            {
                throw EnrollmentInvalidArgumentException("Fail to decode face ISO image (fail to read header)");
            }
            if (const std::vector<uint8_t> id = { 'F', 'A', 'C', '\0' };
                std::search(isoImage.begin(), isoImage.end(), id.begin(), id.end()) == isoImage.end())
            {
                throw EnrollmentInvalidArgumentException("Fail to decode face ISO image (invalid id)");
            }
            static constexpr size_t VersionIndex = SizeOfIdentifier;
            if (const std::vector<uint8_t> ver = { '0', '3', '0', '\0' };
                std::search(isoImage.begin() + VersionIndex, isoImage.end(), ver.begin(), ver.end()) == isoImage.end())
            {
                throw EnrollmentInvalidArgumentException("Fail to decode face ISO image (invalid version)");
            }
            static constexpr size_t QualityBlocksCountIndex = 35UL;
            static constexpr size_t SizeOfQualityBlocksCount = 1UL;
            if (isoImage.size() < (QualityBlocksCountIndex + SizeOfQualityBlocksCount))
            {
                throw EnrollmentInvalidArgumentException(
                  "Fail to decode face ISO image (fail to read quality blocks count)");
            }
            static constexpr size_t QualityBlockSize = 5UL;
            const auto qualityBlocksCount = isoImage[QualityBlocksCountIndex];
            const auto qualityBlocksSize = qualityBlocksCount * QualityBlockSize;
            const auto landmarkPointsCountIndex =
              QualityBlocksCountIndex + qualityBlocksSize + SizeOfQualityBlocksCount;
            static constexpr size_t SizeOfLandmarkPointsBlocksCount = 2UL;
            if (isoImage.size() < (landmarkPointsCountIndex + SizeOfLandmarkPointsBlocksCount))
            {
                throw EnrollmentInvalidArgumentException(
                  "Fail to decode face ISO image (fail to read landmark points blocks count)");
            }
            const auto landmarkPointsCount =
              (isoImage[landmarkPointsCountIndex] << 8UL) + isoImage[landmarkPointsCountIndex + 1];
            static constexpr size_t LandmarkPointBlockSize = 8UL;
            const auto landmarkPointsSize = landmarkPointsCount * LandmarkPointBlockSize;
            static constexpr size_t ImageInformationSize = 11UL;
            static constexpr size_t FacialInformationSize = 17UL;
            const auto imageLengthIndex = QualityBlocksCountIndex + SizeOfQualityBlocksCount + qualityBlocksSize +
                                          FacialInformationSize + landmarkPointsSize + ImageInformationSize;
            static constexpr size_t SizeOfImageLength = 4UL;
            if (isoImage.size() < (imageLengthIndex + SizeOfImageLength))
            {
                throw EnrollmentInvalidArgumentException("Fail to decode face ISO image (fail to read image length)");
            }
            const size_t imageLength = (isoImage[imageLengthIndex] << 24U) + (isoImage[imageLengthIndex + 1] << 16U) +
                                       (isoImage[imageLengthIndex + 2] << 8U) + isoImage[imageLengthIndex + 3];
            const auto imageDataIndex = imageLengthIndex + SizeOfImageLength;
            if (isoImage.size() < (imageDataIndex + imageLength))
            {
                throw EnrollmentInvalidArgumentException("Fail to decode face ISO image (fail to read image data)");
            }
            const std::vector<uint8_t> encodedImageData =
              std::vector<uint8_t>(std::next(isoImage.begin(), static_cast<ptrdiff_t>(imageDataIndex)),
                                   std::next(isoImage.begin(), static_cast<ptrdiff_t>(imageDataIndex + imageLength)));
 
            static constexpr size_t EquipmentIDIndex = 31UL;
            const unsigned int captureEquipmentID = (isoImage[EquipmentIDIndex] << 8U) + isoImage[EquipmentIDIndex + 1];
            static constexpr size_t CaptureDeviceTypeIDIndex = 33UL;
            const unsigned int captureDeviceTypeID =
              (isoImage[CaptureDeviceTypeIDIndex] << 8U) + isoImage[CaptureDeviceTypeIDIndex + 1];
 
            FaceAttributes fa;
            static constexpr size_t CaptureDeviceTechnologyIndex = 30UL;
            fa.SetCaptureDeviceTechnology(IsoToFaceCaptureDeviceTechnology(isoImage[CaptureDeviceTechnologyIndex]));
            fa.SetCaptureDeviceVendorID(FaceCaptureDeviceVendorID(captureEquipmentID));
            fa.SetCaptureDeviceTypeID(FaceCaptureDeviceTypeID(captureDeviceTypeID));
 
            return Create(Image::Decode(encodedImageData), fa);
        }

         */
        [[nodiscard]] std::vector<std::shared_ptr<Face>> DetectWith(FaceCaptureSegmentation& detector)
        {
            auto capture = shared_from_this();
            return detector.Detect(capture);
        }

         */
        [[nodiscard]] std::shared_ptr<Image> CropFace(const Rectangle& rectangle, const RGBA& backgroundColor) const
        {
            auto croppedImage = image->CropRectangle(rectangle, backgroundColor);
            return croppedImage;
        }

         */
        [[nodiscard]] bool IsWholeCroppedRectangleInside(const Rectangle& rectangle) const
        {
            auto intersectionType = image->RectangleIntersection(rectangle);
            return intersectionType == Image::Intersection::INSIDE || intersectionType == Image::Intersection::SAME;
        }

         */
        [[nodiscard]] std::shared_ptr<Image> Draw(const std::vector<std::shared_ptr<Face>>& faces,
                                                  const ImageShapeAttributes& attr) const
        {
            const FormattingLogger log(GlobalLogger::Get());
            log.LogInfo("Draw faces %v with attributes %v", faces, attr);
            const BoundingBoxesShape rbs(faces, attr);
            return image->DrawShape(rbs);
        }

         */
        [[nodiscard]] std::shared_ptr<FaceCapture> ResizeToMaxDimension(ImageDimension maxDimension)
        {
            if (std::max(image->Width(), image->Height()) <= maxDimension)
            {
                return shared_from_this();
            }
 
            auto resizedImage = image->ResizeToMaxDimension(maxDimension);
            return Create(std::move(resizedImage));
        }

         */
        [[nodiscard]] ImageDimension MaxImageDimension() const
        {
            return std::max(image->Width(), image->Height());
        }
         */
        [[nodiscard]] std::shared_ptr<Image> Draw(const Rectangle& boundingBox, const ImageShapeAttributes& attr) const
        {
            const FormattingLogger log(GlobalLogger::Get());
            log.LogInfo("Draw rectangle %v with attributes %v", boundingBox, attr);
            const RectangleShape rb(boundingBox, attr);
            return image->DrawShape(rb);
        }
 
        FaceCapture(const FaceCapture&) = delete;
        FaceCapture(FaceCapture&& c) = delete;
        FaceCapture& operator=(const FaceCapture&) = delete;
        FaceCapture& operator=(FaceCapture&& c) = delete;
        virtual ~FaceCapture() = default;
        FaceCapture() = delete;
 
    private:
        FaceCapture(std::shared_ptr<Image> i, FaceAttributes fa)
          : image(std::move(i))
          , faceAttributes(std::move(fa))
        {
        }
 
        class BoundingBoxesShape final : public ImageShape
        {
        public:
            void DrawIn(ImageShapeDrawer& drawer) const final
            {
                for (const auto& f : faces)
                {
                    auto rs = RectangleShape(GetFaceDetectionBox(f), attr);
                    rs.DrawIn(drawer);
                }
            }
 
            BoundingBoxesShape(const std::vector<std::shared_ptr<Face>>& fs, ImageShapeAttributes a)
              : faces(fs)
              , attr(std::move(a))
            {
            }
            BoundingBoxesShape() = delete;
            virtual ~BoundingBoxesShape() = default;
            BoundingBoxesShape(const BoundingBoxesShape&) = delete;
            BoundingBoxesShape(BoundingBoxesShape&&) = delete;
            BoundingBoxesShape& operator=(const BoundingBoxesShape&) = delete;
            BoundingBoxesShape& operator=(BoundingBoxesShape&&) = delete;
 
        private:
            const std::vector<std::shared_ptr<Face>>& faces;
            ImageShapeAttributes attr;
            static Rectangle GetFaceDetectionBox(const std::shared_ptr<Face>& face);
        };
    };
} // namespace inno
// NOLINTEND(cppcoreguidelines-non-private-member-variables-in-classes,misc-non-private-member-variables-in-classes,cppcoreguidelines-avoid-const-or-ref-data-members)