main.cpp

#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <vector>

#include "ColorWheelSchemes.h"

struct RgbColor {
    float r = 0.0f;
    float g = 0.0f;
    float b = 0.0f;

    RgbColor() = default;
    RgbColor(float red, float green, float blue) : r(red), g(green), b(blue) {}

    static float limit() {
        return 255.0f;
    }

    static float clampChannel(float v) {
        return std::clamp(v, 0.0f, limit());
    }

    static float wrapHue(float h) {
        float wrapped = std::fmod(h, limit());
        if (wrapped < 0.0f) {
            wrapped += limit();
        }
        return wrapped;
    }

    static RgbColor fromHsb(float hue, float saturation, float brightness) {
        const float h = (wrapHue(hue) / limit()) * 360.0f;
        const float s = clampChannel(saturation) / limit();
        const float v = clampChannel(brightness) / limit();

        if (s <= 0.0f) {
            const float gray = v * limit();
            return RgbColor(gray, gray, gray);
        }

        const float hh = h / 60.0f;
        const int i = static_cast<int>(std::floor(hh)) % 6;
        const float f = hh - std::floor(hh);
        const float p = v * (1.0f - s);
        const float q = v * (1.0f - s * f);
        const float t = v * (1.0f - s * (1.0f - f));

        switch (i) {
            case 0:
                return RgbColor(v * limit(), t * limit(), p * limit());
            case 1:
                return RgbColor(q * limit(), v * limit(), p * limit());
            case 2:
                return RgbColor(p * limit(), v * limit(), t * limit());
            case 3:
                return RgbColor(p * limit(), q * limit(), v * limit());
            case 4:
                return RgbColor(t * limit(), p * limit(), v * limit());
            default:
                return RgbColor(v * limit(), p * limit(), q * limit());
        }
    }

    void toHsb(float& hue, float& saturation, float& brightness) const {
        const float rr = clampChannel(r) / limit();
        const float gg = clampChannel(g) / limit();
        const float bb = clampChannel(b) / limit();

        const float maxv = std::max(rr, std::max(gg, bb));
        const float minv = std::min(rr, std::min(gg, bb));
        const float delta = maxv - minv;

        brightness = maxv * limit();
        saturation = (maxv <= 0.0f) ? 0.0f : (delta / maxv) * limit();

        if (delta <= 0.0f) {
            hue = 0.0f;
            return;
        }

        float hueDegrees;
        if (maxv == rr) {
            hueDegrees = 60.0f * std::fmod(((gg - bb) / delta), 6.0f);
        } else if (maxv == gg) {
            hueDegrees = 60.0f * (((bb - rr) / delta) + 2.0f);
        } else {
            hueDegrees = 60.0f * (((rr - gg) / delta) + 4.0f);
        }

        if (hueDegrees < 0.0f) {
            hueDegrees += 360.0f;
        }

        hue = (hueDegrees / 360.0f) * limit();
    }

    float getHue() const {
        float h = 0.0f;
        float s = 0.0f;
        float v = 0.0f;
        toHsb(h, s, v);
        return h;
    }

    float getHueAngle() const {
        return (getHue() / limit()) * 360.0f;
    }

    float getSaturation() const {
        float h = 0.0f;
        float s = 0.0f;
        float v = 0.0f;
        toHsb(h, s, v);
        return s;
    }

    float getBrightness() const {
        float h = 0.0f;
        float s = 0.0f;
        float v = 0.0f;
        toHsb(h, s, v);
        return v;
    }

    void setHue(float hue) {
        *this = fromHsb(hue, getSaturation(), getBrightness());
    }

    void setSaturation(float saturation) {
        *this = fromHsb(getHue(), saturation, getBrightness());
    }

    void setBrightness(float brightness) {
        *this = fromHsb(getHue(), getSaturation(), brightness);
    }

    RgbColor& lerp(const RgbColor& other, float amount) {
        const float t = std::clamp(amount, 0.0f, 1.0f);
        r += (other.r - r) * t;
        g += (other.g - g) * t;
        b += (other.b - b) * t;
        return *this;
    }
};

int main() {
    auto scheme = ofxColorTheory::ColorWheelSchemes_<RgbColor>::make(ofxColorTheory::ColorRule::Complementary);
    if (!scheme) {
        std::cerr << "Failed to construct scheme\n";
        return 1;
    }

    scheme->setPrimaryColor(RgbColor(240.0f, 120.0f, 30.0f));
    scheme->regenerate();

    const auto palette = scheme->interpolate(12, ofxColorTheory::ColorSpace::Lch);

    std::cout << "Generated " << palette.size() << " colors:\n";
    for (std::size_t i = 0; i < palette.size(); ++i) {
        const auto& c = palette[i];
        std::cout << std::setw(2) << i << ": "
                  << "(" << std::setw(6) << std::fixed << std::setprecision(1) << c.r << ", "
                  << std::setw(6) << c.g << ", "
                  << std::setw(6) << c.b << ")\n";
    }

    return 0;
}