[prev in list] [next in list] [prev in thread] [next in thread]
List: kde-commits
Subject: [krita] plugins/dockers/artisticcolorselector: ArtColorSel: KisColor refactoring
From: Anna Medonosova <null () kde ! org>
Date: 2018-09-26 5:44:25
Message-ID: E1g52cb-0000ay-HV () code ! kde ! org
[Download RAW message or body]
Git commit 65dbd1290151a329b3728969925a3043d931d401 by Anna Medonosova.
Committed on 26/09/2018 at 05:44.
Pushed by amedonosova into branch 'master'.
ArtColorSel: KisColor refactoring
Summary:
KisColor now uses KisDisplayColorConverter and it's functions, like Advanced Color \
Selector. The color spaces behave like Advanced Selector's. That solves small issues \
with the selector's original color spaces and also enables the benefits of color \
management.
The selector accepts and sets fg and bg color as KoColor.
Reviewers: #krita, dkazakov
Reviewed By: #krita, dkazakov
Subscribers: lsegovia
Tags: #krita
Differential Revision: https://phabricator.kde.org/D15554
M +64 -26 plugins/dockers/artisticcolorselector/artisticcolorselector_dock.cpp
M +4 -3 plugins/dockers/artisticcolorselector/artisticcolorselector_dock.h
M +153 -40 plugins/dockers/artisticcolorselector/forms/wdgARCSSettings.ui
M +5 -0 plugins/dockers/artisticcolorselector/kis_arcs_constants.h
M +111 -111 plugins/dockers/artisticcolorselector/kis_color.cpp
M +61 -86 plugins/dockers/artisticcolorselector/kis_color.h
M +129 -103 plugins/dockers/artisticcolorselector/kis_color_selector.cpp
M +22 -13 plugins/dockers/artisticcolorselector/kis_color_selector.h
https://commits.kde.org/krita/65dbd1290151a329b3728969925a3043d931d401
diff --git a/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.cpp \
b/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.cpp index \
ae3595e3453..76b4dfd068a 100644
--- a/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.cpp
+++ b/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.cpp
@@ -23,6 +23,7 @@
#include <KoResourceServerObserver.h>
#include <KoResourceServerAdapter.h>
#include <KoCanvasBase.h>
+#include <kis_canvas2.h>
#include <KoColor.h>
#include <resources/KoGamutMask.h>
#include <kis_icon_utils.h>
@@ -33,8 +34,8 @@
#include <kis_node_selection_adapter.h>
#include <kis_group_layer.h>
#include <KisView.h>
-//#include <kis_node_manager.h>
#include <KoResourceItemChooser.h>
+#include <kis_display_color_converter.h>
#include <QWidget>
#include <QMenu>
@@ -46,7 +47,6 @@
#include "artisticcolorselector_dock.h"
#include <KisViewManager.h>
#include <kis_canvas_resource_provider.h>
-#include <kis_arcs_constants.h>
#include "ui_wdgArtisticColorSelector.h"
#include "ui_wdgARCSSettings.h"
@@ -78,9 +78,12 @@ struct WheelPreferencesPopupUI: public QWidget, public \
Ui_wdgWheelPreferencesPop
ArtisticColorSelectorDock::ArtisticColorSelectorDock()
: QDockWidget(i18n("Artistic Color Selector"))
+ , m_canvas(nullptr)
, m_resourceProvider(0)
, m_selectedMask(nullptr)
{
+ setEnabled(false);
+
m_hsxButtons = new QButtonGroup();
m_preferencesUI = new ARCSSettingsUI();
m_wheelPrefsUI = new WheelPreferencesPopupUI();
@@ -168,7 +171,10 @@ ArtisticColorSelectorDock::ArtisticColorSelectorDock()
m_preferencesUI->permissiveGamutMask->setChecked(!m_selectorUI->colorSelector->enforceGamutMask());
m_preferencesUI->showMaskPreview->setChecked(m_selectorUI->colorSelector->maskPreviewActive());
- m_preferencesUI->valueScaleGamma->setValue(m_selectorUI->colorSelector->gamma());
+ m_preferencesUI->spLumaR->setValue(m_selectorUI->colorSelector->lumaR());
+ m_preferencesUI->spLumaG->setValue(m_selectorUI->colorSelector->lumaG());
+ m_preferencesUI->spLumaB->setValue(m_selectorUI->colorSelector->lumaB());
+ m_preferencesUI->spLumaGamma->setValue(m_selectorUI->colorSelector->lumaGamma());
switch(m_selectorUI->colorSelector->getColorSpace())
{
@@ -179,9 +185,9 @@ ArtisticColorSelectorDock::ArtisticColorSelectorDock()
}
if (m_selectorUI->colorSelector->getColorSpace() == KisColor::HSY) {
- m_preferencesUI->valueScaleGammaBox->show();
+ m_preferencesUI->lumaCoefficientBox->show();
} else {
- m_preferencesUI->valueScaleGammaBox->hide();
+ m_preferencesUI->lumaCoefficientBox->hide();
}
connect(m_wheelPrefsUI->numValueScaleSteps , SIGNAL(valueChanged(int)) \
, SLOT(slotPreferenceChanged())); @@ -203,7 +209,11 @@ \
ArtisticColorSelectorDock::ArtisticColorSelectorDock()
connect(m_preferencesUI->showValueScaleNumbers, SIGNAL(toggled(bool)) \
, SLOT(slotPreferenceChanged()));
connect(m_preferencesUI->enforceGamutMask , SIGNAL(toggled(bool)) \
, SLOT(slotPreferenceChanged()));
connect(m_preferencesUI->showMaskPreview , SIGNAL(toggled(bool)), \
SLOT(slotGamutMaskActivatePreview(bool)));
- connect(m_preferencesUI->valueScaleGamma , SIGNAL(valueChanged(qreal)), \
SLOT(slotSetGamma(qreal))); +
+ connect(m_preferencesUI->spLumaR , SIGNAL(valueChanged(qreal)), \
SLOT(slotColorSpaceSelected())); + connect(m_preferencesUI->spLumaG , \
SIGNAL(valueChanged(qreal)), SLOT(slotColorSpaceSelected())); + \
connect(m_preferencesUI->spLumaB , SIGNAL(valueChanged(qreal)), \
SLOT(slotColorSpaceSelected())); + connect(m_preferencesUI->spLumaGamma , \
SIGNAL(valueChanged(qreal)), SLOT(slotColorSpaceSelected()));
connect(m_selectorUI->colorSelector , SIGNAL(sigFgColorChanged(const \
KisColor&)) , SLOT(slotFgColorChanged(const KisColor&)));
connect(m_selectorUI->colorSelector , SIGNAL(sigBgColorChanged(const \
KisColor&)) , SLOT(slotBgColorChanged(const KisColor&))); @@ -211,7 +221,7 @@ \
ArtisticColorSelectorDock::ArtisticColorSelectorDock() // gamut mask connections
connect(m_selectorUI->bnToggleMask , SIGNAL(toggled(bool)) \
, SLOT(slotGamutMaskToggle(bool)));
- connect(m_hsxButtons , SIGNAL(buttonClicked(int)) \
, SLOT(slotColorSpaceSelected(int))); + connect(m_hsxButtons \
, SIGNAL(buttonClicked(int)) , SLOT(slotColorSpaceSelected()));
setWidget(m_selectorUI);
}
@@ -225,10 +235,8 @@ ArtisticColorSelectorDock::~ArtisticColorSelectorDock()
void ArtisticColorSelectorDock::setViewManager(KisViewManager* kisview)
{
m_resourceProvider = kisview->resourceProvider();
- m_selectorUI->colorSelector->setFgColor(m_resourceProvider->resourceManager()->foregroundColor().toQColor());
- m_selectorUI->colorSelector->setBgColor(m_resourceProvider->resourceManager()->backgroundColor().toQColor());
- connect(m_resourceProvider->resourceManager(), SIGNAL(canvasResourceChanged(int, \
const QVariant&)),
- SLOT(slotCanvasResourceChanged(int, const QVariant&)));
+ m_selectorUI->colorSelector->setFgColor(m_resourceProvider->resourceManager()->foregroundColor());
+ m_selectorUI->colorSelector->setBgColor(m_resourceProvider->resourceManager()->backgroundColor());
connect(m_resourceProvider, SIGNAL(sigGamutMaskChanged(KoGamutMask*)),
this, SLOT(slotGamutMaskSet(KoGamutMask*)));
@@ -245,40 +253,45 @@ void ArtisticColorSelectorDock::setViewManager(KisViewManager* \
kisview) void ArtisticColorSelectorDock::slotCanvasResourceChanged(int key, const \
QVariant& value) {
if(key == KoCanvasResourceManager::ForegroundColor)
- m_selectorUI->colorSelector->setFgColor(value.value<KoColor>().toQColor());
+ m_selectorUI->colorSelector->setFgColor(value.value<KoColor>());
if(key == KoCanvasResourceManager::BackgroundColor)
- m_selectorUI->colorSelector->setBgColor(value.value<KoColor>().toQColor());
+ m_selectorUI->colorSelector->setBgColor(value.value<KoColor>());
}
void ArtisticColorSelectorDock::slotFgColorChanged(const KisColor& color)
{
m_resourceProvider->resourceManager()->setForegroundColor(
- KoColor(color.getQColor(), \
m_resourceProvider->resourceManager()->foregroundColor().colorSpace()) + \
KoColor(color.toKoColor(), \
m_resourceProvider->resourceManager()->foregroundColor().colorSpace()) );
}
void ArtisticColorSelectorDock::slotBgColorChanged(const KisColor& color)
{
m_resourceProvider->resourceManager()->setBackgroundColor(
- KoColor(color.getQColor(), \
m_resourceProvider->resourceManager()->backgroundColor().colorSpace()) + \
KoColor(color.toKoColor(), \
m_resourceProvider->resourceManager()->backgroundColor().colorSpace()) );
}
-void ArtisticColorSelectorDock::slotColorSpaceSelected(int type)
+void ArtisticColorSelectorDock::slotColorSpaceSelected()
{
- m_selectorUI->colorSelector->setColorSpace(static_cast<KisColor::Type>(type), \
m_preferencesUI->valueScaleGamma->value()); + KisColor::Type type = \
static_cast<KisColor::Type>( + \
m_hsxButtons->id(m_hsxButtons->checkedButton()));
- if (m_selectorUI->colorSelector->getColorSpace() == KisColor::HSY) {
- m_preferencesUI->valueScaleGammaBox->show();
+ m_selectorUI->colorSelector->setColorSpace(type);
+
+ if (type == KisColor::HSY) {
+ m_preferencesUI->lumaCoefficientBox->show();
} else {
- m_preferencesUI->valueScaleGammaBox->hide();
+ m_preferencesUI->lumaCoefficientBox->hide();
}
-}
-void ArtisticColorSelectorDock::slotSetGamma(qreal gamma)
-{
- m_selectorUI->colorSelector->setGamma(gamma);
+ m_selectorUI->colorSelector->setLumaCoefficients(
+ m_preferencesUI->spLumaR->value(),
+ m_preferencesUI->spLumaG->value(),
+ m_preferencesUI->spLumaB->value(),
+ m_preferencesUI->spLumaGamma->value()
+ );
}
void ArtisticColorSelectorDock::slotPreferenceChanged()
@@ -342,7 +355,6 @@ void ArtisticColorSelectorDock::slotPreferenceChanged()
m_wheelPrefsUI->bnInverseSat->setChecked(false);
m_selectorUI->colorSelector->setInverseSaturation(false);
}
-
}
void ArtisticColorSelectorDock::slotResetDefaultSettings()
@@ -429,12 +441,33 @@ void ArtisticColorSelectorDock::slotGamutMaskToggle(bool \
checked)
void ArtisticColorSelectorDock::setCanvas(KoCanvasBase *canvas)
{
- setEnabled(canvas != 0);
+ if (!canvas) {
+ return;
+ }
+
+ m_canvas = dynamic_cast<KisCanvas2*>(canvas);
+
+ if (m_canvas) {
+ m_canvas->disconnectCanvasObserver(this);
+ }
+
+ if (m_canvas) {
+ connect(m_canvas->resourceManager(), SIGNAL(canvasResourceChanged(int, const \
QVariant&)), + SLOT(slotCanvasResourceChanged(int, const QVariant&)));
+
+ connect(m_canvas->displayColorConverter(), \
SIGNAL(displayConfigurationChanged()), + \
SLOT(slotSelectorSettingsChanged())); +
+ m_selectorUI->colorSelector->setColorConverter(m_canvas->displayColorConverter());
+ setEnabled(true);
+ }
}
void ArtisticColorSelectorDock::unsetCanvas()
{
setEnabled(false);
+ m_canvas = nullptr;
+ m_selectorUI->colorSelector->setColorConverter(KisDisplayColorConverter::dumbConverterInstance());
}
void ArtisticColorSelectorDock::slotGamutMaskSet(KoGamutMask *mask)
@@ -472,3 +505,8 @@ void ArtisticColorSelectorDock::slotGamutMaskPreviewUpdate()
{
m_selectorUI->colorSelector->update();
}
+
+void ArtisticColorSelectorDock::slotSelectorSettingsChanged()
+{
+ m_selectorUI->colorSelector->update();
+}
diff --git a/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.h \
b/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.h index \
559bb06cd8e..9b82125554a 100644
--- a/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.h
+++ b/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.h
@@ -51,15 +51,14 @@ public:
~ArtisticColorSelectorDock() override;
QString observerName() override { return "ArtisticColorSelectorDock"; }
void setViewManager(KisViewManager* kisview) override;
- void setCanvas(KoCanvasBase *canvas) override;
+ void setCanvas(KoCanvasBase* canvas) override;
void unsetCanvas() override;
private Q_SLOTS:
void slotCanvasResourceChanged(int key, const QVariant& value);
void slotFgColorChanged(const KisColor& color);
void slotBgColorChanged(const KisColor& color);
- void slotColorSpaceSelected(int type);
- void slotSetGamma(qreal gamma);
+ void slotColorSpaceSelected();
void slotPreferenceChanged();
void slotResetDefaultSettings();
void slotGamutMaskToggle(bool value);
@@ -67,8 +66,10 @@ private Q_SLOTS:
void slotGamutMaskSet(KoGamutMask* mask);
void slotGamutMaskUnset();
void slotGamutMaskPreviewUpdate();
+ void slotSelectorSettingsChanged();
private:
+ KisCanvas2* m_canvas;
KisCanvasResourceProvider* m_resourceProvider;
QButtonGroup* m_hsxButtons;
ArtisticColorSelectorUI* m_selectorUI;
diff --git a/plugins/dockers/artisticcolorselector/forms/wdgARCSSettings.ui \
b/plugins/dockers/artisticcolorselector/forms/wdgARCSSettings.ui index \
53e899a9f9c..9ecbd7d0b56 100644
--- a/plugins/dockers/artisticcolorselector/forms/wdgARCSSettings.ui
+++ b/plugins/dockers/artisticcolorselector/forms/wdgARCSSettings.ui
@@ -6,8 +6,8 @@
<rect>
<x>0</x>
<y>0</y>
- <width>358</width>
- <height>472</height>
+ <width>446</width>
+ <height>769</height>
</rect>
</property>
<layout class="QVBoxLayout" name="verticalLayout">
@@ -95,49 +95,157 @@
</layout>
</item>
<item>
- <widget class="QFrame" name="valueScaleGammaBox">
- <property name="frameShape">
- <enum>QFrame::NoFrame</enum>
+ <widget class="QGroupBox" name="lumaCoefficientBox">
+ <property name="sizePolicy">
+ <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+ <horstretch>0</horstretch>
+ <verstretch>0</verstretch>
+ </sizepolicy>
</property>
- <layout class="QHBoxLayout" name="horizontalLayout_2">
- <item>
- <widget class="QLabel" name="labelValueScaleGamma">
- <property name="text">
- <string>Value Scale Gamma</string>
- </property>
- </widget>
- </item>
+ <property name="title">
+ <string>Luma Coefficients</string>
+ </property>
+ <layout class="QHBoxLayout" name="horizontalLayout_15">
<item>
- <widget class="QDoubleSpinBox" name="valueScaleGamma">
- <property name="decimals">
- <number>1</number>
+ <layout class="QGridLayout" name="gridLayout_5">
+ <property name="leftMargin">
+ <number>0</number>
</property>
- <property name="minimum">
- <double>0.100000000000000</double>
+ <property name="rightMargin">
+ <number>0</number>
</property>
- <property name="maximum">
- <double>50.000000000000000</double>
+ <property name="verticalSpacing">
+ <number>6</number>
</property>
- <property name="singleStep">
- <double>0.100000000000000</double>
- </property>
- <property name="value">
- <double>1.000000000000000</double>
- </property>
- </widget>
- </item>
- <item>
- <spacer name="horizontalSpacer">
- <property name="orientation">
- <enum>Qt::Horizontal</enum>
- </property>
- <property name="sizeHint" stdset="0">
- <size>
- <width>40</width>
- <height>20</height>
- </size>
- </property>
- </spacer>
+ <item row="0" column="3">
+ <widget class="KisDoubleParseSpinBox" name="spLumaG">
+ <property name="sizePolicy">
+ <sizepolicy hsizetype="Fixed" vsizetype="Minimum">
+ <horstretch>0</horstretch>
+ <verstretch>0</verstretch>
+ </sizepolicy>
+ </property>
+ <property name="minimumSize">
+ <size>
+ <width>50</width>
+ <height>0</height>
+ </size>
+ </property>
+ <property name="decimals">
+ <number>4</number>
+ </property>
+ </widget>
+ </item>
+ <item row="0" column="2">
+ <widget class="QLabel" name="greenlabel">
+ <property name="sizePolicy">
+ <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
+ <horstretch>0</horstretch>
+ <verstretch>0</verstretch>
+ </sizepolicy>
+ </property>
+ <property name="text">
+ <string>Green':</string>
+ </property>
+ </widget>
+ </item>
+ <item row="0" column="4">
+ <widget class="QLabel" name="bluelabel">
+ <property name="sizePolicy">
+ <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
+ <horstretch>0</horstretch>
+ <verstretch>0</verstretch>
+ </sizepolicy>
+ </property>
+ <property name="text">
+ <string>Blue':</string>
+ </property>
+ </widget>
+ </item>
+ <item row="0" column="1">
+ <widget class="KisDoubleParseSpinBox" name="spLumaR">
+ <property name="sizePolicy">
+ <sizepolicy hsizetype="Fixed" vsizetype="Minimum">
+ <horstretch>0</horstretch>
+ <verstretch>0</verstretch>
+ </sizepolicy>
+ </property>
+ <property name="minimumSize">
+ <size>
+ <width>50</width>
+ <height>0</height>
+ </size>
+ </property>
+ <property name="decimals">
+ <number>4</number>
+ </property>
+ </widget>
+ </item>
+ <item row="0" column="5">
+ <widget class="KisDoubleParseSpinBox" name="spLumaB">
+ <property name="sizePolicy">
+ <sizepolicy hsizetype="Fixed" vsizetype="Minimum">
+ <horstretch>0</horstretch>
+ <verstretch>0</verstretch>
+ </sizepolicy>
+ </property>
+ <property name="minimumSize">
+ <size>
+ <width>50</width>
+ <height>0</height>
+ </size>
+ </property>
+ <property name="decimals">
+ <number>4</number>
+ </property>
+ </widget>
+ </item>
+ <item row="1" column="1">
+ <widget class="KisDoubleParseSpinBox" name="spLumaGamma">
+ <property name="toolTip">
+ <string><html><head/><body><p>This sets the \
gamma value that the linearised HSY Luminosity is crunched with. 1 makes the selector \
fully linear, 2.2 is a practical default \
value.</p></body></html></string> + </property>
+ <property name="decimals">
+ <number>1</number>
+ </property>
+ <property name="minimum">
+ <double>-3.000000000000000</double>
+ </property>
+ <property name="maximum">
+ <double>3.000000000000000</double>
+ </property>
+ <property name="singleStep">
+ <double>0.100000000000000</double>
+ </property>
+ <property name="value">
+ <double>2.200000000000000</double>
+ </property>
+ </widget>
+ </item>
+ <item row="1" column="0">
+ <widget class="QLabel" name="gamma_label">
+ <property name="text">
+ <string>Gamma:</string>
+ </property>
+ </widget>
+ </item>
+ <item row="0" column="0">
+ <widget class="QLabel" name="redlabel">
+ <property name="sizePolicy">
+ <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
+ <horstretch>0</horstretch>
+ <verstretch>0</verstretch>
+ </sizepolicy>
+ </property>
+ <property name="text">
+ <string>Red': </string>
+ </property>
+ <property name="alignment">
+ <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+ </property>
+ </widget>
+ </item>
+ </layout>
</item>
</layout>
</widget>
@@ -292,6 +400,11 @@
</layout>
</widget>
<customwidgets>
+ <customwidget>
+ <class>KisDoubleParseSpinBox</class>
+ <extends>QDoubleSpinBox</extends>
+ <header>kis_double_parse_spin_box.h</header>
+ </customwidget>
<customwidget>
<class>KisSliderSpinBox</class>
<extends>QWidget</extends>
diff --git a/plugins/dockers/artisticcolorselector/kis_arcs_constants.h \
b/plugins/dockers/artisticcolorselector/kis_arcs_constants.h index \
0c3be3bdbc2..74837691f81 100644
--- a/plugins/dockers/artisticcolorselector/kis_arcs_constants.h
+++ b/plugins/dockers/artisticcolorselector/kis_arcs_constants.h
@@ -34,6 +34,11 @@ static const int DEFAULT_HUE_STEPS = 12;
static const int DEFAULT_SATURATION_STEPS = 7;
static const int DEFAULT_VALUE_SCALE_STEPS = 11;
+static const qreal DEFAULT_LUMA_R = 0.2126;
+static const qreal DEFAULT_LUMA_G = 0.7152;
+static const qreal DEFAULT_LUMA_B = 0.0722;
+static const qreal DEFAULT_LUMA_GAMMA = 2.2;
+
// color scheme for the selector
static const QColor COLOR_MIDDLE_GRAY = QColor(128,128,128,255);
static const QColor COLOR_DARK = QColor(20,20,20,255);
diff --git a/plugins/dockers/artisticcolorselector/kis_color.cpp \
b/plugins/dockers/artisticcolorselector/kis_color.cpp index 51145c6bcdf..ed84d91c015 \
100644
--- a/plugins/dockers/artisticcolorselector/kis_color.cpp
+++ b/plugins/dockers/artisticcolorselector/kis_color.cpp
@@ -16,153 +16,153 @@
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#include <KoColorSpaceMaths.h>
+#include <KoColor.h>
#include "kis_color.h"
+#include <kis_arcs_constants.h>
-/////////////////////////////////////////////////////////////////////////////////////////////////
-// --------- CoreImpl \
------------------------------------------------------------------------ //
-template<class HSXType>
-struct CoreImpl: public KisColor::Core
+KisColor::KisColor(KisDisplayColorConverter* converter, Type type,
+ qreal lR, qreal lG, qreal lB, qreal lGamma)
{
- void setRGB(float r, float g, float b, float a) override {
- rgb(0) = r;
- rgb(1) = g;
- rgb(2) = b;
- hsx(3) = a;
- updateHSX();
- }
-
- void setHSX(float h, float s, float x, float a) override {
- hsx(0) = h;
- hsx(1) = s;
- hsx(2) = x;
- hsx(3) = a;
- updateRGB();
- }
-
- void updateRGB() override {
- float h = qBound(0.0f, hsx(0), 1.0f);
- float s = qBound(0.0f, hsx(1), 1.0f);
- float x = qBound(0.0f, hsx(2), 1.0f);
-
- KisColor::VecRGB gray(x, x, x);
- ::getRGB(rgb(0), rgb(1), rgb(2), h);
- ::setLightness<HSXType>(rgb(0), rgb(1), rgb(2), x);
- rgb = gray + (rgb - gray) * s;
- }
-
- void updateHSX() override {
- float r = qBound(0.0f, rgb(0), 1.0f);
- float g = qBound(0.0f, rgb(1), 1.0f);
- float b = qBound(0.0f, rgb(2), 1.0f);
-
- float h = ::getHue(r, g, b);
- float x = ::getLightness<HSXType>(r, g, b);
- KisColor::VecRGB hue(0.0, 0.0, 0.0);
- ::getRGB(hue(0), hue(1), hue(2), h);
- ::setLightness<HSXType>(hue(0), hue(1), hue(2), x);
- KisColor::VecRGB diff1 = hue - KisColor::VecRGB(x,x,x);
- KisColor::VecRGB diff2 = rgb - KisColor::VecRGB(x,x,x);
-
- hsx(0) = h;
- hsx(1) = diff1.dot(diff2) / diff1.squaredNorm(); // project rgb onto \
(VecRGB(x,x,x) - hue)
- hsx(2) = x;
- }
-};
-
-/////////////////////////////////////////////////////////////////////////////////////////////////
-// --------- KisColor \
------------------------------------------------------------------------ // + \
m_colorConverter = converter; + m_type = type;
+ m_lumaR = lR;
+ m_lumaG = lG;
+ m_lumaB = lB;
+ m_lumaGamma = lGamma;
+
+ initHSX(type, 0.0, 0.0, 0.0);
+}
-KisColor::KisColor(Type type)
+KisColor::KisColor(qreal hue, KisDisplayColorConverter* converter, Type type,
+ qreal lR, qreal lG, qreal lB, qreal lGamma)
{
- initRGB(type, 0.0f, 0.0f, 0.0f, 1.0f);
+ m_colorConverter = converter;
+ m_type = type;
+ m_lumaR = lR;
+ m_lumaG = lG;
+ m_lumaB = lB;
+ m_lumaGamma = lGamma;
+
+ initHSX(type, hue, 0.0, 0.0);
}
-KisColor::KisColor(float hue, float a, Type type)
+KisColor::KisColor(const QColor& color, KisDisplayColorConverter* converter, Type \
type, + qreal lR, qreal lG, qreal lB, qreal lGamma)
{
- float r = 0;
- float g = 0;
- float b = 0;
- ::getRGB(r, g, b, hue);
- initRGB(type, r, g, b, a);
+ m_colorConverter = converter;
+ m_type = type;
+ m_lumaR = lR;
+ m_lumaG = lG;
+ m_lumaB = lB;
+ m_lumaGamma = lGamma;
+
+ KoColor koColor = m_colorConverter->approximateFromRenderedQColor(color);
+ fromKoColor(koColor);
}
-KisColor::KisColor(float r, float g, float b, float a, Type type)
+KisColor::KisColor(Qt::GlobalColor color, KisDisplayColorConverter* converter,
+ Type type, qreal lR, qreal lG, qreal lB, qreal lGamma)
{
- initRGB(type, r, g, b, a);
+ QColor c(color);
+ m_colorConverter = converter;
+ m_type = type;
+ m_lumaR = lR;
+ m_lumaG = lG;
+ m_lumaB = lB;
+ m_lumaGamma = lGamma;
+
+ KoColor koColor = m_colorConverter->approximateFromRenderedQColor(c);
+ fromKoColor(koColor);
}
-KisColor::KisColor(const QColor& color, Type type)
+KisColor::KisColor(const KisColor& color)
{
- initRGB(type, color.redF(), color.greenF(), color.blueF(), color.alphaF());
+ m_colorConverter = color.colorConverter();
+ m_lumaR = color.lumaR();
+ m_lumaG = color.lumaG();
+ m_lumaB = color.lumaB();
+ m_lumaGamma = color.lumaGamma();
+ initHSX(color.getType(), color.getH(), color.getS(), color.getX());
}
-KisColor::KisColor(Qt::GlobalColor color, Type type)
+KisColor::KisColor(const KoColor &color, KisDisplayColorConverter* converter, \
KisColor::Type type, + qreal lR, qreal lG, qreal lB, qreal lGamma)
{
- QColor c(color);
- initRGB(type, c.redF(), c.greenF(), c.blueF(), c.alphaF());
+ m_colorConverter = converter;
+ m_type = type;
+ m_lumaR = lR;
+ m_lumaG = lG;
+ m_lumaB = lB;
+ m_lumaGamma = lGamma;
+ fromKoColor(color);
}
-KisColor::KisColor(const KisColor& color)
+KisColor::KisColor(const KisColor& color, KisColor::Type type,
+ qreal lR, qreal lG, qreal lB, qreal lGamma)
{
- initHSX(color.getType(), color.getH(), color.getS(), color.getX(), \
color.getA()); + m_colorConverter = color.colorConverter();
+ m_type = type;
+ m_lumaR = lR;
+ m_lumaG = lG;
+ m_lumaB = lB;
+ m_lumaGamma = lGamma;
+ initHSX(type, color.getH(), color.getS(), color.getX());
}
-KisColor::KisColor(const KisColor& color, KisColor::Type type)
+KisColor::~KisColor()
{
- if(color.getType() == type)
- initHSX(type, color.getH(), color.getS(), color.getX(), color.getA());
- else
- initRGB(type, color.getR(), color.getG(), color.getB(), color.getA());
}
-KisColor::~KisColor()
+QColor KisColor::toQColor() const
{
- core()->~Core();
+ return m_colorConverter->toQColor(toKoColor());
}
-void KisColor::initRGB(Type type, float r, float g, float b, float a)
+KoColor KisColor::toKoColor() const
{
- // an offset that is added to the m_coreData buffer to make sure
- // the struct created with the placement new operator is aligned at 16 bytes
- // this is required by Eigen for vectorization
- m_offset = quint8(16 - (reinterpret_cast<size_t>(m_coreData) % 16)) % 16;
-
- switch(type)
- {
- case HSY: { new (m_coreData + m_offset) CoreImpl<HSYType>; } break;
- case HSV: { new (m_coreData + m_offset) CoreImpl<HSVType>; } break;
- case HSL: { new (m_coreData + m_offset) CoreImpl<HSLType>; } break;
- case HSI: { new (m_coreData + m_offset) CoreImpl<HSIType>; } break;
+ KoColor color;
+
+ switch (m_type) {
+ case HSV:
+ color = m_colorConverter->fromHsvF(m_hue, m_saturation, m_value);
+ break;
+ case HSI:
+ color = m_colorConverter->fromHsiF(m_hue, m_saturation, m_value);
+ break;
+ case HSL:
+ color = m_colorConverter->fromHslF(m_hue, m_saturation, m_value);
+ break;
+ case HSY:
+ color = m_colorConverter->fromHsyF(m_hue, m_saturation, m_value, m_lumaR, \
m_lumaG, m_lumaB, m_lumaGamma); + break;
}
-
- core()->type = type;
- core()->setRGB(r, g, b, a);
+
+ return color;
}
-void KisColor::initHSX(Type type, float h, float s, float x, float a)
+void KisColor::fromKoColor(const KoColor& color)
{
- // an offset that is added to the m_coreData buffer to make sure
- // the struct created with the placement new operator is aligned at 16 bytes
- // this is required by Eigen for vectorization
- m_offset = quint8(16 - (reinterpret_cast<size_t>(m_coreData) % 16)) % 16;
-
- switch(type)
- {
- case HSY: { new (m_coreData + m_offset) CoreImpl<HSYType>; } break;
- case HSV: { new (m_coreData + m_offset) CoreImpl<HSVType>; } break;
- case HSL: { new (m_coreData + m_offset) CoreImpl<HSLType>; } break;
- case HSI: { new (m_coreData + m_offset) CoreImpl<HSIType>; } break;
+ switch (m_type) {
+ case HSV:
+ m_colorConverter->getHsvF(color, &m_hue, &m_saturation, &m_value);
+ break;
+ case HSI:
+ m_colorConverter->getHsiF(color, &m_hue, &m_saturation, &m_value);
+ break;
+ case HSL:
+ m_colorConverter->getHsvF(color, &m_hue, &m_saturation, &m_value);
+ break;
+ case HSY:
+ m_colorConverter->getHsyF(color, &m_hue, &m_saturation, &m_value, m_lumaR, \
m_lumaG, m_lumaB, m_lumaGamma); + break;
}
-
- core()->type = type;
- core()->setHSX(h, s, x, a);
}
-KisColor& KisColor::operator=(const KisColor& color)
+void KisColor::initHSX(Type type, qreal h, qreal s, qreal x)
{
- initHSX(color.getType(), color.getH(), color.getS(), color.getX(), \
color.getA());
- return *this;
+ m_type = type;
+ m_hue = h;
+ m_saturation = s;
+ m_value = x;
}
-
diff --git a/plugins/dockers/artisticcolorselector/kis_color.h \
b/plugins/dockers/artisticcolorselector/kis_color.h index a715fb09139..f1001846f90 \
100644
--- a/plugins/dockers/artisticcolorselector/kis_color.h
+++ b/plugins/dockers/artisticcolorselector/kis_color.h
@@ -21,107 +21,82 @@
#define H_KIS_COLOR_H
#include <QtGlobal>
-#include <Eigen/Core>
#include <QColor>
+#include <kis_display_color_converter.h>
+#include <kis_arcs_constants.h>
+
class KisColor
{
public:
enum Type { HSY, HSV, HSL, HSI };
- typedef Eigen::Vector4f VecHSXA;
- typedef Eigen::Vector3f VecRGB;
-
- struct Core
- {
- virtual ~Core() { }
- virtual void setRGB(float r, float g, float b, float a) = 0;
- virtual void setHSX(float h, float s, float x, float a) = 0;
- virtual void updateRGB() = 0;
- virtual void updateHSX() = 0;
-
- VecRGB rgb;
- VecHSXA hsx;
- Type type;
- };
-
-public:
- KisColor(Type type=HSY);
- KisColor(float hue, float a=1.0f, Type type=HSY);
- KisColor(float r, float g, float b, float a=1.0f, Type type=HSY);
- KisColor(const QColor& color, Type type=HSY);
- KisColor(Qt::GlobalColor color, Type type=HSY);
- KisColor(const KisColor& color);
- KisColor(const KisColor& color, Type type);
- ~KisColor();
-
- inline Type getType() const { return core()->type; }
- inline bool hasUndefHue() const { return getS() == 0.0f; }
-
- inline float getR() const { return core()->rgb(0); }
- inline float getG() const { return core()->rgb(1); }
- inline float getB() const { return core()->rgb(2); }
- inline float getH() const { return core()->hsx(0); }
- inline float getS() const { return core()->hsx(1); }
- inline float getX(float gamma=1.0f) const { return pow(core()->hsx(2), 1/gamma); \
}
- inline float getA() const { return core()->hsx(3); }
- inline void setR(float v) { setRGB(v, core()->rgb(1), core()->rgb(2), \
core()->hsx(3)); }
- inline void setG(float v) { setRGB(core()->rgb(0), v, core()->rgb(2), \
core()->hsx(3)); }
- inline void setB(float v) { setRGB(core()->rgb(0), core()->rgb(1), v, \
core()->hsx(3)); }
- inline void setH(float v) { setHSX(v, core()->hsx(1), core()->hsx(2), \
core()->hsx(3)); }
- inline void setS(float v) { setHSX(core()->hsx(0), v, core()->hsx(2), \
core()->hsx(3)); }
- inline void setX(float v, float gamma=1.0f) {
- setHSX(core()->hsx(0), core()->hsx(1), v, core()->hsx(3), gamma);
- }
- inline void setA(float v) { core()->hsx(3) = qBound(0.0f, v, 1.0f); \
}
-
- inline QColor getQColor() const { return QColor(getR()*255, getG()*255, \
getB()*255, getA()*255); }
-
- inline void setRGB(float r, float g, float b, float a=1.0f) { core()->setRGB(r, \
g, b, a); }
- inline void setHSX(float h, float s, float x, float a=1.0f, float gamma=1.0f) {
- core()->setHSX(h, s, pow(x, gamma), a);
- }
+ KisColor(KisDisplayColorConverter *converter = \
KisDisplayColorConverter::dumbConverterInstance(), + Type type=HSY, qreal \
lR = DEFAULT_LUMA_R, qreal lG = DEFAULT_LUMA_G, + qreal lB = \
DEFAULT_LUMA_B, qreal lGamma = DEFAULT_LUMA_GAMMA);
- KisColor& operator = (const KisColor& color);
-
- friend KisColor operator - (const KisColor& a, const KisColor& b) {
- KisColor result;
- result.core()->hsx = a.core()->hsx - b.core()->hsx;
- result.core()->updateRGB();
-
- if(a.hasUndefHue() || b.hasUndefHue())
- result.setH(0.0f);
-
- return result;
- }
-
- friend KisColor operator + (const KisColor& a, const KisColor& b) {
- KisColor result;
- result.core()->hsx = a.core()->hsx + b.core()->hsx;
- result.core()->updateRGB();
- return result;
- }
+ KisColor(qreal hue, KisDisplayColorConverter *converter, Type type,
+ qreal lR = DEFAULT_LUMA_R, qreal lG = DEFAULT_LUMA_G,
+ qreal lB = DEFAULT_LUMA_B, qreal lGamma = DEFAULT_LUMA_GAMMA);
+
+ KisColor(const QColor& color, KisDisplayColorConverter* converter, Type \
type=HSY, + qreal lR = DEFAULT_LUMA_R, qreal lG = DEFAULT_LUMA_G,
+ qreal lB = DEFAULT_LUMA_B, qreal lGamma = DEFAULT_LUMA_GAMMA);
+
+ KisColor(Qt::GlobalColor color, KisDisplayColorConverter* converter, Type \
type=HSY, + qreal lR = DEFAULT_LUMA_R, qreal lG = DEFAULT_LUMA_G,
+ qreal lB = DEFAULT_LUMA_B, qreal lGamma = DEFAULT_LUMA_GAMMA);
+
+ KisColor(const KisColor& color);
+
+ KisColor(const KisColor& color, Type type,
+ qreal lR = DEFAULT_LUMA_R, qreal lG = DEFAULT_LUMA_G,
+ qreal lB = DEFAULT_LUMA_B, qreal lGamma = DEFAULT_LUMA_GAMMA);
+
+ KisColor(const KoColor &color, KisDisplayColorConverter* converter, Type \
type=HSY, + qreal lR = DEFAULT_LUMA_R, qreal lG = DEFAULT_LUMA_G,
+ qreal lB = DEFAULT_LUMA_B, qreal lGamma = DEFAULT_LUMA_GAMMA);
+
+ ~KisColor();
- friend KisColor operator * (const KisColor& a, float b) {
- KisColor result;
- result.core()->hsx = a.core()->hsx * b;
- result.core()->updateRGB();
- return result;
- }
+ inline Type getType() const { return m_type; }
+ inline qreal getH() const { return m_hue; }
+ inline qreal getS() const { return m_saturation; }
+ inline qreal getX() const { return m_value; }
+ inline qreal lumaR() const { return m_lumaR; }
+ inline qreal lumaG() const { return m_lumaG; }
+ inline qreal lumaB() const { return m_lumaB; }
+ inline qreal lumaGamma() const { return m_lumaGamma; }
+
+ inline void setH(qreal v) { m_hue = v; }
+ inline void setS(qreal v) { m_saturation = v; }
+ inline void setX(qreal v) { m_value = v; }
- friend KisColor operator * (float a, const KisColor& b) {
- return b * a;
+ QColor toQColor() const;
+ KoColor toKoColor() const;
+ void fromKoColor(const KoColor &color);
+
+ inline void setHSX(qreal h, qreal s, qreal x) {
+ m_hue = h;
+ m_saturation = s;
+ m_value = x;
}
+
+ inline KisDisplayColorConverter* colorConverter() const { return \
m_colorConverter; }
private:
- void initRGB(Type type, float r, float g, float b, float a);
- void initHSX(Type type, float h, float s, float x, float a);
- inline Core* core() { return reinterpret_cast<Core*> \
(m_coreData + m_offset); }
- inline const Core* core() const { return reinterpret_cast<const \
Core*>(m_coreData + m_offset); } + void initHSX(Type type, qreal h, qreal s, qreal \
x);
private:
- quint8 m_coreData[sizeof(Core) + 15];
- quint8 m_offset;
+ qreal m_hue;
+ qreal m_value;
+ qreal m_saturation;
+ qreal m_lumaR;
+ qreal m_lumaG;
+ qreal m_lumaB;
+ qreal m_lumaGamma;
+ KisColor::Type m_type;
+ KisDisplayColorConverter* m_colorConverter;
};
#endif // H_KIS_COLOR_H
diff --git a/plugins/dockers/artisticcolorselector/kis_color_selector.cpp \
b/plugins/dockers/artisticcolorselector/kis_color_selector.cpp index \
cc633323bd0..88ba6f9bcce 100644
--- a/plugins/dockers/artisticcolorselector/kis_color_selector.cpp
+++ b/plugins/dockers/artisticcolorselector/kis_color_selector.cpp
@@ -40,9 +40,12 @@
KisColorSelector::KisColorSelector(QWidget* parent, KisColor::Type type)
: QWidget(parent)
+ , m_colorConverter(KisDisplayColorConverter::dumbConverterInstance())
, m_colorSpace(type)
, m_inverseSaturation(false)
- , m_gamma(1.0f)
+ , m_selectedColor(m_colorConverter)
+ , m_fgColor(m_colorConverter)
+ , m_bgColor(m_colorConverter)
, m_clickedRing(-1)
, m_gamutMaskOn(false)
, m_currentGamutMask(nullptr)
@@ -51,25 +54,32 @@ KisColorSelector::KisColorSelector(QWidget* parent, \
KisColor::Type type) {
m_viewConverter = new KisGamutMaskViewConverter();
+ setLumaCoefficients(DEFAULT_LUMA_R, DEFAULT_LUMA_G, \
DEFAULT_LUMA_B,DEFAULT_LUMA_GAMMA); +
recalculateRings(DEFAULT_SATURATION_STEPS, DEFAULT_HUE_STEPS);
recalculateAreas(DEFAULT_VALUE_SCALE_STEPS);
- selectColor(KisColor(Qt::red, KisColor::HSY));
+ selectColor(KisColor(Qt::red, m_colorConverter, KisColor::HSY, m_lumaR, m_lumaG, \
m_lumaB, m_lumaGamma));
using namespace std::placeholders; // For _1 placeholder
auto function = std::bind(&KisColorSelector::slotUpdateColorAndPreview, this, \
_1);
m_updateColorCompressor.reset(new ColorCompressorType(20 /* ms */, function));
}
-void KisColorSelector::setColorSpace(KisColor::Type type, float valueScaleGamma)
+void KisColorSelector::setColorSpace(KisColor::Type type)
{
m_colorSpace = type;
- setGamma(valueScaleGamma);
- m_selectedColor = KisColor(m_selectedColor, m_colorSpace);
+ m_selectedColor = KisColor(m_selectedColor, m_colorSpace, m_lumaR, m_lumaG, \
m_lumaB, m_lumaGamma);
#ifdef DEBUG_ARC_SELECTOR
dbgPlugins << "KisColorSelector::setColorSpace: set to:" << m_colorSpace;
#endif
+ update();
+}
+
+void KisColorSelector::setColorConverter(KisDisplayColorConverter *colorConverter)
+{
+ m_colorConverter = colorConverter;
update();
}
@@ -80,7 +90,7 @@ void KisColorSelector::setNumLightPieces(int num)
recalculateAreas(quint8(num));
if (m_selectedLightPiece >= 0)
- m_selectedLightPiece = getLightIndex(m_selectedColor.getX(m_gamma));
+ m_selectedLightPiece = getLightIndex(m_selectedColor.getX());
update();
}
@@ -111,64 +121,72 @@ void KisColorSelector::setNumRings(int num)
void KisColorSelector::selectColor(const KisColor& color)
{
- m_selectedColor = KisColor(color, m_colorSpace);
+ m_selectedColor = KisColor(color, m_colorSpace, m_lumaR, m_lumaG, m_lumaB, \
m_lumaGamma); m_selectedPiece = getHueIndex(m_selectedColor.getH() * PI2);
m_selectedRing = getSaturationIndex(m_selectedColor.getS());
- m_selectedLightPiece = getLightIndex(m_selectedColor.getX(m_gamma));
+ m_selectedLightPiece = getLightIndex(m_selectedColor.getX());
update();
}
-void KisColorSelector::setFgColor(const KisColor& fgColor)
+void KisColorSelector::setFgColor(const KoColor& fgColor)
{
if (!m_widgetUpdatesSelf) {
- m_fgColor = KisColor(fgColor, m_colorSpace);
- m_selectedColor = KisColor(fgColor, m_colorSpace);
+ m_fgColor = KisColor(fgColor, m_colorConverter, m_colorSpace, m_lumaR, \
m_lumaG, m_lumaB, m_lumaGamma); + m_selectedColor = KisColor(fgColor, \
m_colorConverter, m_colorSpace, m_lumaR, m_lumaG, m_lumaB, m_lumaGamma);
#ifdef DEBUG_ARC_SELECTOR
dbgPlugins << "KisColorSelector::setFgColor: m_fgColor set to:"
<< "H:" << m_fgColor.getH()
<< "S:" << m_fgColor.getS()
- << "X:" << m_fgColor.getX(m_gamma);
+ << "X:" << m_fgColor.getX();
dbgPlugins << "KisColorSelector::setFgColor: m_selectedColor set to:"
<< "H:" << m_selectedColor.getH()
<< "S:" << m_selectedColor.getS()
- << "X:" << m_selectedColor.getX(m_gamma);
+ << "X:" << m_selectedColor.getX();
#endif
update();
}
}
-void KisColorSelector::setBgColor(const KisColor& bgColor)
+void KisColorSelector::setBgColor(const KoColor& bgColor)
{
if (!m_widgetUpdatesSelf) {
- m_bgColor = KisColor(bgColor, m_colorSpace);
+ m_bgColor = KisColor(bgColor, m_colorConverter, m_colorSpace, m_lumaR, \
m_lumaG, m_lumaB, m_lumaGamma); #ifdef DEBUG_ARC_SELECTOR
dbgPlugins << "KisColorSelector::setBgColor: m_bgColor set to:"
<< "H:" << m_bgColor.getH()
<< "S:" << m_bgColor.getS()
- << "X:" << m_bgColor.getX(m_gamma);
+ << "X:" << m_bgColor.getX();
#endif
update();
}
}
-void KisColorSelector::setLight(float light)
+void KisColorSelector::setLight(qreal light)
{
- m_selectedColor.setX(qBound(0.0f, light, 1.0f), m_gamma);
- m_selectedLightPiece = getLightIndex(m_selectedColor.getX(m_gamma));
+ m_selectedColor.setX(qBound(0.0, light, 1.0));
+ m_selectedLightPiece = getLightIndex(m_selectedColor.getX());
update();
}
-void KisColorSelector::setGamma(float gamma) {
+void KisColorSelector::setLumaCoefficients(qreal lR, qreal lG, qreal lB, qreal \
lGamma) +{
+ m_lumaR = lR;
+ m_lumaG = lG;
+ m_lumaB = lB;
+
if (m_colorSpace == KisColor::HSY) {
- m_gamma = gamma;
+ m_lumaGamma = lGamma;
} else {
- m_gamma = 1.0f;
+ m_lumaGamma = 1.0;
}
+ m_selectedColor = KisColor(m_selectedColor, m_colorSpace, m_lumaR, m_lumaG, \
m_lumaB, m_lumaGamma); +
#ifdef DEBUG_ARC_SELECTOR
- dbgPlugins << "KisColorSelector::setGamma: set to:" << m_gamma;
+ dbgPlugins << "KisColorSelector::setLumaCoefficients: " << m_lumaR
+ << " " << m_lumaG << " " << m_lumaB << " " << m_lumaGamma;
#endif
update();
@@ -269,7 +287,7 @@ QPointF KisColorSelector::mapColorToUnit(const KisColor& color, \
bool invertSatur
KisColorSelector::Radian KisColorSelector::mapCoordToAngle(qreal x, qreal y) const
{
- float angle = std::atan2(-y, -x);
+ qreal angle = std::atan2(-y, -x);
#ifdef DEBUG_ARC_SELECTOR
dbgPlugins << "KisColorSelector::mapCoordToAngle: "
@@ -281,11 +299,11 @@ KisColorSelector::Radian \
KisColorSelector::mapCoordToAngle(qreal x, qreal y) con return angle;
}
-QPointF KisColorSelector::mapHueToAngle(float hue) const
+QPointF KisColorSelector::mapHueToAngle(qreal hue) const
{
- float angle = hue * 2.0 * M_PI - M_PI;
- float x = std::cos(angle);
- float y = std::sin(angle);
+ qreal angle = hue * 2.0 * M_PI - M_PI;
+ qreal x = std::cos(angle);
+ qreal y = std::sin(angle);
return QPointF(x,y);
}
@@ -326,14 +344,14 @@ qreal KisColorSelector::getLight(const QPointF& pt) const
qint8 KisColorSelector::getHueIndex(Radian hue) const
{
qreal partSize = 1.0 / qreal(getNumPieces());
- return qint8(qRound(hue.scaled(0.0f, 1.0f) / partSize) % getNumPieces());
+ return qint8(qRound(hue.scaled(0.0, 1.0) / partSize) % getNumPieces());
}
qreal KisColorSelector::getHue(int hueIdx, Radian shift) const
{
Radian hue = (qreal(hueIdx) / qreal(getNumPieces())) * PI2;
hue += shift;
- return hue.scaled(0.0f, 1.0f);
+ return hue.scaled(0.0, 1.0);
}
qint8 KisColorSelector::getSaturationIndex(qreal saturation) const
@@ -460,7 +478,7 @@ void KisColorSelector::requestUpdateColorAndPreview(const \
KisColor &color, Acs::
dbgPlugins << "KisColorSelector::requestUpdateColorAndPreview: requesting update \
to: " << "H:" << color.getH()
<< "S:" << color.getS()
- << "X:" << color.getX(m_gamma);
+ << "X:" << color.getX();
#endif
m_updateColorCompressor->start(qMakePair(color, role));
}
@@ -478,7 +496,7 @@ void KisColorSelector::slotUpdateColorAndPreview(QPair<KisColor, \
Acs::ColorRole>
dbgPlugins << "KisColorSelector::slotUpdateColorAndPreview: m_selectedColor set \
to:" << "H:" << m_selectedColor.getH()
<< "S:" << m_selectedColor.getS()
- << "X:" << m_selectedColor.getX(m_gamma);
+ << "X:" << m_selectedColor.getX();
#endif
if (selectAsFgColor) { emit sigFgColorChanged(m_selectedColor); }
@@ -502,13 +520,13 @@ void KisColorSelector::drawRing(QPainter& painter, \
KisColorSelector::ColorRing& QBrush brush(Qt::SolidPattern);
for(int i=0; i<ring.pieced.size(); ++i) {
- float hue = float(i) / float(ring.pieced.size());
- hue = (hue >= 1.0f) ? (hue - 1.0f) : hue;
- hue = (hue < 0.0f) ? (hue + 1.0f) : hue;
+ qreal hue = qreal(i) / qreal(ring.pieced.size());
+ hue = (hue >= 1.0) ? (hue - 1.0) : hue;
+ hue = (hue < 0.0) ? (hue + 1.0) : hue;
- KisColor color(hue, 1.0f, m_colorSpace);
+ KisColor color(hue, m_colorConverter, m_colorSpace);
color.setS(ring.saturation);
- color.setX(m_selectedColor.getX(m_gamma), m_gamma);
+ color.setX(m_selectedColor.getX());
if(m_gamutMaskOn && m_enforceGamutMask && colorIsClear(color)) {
painter.setPen(clearMaskPen);
@@ -519,7 +537,7 @@ void KisColorSelector::drawRing(QPainter& painter, \
KisColorSelector::ColorRing& if ((m_enforceGamutMask) && (!colorIsClear(color))) {
brush.setColor(COLOR_MASK_FILL);
} else {
- brush.setColor(color.getQColor());
+ brush.setColor(color.toQColor());
}
painter.setBrush(brush);
@@ -528,22 +546,22 @@ void KisColorSelector::drawRing(QPainter& painter, \
KisColorSelector::ColorRing& }
else {
KisColor colors[7] = {
- KisColor(Qt::cyan , m_colorSpace),
- KisColor(Qt::green , m_colorSpace),
- KisColor(Qt::yellow , m_colorSpace),
- KisColor(Qt::red , m_colorSpace),
- KisColor(Qt::magenta, m_colorSpace),
- KisColor(Qt::blue , m_colorSpace),
- KisColor(Qt::cyan , m_colorSpace)
+ KisColor(Qt::cyan , m_colorConverter, m_colorSpace, m_lumaR, m_lumaG, \
m_lumaB, m_lumaGamma), + KisColor(Qt::green , m_colorConverter, \
m_colorSpace, m_lumaR, m_lumaG, m_lumaB, m_lumaGamma), + \
KisColor(Qt::yellow , m_colorConverter, m_colorSpace, m_lumaR, m_lumaG, m_lumaB, \
m_lumaGamma), + KisColor(Qt::red , m_colorConverter, m_colorSpace, \
m_lumaR, m_lumaG, m_lumaB, m_lumaGamma), + KisColor(Qt::magenta, \
m_colorConverter, m_colorSpace, m_lumaR, m_lumaG, m_lumaB, m_lumaGamma), + \
KisColor(Qt::blue , m_colorConverter, m_colorSpace, m_lumaR, m_lumaG, m_lumaB, \
m_lumaGamma), + KisColor(Qt::cyan , m_colorConverter, m_colorSpace, \
m_lumaR, m_lumaG, m_lumaB, m_lumaGamma) };
QConicalGradient gradient(0, 0, 0);
for(int i=0; i<=6; ++i) {
- qreal hue = float(i) / 6.0f;
+ qreal hue = qreal(i) / 6.0;
colors[i].setS(ring.saturation);
- colors[i].setX(m_selectedColor.getX(m_gamma), m_gamma);
- gradient.setColorAt(hue, colors[i].getQColor());
+ colors[i].setX(m_selectedColor.getX());
+ gradient.setColorAt(hue, colors[i].toQColor());
}
painter.scale(rect.width()/2, rect.height()/2);
@@ -601,8 +619,8 @@ void KisColorSelector::drawOutline(QPainter& painter, const \
QRect& rect) void KisColorSelector::drawLightStrip(QPainter& painter, const QRect& \
rect) {
qreal penSize = qreal(qMin(QWidget::width(), QWidget::height())) / 200.0;
- KisColor valueScaleColor(m_selectedColor);
- KisColor grayScaleColor(Qt::gray, m_colorSpace);
+ KisColor valueScaleColor(m_selectedColor, m_colorSpace, m_lumaR, m_lumaG, \
m_lumaB, m_lumaGamma); + KisColor grayScaleColor(Qt::gray, m_colorConverter, \
m_colorSpace, m_lumaR, m_lumaG, m_lumaB, m_lumaGamma); int rectSize = rect.height();
painter.resetTransform();
@@ -626,17 +644,17 @@ void KisColorSelector::drawLightStrip(QPainter& painter, const \
QRect& rect)
if (getNumLightPieces() > 1) {
for(int i=0; i<getNumLightPieces(); ++i) {
- float t1 = float(i) / float(getNumLightPieces());
- float t2 = float(i+1) / float(getNumLightPieces());
- float light = 1.0f - (float(i) / float(getNumLightPieces()-1));
- float diff = t2 - t1;// + 0.001;
+ qreal t1 = qreal(i) / qreal(getNumLightPieces());
+ qreal t2 = qreal(i+1) / qreal(getNumLightPieces());
+ qreal light = 1.0 - (qreal(i) / qreal(getNumLightPieces()-1));
+ qreal diff = t2 - t1;// + 0.001;
QRectF rectColor = QRectF(rectColorLeftX, t1, rectColorWidth, diff);
rectColor = matrix.mapRect(rectColor);
- valueScaleColor.setX(light, m_gamma);
+ valueScaleColor.setX(light);
- painter.fillRect(rectColor, valueScaleColor.getQColor());
+ painter.fillRect(rectColor, valueScaleColor.toQColor());
if (i == m_selectedLightPiece) {
painter.setPen(QPen(QBrush(COLOR_SELECTED), penSize));
@@ -649,16 +667,16 @@ void KisColorSelector::drawLightStrip(QPainter& painter, const \
QRect& rect)
for(int i=0; i<rectSize; ++i) {
int y = rect.y() + i;
- float light = 1.0f - (float(i) / float(rectSize-1));
- valueScaleColor.setX(light, m_gamma);
- painter.setPen(QPen(QBrush(valueScaleColor.getQColor()), penSize));
+ qreal light = 1.0 - (qreal(i) / qreal(rectSize-1));
+ valueScaleColor.setX(light);
+ painter.setPen(QPen(QBrush(valueScaleColor.toQColor()), penSize));
painter.drawLine(rect.left(), y, rect.right(), y);
}
painter.setRenderHint(QPainter::Antialiasing, true);
painter.setPen(QPen(QBrush(COLOR_SELECTED), penSize));
- float t = 1.0f - m_selectedColor.getX(m_gamma);
+ qreal t = 1.0 - m_selectedColor.getX();
int y = rect.y() + int(rectSize * t);
painter.drawLine(rect.left(), y, rect.right(), y);
@@ -667,7 +685,7 @@ void KisColorSelector::drawLightStrip(QPainter& painter, const \
QRect& rect) if (m_showColorBlip) {
painter.setRenderHint(QPainter::Antialiasing, false);
// draw position of fg color value on the strip
- float fgColorValue = 1.0f - m_fgColor.getX(m_gamma);
+ qreal fgColorValue = 1.0 - m_fgColor.getX();
int y = rect.y() + int(rectSize * fgColorValue);
painter.setPen(QPen(QBrush(COLOR_LIGHT), penSize));
@@ -684,20 +702,29 @@ void KisColorSelector::drawLightStrip(QPainter& painter, const \
QRect& rect) valueScalePieces = 11;
}
+ QFont font = painter.font();
+ font.setPointSize(font.pointSize()-2);
+ painter.setFont(font);
+
for(int i=0; i<valueScalePieces; ++i) {
- float t1 = float(i) / float(valueScalePieces);
- float t2 = float(i+1) / float(valueScalePieces);
- float light = 1.0f - (float(i) / float(valueScalePieces-1));
- float diff = t2 - t1;// + 0.001;
+ qreal t1 = qreal(i) / qreal(valueScalePieces);
+ qreal t2 = qreal(i+1) / qreal(valueScalePieces);
+ qreal light = 1.0 - (qreal(i) / qreal(valueScalePieces-1));
+ qreal diff = t2 - t1;// + 0.001;
- grayScaleColor.setX(light, m_gamma);
+ grayScaleColor.setX(light);
QRectF rectValue = QRectF(0.0, t1, rectColorLeftX, diff);
rectValue = matrix.mapRect(rectValue);
- painter.fillRect(rectValue, grayScaleColor.getQColor());
+ painter.fillRect(rectValue, grayScaleColor.toQColor());
- int valueNumber = (1.0 - grayScaleColor.getX())*100;
+ int valueNumber = 0;
+ if (m_colorSpace == KisColor::HSY) {
+ valueNumber = 100 - round(pow(pow(grayScaleColor.getX(), \
m_lumaGamma), 1.0/2.2)*100); + } else {
+ valueNumber = 100 - grayScaleColor.getX()*100;
+ }
if (valueNumber < 55) {
painter.setPen(QPen(QBrush(COLOR_DARK), penSize));
@@ -731,7 +758,7 @@ void KisColorSelector::drawBlip(QPainter& painter, const QRect& \
rect) painter.drawEllipse(fgColorPos, 0.05, 0.05);
painter.setPen(QPen(QBrush(COLOR_LIGHT), 0.01));
- painter.setBrush(m_fgColor.getQColor());
+ painter.setBrush(m_fgColor.toQColor());
painter.drawEllipse(fgColorPos, 0.04, 0.04);
}
@@ -781,7 +808,7 @@ void KisColorSelector::paintEvent(QPaintEvent* /*event*/)
wdgPainter.setRenderHint(QPainter::Antialiasing, true);
QRect fgRect(0, 0, QWidget::width(), QWidget::height());
- wdgPainter.fillRect(fgRect, m_fgColor.getQColor());
+ wdgPainter.fillRect(fgRect, m_fgColor.toQColor());
int bgSide = qMin(QWidget::width()*0.15,QWidget::height()*0.15);
@@ -792,8 +819,8 @@ void KisColorSelector::paintEvent(QPaintEvent* /*event*/)
QPointF(QWidget::width(), QWidget::height()-bgSide)
};
- wdgPainter.setBrush(m_bgColor.getQColor());
- wdgPainter.setPen(m_bgColor.getQColor());
+ wdgPainter.setBrush(m_bgColor.toQColor());
+ wdgPainter.setPen(m_bgColor.toQColor());
wdgPainter.drawPolygon(bgPolyPoints, 3);
}
@@ -851,23 +878,21 @@ void KisColorSelector::mousePressEvent(QMouseEvent* event)
if (getNumPieces() == 1) {
Radian angle = mapCoordToAngle(m_clickPos.x(), m_clickPos.y());
- KisColor color(m_colorSpace);
- color.setHSX(angle.scaled(0.0f, 1.0f)
+ KisColor color(m_colorConverter, m_colorSpace);
+ color.setHSX(angle.scaled(0.0, 1.0)
, getSaturation(m_clickedRing)
- , m_selectedColor.getX(m_gamma)
- , color.getA()
- , m_gamma
+ , m_selectedColor.getX()
);
#ifdef DEBUG_ARC_SELECTOR
dbgPlugins << "KisColorSelector::mousePressEvent: picked color: "
<< "H:" << color.getH()
<< "S:" << color.getS()
- << "X:" << color.getX(m_gamma);
+ << "X:" << color.getX();
#endif
if ((!m_enforceGamutMask) || colorIsClear(color)) {
- m_selectedColor.setHSX(color.getH(), color.getS(), \
color.getX(m_gamma), color.getA(), m_gamma); + \
m_selectedColor.setHSX(color.getH(), color.getS(), color.getX()); \
requestUpdateColorAndPreview(m_selectedColor, colorRole); m_selectedRing = \
m_clickedRing; m_mouseMoved = true;
@@ -894,16 +919,14 @@ void KisColorSelector::mouseMoveEvent(QMouseEvent* event)
if (getNumPieces() == 1) {
Radian angle = mapCoordToAngle(dragPos.x(), dragPos.y());
- KisColor color(m_colorSpace);
- color.setHSX(angle.scaled(0.0f, 1.0f)
+ KisColor color(m_colorConverter, m_colorSpace);
+ color.setHSX(angle.scaled(0.0, 1.0)
, getSaturation(m_clickedRing)
- , m_selectedColor.getX(m_gamma)
- , color.getA()
- , m_gamma
+ , m_selectedColor.getX()
);
if ((!m_enforceGamutMask) || colorIsClear(color)) {
- m_selectedColor.setHSX(color.getH(), color.getS(), color.getX(m_gamma), \
color.getA(), m_gamma); + m_selectedColor.setHSX(color.getH(), \
color.getS(), color.getX()); requestUpdateColorAndPreview(m_selectedColor, \
colorRole); }
}
@@ -917,21 +940,21 @@ void KisColorSelector::mouseReleaseEvent(QMouseEvent* \
/*event*/)
if (!m_mouseMoved && m_clickedRing >= 0) {
Radian angle = mapCoordToAngle(m_clickPos.x(), m_clickPos.y());
- KisColor color(m_colorSpace);
+ KisColor color(m_colorConverter, m_colorSpace);
qint8 hueIndex = getHueIndex(angle);
if (getNumPieces() > 1) {
color.setH(getHue(hueIndex));
} else {
- color.setH(angle.scaled(0.0f, 1.0f));
+ color.setH(angle.scaled(0.0, 1.0));
}
color.setS(getSaturation(m_clickedRing));
- color.setX(m_selectedColor.getX(m_gamma), m_gamma);
+ color.setX(m_selectedColor.getX());
if ((!m_enforceGamutMask) || colorIsClear(color)) {
- m_selectedColor.setHSX(color.getH(), color.getS(), color.getX(m_gamma), \
color.getA(), m_gamma); + m_selectedColor.setHSX(color.getH(), \
color.getS(), color.getX()); m_selectedPiece = hueIndex;
m_selectedRing = m_clickedRing;
requestUpdateColorAndPreview(m_selectedColor, colorRole);
@@ -967,17 +990,22 @@ void KisColorSelector::saveSettings()
{
KisConfig cfg(false);
cfg.writeEntry("ArtColorSel.ColorSpace" , qint32(m_colorSpace));
+
+ cfg.writeEntry("ArtColorSel.lumaR", qreal(m_lumaR));
+ cfg.writeEntry("ArtColorSel.lumaG", qreal(m_lumaG));
+ cfg.writeEntry("ArtColorSel.lumaB", qreal(m_lumaB));
+ cfg.writeEntry("ArtColorSel.lumaGamma", qreal(m_lumaGamma));
+
cfg.writeEntry("ArtColorSel.NumRings" , m_colorRings.size());
cfg.writeEntry("ArtColorSel.RingPieces" , qint32(m_numPieces));
cfg.writeEntry("ArtColorSel.LightPieces", qint32(m_numLightPieces));
cfg.writeEntry("ArtColorSel.InversedSaturation", m_inverseSaturation);
- cfg.writeEntry("ArtColorSel.Light" , m_selectedColor.getX(m_gamma));
+ cfg.writeEntry("ArtColorSel.Light" , m_selectedColor.getX());
cfg.writeEntry("ArtColorSel.SelColorH", m_selectedColor.getH());
cfg.writeEntry("ArtColorSel.SelColorS", m_selectedColor.getS());
- cfg.writeEntry("ArtColorSel.SelColorX", m_selectedColor.getX(m_gamma));
- cfg.writeEntry("ArtColorSel.SelColorA", m_selectedColor.getA());
+ cfg.writeEntry("ArtColorSel.SelColorX", m_selectedColor.getX());
cfg.writeEntry("ArtColorSel.defaultHueSteps", quint32(m_defaultHueSteps));
cfg.writeEntry("ArtColorSel.defaultSaturationSteps", \
quint32(m_defaultSaturationSteps)); @@ -989,7 +1017,6 @@ void \
KisColorSelector::saveSettings() cfg.writeEntry("ArtColorSel.enforceGamutMask", \
m_enforceGamutMask);
cfg.writeEntry("ArtColorSel.maskPreviewActive", m_maskPreviewActive);
- cfg.writeEntry("ArtColorSel.valueScaleGamma", gamma());
}
void KisColorSelector::loadSettings()
@@ -1003,21 +1030,20 @@ void KisColorSelector::loadSettings()
setNumLightPieces(cfg.readEntry("ArtColorSel.LightPieces", \
DEFAULT_VALUE_SCALE_STEPS));
KisColor::Type colorSpace = \
KisColor::Type(cfg.readEntry<qint32>("ArtColorSel.ColorSpace" , \
KisColor::HSY));
- float valueScaleGamma = cfg.readEntry("ArtColorSel.valueScaleGamma", 2.2f);
- if (colorSpace == KisColor::HSY) {
- setGamma(valueScaleGamma);
- }
+ setColorSpace(colorSpace);
- setColorSpace(colorSpace, valueScaleGamma);
+ setLumaCoefficients(cfg.readEntry("ArtColorSel.lumaR", DEFAULT_LUMA_R),
+ cfg.readEntry("ArtColorSel.lumaG", DEFAULT_LUMA_G),
+ cfg.readEntry("ArtColorSel.lumaB", DEFAULT_LUMA_B),
+ cfg.readEntry("ArtColorSel.lumaGamma", DEFAULT_LUMA_GAMMA));
- m_selectedColor.setH(cfg.readEntry<float>("ArtColorSel.SelColorH", 0.0f));
- m_selectedColor.setS(cfg.readEntry<float>("ArtColorSel.SelColorS", 0.0f));
- m_selectedColor.setX(cfg.readEntry<float>("ArtColorSel.SelColorX", 0.0f), \
m_gamma);
- m_selectedColor.setA(1.0f);
+ m_selectedColor.setH(cfg.readEntry<qreal>("ArtColorSel.SelColorH", 0.0));
+ m_selectedColor.setS(cfg.readEntry<qreal>("ArtColorSel.SelColorS", 0.0));
+ m_selectedColor.setX(cfg.readEntry<qreal>("ArtColorSel.SelColorX", 0.0));
setInverseSaturation(cfg.readEntry<bool>("ArtColorSel.InversedSaturation", \
false));
- setLight(cfg.readEntry<float>("ArtColorSel.Light", 0.5f));
+ setLight(cfg.readEntry<qreal>("ArtColorSel.Light", 0.5f));
setNumRings(cfg.readEntry("ArtColorSel.NumRings", DEFAULT_SATURATION_STEPS));
setNumPieces(cfg.readEntry("ArtColorSel.RingPieces", DEFAULT_HUE_STEPS));
diff --git a/plugins/dockers/artisticcolorselector/kis_color_selector.h \
b/plugins/dockers/artisticcolorselector/kis_color_selector.h index \
8014cfaa95e..49aa887d55d 100644
--- a/plugins/dockers/artisticcolorselector/kis_color_selector.h
+++ b/plugins/dockers/artisticcolorselector/kis_color_selector.h
@@ -33,13 +33,13 @@
#include <KisGamutMaskViewConverter.h>
class QPainter;
-class QPainter;
+class KisDisplayColorConverter;
class KisColorSelector: public QWidget
{
Q_OBJECT
- typedef KisRadian<float> Radian;
+ typedef KisRadian<qreal> Radian;
struct ColorRing
{
@@ -49,29 +49,33 @@ class KisColorSelector: public QWidget
, innerRadius(0)
{ }
- float saturation;
- float outerRadius;
- float innerRadius;
+ qreal saturation;
+ qreal outerRadius;
+ qreal innerRadius;
QVector<QPainterPath> pieced;
};
public:
KisColorSelector(QWidget* parent, KisColor::Type type=KisColor::HSL);
- void setColorSpace(KisColor::Type type, float valueScaleGamma);
+ void setColorSpace(KisColor::Type type);
+ void setColorConverter(KisDisplayColorConverter* colorConverter);
void setNumPieces(int num);
void setNumLightPieces(int num) __attribute__((optimize(0)));
void setNumRings(int num);
- void setLight(float light=0.0f);
+ void setLight(qreal light=0.0f);
- float gamma() const { return m_gamma; }
- void setGamma(float gamma);
+ void setLumaCoefficients(qreal lR, qreal lG, qreal lB, qreal lGamma);
+ inline qreal lumaR() const { return m_lumaR; }
+ inline qreal lumaG() const { return m_lumaG; }
+ inline qreal lumaB() const { return m_lumaB; }
+ inline qreal lumaGamma() const { return m_lumaGamma; }
void setInverseSaturation(bool inverse);
void selectColor(const KisColor& color);
- void setFgColor(const KisColor& fgColor);
- void setBgColor(const KisColor& bgColor);
+ void setFgColor(const KoColor& fgColor);
+ void setBgColor(const KoColor& bgColor);
void setDefaultHueSteps(int num);
void setDefaultSaturationSteps(int num);
@@ -146,7 +150,7 @@ private:
QPointF mapCoordToUnit(const QPointF& pt, const QRectF& viewRect) const;
QPointF mapColorToUnit(const KisColor& color, bool invertSaturation = true) \
const; Radian mapCoordToAngle(qreal x, qreal y) const;
- QPointF mapHueToAngle(float hue) const;
+ QPointF mapHueToAngle(qreal hue) const;
public:
// This is a private interface for signal compressor, don't use it.
@@ -154,11 +158,11 @@ public:
void slotUpdateColorAndPreview(QPair<KisColor, Acs::ColorRole> color);
private:
+ KisDisplayColorConverter* m_colorConverter;
KisColor::Type m_colorSpace;
quint8 m_numPieces;
quint8 m_numLightPieces;
bool m_inverseSaturation;
- float m_gamma;
qint8 m_selectedRing;
qint8 m_selectedPiece;
qint8 m_selectedLightPiece;
@@ -192,6 +196,11 @@ private:
bool m_widgetUpdatesSelf;
+ qreal m_lumaR;
+ qreal m_lumaG;
+ qreal m_lumaB;
+ qreal m_lumaGamma;
+
typedef KisSignalCompressorWithParam<QPair<KisColor, Acs::ColorRole>> \
ColorCompressorType; QScopedPointer<ColorCompressorType> m_updateColorCompressor;
};
[prev in list] [next in list] [prev in thread] [next in thread]
Configure |
About |
News |
Add a list |
Sponsored by KoreLogic