Print.h

Go to the documentation of this file.

 
#pragma once
#include "enrollment/Exception/NotSupportedException.h"
#include "enrollment/Export.h"
#include "enrollment/Image/Image.h"
#include "enrollment/Image/ImageAttribute.h"
#include "enrollment/Logger/FormattingLogger.h"
#include "enrollment/Logger/Logger.h"
#include "enrollment/Print/CriticalPoint.h"
#include "enrollment/Print/Minutia.h"
#include "enrollment/Print/PrintAttributes/PrintAttributes.h"
#include "enrollment/Print/PrintAttributes/PrintCaptureDeviceTechnology.h"
#include "enrollment/Print/PrintAttributes/PrintCaptureDeviceTypeID.h"
#include "enrollment/Print/PrintAttributes/PrintCaptureDeviceVendorID.h"
#include "enrollment/Print/PrintAttributes/PrintImpression.h"
#include "enrollment/Print/PrintAttributes/PrintPosition.h"
#include "enrollment/Print/PrintExecutor.h"
#include "enrollment/Serialization/Writer.h"
#include <algorithm>
#include <array>
#include <cstdint>
#include <memory>
#include <mutex>
#include <numeric>
#include <optional>
 
// 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 Print final : public Serializable
    {
    public:
        const std::shared_ptr<Image> image;
        const PrintPosition position;
        const PrintAttributes printAttributes;

         */
        [[nodiscard]] std::shared_ptr<Print> ChangeDpiTo(ImageDpi targetDpi) const
        {
            const Image::BicubicImageResampler resampler{ targetDpi };
            return ChangeDpiTo(resampler);
        }

         */
        [[nodiscard]] std::shared_ptr<Print> ChangeDpiTo(const Image::ImageResampler& resampler) const
        {
            return Create(image->ChangeDpiTo(resampler), position, printAttributes, exec);
        }

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

         */
        std::vector<uint8_t> ToIsoRawImage() const
        {
            IsoImage isoImage(*this);
            const std::vector<uint8_t> rawGrayscale = image->AsRawGrayscale().Data();
            return isoImage.FillIsoImage(rawGrayscale);
        }

         */
        static std::shared_ptr<Print> 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 print ISO image (fail to read header)");
            }
            if (const std::vector<uint8_t> id = { 'F', 'I', 'R', '\0' };
                std::search(isoImage.begin(), isoImage.end(), id.begin(), id.end()) == isoImage.end())
            {
                throw EnrollmentInvalidArgumentException("Fail to decode print 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 print ISO image (invalid version)");
            }
            static constexpr size_t CertificationFlagIndex = 14UL;
            static constexpr size_t SizeOfCertificationFlag = 1UL;
            if (isoImage.size() < (CertificationFlagIndex + SizeOfCertificationFlag))
            {
                throw EnrollmentInvalidArgumentException(
                  "Fail to decode print ISO image (fail to read certification flag)");
            }
            const auto certificationFlag = isoImage[CertificationFlagIndex];
            static constexpr size_t DeviceTechnologyId = 29UL;
            static constexpr size_t SizeOfDeviceTechnologyId = 1UL;
            if (isoImage.size() < (DeviceTechnologyId + SizeOfDeviceTechnologyId))
            {
                throw EnrollmentInvalidArgumentException(
                  "Fail to decode print ISO image (fail to read device technology identifier)");
            }
            const auto deviceTechnologyId = isoImage[DeviceTechnologyId];
            static constexpr size_t DeviceVendorId = 30UL;
            static constexpr size_t SizeOfDeviceVendorId = 2UL;
            if (isoImage.size() < (DeviceVendorId + SizeOfDeviceVendorId))
            {
                throw EnrollmentInvalidArgumentException(
                  "Fail to decode print ISO image (fail to read device vendor identifier)");
            }
            const uint16_t deviceVendorId = (isoImage[DeviceVendorId] << 8U) + isoImage[DeviceVendorId + 1];
            static constexpr size_t DeviceTypeId = 32UL;
            static constexpr size_t SizeOfDeviceTypeId = 2UL;
            if (isoImage.size() < (DeviceTypeId + SizeOfDeviceTypeId))
            {
                throw EnrollmentInvalidArgumentException(
                  "Fail to decode print ISO image (fail to read device type identifier)");
            }
            const uint16_t deviceTypeId = (isoImage[DeviceTypeId] << 8U) + isoImage[DeviceTypeId + 1];
            static constexpr size_t QualityBlocksLengthIndex = 34UL;
            static constexpr size_t SizeOfQualityBlocksLength = 1UL;
            static constexpr size_t SizeOfQualityBlock = 5UL;
            if (isoImage.size() < (QualityBlocksLengthIndex + SizeOfQualityBlocksLength))
            {
                throw EnrollmentInvalidArgumentException(
                  "Fail to decode print ISO image (fail to read quality blocks count)");
            }
            const auto qualityBlocksCount = isoImage[QualityBlocksLengthIndex];
            const auto qualityBlocksSize = qualityBlocksCount * SizeOfQualityBlock;
            size_t sizeOfCertificationRecord = 0;
            if (certificationFlag == 1)
            {
                const auto certificationRecordsCountIndex =
                  QualityBlocksLengthIndex + SizeOfQualityBlocksLength + qualityBlocksSize;
                static constexpr size_t SizeOfCertificationRecordsCount = 1UL;
                if (isoImage.size() < (certificationRecordsCountIndex + SizeOfCertificationRecordsCount))
                {
                    throw EnrollmentInvalidArgumentException(
                      "Fail to decode print ISO image (fail to read certification records count)");
                }
                static constexpr size_t SizeOfCertificationRecord = 3UL;
                sizeOfCertificationRecord = isoImage[certificationRecordsCountIndex] * SizeOfCertificationRecord +
                                            SizeOfCertificationRecordsCount;
            }
            const auto positionIndex =
              QualityBlocksLengthIndex + SizeOfQualityBlocksLength + qualityBlocksSize + sizeOfCertificationRecord;
            static constexpr size_t SizeOfPosition = 1UL;
            if (isoImage.size() < (positionIndex + SizeOfPosition))
            {
                throw EnrollmentInvalidArgumentException("Fail to decode print ISO image (fail to read position)");
            }
            const auto position = isoImage[positionIndex];
            static constexpr size_t ImpressionOffsetFromPosition = 13UL;
            static constexpr size_t SizeOfImpression = 1UL;
            const auto impressionIndex = positionIndex + ImpressionOffsetFromPosition;
            if (isoImage.size() < (impressionIndex + SizeOfImpression))
            {
                throw EnrollmentInvalidArgumentException("Fail to decode print ISO image (fail to read impression)");
            }
            const auto impression = isoImage[impressionIndex];
            static constexpr size_t ImageLengthOffsetFromPosition = 18UL;
            const auto imageLengthIndex = positionIndex + ImageLengthOffsetFromPosition;
            static constexpr size_t SizeOfImageLength = 4UL;
            if (isoImage.size() < (imageLengthIndex + SizeOfImageLength))
            {
                throw EnrollmentInvalidArgumentException("Fail to decode print ISO image (fail to read image length)");
            }
            const size_t encodedImageLength = (isoImage[imageLengthIndex] << 24U) +
                                              (isoImage[imageLengthIndex + 1] << 16U) +
                                              (isoImage[imageLengthIndex + 2] << 8U) + isoImage[imageLengthIndex + 3];
            const auto imageDataIndex = imageLengthIndex + SizeOfImageLength;
            if (isoImage.size() < (imageDataIndex + encodedImageLength))
            {
                throw EnrollmentInvalidArgumentException("Fail to decode print 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 + encodedImageLength)));
 
            static constexpr size_t ImageHorizontalDpiOffsetFromPosition = 7UL;
            const auto imageHorizontalDpiIndex = positionIndex + ImageHorizontalDpiOffsetFromPosition;
            const unsigned int imageHorizontalDpi =
              (isoImage[imageHorizontalDpiIndex] << 8U) + isoImage[imageHorizontalDpiIndex + 1];
            static constexpr size_t ImageVerticalDpiOffsetFromPosition = 9UL;
            const auto imageVerticalDpiIndex = positionIndex + ImageVerticalDpiOffsetFromPosition;
            const unsigned int imageVerticalDpi =
              (isoImage[imageVerticalDpiIndex] << 8U) + isoImage[imageVerticalDpiIndex + 1];
            if (imageHorizontalDpi != imageVerticalDpi)
            {
                throw NotSupportedException(
                  "Fail to decode print ISO image (vertical and horizontal image DPI is different)");
            }
            static constexpr size_t ImageScaleUnitOffsetFromPosition = 2UL;
            const auto imageScaleUnitIndex = positionIndex + ImageScaleUnitOffsetFromPosition;
            const auto imageScaleUnit = isoImage[imageScaleUnitIndex];
            static constexpr uint8_t ImageScaleUnitDPI = 1;
            static constexpr uint8_t ImageScaleUnitDPCM = 2;
            if (imageScaleUnit != ImageScaleUnitDPI && imageScaleUnit != ImageScaleUnitDPCM)
            {
                throw EnrollmentInvalidArgumentException("Fail to decode print ISO image (invalid scale unit)");
            }
            auto dpi = ImageDpi{ imageHorizontalDpi };
            if (imageScaleUnit == ImageScaleUnitDPCM)
            {
                dpi = ImageDpi::FromDPCM(imageHorizontalDpi);
            }
 
            PrintAttributes pa;
            pa.SetImpression(IsoToPrintImpression(impression));
            pa.SetCaptureDeviceTechnology(IsoToPrintCaptureDeviceTechnology(deviceTechnologyId));
            pa.SetCaptureDeviceVendorID(PrintCaptureDeviceVendorID(deviceVendorId));
            pa.SetCaptureDeviceTypeID(PrintCaptureDeviceTypeID(deviceTypeId));
            pa.SetCertificationFlag(static_cast<bool>(certificationFlag));
 
            static constexpr size_t ImageBitDepthOffsetFromPosition = 11UL;
            const auto imagBitDepthIndex = positionIndex + ImageBitDepthOffsetFromPosition;
            const auto imageBitDepth = isoImage[imagBitDepthIndex];
            static constexpr uint8_t SupportedBitsPerPixel = 8;
 
            static constexpr size_t ImageCompressionOffsetFromPosition = 12UL;
            const auto imageCompressionIndex = positionIndex + ImageCompressionOffsetFromPosition;
            const auto imageCompression = isoImage[imageCompressionIndex];
            static constexpr uint8_t RawNotPackedImage = 0;
            static constexpr uint8_t RawPackedImage = 1;
 
            if (imageCompression == RawNotPackedImage || imageCompression == RawPackedImage)
            {
                if (imageBitDepth != SupportedBitsPerPixel)
                {
                    throw NotSupportedException("Fail to decode print ISO image (bit depth is not 8 for raw image)");
                }
 
                static constexpr size_t ImageWidthOffsetFromPosition = 14UL;
                const auto imagWidthIndex = positionIndex + ImageWidthOffsetFromPosition;
                const ImageWidth imageWidth = (isoImage[imagWidthIndex] << 8U) + isoImage[imagWidthIndex + 1];
                static constexpr size_t ImageHeightOffsetFromPosition = 16UL;
                const auto imagHeightIndex = positionIndex + ImageHeightOffsetFromPosition;
                const ImageHeight imageHeight = (isoImage[imagHeightIndex] << 8U) + isoImage[imagHeightIndex + 1];
 
                return Print::Create(
                  Image::DecodeRawImage(
                    RawImage{ imageWidth, imageHeight, dpi, RawImage::Type::GRAYSCALE, std::move(encodedImageData) }),
                  IsoToPrintPosition(position),
                  pa);
            }
 
            return Print::Create(
              Image::Decode(encodedImageData, static_cast<unsigned int>(dpi)), IsoToPrintPosition(position), pa);
        }

         */
        uint8_t CalculatePresence()
        {
            const std::scoped_lock lock(presenceMux);
            if (!presence.has_value())
            {
                uint8_t localPresence = 0;
 
                auto gs = image->AsRawGrayscale();
                exec->CalculatePresence(gs.width,
                                        gs.height,
                                        static_cast<unsigned int>(gs.dpi),
                                        gs.Data().data(),
                                        &localPresence,
                                        ThrowOnError{});
 
                presence = localPresence;
            }
            return presence.value();
        }

         */
        uint8_t CalculateNFIQ1()
        {
            const std::scoped_lock lock(nfiq1Mux);
            if (!nfiq1.has_value())
            {
                uint8_t localNFIQ1 = 0;
 
                auto gs = image->AsRawGrayscale();
 
                exec->CalculateNFIQ1(gs.width,
                                     gs.height,
                                     static_cast<unsigned int>(gs.dpi),
                                     gs.Data().data(),
                                     &localNFIQ1,
                                     ThrowOnError{});
 
                nfiq1 = localNFIQ1;
            }
            return nfiq1.value();
        }

         */
        uint8_t CalculateNFIQ2()
        {
            const std::scoped_lock lock(nfiq2Mux);
            log.LogInfo("Calculating NFIQ2 for image %v", image);
 
            if (!nfiq2.has_value())
            {
                if (image->Dpi() != DefaultDpi)
                {
                    static constexpr const char* Msg = "Image for NFIQ2 quality MUST have 500 DPI";
                    log.LogError("Calculating NFIQ2 for image %v failed '%s'", image, Msg);
                    throw InvalidImageArgumentException(Msg);
                }
 
                uint8_t localNFIQ2 = 0;
 
                auto gs = image->AsRawGrayscale();
 
                exec->CalculateNFIQ2(gs.width,
                                     gs.height,
                                     static_cast<unsigned int>(gs.dpi),
                                     gs.Data().data(),
                                     &localNFIQ2,
                                     ThrowOnError{});
 
                nfiq2 = localNFIQ2;
            }
            log.LogInfo("Calculating NFIQ2 for image %v with result %d", image, nfiq2.value());
            return nfiq2.value();
        }

         */
        uint8_t CalculateImageQuality()
        {
            const std::scoped_lock lock(imageQualityMux);
            if (!imageQuality.has_value())
            {
                uint8_t quality = 0;
 
                auto gs = image->AsRawGrayscale();
 
                exec->CalculateImageQuality(
                  gs.width, gs.height, static_cast<unsigned int>(gs.dpi), gs.Data().data(), &quality, ThrowOnError{});
 
                imageQuality = quality;
            }
            return imageQuality.value();
        }

         */
        uint8_t CalculatePlacement()
        {
            const std::scoped_lock lock(placementMux);
            if (!placement.has_value())
            {
                uint8_t localPlacement = 0;
 
                auto gs = image->AsRawGrayscale();
 
                exec->CalculatePlacement(gs.width,
                                         gs.height,
                                         static_cast<unsigned int>(gs.dpi),
                                         gs.Data().data(),
                                         &localPlacement,
                                         ThrowOnError{});
 
                placement = localPlacement;
            }
            return placement.value();
        }

         */
        static uint8_t CalculateIntensity(const std::shared_ptr<inno::Image>& image,
                                          std::shared_ptr<PrintExecutor>& executor)
        {
            uint8_t intensity = 0;
 
            const inno::RawImage rawImage = image->AsRawGrayscale();
 
            executor->GetImageIntensity(
              rawImage.width, rawImage.height, rawImage.Data().data(), &intensity, ThrowOnError{});
 
            return intensity;
        }

         */
        uint8_t CalculateIntensity()
        {
            const std::scoped_lock lock(intensityMux);
            if (!intensity.has_value())
            {
                intensity = CalculateIntensity(image, exec);
            }
            return intensity.value();
        }

         */
        [[nodiscard]] std::shared_ptr<Image> DrawMinutiae(const std::vector<std::shared_ptr<Minutia>>& minutiae,
                                                          const ImageShapeAttributes& attr) const
        {
            return image->DrawShape(MinutiaeShape(minutiae, attr));
        }

         */
        [[nodiscard]] std::shared_ptr<Image> DrawCriticalPoints(
          const std::vector<std::shared_ptr<CriticalPoint>>& points,
          const ImageShapeAttributes& attr) const
        {
            return image->DrawShape(CriticalPointsShape(points, attr));
        }

         */
        void WriteTo(Writer& writer) const final
        {
            writer.Write("i", image);
            writer.Write("p", static_cast<unsigned int>(position));
            writer.Write("a", printAttributes);
 
            const std::scoped_lock lock(presenceMux, nfiq1Mux, nfiq2Mux, imageQualityMux, placementMux, intensityMux);
 
            if (presence.has_value())
            {
                writer.Write("pr", presence.value());
            }
            if (nfiq1.has_value())
            {
                writer.Write("n1", nfiq1.value());
            }
            if (nfiq2.has_value())
            {
                writer.Write("n2", nfiq2.value());
            }
            if (imageQuality.has_value())
            {
                writer.Write("iq", imageQuality.value());
            }
            if (placement.has_value())
            {
                writer.Write("pl", placement.value());
            }
            if (intensity.has_value())
            {
                writer.Write("in", intensity.value());
            }
        }

         */
        bool IsSameAs(const Print& print) const
        {
            return this == &print;
        }

         */
        bool operator==(const Print& f) const
        {
            if (this == &f)
            {
                return true;
            }
 
            return *image == *f.image && position == f.position && printAttributes == f.printAttributes;
        }

         */
        bool operator!=(const Print& f) const
        {
            return !(*this == f);
        }
 
        Print(const Print&) = delete;
        Print(Print&&) = delete;
        Print& operator=(const Print&) = delete;
        Print& operator=(Print&&) = delete;
        virtual ~Print() = default;
        Print() = delete;

         */
        static std::shared_ptr<Print> Create(std::shared_ptr<Image> img,
                                             const PrintPosition& position,
                                             const PrintAttributes& pa = PrintAttributes(),
                                             std::shared_ptr<PrintExecutor> executor = GlobalPrintExecutor::Get())
        {
            return std::shared_ptr<Print>(new Print(std::move(img), position, pa, std::move(executor)));
        }
 
    private:
        std::shared_ptr<PrintExecutor> exec;
        FormattingLogger log;
        mutable std::mutex presenceMux;
        mutable std::mutex nfiq1Mux;
        mutable std::mutex nfiq2Mux;
        mutable std::mutex imageQualityMux;
        mutable std::mutex placementMux;
        mutable std::mutex intensityMux;
 
        std::optional<uint8_t> presence;
        std::optional<uint8_t> nfiq1;
        std::optional<uint8_t> nfiq2;
        std::optional<uint8_t> imageQuality;
        std::optional<uint8_t> placement;
        std::optional<uint8_t> intensity;
 
        Print(std::shared_ptr<Image> img,
              const PrintPosition& pos,
              PrintAttributes pa,
              std::shared_ptr<PrintExecutor> executor)
          : image(std::move(img))
          , position(pos)
          , printAttributes(std::move(pa))
          , exec(std::move(executor))
          , log(GlobalLogger::Get())
        {
            if (exec == nullptr)
            {
                throw NullArgumentException("Could not create Print due to executor can not be null");
            }
 
            if (image == nullptr)
            {
                throw NullArgumentException("Could not create Print due to image can not be null");
            }
        }
 
        class IsoImage
        {
        public:
            explicit IsoImage(const Print& p)
              : print(p)
            {
            }
            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)
            {
                static constexpr size_t GeneralHeaderLength = 16UL;
                static constexpr size_t RepresentationHeaderLength = 41UL;
                static constexpr size_t CertificationBlockSize = 1UL;
                const size_t representationHeaderLength =
                  RepresentationHeaderLength +
                  (print.printAttributes.GetCertificationFlag() ? CertificationBlockSize : 0UL);
                static constexpr size_t RepresentationBodyExtraDataLength = 0;
 
                // Length of encoded image.
                auto imageLength = encodedImage.size();
 
                // Representation length including the representation header length.
                auto representationLength =
                  representationHeaderLength + imageLength + RepresentationBodyExtraDataLength;
 
                // 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:
            size_t writeIndex = 0;
 
            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);
                FillNumberOfFingerPalmRepresentations(isoImage);
                FillCertificationFlag(isoImage);
                FillNumberOfDistinctFingerPalmPositions(isoImage);
            }

            void FillFormatIdentifier(std::vector<uint8_t>& isoImage)
            {
                // Mandatory fields.
                isoImage[writeIndex++] = 'F';
                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 >> ThreeBytesBitsCount) & ByteMask);
                isoImage[writeIndex++] = static_cast<uint8_t>((recordLength >> OneByteBitsCount) & ByteMask);
                isoImage[writeIndex++] = static_cast<uint8_t>(recordLength & ByteMask);
            }

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

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

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

            void FillRepresentationHeader(std::vector<uint8_t>& isoImage,
                                          size_t representationLength,
                                          size_t imageLength)
            {
                FillRepresentationLength(isoImage, representationLength);
                FillCaptureDateTime(isoImage);
                FillCaptureDeviceTechnologyIdentifier(isoImage);
                FillCaptureDeviceVendorIdentifier(isoImage);
                FillCaptureDeviceTypeIdentifier(isoImage);
                FillNumberOfQualityBlocks(isoImage);
                FillCaptureDeviceCertifications(isoImage);
                FillFingerPalmPosition(isoImage);
                FillRepresentationNumber(isoImage);
                FillScaleUnits(isoImage);
                FillCaptureDeviceSpatialHorizontalSamplingRate(isoImage);
                FillCaptureDeviceSpatialVerticalSamplingRate(isoImage);
                FillImageSpatialHorizontalSamplingRate(isoImage);
                FillImageSpatialVerticalSamplingRate(isoImage);
                FillBitDepth(isoImage);
                FillImageCompressionAlgorithm(isoImage);
                FillImpressionType(isoImage);
                FillHorizontalLineLength(isoImage);
                FillVerticalLineLength(isoImage);
                FillImageDataLength(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 >> ThreeBytesBitsCount) & 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 PrintCaptureDeviceTechnology technology = print.printAttributes.GetCaptureDeviceTechnology();
                isoImage[writeIndex++] =
                  static_cast<uint8_t>(PrintToIsoCaptureDeviceTechnology(technology)); // Mandatory field.
            }

            void FillCaptureDeviceVendorIdentifier(std::vector<uint8_t>& isoImage)
            {
                // Mandatory fields.
                const PrintCaptureDeviceVendorID vendor = print.printAttributes.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 PrintCaptureDeviceTypeID type = print.printAttributes.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; // Mandatory field.
            }

            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 FillCaptureDeviceCertifications(std::vector<uint8_t>& isoImage)
            {
                FillNumberOfCertificationBlocks(isoImage);
            }

            void FillNumberOfCertificationBlocks(std::vector<uint8_t>& isoImage)
            {
                // we are not storing any certification block
                if (print.printAttributes.GetCertificationFlag())
                {
                    isoImage[writeIndex++] = 0x00;
                }
            }

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

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

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

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

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

            void FillCaptureDeviceSpatialHorizontalSamplingRate(std::vector<uint8_t>& isoImage)
            {
                // Mandatory fields.
                isoImage[writeIndex++] =
                  static_cast<uint8_t>(static_cast<unsigned int>(print.image->Dpi()) >> OneByteBitsCount);
                isoImage[writeIndex++] = static_cast<uint8_t>(static_cast<unsigned int>(print.image->Dpi()) & ByteMask);
            }

            void FillCaptureDeviceSpatialVerticalSamplingRate(std::vector<uint8_t>& isoImage)
            {
                // Mandatory fields.
                isoImage[writeIndex++] =
                  static_cast<uint8_t>(static_cast<unsigned int>(print.image->Dpi()) >> OneByteBitsCount);
                isoImage[writeIndex++] = static_cast<uint8_t>(static_cast<unsigned int>(print.image->Dpi()) & ByteMask);
            }

            void FillImageSpatialHorizontalSamplingRate(std::vector<uint8_t>& isoImage)
            {
                // Mandatory fields.
                isoImage[writeIndex++] =
                  static_cast<uint8_t>(static_cast<unsigned int>(print.image->Dpi()) >> OneByteBitsCount);
                isoImage[writeIndex++] = static_cast<uint8_t>(static_cast<unsigned int>(print.image->Dpi()) & ByteMask);
            }

            void FillImageSpatialVerticalSamplingRate(std::vector<uint8_t>& isoImage)
            {
                // Mandatory fields.
                isoImage[writeIndex++] =
                  static_cast<uint8_t>(static_cast<unsigned int>(print.image->Dpi()) >> OneByteBitsCount);
                isoImage[writeIndex++] = static_cast<uint8_t>(static_cast<unsigned int>(print.image->Dpi()) & ByteMask);
            }

            void FillBitDepth(std::vector<uint8_t>& isoImage)
            {
                static constexpr uint8_t BitsPerPixel = 8;
                isoImage[writeIndex++] = BitsPerPixel; // Mandatory field.
            }

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

            void FillImpressionType(std::vector<uint8_t>& isoImage)
            {
                isoImage[writeIndex++] =
                  static_cast<uint8_t>(PrintToIsoImpression(print.printAttributes.GetImpression())); // Mandatory field.
            }

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

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

            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 >> ThreeBytesBitsCount) & 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);
                FillExtendedDataBlocks(isoImage);
            }

            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();
            }

            void FillExtendedDataBlocks(std::vector<uint8_t>& /* isoImage */)
            {
                // no extended data are stored
            }

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

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

            void FillDataSection(std::vector<uint8_t>& isoImage)
            {
                isoImage[writeIndex++] = 0x00; // Optional field.
            }
 
            const Print& print;
            static constexpr uint8_t RawCompressionType = 0;
            uint8_t compressionType = RawCompressionType;
            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 = print.image->EncodeIn(encoder);
 
                return isoImage.FillIsoImage(encodedImage);
            }
 
            void Visit(const WsqImageEncoder& /* encoder */) final
            {
                // According to table of compression algorithm codes, WSQ has compression code 2.
                static constexpr uint8_t WsqCompression = 2;
                isoImage.SetCompressionType(WsqCompression);
            }
 
            void Visit(const JpgImageEncoder& /* encoder */) final
            {
                // According to table of compression algorithm codes, JPEG has compression code 3.
                static constexpr uint8_t JpgCompression = 3;
                isoImage.SetCompressionType(JpgCompression);
            }
 
            void Visit(const Jp2ImageEncoder& jp2Encoder) final
            {
                if (jp2Encoder.IsLossy())
                {
                    // According to table of compression algorithm codes, JPEG 2000 lossy has compression code 4.
                    static constexpr uint8_t Jp2Lossy = 4;
                    isoImage.SetCompressionType(Jp2Lossy);
                }
                else
                {
                    // According to table of compression algorithm codes, JPEG 2000 lossless has compression code 5.
                    static constexpr uint8_t Jp2Lossless = 5;
                    isoImage.SetCompressionType(Jp2Lossless);
                }
            }
 
            void Visit(const PngImageEncoder& /* encoder */) final
            {
                // According to table of compression algorithm codes, PNG has compression code 6.
                static constexpr uint8_t PngCompression = 6;
                isoImage.SetCompressionType(PngCompression);
            }
 
            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 Print& p, ImageEncoder& e)
              : print(p)
              , encoder(e)
              , isoImage(IsoImage(p))
            {
            }
            IsoImageEncoder() = delete;
            virtual ~IsoImageEncoder() = default;
            IsoImageEncoder(const IsoImageEncoder&) = delete;
            IsoImageEncoder(IsoImageEncoder&&) = delete;
            IsoImageEncoder& operator=(const IsoImageEncoder&) = delete;
            IsoImageEncoder& operator=(IsoImageEncoder&&) = delete;
 
        private:
            const Print& print;
            ImageEncoder& encoder;
            IsoImage isoImage;
        };
    };
 
} // namespace inno
// NOLINTEND(cppcoreguidelines-non-private-member-variables-in-classes,misc-non-private-member-variables-in-classes,cppcoreguidelines-avoid-const-or-ref-data-members)