lut.h

Go to the documentation of this file.

#pragma once

#include "pixel.h"

namespace scope {

extern const std::array<BGRA8Pixel,256> RainbowTable;

template<int32_t LBound = 0, int32_t UBound = 255, class TResult = uint8_t, class TArg = uint16_t>
class LUT_function {

protected:
    std::array<TResult, UBound - LBound + 1> lut_array;

    typename std::array<TResult, UBound - LBound + 1>::iterator lut;

public:
    explicit LUT_function ( std::function<TResult(double)> f, const double& coeff = 1 ) {
        lut = lut_array.begin() + LBound;
        for ( uint32_t i = LBound ; i <= UBound ; ++i )
            *(lut+i) = f(i*coeff);
    }

    const TResult& operator() (TArg i) const {
        return *(lut+i);
    }
};

enum ColorEnum { None, Gray, Red, Green, Blue, Yellow, Rainbow, Limits };

extern const std::array<CString, 8> gColorStrings;

class ColorProps {

protected:
    mutable std::mutex mutex;

    ColorEnum col;

    uint16_t ll;

    uint16_t ul;

protected:

public:
    ColorProps(const ColorEnum& _col = None, const uint16_t& _ll = 0, const uint16_t& _ul = UINT16_MAX >> 1)
        : col(_col)
        , ll(_ll)
        , ul(_ul) {
    }

    ColorProps(const ColorProps& cp) {
        col = cp.col;
        ll = cp.ll;
        ul = cp.ul;
    }

    ColorProps& operator=(const ColorProps& cp) {
        col = cp.Color();
        ll = cp.LowerLimit();
        ul = cp.UpperLimit();
        return *this;
    }

    uint16_t Range() const { std::lock_guard<std::mutex> lock(mutex); return ul-ll; }
    ColorEnum Color() const { std::lock_guard<std::mutex> lock(mutex); return col; }
    uint16_t LowerLimit() const { std::lock_guard<std::mutex> lock(mutex); return ll; }
    uint16_t UpperLimit() const { std::lock_guard<std::mutex> lock(mutex); return ul; }
    void SetColor(const ColorEnum& _col) { std::lock_guard<std::mutex> lock(mutex); col = _col; }
    void SetLowerLimit(const uint16_t& _ll) { std::lock_guard<std::mutex> lock(mutex); ll = _ll; }
    void SetUpperLimit(const uint16_t& _ul) { std::lock_guard<std::mutex> lock(mutex); ul = _ul; }
    operator ColorEnum() const { std::lock_guard<std::mutex> lock(mutex); return Color(); }
};

#define BGRA8BLACK BGRA8Pixel(0) 

#define BGRA8WHITE BGRA8Pixel(255) 

inline BGRA8Pixel U16ToBGRA8(const uint16_t& gray, const ColorEnum& pixelcolor) {
    switch (pixelcolor) {
        case Gray:
            return BGRA8Pixel(to8(gray));
        case Blue:
            return BGRA8Pixel(to8(gray), 0U, 0U);
        case Green:
            return BGRA8Pixel(0U, to8(gray), 0U);
        case Red:
            return BGRA8Pixel(0U, 0U, to8(gray));
        case Yellow:
            return BGRA8Pixel(0U, to8(gray), to8(gray));
        case None:
            return BGRA8Pixel(0U);
        case Rainbow:
            return RainbowTable[to8(gray)];
        case Limits:
            return ( (to8(gray) == 0)
                ? BGRA8Pixel(255,0,0) 
                : (to8(gray) == 255)
                    ? BGRA8Pixel(0,0,255) 
                    : BGRA8Pixel(to8(gray))
                );
        default:
            return BGRA8Pixel(0U);
    }
}

inline BGRA8Pixel U16ToBGRA8Histo(const uint16_t& gray, const ColorEnum& pixelcolor, const uint16_t& l, const uint16_t& u) {
    const uint8_t tmp8 = to8hist_mod(gray, l, u);
    switch (pixelcolor) {
        case Gray:
            return BGRA8Pixel(tmp8);
        case Blue:
            return BGRA8Pixel(tmp8, 0U, 0U);
        case Green:
            return BGRA8Pixel(0U, tmp8, 0U);
        case Red:
            return BGRA8Pixel(0U, 0U, tmp8);
        case Yellow:
            return BGRA8Pixel(0U, tmp8, tmp8);
        case None:
            return BGRA8Pixel(0U);
        case Rainbow:
            return RainbowTable[tmp8];
        case Limits:
            return ( (tmp8 == 0)
                ? BGRA8Pixel(255,0,0) 
                : (tmp8 == 255)
                    ? BGRA8Pixel(0,0,255) 
                    : BGRA8Pixel(tmp8)
            );
        default:
            return BGRA8Pixel(0U);
    }
}

inline BGRA8Pixel U16ToBGRA8Histo2(const uint16_t& gray, const ColorEnum& pixelcolor, const uint16_t& l, const uint16_t& u, const uint16_t& scaler) {
    const uint8_t tmp8 = to8hist_mod2(gray, l, u, scaler);
    switch (pixelcolor) {
        case Gray:
            return BGRA8Pixel(tmp8);
        case Blue:
            return BGRA8Pixel(tmp8, 0U, 0U);
        case Green:
            return BGRA8Pixel(0U, tmp8, 0U);
        case Red:
            return BGRA8Pixel(0U, 0U, tmp8);
        case Yellow:
            return BGRA8Pixel(0U, tmp8, tmp8);
        case None:
            return BGRA8Pixel(0U);
        case Rainbow:
            return RainbowTable[tmp8];
        case Limits:
            return ( (tmp8 == 0)
                ? BGRA8Pixel(255,0,0) 
                : (tmp8 == 255)
                    ? BGRA8Pixel(0,0,255) 
                    : BGRA8Pixel(tmp8)
            );
        default:
            return BGRA8Pixel(0U);
    }
}

}