PrintCapture.h

Go to the documentation of this file.

 
#pragma once
 
#include "enrollment/Export.h"
#include "enrollment/Image/Image.h"
#include "enrollment/Image/ImageAttribute.h"
#include "enrollment/Logger/Logger.h"
#include "enrollment/Print/HandPosition.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/PrintSegment.h"
#include "enrollment/Serialization/Writer.h"
#include <cmath>
#include <memory>
#include <mutex>
#include <vector>
// cppcoreguidelines-non-private-member-variables-in-classes,misc-non-private-member-variables-in-classes: This is
// not a problem because we are using them only as read only. cppcoreguidelines-avoid-const-or-ref-data-members: We
// design te API with const member variables instead of implementing getter methods. This is nicely transformed in
// C# to properties. Usually our objects are immutable by intention to have no problem in multithreaded
// applications.
// NOLINTBEGIN(cppcoreguidelines-non-private-member-variables-in-classes,misc-non-private-member-variables-in-classes,cppcoreguidelines-avoid-const-or-ref-data-members)
namespace inno
{
    class Logger;
    class PrintCapture;
 
    // Internal interface to overcome cyclic includes between this header and PrintDetector.
    // It is introduced to be possible to add convenient function PrintCapture::SegmentWith.
    class PrintCaptureSegmentation
    {
    public:
        virtual std::vector<std::shared_ptr<PrintSegment>> Segment(const std::shared_ptr<PrintCapture>& capture) = 0;
 
        PrintCaptureSegmentation() = default;
        virtual ~PrintCaptureSegmentation() = default;
        PrintCaptureSegmentation(const PrintCaptureSegmentation&) = delete;
        PrintCaptureSegmentation(PrintCaptureSegmentation&&) = delete;
        PrintCaptureSegmentation& operator=(const PrintCaptureSegmentation&) = delete;
        PrintCaptureSegmentation& operator=(PrintCaptureSegmentation&&) = delete;
    };

     */
    class PrintCapture
      : public CropablePrint
      , public std::enable_shared_from_this<PrintCapture>
    {
    public:
        const std::shared_ptr<Image> image;
        const PrintAttributes printAttributes;

         */
        static std::shared_ptr<PrintCapture> Create(
          std::shared_ptr<Image> img,
          const PrintAttributes& pa = PrintAttributes(),
          std::shared_ptr<PrintExecutor> executor = GlobalPrintExecutor::Get())
        {
            return std::shared_ptr<PrintCapture>(new PrintCapture(std::move(img), pa, std::move(executor)));
        }

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

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

         */
        virtual std::vector<std::shared_ptr<PrintSegment>> SegmentWith(PrintCaptureSegmentation& detector)
        {
            auto capture = shared_from_this();
            auto segments = detector.Segment(capture);
            DoModifySegments(segments);
            return segments;
        }

         */
        [[nodiscard]] std::shared_ptr<Image> CropPrint(const Rectangle& rectangle,
                                                       const PrintCropConfiguration& cfg) const final
        {
            if (cfg.IsAlignedCroppingEnabled())
            {
                return image->CropAlignedRectangle(rectangle, cfg.GetBackgroundColor(), cfg.GetImageDimensions());
            }
 
            return image->CropRectangle(rectangle, cfg.GetBackgroundColor(), cfg.GetImageDimensions());
        }

         */
        [[nodiscard]] std::shared_ptr<Image> CropPrint(const Rectangle& rectangle) const
        {
            static const PrintCropConfiguration DefaultCropCfg;
            return CropPrint(rectangle, DefaultCropCfg);
        }

         */
        std::shared_ptr<Image> Draw(const std::vector<std::shared_ptr<PrintSegment>>& segments,
                                    const ImageShapeAttributes& attr) const
        {
            const RoundingBoxesShape rbs(segments, attr);
            return image->DrawShape(rbs);
        }

         */
        void WriteTo(Writer& writer) const final
        {
            writer.Write("i", image);
            writer.Write("a", printAttributes);
            const std::scoped_lock lock(intensityMux);
            if (intensity.has_value())
            {
                writer.Write("in", intensity.value());
            }
            DoWriteTo(writer);
        }

         */
        uint8_t CalculateIntensity()
        {
            const std::scoped_lock lock(intensityMux);
            if (!intensity.has_value())
            {
                intensity = Print::CalculateIntensity(image, exec);
            }
            return intensity.value();
        }
 
        PrintCapture(const PrintCapture&) = delete;
        PrintCapture(PrintCapture&&) = delete;
        PrintCapture& operator=(const PrintCapture&) = delete;
        PrintCapture& operator=(PrintCapture&&) = delete;
        virtual ~PrintCapture() = default;
        PrintCapture() = delete;
 
    protected:
        explicit PrintCapture(std::shared_ptr<Image> i,
                              PrintAttributes pa = PrintAttributes(),
                              std::shared_ptr<PrintExecutor> executor = GlobalPrintExecutor::Get())
          : image(std::move(i))
          , printAttributes(std::move(pa))
          , exec(std::move(executor))
        {
            if (image == nullptr)
            {
                throw NullArgumentException("Image cannot be null when creating PrintCapture");
            }
        }
        virtual void DoWriteTo(Writer& /* writer */) const
        {
        }
 
        virtual void DoModifySegments(std::vector<std::shared_ptr<PrintSegment>>& segments)
        {
            ClearPositionInSegments(segments);
        }
 
        void ClearPositionInSegments(std::vector<std::shared_ptr<PrintSegment>>& segments)
        {
            for (auto& s : segments)
            {
                if (s->HasPosition())
                {
                    s = std::make_shared<PrintSegment>(
                      shared_from_this(), printAttributes, s->roundingBox, s->angle, 0, exec);
                }
            }
        }
 
    private:
        class RoundingBoxesShape final : public ImageShape
        {
        public:
            void DrawIn(ImageShapeDrawer& drawer) const final
            {
                for (const auto& s : segments)
                {
                    auto rs = RectangleShape(s->roundingBox, attr);
                    rs.DrawIn(drawer);
                }
            }
 
            RoundingBoxesShape(const std::vector<std::shared_ptr<PrintSegment>>& s, ImageShapeAttributes a)
              : segments(s)
              , attr(std::move(a))
            {
            }
            RoundingBoxesShape() = delete;
            virtual ~RoundingBoxesShape() = default;
            RoundingBoxesShape(const RoundingBoxesShape&) = delete;
            RoundingBoxesShape(RoundingBoxesShape&&) = delete;
            RoundingBoxesShape& operator=(const RoundingBoxesShape&) = delete;
            RoundingBoxesShape& operator=(RoundingBoxesShape&&) = delete;
 
        private:
            const std::vector<std::shared_ptr<PrintSegment>>& segments;
            ImageShapeAttributes attr;
        };
 
        std::shared_ptr<PrintExecutor> exec;
        mutable std::mutex printMutex;
        mutable std::mutex intensityMux;
        std::vector<std::shared_ptr<Print>> prints;
        std::optional<uint8_t> intensity;
    };

     */
    class GuessedHandPosition
    {
    public:
         */
        [[nodiscard]] bool IsGuessSuccessful() const
        {
            return hand.has_value();
        }
         */
        [[nodiscard]] HandPosition GetHandPosition() const
        {
 
            if (!hand.has_value())
            {
                throw EnrollmentRuntimeException("Not possible to guess hand position");
            }
 
            return hand.value();
        }
 
        GuessedHandPosition() = default;
        explicit GuessedHandPosition(HandPosition handPosition)
          : hand(handPosition)
        {
        }
        virtual ~GuessedHandPosition() = default;
        GuessedHandPosition(const GuessedHandPosition&) = default;
        GuessedHandPosition(GuessedHandPosition&&) = default;
        GuessedHandPosition& operator=(const GuessedHandPosition&) = default;
        GuessedHandPosition& operator=(GuessedHandPosition&&) = default;
 
    private:
        std::optional<HandPosition> hand;
    };

     */
    class SlapCapture final : public PrintCapture
    {
    public:
        const HandPosition hand;

         */
        std::vector<std::shared_ptr<PrintSegment>> SegmentWith(PrintCaptureSegmentation& detector) final
        {
            return PrintCapture::SegmentWith(detector);
        }

         */
        static std::shared_ptr<SlapCapture> Create(std::shared_ptr<Image> img,
                                                   const HandPosition& hand,
                                                   const PrintAttributes& pa = PrintAttributes(),
                                                   std::shared_ptr<PrintExecutor> executor = GlobalPrintExecutor::Get())
        {
            return std::shared_ptr<SlapCapture>(new SlapCapture(std::move(img), hand, pa, std::move(executor)));
        }
 
        static GuessedHandPosition GuessHandPosition(const std::vector<std::shared_ptr<PrintSegment>>& segments)
        {
            int rightHand = 0;
            int leftHand = 0;
 
            for (const auto& i : segments)
            {
                if (i->HasPosition())
                {
                    auto position = i->GetPosition();
 
                    if (position >= PrintPosition::RIGHT_THUMB && position <= PrintPosition::RIGHT_LITTLE)
                    {
                        rightHand++;
                    }
 
                    else if (position >= PrintPosition::LEFT_THUMB && position <= PrintPosition::LEFT_LITTLE)
                    {
                        leftHand++;
                    }
                }
            }
 
            if (rightHand == 0 && leftHand > 0)
            {
                return GuessedHandPosition{ HandPosition::LEFT };
            }
            if (rightHand > 0 && leftHand == 0)
            {
                return GuessedHandPosition{ HandPosition::RIGHT };
            }
            return GuessedHandPosition{};
        }

         */
        static int CalculateGlobalAngle(const std::vector<std::shared_ptr<inno::PrintSegment>>& segments)
        {
            if (segments.empty())
            {
                throw EnrollmentInvalidArgumentException(
                  "Not possible to calculate global angle, no segments are given");
            }
 
            double sumSines = 0.0;
            double sumCosines = 0.0;
            constexpr int StraightAngle = 180;
            constexpr int CompleteAngle = 360;
            // The clang-tidy suggest to use 'std::numbers::pi'. Due to compilation issues with our dependency
            // Boost 1.73 in Android NDK r26d (first version that contains 'number' header), we're unable to utilize the
            // suggested change. NOLINTNEXTLINE(modernize-use-std-numbers)
            constexpr double MathPI = 3.14159265358979323846;
 
            for (const auto& segment : segments)
            {
                // Convert angle in degrees to radians.
                const double radians = segment->angle * MathPI / StraightAngle;
 
                // Add the sine and cosine components.
                sumSines += sin(radians);
                sumCosines += cos(radians);
            }
 
            // Calculate the average angle in radians
            const double averageRadians = atan2(sumSines, sumCosines);
 
            // Convert the average back to degrees
            double averageDegrees = averageRadians * StraightAngle / MathPI;
 
            if (averageDegrees < 0)
            {
                averageDegrees = CompleteAngle + averageDegrees;
            }
 
            return static_cast<int>(averageDegrees);
        }
 
        SlapCapture(const SlapCapture&) = delete;
        SlapCapture(SlapCapture&&) = delete;
        SlapCapture& operator=(const SlapCapture&) = delete;
        SlapCapture& operator=(SlapCapture&&) = delete;
        virtual ~SlapCapture() = default;
        SlapCapture() = delete;
 
    private:
        SlapCapture(std::shared_ptr<Image> img,
                    HandPosition h,
                    const PrintAttributes& pa = PrintAttributes(),
                    std::shared_ptr<PrintExecutor> executor = GlobalPrintExecutor::Get())
          : PrintCapture(std::move(img), pa, std::move(executor))
          , hand(h)
        {
        }
 
        void DoWriteTo(Writer& writer) const final
        {
            writer.Write("h", static_cast<unsigned int>(hand));
        }
 
        void DoModifySegments(std::vector<std::shared_ptr<PrintSegment>>& /*segments*/) final
        {
            // nothing to modify
        }
    };

     */
    class ThumbsCapture final : public PrintCapture
    {
    public:
         */
        std::vector<std::shared_ptr<PrintSegment>> SegmentWith(PrintCaptureSegmentation& detector) final
        {
            return PrintCapture::SegmentWith(detector);
        }

         */
        static std::shared_ptr<ThumbsCapture> Create(
          std::shared_ptr<Image> img,
          const PrintAttributes& pa = PrintAttributes(),
          std::shared_ptr<PrintExecutor> executor = GlobalPrintExecutor::Get())
        {
            return std::shared_ptr<ThumbsCapture>(new ThumbsCapture(std::move(img), pa, std::move(executor)));
        }
 
        ThumbsCapture(const ThumbsCapture&) = delete;
        ThumbsCapture(ThumbsCapture&&) = delete;
        ThumbsCapture& operator=(const ThumbsCapture&) = delete;
        ThumbsCapture& operator=(ThumbsCapture&&) = delete;
        virtual ~ThumbsCapture() = default;
        ThumbsCapture() = delete;
 
    private:
        ThumbsCapture(std::shared_ptr<Image> img,
                      const PrintAttributes& pa,
                      std::shared_ptr<PrintExecutor> executor = GlobalPrintExecutor::Get())
          : PrintCapture(std::move(img), pa, std::move(executor))
        {
        }
 
        void DoWriteTo(Writer& /*writer*/) const final
        {
            // nothing more to serialize
        }
 
        void DoModifySegments(std::vector<std::shared_ptr<PrintSegment>>& segments) final
        {
            if (segments.size() == 2)
            {
                segments[0]->SetPosition(PrintPosition::LEFT_THUMB);
                segments[1]->SetPosition(PrintPosition::RIGHT_THUMB);
            }
            else
            {
                ClearPositionInSegments(segments);
            }
        }
    };
} // namespace inno
// NOLINTEND(cppcoreguidelines-non-private-member-variables-in-classes,misc-non-private-member-variables-in-classes,cppcoreguidelines-avoid-const-or-ref-data-members)