IrisCapture.h

Go to the documentation of this file.

 
#pragma once
 
#include "enrollment/Export.h"
#include "enrollment/Image/Image.h"
#include "enrollment/Image/ImageAttribute.h"
#include "enrollment/Iris/IrisAttributes/IrisAttributes.h"
#include "enrollment/Iris/IrisDetector.h"
#include "enrollment/Iris/IrisPosition.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 Iris;

     */
    class IrisCapture
    {
    public:
        const std::shared_ptr<Image> image;
        const IrisPosition position;
        const IrisAttributes irisAttributes;

         */
        static std::shared_ptr<IrisCapture> Create(std::shared_ptr<Image> img,
                                                   const IrisPosition& pos,
                                                   const IrisAttributes& ia = IrisAttributes())
        {
            if (img == nullptr)
            {
                throw NullArgumentException("Could not create IrisCapture due to image can not be null");
            }
            return std::shared_ptr<IrisCapture>(new IrisCapture(std::move(img), pos, ia));
        }

         */
        [[nodiscard]] static std::shared_ptr<IrisCapture> 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 iris ISO image (fail to read header)");
            }
            if (const std::vector<uint8_t> id = { 'I', 'I', 'R', '\0' };
                std::search(isoImage.begin(), isoImage.end(), id.begin(), id.end()) == isoImage.end())
            {
                throw EnrollmentInvalidArgumentException("Fail to decode iris ISO image (invalid id)");
            }
            static constexpr size_t VersionIndex = SizeOfIdentifier;
            if (const std::vector<uint8_t> ver = { '0', '2', '0', '\0' };
                std::search(isoImage.begin() + VersionIndex, isoImage.end(), ver.begin(), ver.end()) == isoImage.end())
            {
                throw EnrollmentInvalidArgumentException("Fail to decode iris ISO image (invalid version)");
            }
            static constexpr size_t QualityBlocksCountIndex = 34UL;
            static constexpr size_t SizeOfQualityBlocksCount = 1UL;
            if (isoImage.size() < (QualityBlocksCountIndex + SizeOfQualityBlocksCount))
            {
                throw EnrollmentInvalidArgumentException(
                  "Fail to decode iris 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 representationHeaderIndex =
              QualityBlocksCountIndex + SizeOfQualityBlocksCount + qualityBlocksSize;
            static constexpr size_t RepresentationNumberSize = 2UL;
            const auto positionIndex = representationHeaderIndex + RepresentationNumberSize;
            static constexpr size_t PositionSize = 1UL;
            if (isoImage.size() < positionIndex + PositionSize)
            {
                throw EnrollmentInvalidArgumentException("Fail to decode iris ISO image (fail to read position)");
            }
            const auto position = isoImage[positionIndex];
            const auto imageTypeIndex = positionIndex + PositionSize;
            static constexpr size_t ImageTypeSize = 1UL;
            if (isoImage.size() < imageTypeIndex + ImageTypeSize)
            {
                throw EnrollmentInvalidArgumentException("Fail to decode iris ISO image (fail to read image type)");
            }
 
            const auto imageFormatIndex = imageTypeIndex + ImageTypeSize;
            static constexpr size_t ImageFormatSize = 1UL;
            if (isoImage.size() < imageFormatIndex + ImageFormatSize)
            {
                throw EnrollmentInvalidArgumentException("Fail to decode iris ISO image (fail to read image format)");
            }
            auto imageFormat = isoImage[imageFormatIndex];
            constexpr uint8_t ImageFormatMonoRaw = 2;
 
            static constexpr size_t ImageLengthOffsetFromRepresentationStart = 29UL;
            const auto imageLengthIndex = representationHeaderIndex + ImageLengthOffsetFromRepresentationStart;
            static constexpr size_t SizeOfImageLength = 4UL;
            if (isoImage.size() < (imageLengthIndex + SizeOfImageLength))
            {
                throw EnrollmentInvalidArgumentException("Fail to decode iris 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 iris ISO image (fail to read image data)");
            }
            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 CaptureEquipmentIdIndex = 30UL;
            const unsigned int captureEquipmentID =
              (isoImage[CaptureEquipmentIdIndex] << 8U) + isoImage[CaptureEquipmentIdIndex + 1];
            static constexpr size_t CaptureDeviceTypeIdIndex = 32UL;
            const unsigned int captureDeviceTypeID =
              (isoImage[CaptureDeviceTypeIdIndex] << 8U) + isoImage[CaptureDeviceTypeIdIndex + 1];
 
            IrisAttributes ia;
            static constexpr size_t CaptureDeviceTechnologyIndex = 29UL;
            ia.SetCaptureDeviceTechnology(IsoToIrisCaptureDeviceTechnology(isoImage[CaptureDeviceTechnologyIndex]));
            ia.SetCaptureDeviceVendorID(IrisCaptureDeviceVendorID(captureEquipmentID));
            ia.SetCaptureDeviceTypeID(IrisCaptureDeviceTypeID(captureDeviceTypeID));
            ia.SetImageType(IsoToIrisImageType(isoImage[imageTypeIndex]));
 
            if (imageFormat == ImageFormatMonoRaw)
            {
                // Raw image is in iso iris image
                static constexpr size_t WidthOffsetFromRepresentationStart = 6UL;
                const auto widthIndex = representationHeaderIndex + WidthOffsetFromRepresentationStart;
                const ImageWidth width = ((isoImage[widthIndex] << 8U) + isoImage[widthIndex + 1]);
                static constexpr size_t HeightOffsetFromRepresentationStart = 8UL;
                const auto heightIndex = representationHeaderIndex + HeightOffsetFromRepresentationStart;
                const ImageHeight height = ((isoImage[heightIndex] << 8U) + isoImage[heightIndex + 1]);
                const RawImage raw = { width, height, DefaultDpi, RawImage::GRAYSCALE, std::move(encodedImageData) };
                return IrisCapture::Create(
                  Image::DecodeRawImage(raw), IsoToIrisPosition(static_cast<int>(position)), ia);
            }
            return IrisCapture::Create(
              Image::Decode(encodedImageData), IsoToIrisPosition(static_cast<int>(position)), ia);
        }

         */
        [[nodiscard]] std::shared_ptr<IrisSegment> DetectWith(IrisDetector& detector) const
        {
            return detector.Detect(image, position, irisAttributes);
        }
 
        [[nodiscard]] std::shared_ptr<Image> DrawSegment(const IrisSegment& segment,
                                                         const ImageShapeAttributes& pupil,
                                                         const ImageShapeAttributes& iris) const
        {
            const RoundingShape rcs(segment, pupil, iris);
            return image->DrawShape(rcs);
        }
 
        IrisCapture(const IrisCapture&) = delete;
        IrisCapture(IrisCapture&&) = delete;
        IrisCapture& operator=(const IrisCapture&) = delete;
        IrisCapture& operator=(IrisCapture&&) = delete;
        virtual ~IrisCapture() = default;
        IrisCapture() = delete;
 
    private:
        IrisCapture(std::shared_ptr<Image> img, const IrisPosition& pos, IrisAttributes ia)
          : image(std::move(img))
          , position(pos)
          , irisAttributes(std::move(ia))
        {
        }
 
        class RoundingShape : public ImageShape
        {
        public:
            void DrawIn(ImageShapeDrawer& drawer) const final
            {
                auto ps = RectangleShape(iris.pupilRoundingBox, pupilAttr);
                ps.DrawIn(drawer);
                auto is = RectangleShape(iris.irisRoundingBox, irisAttr);
                is.DrawIn(drawer);
            }
 
            RoundingShape(const IrisSegment& i, ImageShapeAttributes pc, ImageShapeAttributes ic)
              : iris(i)
              , pupilAttr(std::move(pc))
              , irisAttr(std::move(ic))
            {
            }
            RoundingShape() = delete;
            virtual ~RoundingShape() = default;
            RoundingShape(const RoundingShape&) = delete;
            RoundingShape(RoundingShape&&) = delete;
            RoundingShape& operator=(const RoundingShape&) = delete;
            RoundingShape& operator=(RoundingShape&&) = delete;
 
        private:
            const IrisSegment& iris;
            ImageShapeAttributes pupilAttr;
            ImageShapeAttributes irisAttr;
        };
    };
} // namespace inno
// NOLINTEND(cppcoreguidelines-non-private-member-variables-in-classes,misc-non-private-member-variables-in-classes,cppcoreguidelines-avoid-const-or-ref-data-members)