be_image_image.h

/*
 * This software was developed at the National Institute of Standards and
 * Technology (NIST) by employees of the Federal Government in the course
 * of their official duties. Pursuant to title 17 Section 105 of the
 * United States Code, this software is not subject to copyright protection
 * and is in the public domain. NIST assumes no responsibility whatsoever for
 * its use by other parties, and makes no guarantees, expressed or implied,
 * about its quality, reliability, or any other characteristic.
 */
 
#ifndef __BE_IMAGE_IMAGE_H__
#define __BE_IMAGE_IMAGE_H__
 
#include <cstdint>
#include <functional>
#include <stdexcept>
#include <memory>
 
#include <be_framework_status.h>
#include <be_io.h>
#include <be_image.h>
#include <be_memory_autoarray.h>
 
namespace BiometricEvaluation
{
        namespace Image
        {
                /* Forward declaration */
                class Raw;
 
                class Image {
                public:
                        using statusCallback_t = std::function<void(
                            const Framework::Status)>;
 
                        Image(
                            const uint8_t *data,
                            const uint64_t size,
                            const Size dimensions,
                            const uint32_t colorDepth,
                            const uint16_t bitDepth,
                            const Resolution resolution,
                            const CompressionAlgorithm compression,
                            const bool hasAlphaChannel,
                            const std::string &identifier = "",
                            const statusCallback_t &statusCallback =
                                Image::defaultStatusCallback);
 
                        Image(
                            const uint8_t *data,
                            const uint64_t size,
                            const CompressionAlgorithm compression,
                            const std::string &identifier = "",
                            const statusCallback_t &statusCallback =
                                Image::defaultStatusCallback);
 
                        CompressionAlgorithm
                        getCompressionAlgorithm()
                            const;
 
                        Resolution
                        getResolution()
                            const;
 
                        Memory::uint8Array
                        getData()
                            const;
 
                        virtual Memory::uint8Array
                        getRawData()
                            const = 0;
 
                        virtual Memory::uint8Array
                        getRawData(
                            const bool removeAlphaChannelIfPresent)
                            const;
 
                        virtual Memory::uint8Array
                        getRawGrayscaleData(
                            uint8_t depth)
                            const = 0;
 
                        Size
                        getDimensions()
                            const;
 
                        uint32_t
                        getColorDepth()
                            const;
 
                        uint16_t
                        getBitDepth()
                            const;
 
                        bool
                        hasAlphaChannel()
                            const
                        {
                                return (this->_hasAlphaChannel);
                        }
 
                        statusCallback_t
                        getStatusCallback()
                            const;
 
                        std::string
                        getIdentifier()
                            const;
 
                        virtual ~Image();
 
                        /*
                         * Buffer type conversions.
                         */
 
                        static uint64_t
                        valueInColorspace(
                            uint64_t color,
                            uint64_t maxColorValue,
                            uint8_t depth);
 
                        /*
                         * Static functions.
                         */
 
                        static std::shared_ptr<Image>
                        openImage(
                            const uint8_t *data,
                            const uint64_t size,
                            const std::string &identifier = "",
                            const statusCallback_t &statusCallback =
                                Image::defaultStatusCallback);
 
                        static std::shared_ptr<Image>
                        openImage(
                            const Memory::uint8Array &data,
                            const std::string &identifier = "",
                            const statusCallback_t &statusCallback =
                                Image::defaultStatusCallback);
 
                        static std::shared_ptr<Image>
                        openImage(
                            const std::string &path,
                            const statusCallback_t &statusCallback =
                                Image::defaultStatusCallback);
 
                        static CompressionAlgorithm
                        getCompressionAlgorithm(
                            const uint8_t *data,
                            const uint64_t size);
 
                        static CompressionAlgorithm
                        getCompressionAlgorithm(
                            const Memory::uint8Array &data);
 
                        static CompressionAlgorithm
                        getCompressionAlgorithm(
                            const std::string &path);
 
                        static BiometricEvaluation::Image::Raw
                        getRawImage(
                            const std::shared_ptr<BiometricEvaluation::Image::
                            Image> &image);
 
                        static void
                        defaultStatusCallback(
                            const Framework::Status &status);
 
                protected:
                        void
                        setResolution(
                            const Resolution resolution);
 
                        void
                        setDimensions(
                            const Size dimensions);
 
                        void
                        setColorDepth(
                            const uint32_t colorDepth);
 
                        void
                        setBitDepth(
                            const uint16_t bitDepth);
 
                        const uint8_t *
                        getDataPointer()
                            const;
 
                        uint64_t
                        getDataSize()
                            const;
 
                        void
                        setHasAlphaChannel(
                            const bool hasAlphaChannel)
                        {
                                this->_hasAlphaChannel = hasAlphaChannel;
                        }
 
                private:
                        Size _dimensions;
 
                        uint32_t _colorDepth;
 
                        bool _hasAlphaChannel;
 
                        uint16_t _bitDepth;
 
                        Resolution _resolution;
 
                        Memory::AutoArray<uint8_t> _data;
 
                        CompressionAlgorithm _compressionAlgorithm;
 
                        const std::string _identifier{};
 
                        statusCallback_t _statusCallback{
                            Image::defaultStatusCallback};
                };
        }
}
 
#endif /* __BE_IMAGE_IMAGE_H__ */