Iris.h

Go to the documentation of this file.

 
#pragma once
 
#include "enrollment/Exception/CallbackError.h"
#include "enrollment/Export.h"
#include "enrollment/HashUtils.h"
#include "enrollment/Image/Image.h"
#include "enrollment/Image/ImageMask.h"
#include "enrollment/Iris/IrisAttributes/IrisAttributes.h"
#include "enrollment/Iris/IrisExecutor.h"
#include "enrollment/Iris/IrisPosition.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 <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 IrisExtractorConfig : public Serializable
    {
    public:
         */
        enum class Type : uint8_t
        {
            ACCURATE,
            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 IrisExtractorConfig Default()
        {
            static const IrisExtractorConfig Cfg;
            return Cfg;
        }
        IrisExtractorConfig() = default;
        virtual ~IrisExtractorConfig() = default;
        IrisExtractorConfig(const IrisExtractorConfig&) = default;
        IrisExtractorConfig(IrisExtractorConfig&&) = default;
        IrisExtractorConfig& operator=(const IrisExtractorConfig&) = default;
        IrisExtractorConfig& operator=(IrisExtractorConfig&&) = default;
 
    private:
        Type type = Type::ACCURATE;
    };
 
    class Iris;

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

         */
        bool IsIrisTemplateBiometricPositionKnown() const
        {
            return pos.has_value();
        }

         */
        IrisPosition GetIrisTemplateBiometricPosition() const
        {
            if (!pos.has_value())
            {
                throw EnrollmentRuntimeException("IrisTemplate has unknown biometric position");
            }
 
            return pos.value();
        }

         */
        IrisSimilarityScore SimilarWith(const IrisTemplate& gallery) const
        {
            log.LogInfo("Matching irises %v - %v", *this, gallery);
            float score = 0.0F;
 
            exec->Match(data.data(), data.size(), gallery.data.data(), gallery.data.size(), &score, ThrowOnError{});
            auto irisScore = static_cast<IrisSimilarityScore>(score);
            log.LogInfo("Matching irises %v - %v with score %u from %f", *this, gallery, irisScore, score);
            return irisScore;
        }

         */
        unsigned int CalculateQuality()
        {
            const std::scoped_lock lock(qualityMux);
 
            if (!quality.has_value())
            {
                int32_t q = 0;
 
                exec->IrisQuality(data.data(), data.size(), &q, ThrowOnError{});
 
                quality = q;
            }
 
            return static_cast<unsigned int>(quality.value());
        }

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

         */
        void WriteTo(Writer& writer) const override
        {
            writer.WriteArray("t", data);
 
            const std::scoped_lock lock(qualityMux);
            if (quality.has_value())
            {
                writer.Write("q", quality.value());
            }
        }

         */
        IrisTemplate(std::vector<uint8_t>&& templ, std::shared_ptr<IrisExecutor> 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("Iris template MUST have data");
            }
        }

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

         */
        IrisTemplate(const std::vector<uint8_t>& templ, std::shared_ptr<IrisExecutor> 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("Iris template MUST have data");
            }
        }

         */
        explicit IrisTemplate(const std::vector<uint8_t>& templ)
          : data(templ)
          , exec(GlobalIrisExecutor::Get())
          , log(GlobalLogger::Get())
        {
            if (data.empty())
            {
                throw InvalidTemplateException("Iris template MUST have data");
            }
        }

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

         */
        explicit IrisTemplate(std::vector<uint8_t>&& templ, IrisPosition position)
          : data(std::move(templ))
          , exec(GlobalIrisExecutor::Get())
          , log(GlobalLogger::Get())
          , pos(position)
        {
            if (data.empty())
            {
                throw InvalidTemplateException("Iris template MUST have data");
            }
        }

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

         */
        explicit IrisTemplate(const std::vector<uint8_t>& templ, IrisPosition position)
          : data(templ)
          , exec(GlobalIrisExecutor::Get())
          , log(GlobalLogger::Get())
          , pos(position)
        {
            if (data.empty())
            {
                throw InvalidTemplateException("Iris template MUST have data");
            }
        }
 
        [[nodiscard]] bool operator==(const IrisTemplate& other) const noexcept
        {
            return data == other.data && pos == other.pos;
        }
 
        [[nodiscard]] std::size_t Hash() const noexcept
        {
            std::size_t h = detail::HashBytes(data);
            h = detail::HashCombine(h, static_cast<std::size_t>(pos.has_value()));
            if (pos.has_value())
            {
                h = detail::HashCombine(h, static_cast<std::size_t>(pos.value()));
            }
            return h;
        }
 
        IrisTemplate(const IrisTemplate&) = delete;
        IrisTemplate(IrisTemplate&&) = delete;
        IrisTemplate& operator=(const IrisTemplate&) = delete;
        IrisTemplate& operator=(IrisTemplate&&) = delete;
        IrisTemplate() = delete;
        virtual ~IrisTemplate() = default;
 
    private:
        mutable std::mutex qualityMux;
        std::optional<uint32_t> quality;
        std::shared_ptr<IrisExecutor> exec;
        FormattingLogger log;
        std::optional<IrisPosition> pos;
    };

     */
    class ExtractedIris : public IrisTemplate
    {
    public:
        const std::shared_ptr<Iris> iris;

         */
        static std::vector<std::shared_ptr<IrisTemplate>> ToTemplates(
          const std::vector<std::shared_ptr<ExtractedIris>>& irises)
        {
            std::vector<std::shared_ptr<IrisTemplate>> templates(irises.size());
            std::transform(irises.begin(), irises.end(), templates.begin(), [](const auto& t) { return t; });
            return templates;
        }
        void WriteTo(Writer& writer) const final;
 
        ExtractedIris(const ExtractedIris&) = delete;
        ExtractedIris(ExtractedIris&&) = delete;
        ExtractedIris& operator=(const ExtractedIris&) = delete;
        ExtractedIris& operator=(ExtractedIris&&) = delete;
        ExtractedIris() = delete;
        virtual ~ExtractedIris() = default;
 
    private:
        static std::shared_ptr<ExtractedIris> Create(std::shared_ptr<Iris> iris,
                                                     IrisPosition position,
                                                     std::vector<uint8_t>&& templ,
                                                     std::shared_ptr<IrisExecutor> exec)
        {
            return std::shared_ptr<ExtractedIris>(
              new ExtractedIris(std::move(iris), position, std::move(templ), std::move(exec)));
        }
 
        ExtractedIris(std::shared_ptr<Iris> i,
                      IrisPosition position,
                      std::vector<uint8_t>&& t,
                      std::shared_ptr<IrisExecutor> e)
          : IrisTemplate(std::move(t), position, std::move(e))
          , iris(std::move(i))
        {
        }
 
        friend class Iris;
    };

     */
    class Iris final
      : public Serializable
      , public std::enable_shared_from_this<Iris>
    {
    public:
        const std::shared_ptr<Image> image;
        const float confidence;
        const IrisPosition position;
        const IrisAttributes irisAttributes;

         */
        Polygon CalculateEyelid() const
        {
 
            std::vector<Point> points;
            constexpr size_t PolygonLinesCount = 2;
            points.reserve(image->Width() * PolygonLinesCount);
            auto addPoint = +[](void* container, int x, int y)
            {
                auto* ps = static_cast<std::vector<Point>*>(container);
                ps->emplace_back(x, y);
            };
            exec->CalculateEyelid(irisHandler.get(), image->Width(), addPoint, &points, ThrowOnError{});
 
            return Polygon{ std::move(points) };
        }
 
    private:
        class IsoMask : public ImageMask
        {
        public:
            // NOLINTNEXTLINE(fuchsia-statically-constructed-objects)
            inline static const RGBA Iso19794Sclera = RGBA(200, 200, 200, RGBA::FULLY_OPAQUE);
            // NOLINTNEXTLINE(fuchsia-statically-constructed-objects)
            inline static const RGBA Iso19794Eyelid = RGBA(128, 128, 128, RGBA::FULLY_OPAQUE);
 
            void MaskWith(ImageMasker& masker) const final
            {
                masker.MaskCircle(iris, ImageMaskConfiguration{ ImageMaskType::OUTSIDE, Iso19794Sclera });
                masker.MaskPolygon(eyelid, ImageMaskConfiguration{ ImageMaskType::OUTSIDE, Iso19794Eyelid });
                masker.AddToBlur(iris, ImageMaskType::OUTSIDE);
                masker.AddToBlur(eyelid, ImageMaskType::OUTSIDE);
                masker.ApplyBlur(ImageBlurType::ISO_19794_BORDER_BLURRING);
            }
 
            IsoMask(Circle c, Polygon p)
              : iris(std::move(c))
              , eyelid(std::move(p))
            {
            }
            IsoMask() = delete;
            virtual ~IsoMask() = default;
            IsoMask(const IsoMask&) = delete;
            IsoMask(IsoMask&&) = delete;
            IsoMask& operator=(const IsoMask&) = delete;
            IsoMask& operator=(IsoMask&&) = delete;
 
        private:
            Circle iris;
            Polygon eyelid;
        };
 
    public:
         */
        std::shared_ptr<Image> GetISO19794IrisImage() const
        {
            if (image->RectangleIntersection(irisBox) != Image::Intersection::INSIDE)
            {
                throw EnrollmentInvalidArgumentException("Iris is not fully contained within the image");
            }
 
            auto mask = IsoMask{ Circle::CreateInscribedCircle(irisBox), CalculateEyelid() };
 
            auto maskedImage = image->MaskImageBy(mask);
 
            // Defined in 6.4 Cropped Iris Image of 19794-6:2011
            constexpr float IrisMarginFactorW = 0.6F;
            constexpr float IrisMarginFactorH = 0.2F;
 
            const auto irisWidth = static_cast<float>(irisBox.GetWidth());
            const auto irisHeight = static_cast<float>(irisBox.GetHeight());
            const auto marginX = static_cast<X>((irisWidth / 2) * IrisMarginFactorW);
            const auto marginY = static_cast<Y>((irisHeight / 2) * IrisMarginFactorH);
 
            const Rectangle croppedRect{
                { irisBox.GetTopLeft().x - marginX, irisBox.GetTopLeft().y - marginY },
                { irisBox.GetTopRight().x + marginX, irisBox.GetTopRight().y - marginY },
                { irisBox.GetBottomRight().x + marginX, irisBox.GetBottomRight().y + marginY },
                { irisBox.GetBottomLeft().x - marginX, irisBox.GetBottomLeft().y + marginY },
            };
 
            auto croppedMaskedImage = maskedImage->CropRectangle(croppedRect);
            return croppedMaskedImage;
        }

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

         */
        [[nodiscard]] std::vector<uint8_t> ToIsoRawImage() const
        {
            IsoImage isoImage(*this);
            auto rawImage = image->AsRawGrayscale();
            isoImage.SetImageFormat(IsoImage::ImageFormatMonoRaw);
            return isoImage.FillIsoImage(rawImage.Data());
        }

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

         */
        std::shared_ptr<ExtractedIris> Extract(const IrisExtractorConfig& cfg)
        {
            log.LogInfo("Iris extraction for %v with cfg %v ...", image, cfg);
 
            std::vector<uint8_t> templData;
 
            exec->Extract(
              irisHandler.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 iris = shared_from_this();
            auto extractedIris = ExtractedIris::Create(iris, position, std::move(templData), exec);
 
            log.LogInfo("Iris extraction result %v", extractedIris);
 
            return extractedIris;
        }

         */
        void WriteTo(Writer& writer) const final
        {
            writer.Write("i", image);
            writer.Write("c", confidence);
            writer.Write("p", static_cast<int>(position));
            writer.Write("c", static_cast<unsigned int>(irisAttributes.GetCaptureDeviceTechnology()));
            writer.Write("ei", static_cast<unsigned int>(irisAttributes.GetCaptureDeviceVendorID()));
            writer.Write("dt", static_cast<unsigned int>(irisAttributes.GetCaptureDeviceTypeID()));
        }
 
        Iris(const Iris&) = delete;
        Iris(Iris&&) = delete;
        Iris& operator=(const Iris&) = delete;
        Iris& operator=(Iris&&) = delete;
        virtual ~Iris() = default;
        Iris() = delete;
 
    private:
        std::shared_ptr<void> irisHandler;
        Rectangle irisBox;
        Rectangle pupilBox;
        FormattingLogger log;
        std::shared_ptr<IrisExecutor> exec;
 
        /*
         * Constructor sets image for extraction and Logger to log.
         * @param img Iris image
         * @param confidence is detection confidence
         * @param position is iris position defined in IrisPosition enum
         * @param ih detection handler
         * @param irisBox is rounding box of iris
         * @param pupilBox is rounding box of pupil
         * @param log Logger
         * @param exec iris functionality executor
         * @param ia IrisAttributes
         */
        static std::shared_ptr<Iris> Create(std::shared_ptr<Image> img,
                                            float confidence,
                                            const IrisPosition& position,
                                            std::shared_ptr<void> ih,
                                            Rectangle irisBox,
                                            Rectangle pupilBox,
                                            std::shared_ptr<Logger> logger,
                                            std::shared_ptr<IrisExecutor> exec,
                                            const IrisAttributes& ia = IrisAttributes())
        {
            return std::shared_ptr<Iris>(new Iris(std::move(img),
                                                  confidence,
                                                  position,
                                                  std::move(ih),
                                                  std::move(irisBox),
                                                  std::move(pupilBox),
                                                  std::move(logger),
                                                  std::move(exec),
                                                  ia));
        }
 
        Iris(std::shared_ptr<Image> img,
             float conf,
             const IrisPosition& pos,
             std::shared_ptr<void> ih,
             Rectangle ic,
             Rectangle pc,
             std::shared_ptr<Logger> l,
             std::shared_ptr<IrisExecutor> e,
             IrisAttributes ia)
          : image(std::move(img))
          , confidence(conf)
          , position(pos)
          , irisAttributes(std::move(ia))
          , irisHandler(std::move(ih))
          , irisBox(std::move(ic))
          , pupilBox(std::move(pc))
          , log(std::move(l))
          , exec(std::move(e))
        {
            if (exec == nullptr)
            {
                throw NullArgumentException("Could not create Iris due to executor can not be null");
            }
 
            if (image == nullptr)
            {
                throw NullArgumentException("Could not create Iris due to image can not be null");
            }
        }
 
        class IsoImage
        {
        private:
            size_t writeIndex = 0U;
 
        public:
            explicit IsoImage(const Iris& i)
              : iris(i)
            {
            }
            IsoImage() = delete;
            ~IsoImage() = default;
            IsoImage(const IsoImage&) = delete;
            IsoImage(IsoImage&&) = delete;
            IsoImage& operator=(const IsoImage&) = delete;
            IsoImage& operator=(IsoImage&&) = delete;
 
            void SetImageFormat(uint8_t ct)
            {
                imageFormat = ct;
            }
 
            std::vector<uint8_t> FillIsoImage(const std::vector<uint8_t>& encodedImage)
            {
                // General header contains 16 bytes.
                static constexpr size_t GeneralHeaderLength = 16;
 
                // Representation header contains 52 bytes.
                static constexpr size_t RepresentationHeaderLength = 52;
 
                // Length of encoded image.
                auto imageLength = encodedImage.size();
 
                // Representation length including the representation header length.
                auto representationLength = RepresentationHeaderLength + imageLength;
 
                // Record length with image data.
                auto recordLength = GeneralHeaderLength + representationLength;
 
                std::vector<uint8_t> isoImage;
                isoImage.resize(recordLength);
 
                FillGeneralHeader(isoImage, recordLength);
                FillRepresentationHeader(isoImage, representationLength, imageLength);
                FillRepresentationBody(isoImage, encodedImage);
 
                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);
                FillNumberOfEyesRepresented(isoImage);
            }

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

            void FillVersionNumber(std::vector<uint8_t>& isoImage)
            {
                // Mandatory fields.
                isoImage[writeIndex++] = '0';
                isoImage[writeIndex++] = '2';
                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 FillNumberOfEyesRepresented(std::vector<uint8_t>& isoImage)
            {
                // Mandatory field.
                isoImage[writeIndex] = 0x0;
                if (iris.position == IrisPosition::LEFT_EYE || iris.position == IrisPosition::RIGHT_EYE)
                {
                    isoImage[writeIndex] = 0x01;
                }
                writeIndex++;
            }

            void FillRepresentationHeader(std::vector<uint8_t>& isoImage,
                                          size_t representationLength,
                                          size_t imageLength)
            {
                FillRepresentationLength(isoImage, representationLength);
                FillCaptureDateTime(isoImage);
                FillCaptureDeviceTechnologyIdentifier(isoImage);
                FillCaptureDeviceVendorIdentifier(isoImage);
                FillCaptureDeviceTypeIdentifier(isoImage);
                FillQualitySection(isoImage);
                FillRepresentationSequenceNumber(isoImage);
                FillEyeLabel(isoImage);
                FillImageType(isoImage);
                FillImageFormat(isoImage);
                FillIrisImagePropertiesBitField(isoImage);
                FillImageWidth(isoImage);
                FillImageHeight(isoImage);
                FillBitDepth(isoImage);
                FillRange(isoImage);
                FillRollAngleOfEye(isoImage);
                FillRollAngleUncertainty(isoImage);
                FillIrisCentreSmallestX(isoImage);
                FillIrisCentreLargestX(isoImage);
                FillIrisCentreSmallestY(isoImage);
                FillIrisCentreLargestY(isoImage);
                FillIrisDiameterSmallest(isoImage);
                FillIrisDiameterLargest(isoImage);
                FillImageLength(isoImage, imageLength);
            }

            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 IrisCaptureDeviceTechnology technology = iris.irisAttributes.GetCaptureDeviceTechnology();
                isoImage[writeIndex++] =
                  static_cast<uint8_t>(IrisToIsoCaptureDeviceTechnology(technology)); // Mandatory field.
            }

            void FillCaptureDeviceVendorIdentifier(std::vector<uint8_t>& isoImage)
            {
                // Mandatory fields.
                const IrisCaptureDeviceVendorID vendor = iris.irisAttributes.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 IrisCaptureDeviceTypeID type = iris.irisAttributes.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 FillQualitySection(std::vector<uint8_t>& isoImage)
            {
                // Number of quality blocks
                isoImage[writeIndex++] = 0x00;
            }

            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 FillRepresentationSequenceNumber(std::vector<uint8_t>& isoImage)
            {
                // Mandatory fields.
                isoImage[writeIndex++] = 0x00;
                isoImage[writeIndex++] = 0x01;
            }

            void FillEyeLabel(std::vector<uint8_t>& isoImage)
            {
                isoImage[writeIndex++] =
                  static_cast<uint8_t>(IrisPositionToIsoPosition(iris.position)); // Mandatory field.
            }

            void FillImageType(std::vector<uint8_t>& isoImage)
            {
                isoImage[writeIndex++] = static_cast<uint8_t>(IrisImageTypeToIso(iris.irisAttributes.GetImageType()));
            }

            void FillImageFormat(std::vector<uint8_t>& isoImage)
            {
                isoImage[writeIndex++] = imageFormat;
            }

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

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

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

            void FillBitDepth(std::vector<uint8_t>& isoImage)
            {
                // The enrollment sdk image has always bit depth 8
                static constexpr uint8_t UsedBitDepth = 8;
                isoImage[writeIndex++] = UsedBitDepth;
            }

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

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

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

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

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

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

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

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

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

            void FillImageLength(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 FillRepresentationBody(std::vector<uint8_t>& isoImage, const std::vector<uint8_t>& encodedImage)
            {
                FillImageData(isoImage, encodedImage);
            }

            void FillImageData(std::vector<uint8_t>& isoImage, const std::vector<uint8_t>& encodedImage)
            {
                std::copy(
                  encodedImage.begin(), encodedImage.end(), isoImage.begin() + static_cast<ptrdiff_t>(writeIndex));
                writeIndex += encodedImage.size();
            }
 
            const Iris& iris;
            static constexpr uint8_t ImageFormatUnknown = 255;
            uint8_t imageFormat = ImageFormatUnknown;
 
        public:
            static constexpr uint8_t ImageFormatMonoRaw = 2;
            static constexpr uint8_t ImageFormatMonoJPG2000 = 10;
            static constexpr uint8_t ImageFormatMonoPNG = 14;
            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 = iris.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
            {
                isoImage.SetImageFormat(IsoImage::ImageFormatMonoJPG2000);
            }
 
            void Visit(const PngImageEncoder& /* encoder */) final
            {
                isoImage.SetImageFormat(IsoImage::ImageFormatMonoPNG);
            }
 
            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 Iris& i, ImageEncoder& e)
              : iris(i)
              , encoder(e)
              , isoImage(IsoImage(i))
            {
            }
            IsoImageEncoder() = delete;
            virtual ~IsoImageEncoder() = default;
            IsoImageEncoder(const IsoImageEncoder&) = delete;
            IsoImageEncoder(IsoImageEncoder&&) = delete;
            IsoImageEncoder& operator=(const IsoImageEncoder&) = delete;
            IsoImageEncoder& operator=(IsoImageEncoder&&) = delete;
 
        private:
            const Iris& iris;
            ImageEncoder& encoder;
            IsoImage isoImage;
        };
 
        friend class IrisDetector;
    };
 
    inline void ExtractedIris::WriteTo(Writer& writer) const
    {
        writer.Write("i", iris);
        IrisTemplate::WriteTo(writer);
    }
} // namespace inno
// NOLINTEND(cppcoreguidelines-non-private-member-variables-in-classes,misc-non-private-member-variables-in-classes,cppcoreguidelines-avoid-const-or-ref-data-members)