ImageType.h

Go to the documentation of this file.

#pragma once
 
#include "enrollment/Export.h"
#include "enrollment/Image/ImageException.h"
#include <cstdint>
 
namespace inno
{
     */
    class ImageType
    {
    public:
         */
        enum Type : uint8_t
        {
            BMP,
            PNG,
            WSQ,
            IRAW,
            JPG,
            TIFF,
            JPG2000,
            WEBP
        };
        static constexpr uint8_t UNKNOWN = 255;

         */
        constexpr explicit ImageType(Type t)
          : type(t)
        {
        }
 
        ImageType(const ImageType&) = default;
         */
        constexpr explicit ImageType(uint8_t t)
          : type(Convert(t))
        {
        }
 
        ImageType(ImageType&&) = default;
        ImageType& operator=(const ImageType&) = default;
        ImageType& operator=(ImageType&&) = default;
        ~ImageType() = default;
        explicit operator bool() = delete;
        explicit constexpr operator Type() const
        {
            return type;
        }
 
        constexpr bool operator==(ImageType t) const
        {
            return type == t.type;
        }
        constexpr bool operator!=(ImageType t) const
        {
            return !(*this == t);
        }
        constexpr bool operator==(Type t) const
        {
            return type == t;
        }
        constexpr bool operator!=(Type t) const
        {
            return !(*this == t);
        }
 
        [[nodiscard]] constexpr const char* ToFileExtension() const
        {
            switch (type)
            {
            case BMP:
                return ".bmp";
            case PNG:
                return ".png";
            case WSQ:
                return ".wsq";
            case IRAW:
                return ".iraw";
            case JPG:
                return ".jpg";
            case TIFF:
                return ".tiff";
            case JPG2000:
                return ".jp2";
            case WEBP:
                return ".webp";
            }
 
            throw ImageException(ImageException::UNKNOWN_IMAGE);
        }

         */
        static ImageType FromFileExtension(const std::string& extension)
        {
            if (extension == ".bmp")
            {
                return ImageType{ BMP };
            }
 
            if (extension == ".png")
            {
                return ImageType{ PNG };
            }
 
            if (extension == ".wsq")
            {
                return ImageType{ WSQ };
            }
 
            if (extension == ".iraw")
            {
                return ImageType{ IRAW };
            }
 
            if (extension == ".jpeg" || extension == ".jpg" || extension == ".jpe")
            {
                return ImageType{ JPG };
            }
 
            if (extension == ".tiff" || extension == ".tif")
            {
                return ImageType{ TIFF };
            }
 
            if (extension == ".jp2")
            {
                return ImageType{ JPG2000 };
            }
 
            if (extension == ".webp")
            {
                return ImageType{ WEBP };
            }
 
            throw ImageException(ImageException::UNKNOWN_IMAGE);
        }
 
    private:
        Type type;
 
        static constexpr Type Convert(uint8_t t)
        {
            switch (t)
            {
            case BMP:
                return BMP;
            case PNG:
                return PNG;
            case WSQ:
                return WSQ;
            case IRAW:
                return IRAW;
            case JPG:
                return JPG;
            case TIFF:
                return TIFF;
            case JPG2000:
                return JPG2000;
            case WEBP:
                return WEBP;
            default:
                throw ImageException(ImageException::UNKNOWN_IMAGE);
            }
        }
    };
} // namespace inno