color.h

/*****************************************************************************
 * VCLib                                                                     *
 * Visual Computing Library                                                  *
 *                                                                           *
 * Copyright(C) 2021-2025                                                    *
 * Visual Computing Lab                                                      *
 * ISTI - Italian National Research Council                                  *
 *                                                                           *
 * All rights reserved.                                                      *
 *                                                                           *
 * This program is free software; you can redistribute it and/or modify      *
 * it under the terms of the Mozilla Public License Version 2.0 as published *
 * by the Mozilla Foundation; either version 2 of the License, or            *
 * (at your option) any later version.                                       *
 *                                                                           *
 * This program is distributed in the hope that it will be useful,           *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the              *
 * Mozilla Public License Version 2.0                                        *
 * (https://www.mozilla.org/en-US/MPL/2.0/) for more details.                *
 ****************************************************************************/
 
#ifndef VCL_SPACE_CORE_COLOR_H
#define VCL_SPACE_CORE_COLOR_H
 
#include "point.h"
 
#include <vector>
 
namespace vcl {
 
class Color : public Point4<uint8_t>
{
public:
    enum class Representation { INT_0_255, FLOAT_0_1 };
 
    enum class Format { ABGR, ARGB, RGBA, BGRA };
 
    enum ColorABGR : uint32_t {
        Black     = 0xff000000,
        DarkGray  = 0xff404040,
        Gray      = 0xff808080,
        LightGray = 0xffc0c0c0,
        White     = 0xffffffff,
 
        Red   = 0xff0000ff,
        Green = 0xff00ff00,
        Blue  = 0xffff0000,
 
        Yellow  = 0xff00ffff,
        Cyan    = 0xffffff00,
        Magenta = 0xffff00ff,
 
        LightRed   = 0xff8080ff,
        LightGreen = 0xff80ff80,
        LightBlue  = 0xffff8080,
 
        LightCyan    = 0xffffff80,
        LightYellow  = 0xff80ffff,
        LightMagenta = 0xffff80ff,
 
        DarkRed   = 0xff000040,
        DarkGreen = 0xff004000,
        DarkBlue  = 0xff400000,
 
        DarkCyan    = 0xff404000,
        DarkYellow  = 0xff004040,
        DarkMagenta = 0xff400040,
 
        LightBrown = 0xff4080b0,
        DarkBrown  = 0xff002040,
        Brown      = 0xff004080,
    };
 
    enum class ColorMap { RedBlue, Parula, GreyShade };
 
    Color() : Point(0, 0, 0, 255) {}
 
    Color(ColorABGR cc) { *reinterpret_cast<uint32_t*>(Point::data()) = cc; }
 
    Color(uint32_t cc, Format format) { set(cc, format); }
 
    Color(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha = 255) :
            Point(red, green, blue, alpha)
    {
    }
 
    Color(const Point4<uint8_t>& p) : Point4<uint8_t>(p) {}
 
    uint8_t red() const { return x(); }
 
    uint8_t green() const { return y(); }
 
    uint8_t blue() const { return z(); }
 
    uint8_t alpha() const { return w(); }
 
    uint8_t& red() { return x(); }
 
    uint8_t& green() { return y(); }
 
    uint8_t& blue() { return z(); }
 
    uint8_t& alpha() { return w(); }
 
    float redF() const { return (float) x() / 255; }
 
    float greenF() const { return (float) y() / 255; }
 
    float blueF() const { return (float) z() / 255; }
 
    float alphaF() const { return (float) w() / 255; }
 
    uint8_t hsvHue() const
    {
        uint8_t rgbMin, rgbMax;
        uint8_t h;
 
        rgbMin = x() < y() ? (x() < z() ? x() : z()) : (y() < z() ? y() : z());
        rgbMax = x() > y() ? (x() > z() ? x() : z()) : (y() > z() ? y() : z());
 
        if (rgbMax == 0) {
            return 0;
        }
 
        if (255 * long(rgbMax - rgbMin) / rgbMax == 0) {
            return 0;
        }
 
        if (rgbMax == x())
            h = 0 + 43 * (y() - z()) / (rgbMax - rgbMin);
        else if (rgbMax == y())
            h = 85 + 43 * (z() - x()) / (rgbMax - rgbMin);
        else
            h = 171 + 43 * (x() - y()) / (rgbMax - rgbMin);
 
        return h;
    }
 
    uint8_t hsvSaturation() const
    {
        uint8_t rgbMin, rgbMax;
 
        rgbMin = x() < y() ? (x() < z() ? x() : z()) : (y() < z() ? y() : z());
        rgbMax = x() > y() ? (x() > z() ? x() : z()) : (y() > z() ? y() : z());
 
        if (rgbMax == 0) {
            return 0;
        }
 
        return 255 * long(rgbMax - rgbMin) / rgbMax;
    }
 
    float hsvHueF() const { return (float) hsvHue() / 255; }
 
    float hsvSaturationF() const { return (float) hsvSaturation() / 255; }
 
    uint32_t abgr() const
    {
        return *reinterpret_cast<const uint32_t*>(Point::data());
    }
 
    uint32_t argb() const
    {
        return (alpha() << 24) | (red() << 16) | (green() << 8) | blue();
    }
 
    uint32_t rgba() const
    {
        return (red() << 24) | (green() << 16) | (blue() << 8) | alpha();
    }
 
    uint32_t bgra() const
    {
        return (blue() << 24) | (green() << 16) | (red() << 8) | alpha();
    }
 
    unsigned short bgr5() const
    {
        unsigned short r   = x() / 8;
        unsigned short g   = y() / 8;
        unsigned short b   = z() / 8;
        unsigned short res = r + g * 32 + b * 1024;
        return res;
    }
 
    unsigned short rgb5() const
    {
        unsigned short r   = x() / 8;
        unsigned short g   = y() / 8;
        unsigned short b   = z() / 8;
        unsigned short res = b + g * 32 + r * 1024;
        return res;
    }
 
    void setAlpha(uint8_t alpha) { w() = alpha; }
 
    void setRed(uint8_t red) { x() = red; }
 
    void setGreen(uint8_t green) { y() = green; }
 
    void setBlue(uint8_t blue) { z() = blue; }
 
    void setRgb(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha = 255)
    {
        x() = red;
        y() = green;
        z() = blue;
        w() = alpha;
    }
 
    void set(uint32_t cc, Format fmt = Format::ABGR)
    {
        switch (fmt) {
        case Format::ARGB: setArgb(cc); break;
        case Format::ABGR: setAbgr(cc); break;
        case Format::RGBA: setRgba(cc); break;
        case Format::BGRA: setBgra(cc); break;
        }
    }
 
    void setAbgr(uint32_t val)
    {
        *reinterpret_cast<uint32_t*>(Point::data()) = val;
    }
 
    void setArgb(uint32_t val)
    {
        x() = (val >> 16) % 256;
        y() = (val >> 8) % 256;
        z() = val % 256;
        w() = (val >> 24) % 256;
    }
 
    void setRgba(uint32_t val)
    {
        x() = (val >> 24) % 256;
        y() = (val >> 16) % 256;
        z() = (val >> 8) % 256;
        w() = val % 256;
    }
 
    void setBgra(uint32_t val)
    {
        x() = (val >> 8) % 256;
        y() = (val >> 16) % 256;
        z() = (val >> 24) % 256;
        w() = val % 256;
    }
 
    void setBgr5(unsigned short val)
    {
        x() = val % 32 * 8;
        y() = ((val / 32) % 32) * 8;
        z() = ((val / 1024) % 32) * 8;
        w() = 255;
    }
 
    void setRgb5(unsigned short val)
    {
        z() = val % 32 * 8;
        y() = ((val / 32) % 32) * 8;
        x() = ((val / 1024) % 32) * 8;
        w() = 255;
    }
 
    void setHsv(uint8_t h, uint8_t s, uint8_t v, uint8_t alpha = 255)
    {
        w() = alpha;
        if (s == 0) {
            x() = v;
            y() = v;
            z() = v;
        }
        else {
            h = (h / 360.0) * 255;
            uint8_t region, remainder, p, q, t;
            region    = h / 43;
            remainder = (h - (region * 43)) * 6;
 
            p = (v * (255 - s)) >> 8;
            q = (v * (255 - ((s * remainder) >> 8))) >> 8;
            t = (v * (255 - ((s * (255 - remainder)) >> 8))) >> 8;
 
            switch (region) {
            case 0:
                x() = v;
                y() = t;
                z() = p;
                break;
            case 1:
                x() = q;
                y() = v;
                z() = p;
                break;
            case 2:
                x() = p;
                y() = v;
                z() = t;
                break;
            case 3:
                x() = p;
                y() = q;
                z() = v;
                break;
            case 4:
                x() = t;
                y() = p;
                z() = v;
                break;
            default:
                x() = v;
                y() = p;
                z() = q;
                break;
            }
        }
    }
 
    void setAlphaF(float alpha) { w() = (uint8_t) (alpha * 255); }
 
    void setRedF(float red) { x() = (uint8_t) (red * 255); }
 
    void setGreenF(float green) { y() = (uint8_t) (green * 255); }
 
    void setBlueF(float blue) { z() = (uint8_t) (blue * 255); }
 
    void setRgbF(float red, float green, float blue, float alpha = 1.0)
    {
        w() = (uint8_t) (alpha * 255);
        x() = (uint8_t) (red * 255);
        y() = (uint8_t) (green * 255);
        z() = (uint8_t) (blue * 255);
    }
 
    void setHsvF(float hf, float sf, float vf, float alpha = 1.0)
    {
        setHsv(hf * 255, sf * 255, vf * 255, alpha * 255);
    }
 
    bool operator==(const Color& otherColor) const
    {
        return (
            x() == otherColor.x() && y() == otherColor.y() &&
            z() == otherColor.z() && w() == otherColor.w());
    }
 
    bool operator!=(const Color& otherColor) const
    {
        return !(*this == otherColor);
    }
 
    bool operator<(const Color& otherColor) const
    {
        if (x() < otherColor.x())
            return true;
        if (x() > otherColor.x())
            return false;
        if (y() < otherColor.y())
            return true;
        if (y() > otherColor.y())
            return false;
        if (z() < otherColor.z())
            return true;
        if (z() > otherColor.z())
            return false;
        if (w() < otherColor.w())
            return true;
        return false;
    }
 
    friend std::ostream& operator<<(std::ostream& out, const Color& c);
};
 
inline std::ostream& operator<<(std::ostream& out, const Color& c)
{
    out << c.cast<uint>();
    return out;
}
 
inline Color colorLerp(const Color& c0, const Color& c1, float value)
{
    Color c;
    if (value < 0) // out of range - left
        value = 0;
    else if (value > 1) // out of range - right
        value = 1;
    for (uint i = 0; i < 4; i++)
        c(i) = c1(i) * value + c0(i) * (1 - value);
    return c;
}
 
inline Color colorFromIntervalRedBlue(float value)
{
    Color c;
 
    if (value < 0) // out of range - left
        value = 0;
    else if (value > 1) // out of range - right
        value = 1;
 
    c.setHsv(value * 240, 255, 255);
    return c;
}
 
inline Color colorFromIntervalRedBlue(float min, float max, float value)
{
    Color c;
    if (min == max) { // no range
        return Color::Gray;
    }
 
    value = std::abs((value - min) / (max - min));
    return colorFromIntervalRedBlue(value);
}
 
inline Color colorFromIntervalParula(float value)
{
    if (value < 0) // out of range - left
        value = 0;
    else if (value > 1) // out of range - right
        value = 1;
 
    static uint paruVal[9] = {
        0x271680ff,
        0x0363e1ff,
        0x1485d4ff,
        0x06a7c6ff,
        0x38b99eff,
        0x92bf73ff,
        0xd9ba56ff,
        0xfcce2eff,
        0xfffa0aff};
 
    int   ind = int(floor(value * 8.0f));
    float div = (value * 8.0f - ind);
 
    if (div < 0)
        div = 0;
    else if (div > 1)
        div = 1;
 
    return colorLerp(
        (Color::ColorABGR) paruVal[ind],
        (Color::ColorABGR) paruVal[ind + 1],
        div);
}
 
inline Color colorFromIntervalParula(float min, float max, float value)
{
    Color c;
    if (min == max) { // no range
        return Color::Gray;
    }
 
    value = std::abs((value - min) / (max - min));
    return colorFromIntervalParula(value);
}
 
inline Color colorFromIntervalGreyShade(float value)
{
    if (value < 0) // out of range - left
        value = 0;
    else if (value > 1) // out of range - right
        value = 1;
    return Color(value * 255, value * 255, value * 255, 255);
}
 
inline Color colorFromIntervalGreyShade(float min, float max, float value)
{
    Color c;
    if (min == max) { // no range
        return Color::Gray;
    }
 
    value = std::abs((value - min) / (max - min));
    return colorFromIntervalGreyShade(value);
}
 
inline Color colorFromInterval(float value, Color::ColorMap cm)
{
    switch (cm) {
        using enum Color::ColorMap;
    case RedBlue: return colorFromIntervalRedBlue(value);
    case Parula: return colorFromIntervalParula(value);
    case GreyShade: return colorFromIntervalGreyShade(value);
    default: assert(0); return Color::Gray;
    }
}
 
inline Color colorFromInterval(
    float           min,
    float           max,
    float           value,
    Color::ColorMap cm)
{
    if (min == max) { // no range
        return Color::Gray;
    }
 
    value = std::abs((value - min) / (max - min));
    return colorFromInterval(value, cm);
}
 
inline std::vector<Color> colorScattering(
    uint  n,
    float sat = 0.3,
    float val = 0.9)
{
    std::vector<Color> scattering;
    scattering.reserve(n);
 
    for (uint v = 0; v < n; ++v) {
        uint value = v, m = n;
        uint b = 0;
 
        for (uint k = 1; k < n; k <<= 1) {
            if (value << 1 >= m) {
                b += k;
                value -= (m + 1) >> 1;
                m >>= 1;
            }
            else {
                m = (m + 1) >> 1;
            }
        }
 
        Color rc;
        rc.setHsvF(float(b) / float(n), sat, val);
        scattering.push_back(rc);
    }
    return scattering;
}
 
} // namespace vcl
 
#endif // VCL_SPACE_CORE_COLOR_H