color-set.cpp

Go to the documentation of this file.

// SPDX-License-Identifier: GPL-2.0-or-later
 * Copyright (C) 2024 Authors
 * Released under GNU GPL v2+, read the file 'COPYING' for more information.
 */
 
#include "color-set.h"
 
#include <algorithm>
 
#include "colors/color.h"
#include "colors/spaces/base.h"
#include "colors/spaces/components.h"
 
namespace Inkscape::Colors {
 
ColorSet::ColorSet(std::shared_ptr<Space::AnySpace> space, std::optional<bool> alpha)
    : _space_constraint(std::move(space))
    , _alpha_constraint(alpha)
{}
 
Space::Components const &ColorSet::getComponents() const
{
    if (!_space_constraint)
        throw ColorError("Components are only available on a color space constrained ColorSet.");
    return _space_constraint->getComponents(_alpha_constraint && *_alpha_constraint);
}
 
void ColorSet::clear()
{
    if (!_colors.empty()) {
        _colors.clear();
        colors_cleared();
    }
}
 
void ColorSet::grab()
{
    if (!_blocked && !_grabbed) {
        block();
        signal_grabbed.emit();
        unblock();
        _grabbed = true;
    }
}
 
void ColorSet::release()
{
    if (!_blocked && _grabbed) {
        _grabbed = false;
        block();
        signal_released.emit();
        unblock();
    }
}
 
void ColorSet::colors_changed()
{
    // Send signals about this change
    if (!_blocked) {
        block();
        signal_changed.emit();
        unblock();
    }
}
 
void ColorSet::colors_cleared()
{
    if (!_blocked) {
        block();
        signal_cleared.emit();
        unblock();
    }
}
 
bool ColorSet::isSame() const
{
    if (_colors.empty())
        return true;
    for (auto const &[id, color] : _colors) {
        if (color != _colors[0].second)
            return false;
    }
    return true;
}
 
unsigned ColorSet::setAll(Color const &other)
{
    unsigned changed = 0;
    for (auto &[id, color] : _colors) {
        auto was = color;
        color.set(other, true);
        // Comparison after possible color space conversion
        changed += (was != color);
    }
    if (changed) {
        colors_changed();
    }
    return changed;
}
 
unsigned ColorSet::setAll(ColorSet const &other)
{
    unsigned changed = 0;
    for (auto &[id, color] : other) {
        changed += _set(id, color);
    }
    if (changed > 0) {
        colors_changed();
    }
    return changed;
}
 
bool ColorSet::set(std::string id, Color const &other)
{
    if (_set(std::move(id), other)) {
        colors_changed();
        return true;
    }
    return false;
}
 
bool ColorSet::set(Color const &other)
{
    // Always clear the colors if it's being used differently
    if (_colors.size() != 1 || _colors[0].first != "single")
        _colors.clear();
    return set("single", other);
}
 
std::optional<Color> ColorSet::get() const
{
    return get("single");
}
 
/*
 * Internal function for setting a color by id without calling the changed singal.
 */
bool ColorSet::_set(std::string id, Color const &other)
{
    for (auto &[cid, color] : _colors) {
        if (cid == id) {
            auto was = color;
            color.set(other, true);
            return was != color;
        }
    }
    // Add a new entry for this id
    Color copy = other;
 
    // Enforce constraints on space and alpha if any
    if (_space_constraint)
        copy.convert(_space_constraint);
 
    if (_alpha_constraint) {
        copy.enableOpacity(*_alpha_constraint);
    }
 
    _colors.emplace_back(std::move(id), copy);
    return true;
}
 
std::optional<Color> ColorSet::get(std::string const &id) const
{
    for (auto &[cid, color] : _colors) {
        if (cid == id)
            return color.normalized();
    }
    return {};
}
 
unsigned ColorSet::setAll(Space::Component const &c, double value)
{
    if (!isValid(c)) {
        throw ColorError("Incompatible color component used in ColorSet::set.");
    }
    unsigned changed = 0;
    for (auto &[id, color] : _colors) {
        auto was = color;
        color.set(c.index, value);
        // Comparison after possible color space conversion
        changed += (was != color);
    }
    if (changed) {
        colors_changed();
    }
    return changed;
}
 
void ColorSet::setAverage(Space::Component const &c, double value)
{
    if (!_space_constraint || _space_constraint->getType() != c.type)
        throw ColorError("Incompatible color component used in ColorSet::moveAverageTo.");
    auto delta = value - getAverage(c);
    for (auto &[id, color] : _colors) {
        color.set(c.index, color[c.index] + delta);
    }
    colors_changed();
}
 
double ColorSet::getAverage(Space::Component const &c) const {
    if (!isValid(c)) {
        throw ColorError("Incompatible color component used in ColorSet::get.");
    }
    double value = 0.0;
    for (auto const &[id, color] : _colors) {
        value += color[c.index];
    }
    return c.normalize(value / _colors.size());
}
 
std::vector<double> ColorSet::getAll(Space::Component const &c) const
{
    if (!isValid(c)) {
        throw ColorError("Incompatible color component used in ColorSet::getAll.");
    }
    std::vector<double> ret(_colors.size());
    std::transform(_colors.begin(), _colors.end(), ret.begin(),
                   [c](auto &iter) { return c.normalize(iter.second[c.index]); });
    return ret;
}
 
std::shared_ptr<Space::AnySpace> ColorSet::getBestSpace() const
{
    if (_space_constraint)
        return _space_constraint;
 
    unsigned biggest = 0;
    std::shared_ptr<Space::AnySpace> ret;
    std::map<std::shared_ptr<Space::AnySpace>, unsigned> counts;
    for (auto const &[id, color] : _colors) {
        if (++counts[color.getSpace()] > biggest) {
            biggest = counts[color.getSpace()];
            ret = color.getSpace();
        }
    }
    return ret;
}
 
bool ColorSet::isValid(const Space::Component& component) const {
    return _space_constraint && _space_constraint->getType() == component.type;
}
 
Color ColorSet::getAverage() const
{
    if (isEmpty())
        throw ColorError("Can't get the average color of no colors.");
 
    auto avg_space = getBestSpace();
    auto avg_alpha = _alpha_constraint.value_or(true);
 
    std::vector<double> values(avg_space->getComponentCount() + avg_alpha);
 
    for (auto const &[id, color] : _colors) {
        // Colors::Color will return the alpha channel as 1.0 if it doesn't exist.
        if (color.getSpace() == avg_space) {
            for (unsigned int i = 0; i < values.size(); i++) {
                values[i] += color[i];
            }
        } else if (auto copy = color.converted(avg_space)) {
            for (unsigned int i = 0; i < values.size(); i++) {
                values[i] += (*copy)[i];
            }
        }
    }
    for (double &value : values) {
        value /= _colors.size();
    }
    return Color(avg_space, values);
}
 
unsigned ColorSet::size() const
{
    return _colors.size();
}
 
} // 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:fileencoding=utf-8:textwidth=99 :