ICSTemplate.h

Go to the documentation of this file.

 
#pragma once
 
#include "enrollment/Exception/CallbackError.h"
#include "enrollment/Export.h"
#include "enrollment/Logger/FormattingLogger.h"
#include "enrollment/Print/ANSITemplate.h"
#include "enrollment/Print/CriticalPoint.h"
#include "enrollment/Print/ICSMatcher.h"
#include "enrollment/Print/ISOTemplate.h"
#include "enrollment/Print/Minutia.h"
#include "enrollment/Print/Print.h"
#include "enrollment/Print/PrintExecutor.h"
#include "enrollment/Serialization/Writer.h"
#include <array>
#include <mutex>
#include <optional>
#include <string>
#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 ICSTemplate : public Serializable
    {
    public:
        const std::vector<uint8_t> icsTemplateData;

         */
        [[nodiscard]] bool IsICSTemplateBiometricPositionKnown() const
        {
            return pos.has_value();
        }

         */
        [[nodiscard]] PrintPosition GetICSTemplateBiometricPosition() const
        {
            if (!pos.has_value())
            {
                throw EnrollmentRuntimeException("ICSTemplate has unknown biometric position");
            }
 
            return pos.value();
        }

         */
        [[nodiscard]] std::string GetVersion() const
        {
            unsigned int majorVersion = 0;
            unsigned int minorVersion = 0;
 
            exec->GetICSTemplateVersion(icsTemplateData.data(),
                                        static_cast<uint32_t>(icsTemplateData.size()),
                                        &majorVersion,
                                        &minorVersion,
                                        ThrowOnError{});
 
            return std::to_string(majorVersion) + "." + std::to_string(minorVersion);
        }

         */
        [[nodiscard]] std::shared_ptr<ICSTemplate> Anonymize() const
        {
            return std::make_shared<ICSTemplate>(SetPosition(icsTemplateData, 0, exec));
        }

         */
        explicit ICSTemplate(std::vector<uint8_t> d)
          : ICSTemplate(std::move(d), GlobalPrintExecutor::Get())
        {
        }

         */
        ICSTemplate(std::vector<uint8_t> d, std::shared_ptr<PrintExecutor> executor)
          : icsTemplateData(std::move(d))
          , exec(std::move(executor))
        {
            if (exec == nullptr)
            {
                throw NullArgumentException("executor can not be null");
            }
            if (icsTemplateData.empty())
            {
                throw InvalidTemplateException("ICSTemplate MUST have data");
            }
 
            int positionFromData = 0;
            exec->GetICSTemplatePosition(
              &positionFromData, icsTemplateData.data(), static_cast<uint32_t>(icsTemplateData.size()), ThrowOnError{});
            if (positionFromData != 0)
            {
                pos = IsoToPrintPosition(positionFromData);
            }
        }

         */
        explicit ICSTemplate(std::vector<uint8_t> d, PrintPosition position)
          : ICSTemplate(std::move(d), position, GlobalPrintExecutor::Get())
        {
        }

         */
        ICSTemplate(std::vector<uint8_t> d, PrintPosition position, std::shared_ptr<PrintExecutor> executor)
          : icsTemplateData(SetPosition(std::move(d), PrintToIsoPosition(position), executor))
          , exec(std::move(executor))
          , pos(position)
        {
        }

         */
        PrintSimilarityScore SimilarWith(const ICSTemplate& tmpl, const ICSMatcher& matcher) const
        {
            return matcher.Match(*this, tmpl);
        }

         */
        uint8_t CalculateQuality()
        {
            const std::scoped_lock lock(guard);
 
            if (!templateQuality.has_value())
            {
                uint8_t localQuality = 0;
                exec->GetICSTemplateQuality(
                  icsTemplateData.data(), static_cast<uint32_t>(icsTemplateData.size()), &localQuality, ThrowOnError{});
                templateQuality = localQuality;
            }
            return templateQuality.value();
        }

         */
        std::shared_ptr<ISOTemplate> ToISO(const std::shared_ptr<const Print>& print) const
        {
            size_t isoLength = 0;
            std::vector<uint8_t> iso(exec->GetMaxISOTemplateSize());
 
            exec->ConvertICSToISO(
              icsTemplateData.data(),
              icsTemplateData.size(),
              static_cast<unsigned int>(print->printAttributes.GetCaptureDeviceVendorID()),
              print->printAttributes.GetCertificationFlag(),
              print->image->Dpi().ToDPCM(),
              print->image->Width(),
              print->image->Height(),
              static_cast<unsigned int>(PrintToIsoPosition(print->position)),
              static_cast<unsigned int>(PrintToIsoImpression(print->printAttributes.GetImpression())),
              iso.data(),
              &isoLength,
              ThrowOnError{});
 
            iso.resize(isoLength);
            return std::make_shared<ISOTemplate>(std::move(iso));
        }

         */
        std::shared_ptr<ANSITemplate> ToANSI(const std::shared_ptr<const Print>& print) const
        {
            size_t ansiLength = 0;
            std::vector<uint8_t> ansi(exec->GetMaxANSITemplateSize());
 
            exec->ConvertICSToANSI(
              icsTemplateData.data(),
              icsTemplateData.size(),
              static_cast<unsigned int>(print->printAttributes.GetCaptureDeviceVendorID()),
              print->printAttributes.GetCertificationFlag(),
              print->image->Dpi().ToDPCM(),
              print->image->Width(),
              print->image->Height(),
              static_cast<unsigned int>(PrintToIsoPosition(print->position)),
              static_cast<unsigned int>(PrintToIsoImpression(print->printAttributes.GetImpression())),
              ansi.data(),
              &ansiLength,
              ThrowOnError{});
 
            ansi.resize(ansiLength);
            return std::make_shared<ANSITemplate>(std::move(ansi));
        }

         */
        std::vector<std::shared_ptr<Minutia>> GetMinutiae() const
        {
            size_t minutiaeCount = 0;
            inno_Minutia_out* m = nullptr;
 
            exec->GetMinutiae(GlobalLogger::Get(),
                              icsTemplateData.data(),
                              static_cast<unsigned int>(icsTemplateData.size()),
                              &m,
                              &minutiaeCount,
                              ThrowOnError{});
 
            std::vector<std::shared_ptr<Minutia>> minutiae;
            for (size_t i = 0; i < minutiaeCount; i++)
            {
                static constexpr float MaxDegree = 360.0F;
                static constexpr float MaxValuesInByte = 256.0F;
                static constexpr float AngleUnit = MaxDegree / MaxValuesInByte;
                minutiae.emplace_back(std::make_shared<Minutia>(
                  Point{ m[i].x, m[i].y },                    // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)
                  static_cast<Minutia::Type>(m[i].type),      // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)
                  AngleUnit * static_cast<float>(m[i].angle), // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)
                  m[i].quality));                             // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)
            };
 
            exec->FreeMinutiae(m);
 
            return minutiae;
        }

         */
        std::vector<std::shared_ptr<CriticalPoint>> GetCriticalPoints() const
        {
            size_t criticalPointsCount = 0;
            inno_CriticalPoint_out* p = nullptr;
 
            std::vector<inno_CriticalPoint_out> criticalPoints;
            auto criticalPointAllocator = +[](void* container, size_t length) -> inno_CriticalPoint_out*
            {
                // It is "safe" cast because we forward pointer to vector created in "user cpp space"
                // (the space where this header is compiled) and the "own cpp space" (out compiled shared library)
                // wil provide it back for us to the same "user cpp space". We have all spaces under control.
                // It is used to do not have unecessary copy data from "own cpp space" into "user cpp space".
                std::vector<inno_CriticalPoint_out>& vec =
                  *static_cast<std::vector<inno_CriticalPoint_out>*>(container);
                vec.resize(length);
                return vec.data();
            };
 
            exec->GetCriticalPoints(GlobalLogger::Get(),
                                    icsTemplateData.data(),
                                    static_cast<unsigned int>(icsTemplateData.size()),
                                    &p,
                                    &criticalPointsCount,
                                    criticalPointAllocator,
                                    &criticalPoints,
                                    ThrowOnError{});
 
            std::vector<std::shared_ptr<CriticalPoint>> points;
            for (size_t i = 0; i < criticalPointsCount; i++)
            {
                static constexpr float MaxDegree = 360.0F;
                static constexpr float MaxValuesInByte = 256.0F;
                static constexpr float AngleUnit = MaxDegree / MaxValuesInByte;
                points.emplace_back(std::make_shared<CriticalPoint>(
                  Point{ p[i].x, p[i].y }, // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)
                  static_cast<CriticalPoint::Type>(
                    p[i].type),                               // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)
                  AngleUnit * static_cast<float>(p[i].angle)) // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)
                );
            };
            return points;
        }
 
        void WriteTo(Writer& w) const override
        {
            w.WriteArray("d", icsTemplateData);
 
            const std::scoped_lock lock(guard);
 
            if (templateQuality.has_value())
            {
                w.Write("q", templateQuality.value());
            }
        }
 
        ICSTemplate(const ICSTemplate&) = delete;
        ICSTemplate(ICSTemplate&&) = delete;
        ICSTemplate& operator=(const ICSTemplate&) = delete;
        ICSTemplate& operator=(ICSTemplate&&) = delete;
        ICSTemplate() = delete;
        virtual ~ICSTemplate() = default;
 
    private:
        std::shared_ptr<PrintExecutor> exec;
        mutable std::mutex guard;
        std::optional<uint8_t> templateQuality;
        std::optional<PrintPosition> pos;
 
        // IEngine does not support position change in template, we have to create new template
        static std::vector<uint8_t> SetPosition(std::vector<uint8_t> icsTemplateData,
                                                int position,
                                                const std::shared_ptr<PrintExecutor>& executor)
        {
            if (executor == nullptr)
            {
                throw NullArgumentException("executor can not be null");
            }
            if (icsTemplateData.empty())
            {
                throw InvalidTemplateException("ICSTemplate MUST have data");
            }
            executor->SetICSTemplatePosition(
              position, icsTemplateData.data(), static_cast<uint32_t>(icsTemplateData.size()), ThrowOnError{});
            return icsTemplateData;
        }
    };
} // namespace inno
// NOLINTEND(cppcoreguidelines-non-private-member-variables-in-classes,misc-non-private-member-variables-in-classes,cppcoreguidelines-avoid-const-or-ref-data-members)