be_image.h

Go to the documentation of this file.

/*
 * 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_H__
#define __BE_IMAGE_H__
 
#include <cstdint>
#include <iostream>
#include <vector>
 
#include <be_framework_enumeration.h>
#include <be_memory_autoarray.h>
 
namespace BiometricEvaluation 
{
        namespace Image
        {
                enum class CompressionAlgorithm
                {
                        None            = 0,
                        Facsimile       = 1,
                        WSQ20           = 2,
                        JPEGB           = 3,
                        JPEGL           = 4,
                        JP2             = 5,
                        JP2L            = 6,
                        PNG             = 7,
                        NetPBM          = 8,
                        BMP             = 9,
                        TIFF            = 10
                };
 
                enum class PixelFormat
                {
                        MonoWhite       = 0,
                        MonoBlack       = 1,
                        Gray8           = 2,
                        RGB24           = 3
                };
 
                struct Coordinate {
                        Coordinate(
                            const uint32_t x = 0,
                            const uint32_t y = 0,
                            const float xDistance = 0,
                            const float yDistance = 0);
 
                        uint32_t x;
                        uint32_t y;
                        float xDistance;
                        float yDistance;
                };
                using Coordinate = struct Coordinate;
 
                std::string
                to_string(
                    const Coordinate &c);
                std::ostream& operator<< (std::ostream&, const Coordinate&);
                using CoordinateSet = std::vector<Image::Coordinate>;
                bool
                operator==(
                    const Coordinate &lhs,
                    const Coordinate &rhs);
                bool
                operator!=(
                    const Coordinate &lhs,
                    const Coordinate &rhs);
 
                std::string
                to_string(
                    const CoordinateSet &coordinates);
                std::ostream&
                operator<<(
                    std::ostream &stream,
                    const CoordinateSet &coordinates);
 
                struct Size {
                        Size(
                            const uint32_t xSize = 0,
                            const uint32_t ySize = 0);
 
                        uint32_t xSize;
                        uint32_t ySize;
                };
                using Size = struct Size;
                std::string
                to_string(
                    const Size &s);
                std::ostream& operator<< (std::ostream&, const Size&);
                bool
                operator==(
                    const Size &lhs,
                    const Size &rhs);
                bool
                operator!=(
                    const Size &lhs,
                    const Size &rhs);
 
                struct Resolution {
                        enum class Units {
                                NA      = 0,
                                PPI     = 1,
                                PPMM    = 2,
                                PPCM    = 3
                        };
                                
                        Resolution(
                            const double xRes = 0.0,
                            const double yRes = 0.0,
                            const Units units = Units::PPI);
 
                        double xRes;
                        double yRes;
                        Units units;
 
                        Resolution
                        toUnits(
                            const Units &units)
                            const;
                };
                using Resolution = struct Resolution;
 
                const double CentimetersPerInch = 2.54;
                const double MillimetersPerInch = CentimetersPerInch * 10;
 
                std::string
                to_string(
                    const Resolution &r);
                std::ostream& operator<< (std::ostream&, const Resolution&);
                bool
                operator==(
                    const Resolution &lhs,
                    const Resolution &rhs);
                bool
                operator!=(
                    const Resolution &lhs,
                    const Resolution &rhs);
                
                float
                distance(
                    const Coordinate &p1,
                    const Coordinate &p2);
 
                BiometricEvaluation::Memory::uint8Array
                removeComponents(
                    const BiometricEvaluation::Memory::uint8Array &rawData,
                    const uint8_t bitDepth,
                    const std::vector<bool> &components);
 
                struct ROI {
                        ROI();
 
                        ROI(
                            const Size size,
                            const uint32_t horzOffset,
                            const uint32_t vertOffset,
                            const CoordinateSet &path);
 
                        Size size;
                        uint32_t horzOffset;
                        uint32_t vertOffset;
                        CoordinateSet path;
                };
                using ROI = struct ROI;
 
                std::string
                to_string(
                    const ROI &r);
                std::ostream& operator<< (std::ostream&, const ROI&);
                bool
                operator==(
                    const ROI &lhs,
                    const ROI &rhs);
                bool
                operator!=(
                    const ROI &lhs,
                    const ROI &rhs);
        }
}
 
BE_FRAMEWORK_ENUMERATION_DECLARATIONS(
    BiometricEvaluation::Image::CompressionAlgorithm,
    BE_Image_CompressionAlgorithm_EnumToStringMap);
 
BE_FRAMEWORK_ENUMERATION_DECLARATIONS(
    BiometricEvaluation::Image::PixelFormat,
    BE_Image_PixelFormat_EnumToStringMap);
 
BE_FRAMEWORK_ENUMERATION_DECLARATIONS(
    BiometricEvaluation::Image::Resolution::Units,
    BE_Image_Resolution_Units_EnumToStringMap);
 
#endif /* __BE_IMAGE_H__ */