slapsegiii.h

 
#ifndef SLAPSEGIII_H_
#define SLAPSEGIII_H_
 
#include <cstddef>
#include <filesystem>
#include <memory>
#include <set>
#include <string>
#include <vector>
 
namespace SlapSegIII
{
        enum class FrictionRidgeGeneralizedPosition
        {
                Unknown = 0,
                RightThumb = 1,
                RightIndex = 2,
                RightMiddle = 3,
                RightRing = 4,
                RightLittle = 5,
                LeftThumb = 6,
                LeftIndex = 7,
                LeftMiddle = 8,
                LeftRing = 9,
                LeftLittle = 10
        };
 
        struct Coordinate
        {
                Coordinate(
                    const int32_t x = 0,
                    const int32_t y = 0)
                    noexcept;
 
                int32_t x{};
                int32_t y{};
        };
 
        struct SlapImage
        {
                enum class Kind
                {
                        TwoInch = 2,
                        ThreeInch = 3,
                        UpperPalm = 5,
                        FullPalm = 8
                };
 
                enum class CaptureTechnology
                {
                        Unknown = 0,
                        ScannedInkOnPaper = 2,
                        OpticalTIRBright = 3
                };
 
                enum class Orientation
                {
                        Right = 0,
                        Left = 1,
                        Thumbs = 2
                };
 
                enum class Deficiency
                {
                        Artifacts = 0,
                        ImageQuality,
                        HandGeometry,
                        Incomplete
                };
 
                SlapImage();
 
                SlapImage(
                    const uint16_t width,
                    const uint16_t height,
                    const uint16_t ppi,
                    const Kind kind,
                    const CaptureTechnology captureTechnology,
                    const Orientation orientation,
                    const std::vector<std::byte> &pixels);
 
                uint16_t width{};
                uint16_t height{};
                uint16_t ppi{};
                Kind kind{};
                CaptureTechnology captureTechnology{};
                Orientation orientation{};
                std::vector<std::byte> pixels{};
        };
 
        struct SegmentationPosition
        {
                struct Result
                {
                        enum class Code
                        {
                                Success = 0,
                                FingerNotFound,
                                FailedToSegment,
                                VendorDefined
                        };
 
                        Result(
                            const Code code = Code::Success,
                            const std::string &message = "");
 
                        Code code{};
                        std::string message{};
                };
 
                SegmentationPosition();
 
                SegmentationPosition(
                    const FrictionRidgeGeneralizedPosition frgp,
                    const Coordinate &tl,
                    const Coordinate &tr,
                    const Coordinate &bl,
                    const Coordinate &br,
                    const Result result = {});
 
                FrictionRidgeGeneralizedPosition frgp{};
                Coordinate tl{};
                Coordinate tr{};
                Coordinate bl{};
                Coordinate br{};
                Result result{};
        };
 
        struct ReturnStatus
        {
                enum class Code
                {
                        Success = 0,
                        InvalidImageData,
                        RequestRecapture,
                        RequestRecaptureWithAttempt,
                        UnsupportedResolution,
                        UnsupportedSlapType,
                        NotImplemented,
                        VendorDefined
                };
 
                ReturnStatus(
                    const Code code = Code::Success,
                    const std::set<SlapImage::Deficiency>
                    &imageDeficiencies = {},
                    const std::string &message = "");
 
                Code code{};
                std::set<SlapImage::Deficiency> imageDeficiencies{};
                std::string message{};
        };
 
        struct SubmissionIdentification
        {
                SubmissionIdentification();
 
                SubmissionIdentification(
                    const std::string &libraryIdentifier,
                    const uint16_t version,
                    const std::string &marketingIdentifier = "");
 
                uint16_t version{};
                std::string libraryIdentifier{};
                std::string marketingIdentifier{};
 
        };
 
        class Interface
        {
        public:
                virtual
                SubmissionIdentification
                getIdentification()
                    const = 0;
 
                virtual
                std::tuple<std::set<SlapImage::Kind>, bool>
                getSupported()
                    const = 0;
 
                virtual
                std::tuple<ReturnStatus, std::vector<SegmentationPosition>>
                segment(
                    const SlapImage &image) = 0;
 
                virtual
                std::tuple<ReturnStatus, SlapImage::Orientation>
                determineOrientation(
                    const SlapImage &image) = 0;
 
                virtual ~Interface();
 
                static
                std::shared_ptr<Interface>
                getImplementation(
                    const std::filesystem::path &configurationDirectory);
        };
 
        /*
         * API versioning.
         *
         * NIST code will extern the version number symbols. Participant code
         * shall compile them into their core library.
         */
        #ifdef NIST_EXTERN_API_VERSION
        extern uint16_t API_MAJOR_VERSION;
        extern uint16_t API_MINOR_VERSION;
        extern uint16_t API_PATCH_VERSION;
        #else /* NIST_EXTERN_API_VERSION */
        uint16_t API_MAJOR_VERSION{1};
        uint16_t API_MINOR_VERSION{2};
        uint16_t API_PATCH_VERSION{0};
        #endif /* NIST_EXTERN_API_VERSION */
 
        /*
         * Ensure that std::byte is exactly 8 bits, such that reinterpret_casts
         * may be safely used.
         */
        static_assert(std::is_same_v<std::underlying_type_t<std::byte>,
            uint8_t>, "std::byte not represented as unsigned 8 bit type");
}
 
#endif /* SLAPSEGIII_H_ */