PrintSegment.h

Go to the documentation of this file.

 
#pragma once
 
#include "enrollment/Print/Print.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/Serialization/Writer.h"
#include <memory>
#include <mutex>
#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 PrintCropConfiguration
    {
    public:
         */
        void SetImageDimensions(ImageWidth width, ImageHeight height)
        {
            if (width == 0)
            {
                throw EnrollmentInvalidArgumentException("Width can not be 0");
            }
            if (height == 0)
            {
                throw EnrollmentInvalidArgumentException("Height can not be 0");
            }
 
            w = width;
            h = height;
        }
         */
        [[nodiscard]] ImageWidth GetImageWidth() const
        {
            return w;
        }
         */
        [[nodiscard]] ImageHeight GetImageHeight() const
        {
            return h;
        }
 
        [[nodiscard]] ImageDimensions GetImageDimensions() const
        {
            return { w, h };
        }

         */
        void SetBackgroundColor(RGBA color)
        {
            backgroundColor = std::move(color);
        }
         */
        [[nodiscard]] RGBA GetBackgroundColor() const
        {
            return backgroundColor;
        }

         */
        void EnableAlignedCropping(bool aligned)
        {
            alignedCrop = aligned;
        }

         */
        [[nodiscard]] bool IsAlignedCroppingEnabled() const
        {
            return alignedCrop;
        }

        PrintCropConfiguration() = default;
        virtual ~PrintCropConfiguration() = default;
        PrintCropConfiguration(const PrintCropConfiguration&) = delete;
        PrintCropConfiguration(PrintCropConfiguration&&) = delete;
        PrintCropConfiguration& operator=(const PrintCropConfiguration&) = delete;
        PrintCropConfiguration& operator=(PrintCropConfiguration&&) = delete;
 
    private:
        ImageWidth w = 0;
        ImageHeight h = 0;
        RGBA backgroundColor = Colors::White;
        bool alignedCrop = true;
    };
 
    // Internal interface to overcome cyclic includes between this header and PrintCapture.
    class CropablePrint : public Serializable
    {
    public:
        [[nodiscard]] virtual std::shared_ptr<Image> CropPrint(const Rectangle& rectangle,
                                                               const PrintCropConfiguration& cropCfg) const = 0;
 
        CropablePrint() = default;
        virtual ~CropablePrint() = default;
        CropablePrint(const CropablePrint&) = delete;
        CropablePrint(CropablePrint&&) = delete;
        CropablePrint& operator=(const CropablePrint&) = delete;
        CropablePrint& operator=(CropablePrint&&) = delete;
    };

     */
    class PrintSegment final : public Serializable
    {
    public:
        const Rectangle roundingBox;
        // Provides angle of prints 0-360 in degrees.
        const int angle;

         */
        bool HasPosition() const
        {
            const std::scoped_lock lock(posMutex);
            return pos.has_value();
        }

         */
        void SetPosition(const PrintPosition& position)
        {
            const std::scoped_lock lock(posMutex);
            pos = position;
        }
         */
        PrintPosition GetPosition()
        {
            const std::scoped_lock lock(posMutex);
 
            if (!pos.has_value())
            {
                throw EnrollmentRuntimeException("No print position");
            }
 
            return pos.value();
        }

         */
        std::shared_ptr<PrintSegment> Resize(Rectangle::Width newWidth, Rectangle::Height newHeight) const
        {
            auto newRect = roundingBox.Resize(newWidth, newHeight);
            return std::make_shared<PrintSegment>(imagePrint, attr, newRect, angle, ConvertPosition(), exec);
        }

         */
        std::shared_ptr<Print> ToPrint()
        {
            static const PrintCropConfiguration DefaultCropCfg;
            return ToPrint(DefaultCropCfg);
        }

         */
        std::shared_ptr<Print> ToPrint(const PrintCropConfiguration& cfg)
        {
            const std::scoped_lock lock(posMutex);
 
            if (not pos.has_value())
            {
                throw EnrollmentRuntimeException("Not possible to create print from PrintSegment without position");
            }
 
            return Print::Create(imagePrint->CropPrint(roundingBox, cfg), pos.value(), attr, exec);
        }

         */
        void WriteTo(Writer& writer) const final
        {
            writer.Write("rb", roundingBox);
            writer.Write("a", angle);
            writer.Write("t", attr);
 
            const std::scoped_lock lock(posMutex);
 
            if (pos.has_value())
            {
                writer.Write("p", static_cast<unsigned int>(pos.value()));
            }
        }
 
        PrintSegment() = delete;
        virtual ~PrintSegment() = default;
        PrintSegment(const PrintSegment& s)
          : roundingBox(s.roundingBox)
          , angle(s.angle)
          , imagePrint(s.imagePrint)
          , exec(s.exec)
          , pos(s.pos)
          , attr(s.attr)
        {
        }
        PrintSegment(PrintSegment&&) = delete;
        PrintSegment(std::shared_ptr<CropablePrint> pc,
                     PrintAttributes pa,
                     Rectangle r,
                     int a,
                     int position,
                     std::shared_ptr<PrintExecutor> executor)
          : roundingBox(std::move(r))
          , angle(a)
          , imagePrint(std::move(pc))
          , exec(std::move(executor))
          , attr(std::move(pa))
        {
            // When segmentation algorithm deduce position then assign it
            if (position > 0)
            {
                pos = static_cast<PrintPosition>(position);
            }
        }
        PrintSegment& operator=(const PrintSegment&) = delete;
        PrintSegment& operator=(PrintSegment&&) = delete;
 
    private:
        std::shared_ptr<CropablePrint> imagePrint;
        std::shared_ptr<PrintExecutor> exec;
        std::optional<PrintPosition> pos;
        mutable std::mutex posMutex;
        PrintAttributes attr;
 
        int ConvertPosition() const
        {
            const std::scoped_lock lock(posMutex);
            if (pos.has_value())
            {
                return static_cast<int>(pos.value());
            }
 
            return 0;
        }
    };
} // namespace inno
// NOLINTEND(cppcoreguidelines-non-private-member-variables-in-classes,misc-non-private-member-variables-in-classes,cppcoreguidelines-avoid-const-or-ref-data-members)