color.cpp

Go to the documentation of this file.

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Author:
 *   Martin Owens <doctormo@geek-2.com>
 *
 * Copyright (C) 2023 AUTHORS
 *
 * Released under GNU GPL v2+, read the file 'COPYING' for more information.
 */
 
#include "colors/color.h"
 
#include <cassert>
#include <cmath>
#include <utility>
 
#include "colors/manager.h"
#include "spaces/base.h"
#include "spaces/components.h"
 
namespace Inkscape::Colors {
namespace {
 
template <typename T>
static decltype(auto) assert_nonnull(T &&t)
{
    assert(t);
    return std::forward<T>(t);
}
 
} // namespace
 
Color::Color(Space::Type space_type, std::vector<double> values)
    : Color(assert_nonnull(Manager::get().find(space_type)), std::move(values))
{}
 
Color::Color(uint32_t rgba, bool opacity)
    : Color(Space::Type::RGB, rgba_to_values(rgba, opacity))
{}
 
Color::Color(std::shared_ptr<Space::AnySpace> space, std::vector<double> colors)
    : _values(std::move(colors))
    , _space(std::move(space))
{
    assert(_space->isValidData(_values));
}
 
bool Color::operator==(Color const &other) const
{
    // TODO: Adjust epsilon value to ignore roundtrip conversion rounding errors,
    // but still keep high precision of color comparision.
    //
    // I arrived at this value empirically. If it is too big, then sometimes changes (by the user) are not picked up,
    // and no refresh happens. If it is too small, then roundtrip conversions will also trigger changes, while they ideally should not.
    // It's all a bit fragile.
    return _space == other._space && _isnear(other._values, 0.00001);
}
 
double Color::get(unsigned index) const
{
    assert(index <= getOpacityChannel());
    if (index < _values.size()) {
        return _values[index];
    } else {
        return 1.0;
    }
}
 
std::string Color::toString(bool opacity) const
{
    return _space->toString(_values, opacity);
}
 
uint32_t Color::toRGBA(double opacity) const
{
    return _space->toRGBA(_values, opacity);
}
 
uint32_t Color::toARGB(double opacity) const
{
    auto value = toRGBA(opacity);
    return (value >> 8) | ((value & 0xff) << 24);
}
 
uint32_t Color::toABGR(double opacity) const
{
    auto value = toRGBA(opacity);
    return (value << 24) | ((value << 8) & 0x00ff0000) | ((value >> 8) & 0x0000ff00) | (value >> 24);
}
 
bool Color::convert(Color const &other)
{
    if (convert(other._space)) {
        enableOpacity(other.hasOpacity());
        return true;
    }
    return false;
}
 
bool Color::convert(std::shared_ptr<Space::AnySpace> to_space)
{
    if (!to_space || !to_space->isValid()) {
        return false;
    }
 
    if (_space != to_space) {
        _space->convert(_values, to_space);
        _space = std::move(to_space);
        assert(_space->isValidData(_values));
    }
    _name = "";
 
    return true;
}
 
bool Color::convert(Space::Type type)
{
    if (auto space = Manager::get().find(type)) {
        return convert(space);
    }
    return false;
}
 
std::optional<Color> Color::converted(Color const &other) const
{
    Color copy = *this;
    if (copy.convert(other)) {
        return copy;
    }
    return {};
}
 
std::optional<Color> Color::converted(std::shared_ptr<Space::AnySpace> to_space) const
{
    Color copy = *this;
    if (copy.convert(std::move(to_space))) {
        return copy;
    }
    return {};
}
 
std::optional<Color> Color::converted(Space::Type type) const
{
    Color copy = *this;
    if (copy.convert(type)) {
        return copy;
    }
    return {};
}
 
void Color::setValues(std::vector<double> values)
{
    _name = "";
    _values = std::move(values);
    assert(_space->isValidData(_values));
}
 
bool Color::set(Color const &other, bool keep_space)
{
    if (keep_space) {
        auto prev_space = _space;
        auto prev_values = _values;
        bool prev_opacity = hasOpacity();
 
        if (set(other, false)) {
            // Convert back to the previous space if needed.
            convert(prev_space);
            enableOpacity(prev_opacity);
            // Return true if the converted result is different
            return !_isnear(prev_values);
        }
    } else if (*this != other) {
        _space = other._space;
        _values = other._values;
        _name = other._name;
        return true;
    }
    return false;
}
 
bool Color::set(std::string const &parsable, bool keep_space)
{
    if (auto color = Color::parse(parsable)) {
        return set(*color, keep_space);
    }
    return false;
}
 
bool Color::_isnear(std::vector<double> const &other, double epsilon) const
{
    bool is_near = _values.size() == other.size();
    for (size_t i = 0; is_near && i < _values.size(); i++) {
        is_near &= std::abs(_values[i] - other[i]) < epsilon;
    }
    return is_near;
}
 
std::optional<Color> Color::parse(char const *value)
{
    if (!value) {
        return {};
    }
    return parse(std::string(value));
}
 
std::optional<Color> Color::parse(std::string const &value)
{
    Space::Type space_type;
    std::string cms_name;
    std::vector<double> values;
    std::vector<double> fallback;
    if (Parsers::get().parse(value, space_type, cms_name, values, fallback)) {
        return ifValid(space_type, std::move(values));
    }
    // Couldn't be parsed as a color at all
    return {};
}
 
std::optional<Color> Color::ifValid(Space::Type space_type, std::vector<double> values)
{
    if (auto space = Manager::get().find(space_type)) {
        if (space->isValidData(values)) {
            return std::make_optional<Color>(std::move(space), std::move(values));
        }
    }
    // Invalid color data, return empty optional
    return {};
}
 
bool Color::set(unsigned int index, double value)
{
    assert(index <= getOpacityChannel());
    if (index == _values.size()) {
        _values.push_back(1.0);
    }
    auto const changed = std::abs(_values[index] - value) >= 0.001;
    _values[index] = value;
    return changed;
}
 
bool Color::set(uint32_t rgba, bool opacity)
{
    if (_space->getType() != Space::Type::RGB) {
        // Ensure we are in RGB
        _space = assert_nonnull(Manager::get().find(Space::Type::RGB));
    } else if (rgba == toRGBA(opacity)) {
        return false; // nothing to do.
    }
    _name = "";
    _values = std::move(rgba_to_values(rgba, opacity));
    return true;
}
 
void Color::enableOpacity(bool enable)
{
    auto const has_opacity = hasOpacity();
    if (enable && !has_opacity) {
        _values.push_back(1.0);
    } else if (!enable && has_opacity) {
        _values.pop_back();
    }
}
 
bool Color::hasOpacity() const
{
    return _values.size() > getOpacityChannel();
}
 
double Color::getOpacity() const
{
    return hasOpacity() ? _values.back() : 1.0;
}
 
double Color::stealOpacity()
{
    auto ret = getOpacity();
    enableOpacity(false);
    return ret;
}
 
unsigned int Color::getOpacityChannel() const
{
    return _space->getComponentCount();
}
 
unsigned int Color::getPin(unsigned int channel) const
{
    return 1 << channel;
}
 
bool Color::setOpacity(double opacity)
{
    if (hasOpacity()) {
        if (opacity == _values.back()) {
            return false;
        }
        _values.back() = opacity;
    } else {
        _values.emplace_back(opacity);
    }
    return true;
}
 
void Color::normalize()
{
    for (auto const &comp : _space->getComponents(hasOpacity())) {
        _values[comp.index] = comp.normalize(_values[comp.index]);
    }
}
 
Color Color::normalized() const
{
    Color copy = *this;
    copy.normalize();
    return copy;
}
 
void Color::invert(unsigned int pin)
{
    for (unsigned int i = 0; i < _values.size(); i++) {
        if (pin & (1 << i)) {
            continue;
        }
        _values[i] = 1.0 - _values[i];
    }
}
 
void Color::jitter(double force, unsigned int pin)
{
    for (unsigned int i = 0; i < _values.size(); i++) {
        if (pin & (1 << i)) {
            continue;
        }
        // Random number between -0.5 and 0.5 times the force.
        double r = (static_cast<double>(std::rand()) / RAND_MAX - 0.5);
        _values[i] += r * force;
    }
    normalize();
}
 
void Color::compose(Color const &other)
{
    auto alpha = other.getOpacity();
    _color_mutate_inplace(other, getPin(getOpacityChannel()),
                          [alpha](auto &value, auto otherValue) { value = value * (1.0 - alpha) + otherValue * alpha; });
    setOpacity(1.0 - (1.0 - getOpacity()) * (1.0 - alpha));
}
 
Color Color::composed(Color const &other) const
{
    Color copy = *this;
    copy.compose(other);
    return copy;
}
 
/*
 * Modify this color to be the average between two colors, modifying the first.
 *
 * @arg other  - The other color to average with
 * @arg pos    - The position (i.e. t) between the two colors.
 * @pin pin    - Bit field, which channels should not change (see invert)
 */
void Color::average(Color const &other, double pos, unsigned int pin)
{
    _color_mutate_inplace(other, pin,
                          [pos](auto &value, auto otherValue) { value = value * (1 - pos) + otherValue * pos; });
}
 
Color Color::averaged(Color const &other, double pos) const
{
    Color copy = *this;
    copy.average(other, pos);
    return copy;
}
 
double Color::difference(Color const &other) const
{
    double ret = 0.0;
    if (auto copy = other.converted(*this)) {
        for (unsigned int i = 0; i < _values.size(); i++) {
            ret += std::pow(_values[i] - (*copy)[i], 2);
        }
    }
    return ret;
}
 
bool Color::isClose(Color const &other, double epsilon) const
{
    bool match = _space == other._space && _values.size() == other._values.size();
    for (unsigned int i = 0; match && i < _values.size(); i++) {
        match &= (std::fabs(_values[i] - other._values[i]) < epsilon);
    }
    return match;
}
 
bool Color::isSimilar(Color const &other, double epsilon) const
{
    if (other._space != _space) {
        if (auto copy = other.converted(_space)) {
            return isClose(*copy, epsilon);
        }
        return false; // bad color conversion
    }
    return isClose(other, epsilon);
}
 
bool Color::isOutOfGamut(std::shared_ptr<Space::AnySpace> other) const
{
    return _space->outOfGamut(_values, other);
}
 
bool Color::isOverInked() const
{
    return _space->overInk(_values);
}
 
// Color-color in-place modification template
template <typename Func>
void Color::_color_mutate_inplace(Color const &other, unsigned int pin, Func func)
{
    // Convert the other's space and opacity if it's different
    if (other._space != _space || other.hasOpacity() != hasOpacity()) {
        if (auto copy = other.converted(*this)) {
            return _color_mutate_inplace(*copy, pin, func);
        }
        return; // Bad conversion
    }
 
    // Both are good, so average each channel
    for (unsigned int i = 0; i < _values.size(); i++) {
        if (pin & (1 << i)) {
            continue;
        }
        func(_values[i], other[i]);
    }
}
 
}; // namespace Inkscape::Colors
 
/*
  Local Variables:
  mode:c++
  c-file-style:"stroustrup"
  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
  indent-tabs-mode:nil
  fill-column:99
  End:
*/
// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :