[prev in list] [next in list] [prev in thread] [next in thread]
List: kde-commits
Subject: [calligra] /: Adds HSI and HSY' to the advanced colour selector.
From: Wolthera van Hovell <griffinvalley () gmail ! com>
Date: 2014-06-30 19:51:06
Message-ID: E1X1hbW-0006qX-9d () scm ! kde ! org
[Download RAW message or body]
Git commit ce3cff7046c186d62b29fd0a04205114b542bdbc by Wolthera van Hovell.
Committed on 30/06/2014 at 19:50.
Pushed by woltherav into branch 'master'.
Adds HSI and HSY' to the advanced colour selector.
So, I want to add Intensity and Luma(The latter would be like mypaint)
to the advanced colour selector options in Krita.
But for that I first need conversion functions.
HSI, intensity, uses a system where a color is mapped to a tone scale
depending on the sum of it's components. So basically, Intensity=
(r+b+g)/3.
HSY, Luma, is similar, but it weights the components instead. So
Luminosity=(r*R'+g*G'+b*B').
Both are a little more intuitive to use for artists.
Krita's Advanced c-pick currently uses QColor hsv and hsl functions
through the display converter. This patch tries to add eight functions
to KoColorConversions:
*HSIToRGB, RGBToHSI, HCIToRGB, RGBToHCI.
These functions are for converting from and to HSI, these functions use
qreals in the range of 0.0-1.0.
*HSYToRGB, RGBToHSY, HCYToRGB, RGBToHCY.
These functions are for converting from and to HSY, these functions also
use qreals in the range of 0.0-1.0. On top of that, they have extra
parameters for setting the weights, which default to rec
601(http://en.wikipedia.org/wiki/CCIR_601) when not specified.
The difference between the HSI, HSY and HCI, HCY functions is that HSI
and HSY maps to a cyllindrical space using a weighted HSL algorithm.
This is useful for colour selectors because the output is more intuitive
and has no unexpected shifts in either direction. The HCI and HCY
functions on the other hand are the basic formulas and I put them in for
compatibility.
Implementation:
The code is implemented in the advanced colour selector through
kis_display_converter, where it creates or converts a qcolor for the
proper values.
In the advanced color selector itself we can now select shapes that use
HSI and HSY, and we can request the MyPaint shade selector to use HSL,
HSI and HSY. These options have been added to the settings window, with
tooltips and all.
M +4 -4 krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector.cpp
M +4 -4 krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector.h
M +13 -0 krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_combo_box.cpp
M +47 -3 krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_component.cpp
M +6 -2 krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_component.h
M +2 -0 krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_container.cpp
M +2 -2 krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_ring.cpp
M +22 -0 krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_settings.cpp
M +151 -23 krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_simple.cpp
M +1 -1 krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_triangle.cpp
M +55 -8 krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_wheel.cpp
M +29 -6 krita/plugins/extensions/dockers/advancedcolorselector/kis_my_paint_shade_selector.cpp
M +65 -6 krita/plugins/extensions/dockers/advancedcolorselector/wdg_color_selector_settings.ui
M +47 -0 krita/ui/canvas/kis_display_color_converter.cpp
M +4 -0 krita/ui/canvas/kis_display_color_converter.h
M +592 -0 libs/pigment/KoColorConversions.cpp
M +23 -0 libs/pigment/KoColorConversions.h
http://commits.kde.org/calligra/ce3cff7046c186d62b29fd0a04205114b542bdbc
diff --git a/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector.cpp \
b/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector.cpp index \
efc1a38..acd404c 100644
--- a/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector.cpp
+++ b/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector.cpp
@@ -123,10 +123,10 @@ void KisColorSelector::setConfiguration(Configuration conf)
Q_ASSERT(false);
}
- connect(m_mainComponent, SIGNAL(paramChanged(qreal,qreal,qreal,qreal,qreal)),
- m_subComponent, SLOT(setParam(qreal,qreal,qreal,qreal,qreal)), \
Qt::UniqueConnection);
- connect(m_subComponent, SIGNAL(paramChanged(qreal,qreal,qreal,qreal,qreal)),
- m_mainComponent, SLOT(setParam(qreal,qreal,qreal,qreal, qreal)), \
Qt::UniqueConnection); + connect(m_mainComponent, \
SIGNAL(paramChanged(qreal,qreal,qreal,qreal,qreal,qreal,qreal,qreal,qreal)), + \
m_subComponent, SLOT(setParam(qreal,qreal,qreal,qreal,qreal,qreal,qreal,qreal,qreal)), \
Qt::UniqueConnection); + connect(m_subComponent, \
SIGNAL(paramChanged(qreal,qreal,qreal,qreal,qreal,qreal,qreal,qreal,qreal)), + \
m_mainComponent, SLOT(setParam(qreal,qreal,qreal,qreal, qreal, qreal, qreal, qreal, \
qreal)), Qt::UniqueConnection);
connect(m_mainComponent, SIGNAL(update()), m_signalCompressor, SLOT(start()), \
Qt::UniqueConnection);
connect(m_subComponent, SIGNAL(update()), m_signalCompressor, SLOT(start()), \
Qt::UniqueConnection);
diff --git a/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector.h \
b/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector.h index \
61c1786..7360a9d 100644
--- a/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector.h
+++ b/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector.h
@@ -33,7 +33,7 @@ class KisColorSelector : public KisColorSelectorBase
Q_OBJECT
public:
enum Type {Ring, Square, Wheel, Triangle, Slider};
- enum Parameters {H, hsvS, V, hslS, L, SL, SV, SV2, hsvSH, hslSH, VH, LH};
+ enum Parameters {H, hsvS, V, hslS, L, SL, SV, SV2, hsvSH, hslSH, VH, LH, SI, SY, \
hsiSH, hsySH, I, Y, IH, YH, hsiS, hsyS}; struct Configuration {
Type mainType;
Type subType;
@@ -67,7 +67,7 @@ public:
int imtp=strili.at(2).toInt();
int istp=strili.at(3).toInt();
- if(imt>Slider || ist>Slider || imtp>LH || istp>LH)
+ if(imt>Slider || ist>Slider || imtp>hsyS || istp>hsyS)//this was LH \
before return;
mainType = Type(imt);
@@ -85,8 +85,8 @@ public:
// enum MainType {Ring, Square, Wheel};
// enum SubType {Triangle, Square, Slider};
-// enum MainTypeParameter {SL, SV, SH, VH, LH, VSV/*experimental*/};
-// enum SubTypeParameter {H, S, V, L};
+// enum MainTypeParameter {SL, SV, SH, VH, LH, VSV/*experimental*/, SI, SY, YH, \
IH}; +// enum SubTypeParameter {H, S, V, L, I, Y, hsiS, hsyS};
KisColorSelector(Configuration conf, QWidget* parent = 0);
KisColorSelector(QWidget* parent=0);
diff --git a/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_combo_box.cpp \
b/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_combo_box.cpp
index 6293465..c6658a1 100644
--- a/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_combo_box.cpp
+++ b/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_combo_box.cpp
@@ -43,15 +43,21 @@ public:
layout->addWidget(new \
KisColorSelector(KisColorSelector::Configuration(KisColorSelector::Square, \
KisColorSelector::Ring, KisColorSelector::SL , KisColorSelector::H), this), 0,1); \
layout->addWidget(new \
KisColorSelector(KisColorSelector::Configuration(KisColorSelector::Square, \
KisColorSelector::Ring, KisColorSelector::SV , KisColorSelector::H), this), 0,2); \
layout->addWidget(new \
KisColorSelector(KisColorSelector::Configuration(KisColorSelector::Square, \
KisColorSelector::Ring, KisColorSelector::SV2, KisColorSelector::H), this), 0,3); \
+ layout->addWidget(new \
KisColorSelector(KisColorSelector::Configuration(KisColorSelector::Square, \
KisColorSelector::Ring, KisColorSelector::SI , KisColorSelector::H), this), 0,4); \
+ layout->addWidget(new \
KisColorSelector(KisColorSelector::Configuration(KisColorSelector::Square, \
KisColorSelector::Ring, KisColorSelector::SY , KisColorSelector::H), this), 0,5);
layout->addWidget(new \
KisColorSelector(KisColorSelector::Configuration(KisColorSelector::Square, \
KisColorSelector::Slider, KisColorSelector::SV, KisColorSelector::H), this), 1,0); \
layout->addWidget(new \
KisColorSelector(KisColorSelector::Configuration(KisColorSelector::Square, \
KisColorSelector::Slider, KisColorSelector::SL, KisColorSelector::H), this), 1,1); \
layout->addWidget(new \
KisColorSelector(KisColorSelector::Configuration(KisColorSelector::Square, \
KisColorSelector::Slider, KisColorSelector::SV2, KisColorSelector::H), this), 1,2); \
+ layout->addWidget(new \
KisColorSelector(KisColorSelector::Configuration(KisColorSelector::Square, \
KisColorSelector::Slider, KisColorSelector::SI, KisColorSelector::H), this), 1,3); \
+ layout->addWidget(new \
KisColorSelector(KisColorSelector::Configuration(KisColorSelector::Square, \
KisColorSelector::Slider, KisColorSelector::SY, KisColorSelector::H), this), 1,4);
layout->addWidget(new \
KisColorSelector(KisColorSelector::Configuration(KisColorSelector::Square, \
KisColorSelector::Slider, KisColorSelector::VH, KisColorSelector::hsvS), this), 2,0); \
layout->addWidget(new \
KisColorSelector(KisColorSelector::Configuration(KisColorSelector::Square, \
KisColorSelector::Slider, KisColorSelector::LH, KisColorSelector::hslS), this), 2,1); \
layout->addWidget(new \
KisColorSelector(KisColorSelector::Configuration(KisColorSelector::Square, \
KisColorSelector::Slider, KisColorSelector::hsvSH, KisColorSelector::V), this), 2,2); \
layout->addWidget(new \
KisColorSelector(KisColorSelector::Configuration(KisColorSelector::Square, \
KisColorSelector::Slider, KisColorSelector::hslSH, KisColorSelector::L), this), 2,3); \
+ layout->addWidget(new \
KisColorSelector(KisColorSelector::Configuration(KisColorSelector::Square, \
KisColorSelector::Slider, KisColorSelector::IH, KisColorSelector::hsiS), this), 2,4); \
+ layout->addWidget(new \
KisColorSelector(KisColorSelector::Configuration(KisColorSelector::Square, \
KisColorSelector::Slider, KisColorSelector::YH, KisColorSelector::hsyS), this), 2,5); \
layout->addWidget(new \
KisColorSelector(KisColorSelector::Configuration(KisColorSelector::Wheel, \
KisColorSelector::Slider, KisColorSelector::VH, KisColorSelector::hsvS), this), 3,0); \
layout->addWidget(new \
KisColorSelector(KisColorSelector::Configuration(KisColorSelector::Wheel, \
KisColorSelector::Slider, KisColorSelector::LH, KisColorSelector::hslS), this), 3,1); \
@@ -59,6 +65,13 @@ public: layout->addWidget(new \
KisColorSelector(KisColorSelector::Configuration(KisColorSelector::Wheel, \
KisColorSelector::Slider, KisColorSelector::hslSH, KisColorSelector::L), this), 3,3); \
+ layout->addWidget(new \
KisColorSelector(KisColorSelector::Configuration(KisColorSelector::Wheel, \
KisColorSelector::Slider, KisColorSelector::IH, KisColorSelector::hsiS), this), 4,0); \
+ layout->addWidget(new \
KisColorSelector(KisColorSelector::Configuration(KisColorSelector::Wheel, \
KisColorSelector::Slider, KisColorSelector::YH, KisColorSelector::hsyS), this), 4,1); \
+ layout->addWidget(new \
KisColorSelector(KisColorSelector::Configuration(KisColorSelector::Wheel, \
KisColorSelector::Slider, KisColorSelector::hsiSH, KisColorSelector::I), this), 4,2); \
+ layout->addWidget(new \
KisColorSelector(KisColorSelector::Configuration(KisColorSelector::Wheel, \
KisColorSelector::Slider, KisColorSelector::hsySH, KisColorSelector::Y), this), 4,3); \
+ +
+
for(int i=0; i<this->layout()->count(); i++) {
KisColorSelector* item = \
dynamic_cast<KisColorSelector*>(this->layout()->itemAt(i)->widget()); \
Q_ASSERT(item);
diff --git a/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_component.cpp \
b/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_component.cpp
index 8e17c2a..24feaf9 100644
--- a/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_component.cpp
+++ b/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_component.cpp
@@ -31,6 +31,10 @@ KisColorSelectorComponent::KisColorSelectorComponent(KisColorSelector* \
parent) : m_value(1),
m_hslSaturation(1),
m_lightness(0.5),
+ m_hsiSaturation(1),
+ m_intensity(0.333),
+ m_hsySaturation(1),
+ m_luma(0.299),
m_parent(parent),
m_width(0),
m_height(0),
@@ -104,13 +108,17 @@ KoColor KisColorSelectorComponent::currentColor()
return selectColor(m_lastX, m_lastY);
}
-void KisColorSelectorComponent::setParam(qreal hue, qreal hsvSaturation, qreal \
value, qreal hslSaturation, qreal lightness) +void \
KisColorSelectorComponent::setParam(qreal hue, qreal hsvSaturation, qreal value, \
qreal hslSaturation, qreal lightness, qreal hsiSaturation, qreal intensity, qreal \
hsySaturation, qreal luma) {
if(qFuzzyCompare(m_hue, hue) &&
qFuzzyCompare(m_hsvSaturation, hsvSaturation) &&
qFuzzyCompare(m_value, value) &&
qFuzzyCompare(m_hslSaturation, hslSaturation) &&
- qFuzzyCompare(m_lightness, lightness))
+ qFuzzyCompare(m_lightness, lightness) &&
+ qFuzzyCompare(m_hsiSaturation, hsiSaturation) &&
+ qFuzzyCompare(m_intensity, intensity) &&
+ qFuzzyCompare(m_hsySaturation, hsySaturation) &&
+ qFuzzyCompare(m_luma, luma))
return;
if(hue>=0. && hue<=1.)
@@ -119,22 +127,58 @@ void KisColorSelectorComponent::setParam(qreal hue, qreal \
hsvSaturation, qreal v if(hsvSaturation>=0. && hsvSaturation<=1.) {
m_hsvSaturation=hsvSaturation;
m_hslSaturation=-1;
+ m_hsiSaturation=-1;
+ m_hsySaturation=-1;
}
if(value>=0. && value<=1.) {
m_value=value;
- m_lightness=-1;
+ m_intensity=-1;
+ m_luma=-1;
+ m_lightness=-1;
}
if(hslSaturation>=0. && hslSaturation<=1.) {
m_hslSaturation=hslSaturation;
m_hsvSaturation=-1;
+ m_hsiSaturation=-1;
+ m_hsySaturation=-1;
}
if(lightness>=0. && lightness<=1.) {
m_lightness=lightness;
m_value=-1;
+ m_luma=-1;
+ m_intensity=-1;
}
+ if(hsiSaturation>=0. && hsiSaturation<=1.) {
+ m_hsiSaturation=hsiSaturation;
+ m_hsvSaturation=-1;
+ m_hslSaturation=-1;
+ m_hsySaturation=-1;
+ }
+
+ if(intensity>=0. && intensity<=1.) {
+ m_intensity=intensity;
+ m_value=-1;
+ m_luma=-1;
+ m_lightness=-1;
+ }
+
+ if(hsySaturation>=0. && hsySaturation<=1.) {
+ m_hsySaturation=hsySaturation;
+ m_hsvSaturation=-1;
+ m_hsiSaturation=-1;
+ m_hslSaturation=-1;
+ }
+
+ if(luma>=0. && luma<=1.) {
+ m_intensity=-1;
+ m_value=-1;
+ m_luma=luma;
+ m_lightness=-1;
+ }
+
m_dirty=true;
emit update();
diff --git a/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_component.h \
b/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_component.h
index f50fdbf..9362dff 100644
--- a/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_component.h
+++ b/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_component.h
@@ -64,12 +64,12 @@ public:
public slots:
/// set hue, saturation, value or/and lightness
/// unused parameters should be set to -1
- void setParam(qreal hue, qreal hsvSaturation, qreal value, qreal hslSaturation, \
qreal lightness); + void setParam(qreal hue, qreal hsvSaturation, qreal value, \
qreal hslSaturation, qreal lightness, qreal hsiSaturation, qreal intensity, qreal \
hsySaturation, qreal luma); signals:
/// request for repaint, for instance, if the hue changes.
void update();
/// -1, if unaffected
- void paramChanged(qreal hue, qreal hsvSaturation, qreal value, qreal \
hslSaturation, qreal lightness); + void paramChanged(qreal hue, qreal \
hsvSaturation, qreal value, qreal hslSaturation, qreal lightness, qreal \
hsiSaturation, qreal intensity, qreal hsySaturation, qreal luma); protected:
const KoColorSpace* colorSpace() const;
/// returns true, if ether the colour space, the size or the parameters have \
changed since the last paint event @@ -95,6 +95,10 @@ protected:
qreal m_value;
qreal m_hslSaturation;
qreal m_lightness;
+ qreal m_hsiSaturation;
+ qreal m_intensity;
+ qreal m_hsySaturation;
+ qreal m_luma;
Parameter m_parameter;
Type m_type;
KisColorSelector* m_parent;
diff --git a/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_container.cpp \
b/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_container.cpp
index b0d7204..a10ba14 100644
--- a/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_container.cpp
+++ b/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_container.cpp
@@ -141,6 +141,8 @@ void KisColorSelectorContainer::updateSettings()
else
newShadeSelector = 0;
+
+
if(m_shadeSelector!=newShadeSelector && m_shadeSelector!=0) {
m_shadeSelector->hide();
}
diff --git a/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_ring.cpp \
b/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_ring.cpp \
index b850064..9878bf4 100644
--- a/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_ring.cpp
+++ b/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_ring.cpp
@@ -114,7 +114,7 @@ KoColor KisColorSelectorRing::selectColor(int x, int y)
QPoint ringCoord = QPoint(x, y)-ringMiddle;
qreal hue = std::atan2(qreal(ringCoord.y()), qreal(ringCoord.x()))+(M_PI);
hue/=2.*M_PI;
- emit paramChanged(hue, -1, -1, -1, -1);
+ emit paramChanged(hue, -1, -1, -1, -1, -1, -1, -1, -1);
m_lastHue=hue;
emit update();
@@ -126,7 +126,7 @@ void KisColorSelectorRing::setColor(const KoColor &color)
qreal h, s, v;
m_parent->converter()->getHsvF(color, &h, &s, &v);
- emit paramChanged(h, -1, -1, -1, -1);
+ emit paramChanged(h, -1, -1, -1, -1, -1, -1, -1, -1);
// selector keeps the position on the ring if hue is undefined (when saturation \
is 0) if (!qFuzzyCompare(s, 0.0)) {
diff --git a/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_settings.cpp \
b/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_settings.cpp
index 715e9ae..f171c2e 100644
--- a/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_settings.cpp
+++ b/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_settings.cpp
@@ -151,6 +151,17 @@ void KisColorSelectorSettings::savePreferences() const
cfg.writeEntry("shadeSelectorUpdateOnLeftClick", \
ui->shadeSelectorUpdateOnLeftClick->isChecked());
cfg.writeEntry("shadeSelectorUpdateOnBackground", \
ui->shadeSelectorUpdateOnBackground->isChecked());
+ //mypaint model
+ QString shadeMyPaintType("HSV");
+ if(ui->MyPaint_HSL->isChecked())
+ shadeMyPaintType="HSL";
+ if(ui->MyPaint_HSI->isChecked())
+ shadeMyPaintType="HSI";
+ if(ui->MyPaint_HSY->isChecked())
+ shadeMyPaintType="HSY";
+
+ cfg.writeEntry("shadeMyPaintType", shadeMyPaintType);
+
cfg.writeEntry("minimalShadeSelectorAsGradient", \
ui->minimalShadeSelectorAsGradient->isChecked());
cfg.writeEntry("minimalShadeSelectorPatchCount", \
ui->minimalShadeSelectorPatchesPerLine->value());
cfg.writeEntry("minimalShadeSelectorLineConfig", \
ui->minimalShadeSelectorLineSettings->toString()); @@ -253,6 +264,12 @@ void \
KisColorSelectorSettings::loadPreferences()
ui->shadeSelectorUpdateOnForeground->setChecked(cfg.readEntry("shadeSelectorUpdateOnForeground", \
true));
ui->shadeSelectorUpdateOnBackground->setChecked(cfg.readEntry("shadeSelectorUpdateOnBackground", \
true));
+ QString shadeMyPaintType=cfg.readEntry("shadeMyPaintType", "HSV");
+ ui->MyPaint_HSV->setChecked(shadeMyPaintType=="HSV");
+ ui->MyPaint_HSL->setChecked(shadeMyPaintType=="HSL");
+ ui->MyPaint_HSI->setChecked(shadeMyPaintType=="HSI");
+ ui->MyPaint_HSY->setChecked(shadeMyPaintType=="HSY");
+
bool asGradient = cfg.readEntry("minimalShadeSelectorAsGradient", true);
if(asGradient) ui->minimalShadeSelectorAsGradient->setChecked(true);
else ui->minimalShadeSelectorAsColorPatches->setChecked(true);
@@ -313,6 +330,11 @@ void KisColorSelectorSettings::loadDefaultPreferences()
ui->shadeSelectorTypeMinimal->setChecked(false);
ui->shadeSelectorTypeHidden->setChecked(false);
+ ui->MyPaint_HSV->setChecked(true);
+ ui->MyPaint_HSL->setChecked(false);
+ ui->MyPaint_HSI->setChecked(false);
+ ui->MyPaint_HSY->setChecked(false);
+
ui->shadeSelectorUpdateOnRightClick->setChecked(false);
ui->shadeSelectorUpdateOnLeftClick->setChecked(false);
ui->shadeSelectorUpdateOnForeground->setChecked(true);
diff --git a/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_simple.cpp \
b/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_simple.cpp
index 99a761a..38d66c5 100644
--- a/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_simple.cpp
+++ b/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_simple.cpp
@@ -45,38 +45,68 @@ KoColor KisColorSelectorSimple::selectColor(int x, int y)
switch (m_parameter) {
case KisColorSelector::H:
- emit paramChanged(relPos, -1, -1, -1, -1);
+ emit paramChanged(relPos, -1, -1, -1, -1, -1, -1, -1, -1);
break;
case KisColorSelector::hsvS:
- emit paramChanged(-1, relPos, -1, -1, -1);
+ emit paramChanged(-1, relPos, -1, -1, -1, -1, -1, -1, -1);
break;
case KisColorSelector::hslS:
- emit paramChanged(-1, -1, -1, relPos, -1);
+ emit paramChanged(-1, -1, -1, relPos, -1, -1, -1, -1, -1);
break;
+ case KisColorSelector::hsiS:
+ emit paramChanged(-1, -1, -1, -1, -1, relPos, -1, -1, -1);
+ break;
+ case KisColorSelector::hsyS:
+ emit paramChanged(-1, -1, -1, -1, -1, -1, -1, relPos, -1);
+ break;
case KisColorSelector::V:
- emit paramChanged(-1, -1, relPos, -1, -1);
+ emit paramChanged(-1, -1, relPos, -1, -1, -1, -1, -1, -1);
break;
case KisColorSelector::L:
- emit paramChanged(-1, -1, -1, -1, relPos);
+ emit paramChanged(-1, -1, -1, -1, relPos, -1, -1, -1, -1);
+ break;
+ case KisColorSelector::I:
+ emit paramChanged(-1, -1, -1, -1, -1, -1, relPos, -1, -1);
+ break;
+ case KisColorSelector::Y:
+ emit paramChanged(-1, -1, -1, -1, -1, -1, -1, -1, relPos);
break;
case KisColorSelector::SL:
- emit paramChanged(-1, -1, -1, xRel, yRel);
+ emit paramChanged(-1, -1, -1, xRel, yRel, -1, -1, -1, -1);
+ break;
+ case KisColorSelector::SI:
+ emit paramChanged(-1, -1, -1, -1, -1, xRel, yRel, -1, -1);
+ break;
+ case KisColorSelector::SY:
+ emit paramChanged(-1, -1, -1, -1, -1, -1, -1, xRel, yRel);
break;
case KisColorSelector::SV2:
case KisColorSelector::SV:
- emit paramChanged(-1, xRel, yRel, -1, -1);
+ emit paramChanged(-1, xRel, yRel, -1, -1, -1, -1, -1, -1);
break;
case KisColorSelector::hsvSH:
- emit paramChanged(xRel, yRel, -1, -1, -1);
+ emit paramChanged(xRel, yRel, -1, -1, -1, -1, -1, -1, -1);
break;
case KisColorSelector::hslSH:
- emit paramChanged(xRel, -1, -1, yRel, -1);
+ emit paramChanged(xRel, -1, -1, yRel, -1, -1, -1, -1, -1);
+ break;
+ case KisColorSelector::hsiSH:
+ emit paramChanged(xRel, -1, -1, -1, -1, yRel, -1, -1, -1);
+ break;
+ case KisColorSelector::hsySH:
+ emit paramChanged(xRel, -1, -1, -1, -1, -1, -1, yRel, -1);
break;
case KisColorSelector::VH:
- emit paramChanged(xRel, -1, yRel, -1, -1);
+ emit paramChanged(xRel, -1, yRel, -1, -1, -1, -1, -1, -1);
break;
case KisColorSelector::LH:
- emit paramChanged(xRel, -1, -1, -1, yRel);
+ emit paramChanged(xRel, -1, -1, -1, yRel, -1, -1, -1, -1);
+ break;
+ case KisColorSelector::IH:
+ emit paramChanged(xRel, -1, -1, -1, -1, -1, yRel, -1, -1);
+ break;
+ case KisColorSelector::YH:
+ emit paramChanged(xRel, -1, -1, -1, -1, -1, -1, -1, yRel);
break;
}
@@ -88,24 +118,44 @@ void KisColorSelectorSimple::setColor(const KoColor &color)
{
qreal hsvH, hsvS, hsvV;
qreal hslH, hslS, hslL;
+ qreal hsiH, hsiS, hsiI;
+ qreal hsyH, hsyS, hsyY;
+
m_parent->converter()->getHsvF(color, &hsvH, &hsvS, &hsvV);
m_parent->converter()->getHslF(color, &hslH, &hslS, &hslL);
+ //here we add our convertor options
+ m_parent->converter()->getHsiF(color, &hsiH, &hsiS, &hsiI);
+ m_parent->converter()->getHsyF(color, &hsyH, &hsyS, &hsyY);
+
+ //workaround, for some reason the HSI and HSY algorithms are fine, but they don't \
seem to update the selectors properly. + hsiH=hslH;
+ hsyH=hslH;
switch (m_parameter) {
case KisColorSelector::SL:
m_lastClickPos.setX(hslS);
m_lastClickPos.setY(1 - hslL);
- emit paramChanged(-1, -1, -1, hslS, hslL);
+ emit paramChanged(-1, -1, -1, hslS, hslL, -1, -1, -1, -1);
+ break;
+ case KisColorSelector::SI:
+ m_lastClickPos.setX(hsiS);
+ m_lastClickPos.setY(1 - hsiI);
+ emit paramChanged(-1, -1, -1, -1, -1, hsiS, hsiI, -1, -1);
+ break;
+ case KisColorSelector::SY:
+ m_lastClickPos.setX(hsyS);
+ m_lastClickPos.setY(1 - hsyY);
+ emit paramChanged(-1, -1, -1, -1, -1, -1, -1, hsyS, hsyY);
break;
case KisColorSelector::LH:
m_lastClickPos.setX(qBound<qreal>(0., hslH, 1.));
m_lastClickPos.setY(1 - hslL);
- emit paramChanged(hslH, -1, -1, -1, hslL);
+ emit paramChanged(hslH, -1, -1, -1, hslL, -1, -1, -1, -1);
break;
case KisColorSelector::SV:
m_lastClickPos.setX(hsvS);
m_lastClickPos.setY(1 - hsvV);
- emit paramChanged(-1, hsvS, hsvV, -1, -1);
+ emit paramChanged(-1, hsvS, hsvV, -1, -1, -1, -1, -1, -1);
break;
case KisColorSelector::SV2: {
qreal xRel = hsvS;
@@ -116,43 +166,81 @@ void KisColorSelectorSimple::setColor(const KoColor &color)
m_lastClickPos.setX(xRel);
m_lastClickPos.setY(yRel);
- emit paramChanged(-1, -1, -1, xRel, yRel);
+ emit paramChanged(-1, -1, -1, xRel, yRel, -1, -1, -1, -1);
break;
}
case KisColorSelector::VH:
m_lastClickPos.setX(qBound<qreal>(0., hsvH, 1.));
m_lastClickPos.setY(1 - hsvV);
- emit paramChanged(hsvH, -1, hsvV, -1, -1);
+ emit paramChanged(hsvH, -1, hsvV, -1, -1, -1, -1, -1, -1);
+ break;
+ case KisColorSelector::IH:
+ m_lastClickPos.setX(qBound<qreal>(0., hsiH, 1.));
+ m_lastClickPos.setY(1 - hsiI);
+ emit paramChanged(hsiH, -1, -1, -1, -1, -1, hsiI, -1, -1);
+ break;
+ case KisColorSelector::YH:
+ m_lastClickPos.setX(qBound<qreal>(0., hsyH, 1.));
+ m_lastClickPos.setY(1 - hsyY);
+ emit paramChanged(hsyH, -1, -1, -1, -1, -1, -1, -1, hsyY);
break;
case KisColorSelector::hsvSH:
m_lastClickPos.setX(qBound<qreal>(0., hsvH, 1.));
m_lastClickPos.setY(1 - hsvS);
- emit paramChanged(hsvH, hsvS, -1, -1, -1);
+ emit paramChanged(hsvH, hsvS, -1, -1, -1, -1, -1, -1, -1);
break;
case KisColorSelector::hslSH:
m_lastClickPos.setX(qBound<qreal>(0., hslH, 1.));
m_lastClickPos.setY(1 - hslS);
- emit paramChanged(hslH, -1, -1, hslS, -1);
+ emit paramChanged(hslH, -1, -1, hslS, -1, -1, -1, -1, -1);
+ break;
+
+ case KisColorSelector::hsiSH:
+ m_lastClickPos.setX(qBound<qreal>(0., hsiH, 1.));
+ m_lastClickPos.setY(1 - hsiS);
+ emit paramChanged(hsiH, -1, -1, hsiS, -1, -1, -1, -1, -1);
+ break;
+
+ case KisColorSelector::hsySH:
+ m_lastClickPos.setX(qBound<qreal>(0., hsyH, 1.));
+ m_lastClickPos.setY(1 - hsyS);
+ emit paramChanged(hsyH, -1, -1, hsyS, -1, -1, -1, -1, -1);
break;
case KisColorSelector::L:
m_lastClickPos.setX(qBound<qreal>(0., hslL, 1.));
- emit paramChanged(-1, -1, -1, -1, hslL);
+ emit paramChanged(-1, -1, -1, -1, hslL, -1, -1, -1, -1);
+ break;
+ case KisColorSelector::I:
+ m_lastClickPos.setX(qBound<qreal>(0., hsiI, 1.));
+ emit paramChanged(-1, -1, -1, -1, -1, -1, hsiI, -1, -1);
break;
case KisColorSelector::V:
m_lastClickPos.setX(hsvV);
- emit paramChanged(-1, -1, hsvV, -1, -1);
+ emit paramChanged(-1, -1, hsvV, -1, -1, -1, -1, -1, -1);
+ break;
+ case KisColorSelector::Y:
+ m_lastClickPos.setX(qBound<qreal>(0., hsyY, 1.));
+ emit paramChanged(-1, -1, -1, -1, -1, -1, -1, -1, hsyY);
break;
case KisColorSelector::hsvS:
m_lastClickPos.setX( hsvS );
- emit paramChanged(-1, hsvS, -1, -1, -1);
+ emit paramChanged(-1, hsvS, -1, -1, -1, -1, -1, -1, -1);
break;
case KisColorSelector::hslS:
m_lastClickPos.setX( hslS );
- emit paramChanged(-1, -1, -1, hslS, -1);
+ emit paramChanged(-1, -1, -1, hslS, -1, -1, -1, -1, -1);
+ break;
+ case KisColorSelector::hsiS:
+ m_lastClickPos.setX( hsiS );
+ emit paramChanged(-1, -1, -1, -1, -1, hsiS, -1, -1, -1);
+ break;
+ case KisColorSelector::hsyS:
+ m_lastClickPos.setX( hsyS );
+ emit paramChanged(-1, -1, -1, -1, -1, -1, -1, hsyS, -1);
break;
case KisColorSelector::H:
m_lastClickPos.setX(qBound<qreal>(0., hsvH, 1.));
- emit paramChanged(hsvH, -1, -1, -1, -1);
+ emit paramChanged(hsvH, -1, -1, -1, -1, -1, -1, -1, -1);
break;
default:
Q_ASSERT(false);
@@ -188,8 +276,12 @@ void KisColorSelectorSimple::paint(QPainter* painter)
case KisColorSelector::H:
case KisColorSelector::hsvS:
case KisColorSelector::hslS:
+ case KisColorSelector::hsiS:
+ case KisColorSelector::hsyS:
case KisColorSelector::V:
case KisColorSelector::L:
+ case KisColorSelector::I:
+ case KisColorSelector::Y:
if(width()>height()) {
painter->setPen(QColor(0,0,0));
painter->drawLine(m_lastClickPos.x()*width()-1, 0, \
m_lastClickPos.x()*width()-1, height()); @@ -206,10 +298,16 @@ void \
KisColorSelectorSimple::paint(QPainter* painter) case KisColorSelector::SL:
case KisColorSelector::SV:
case KisColorSelector::SV2:
+ case KisColorSelector::SI:
+ case KisColorSelector::SY:
case KisColorSelector::hslSH:
case KisColorSelector::hsvSH:
+ case KisColorSelector::hsiSH:
+ case KisColorSelector::hsySH:
case KisColorSelector::VH:
case KisColorSelector::LH:
+ case KisColorSelector::IH:
+ case KisColorSelector::YH:
painter->setPen(QColor(0,0,0));
painter->drawEllipse(m_lastClickPos.x()*width()-5, \
m_lastClickPos.y()*height()-5, 10, 10); painter->setPen(QColor(255,255,255));
@@ -242,18 +340,36 @@ KoColor KisColorSelectorSimple::colorAt(int x, int y)
case KisColorSelector::SV2:
color = m_parent->converter()->fromHsvF(m_hue, xRel, xRel + \
(1.0-xRel)*yRel); break;
+ case KisColorSelector::SI:
+ color = m_parent->converter()->fromHsiF(m_hue, xRel, yRel);
+ break;
+ case KisColorSelector::SY:
+ color = m_parent->converter()->fromHsyF(m_hue, xRel, yRel);
+ break;
case KisColorSelector::hsvSH:
color = m_parent->converter()->fromHsvF(xRel, yRel, m_value);
break;
case KisColorSelector::hslSH:
color = m_parent->converter()->fromHslF(xRel, yRel, m_lightness);
break;
+ case KisColorSelector::hsiSH:
+ color = m_parent->converter()->fromHsiF(xRel, yRel, m_intensity);
+ break;
+ case KisColorSelector::hsySH:
+ color = m_parent->converter()->fromHsyF(xRel, yRel, m_luma);
+ break;
case KisColorSelector::VH:
color = m_parent->converter()->fromHsvF(xRel, m_hsvSaturation, yRel);
break;
case KisColorSelector::LH:
color = m_parent->converter()->fromHslF(xRel, m_hslSaturation, yRel);
break;
+ case KisColorSelector::IH:
+ color = m_parent->converter()->fromHsiF(xRel, m_hsiSaturation, yRel);
+ break;
+ case KisColorSelector::YH:
+ color = m_parent->converter()->fromHsyF(xRel, m_hsySaturation, yRel);
+ break;
case KisColorSelector::H:
color = m_parent->converter()->fromHsvF(relPos, 1, 1);
break;
@@ -269,6 +385,18 @@ KoColor KisColorSelectorSimple::colorAt(int x, int y)
case KisColorSelector::L:
color = m_parent->converter()->fromHslF(m_hue, m_hslSaturation, relPos);
break;
+ case KisColorSelector::hsiS:
+ color = m_parent->converter()->fromHsiF(m_hue, relPos, m_intensity);
+ break;
+ case KisColorSelector::I:
+ color = m_parent->converter()->fromHsiF(m_hue, m_hsiSaturation, relPos);
+ break;
+ case KisColorSelector::hsyS:
+ color = m_parent->converter()->fromHsyF(m_hue, relPos, m_luma);
+ break;
+ case KisColorSelector::Y:
+ color = m_parent->converter()->fromHsyF(m_hue, m_hsySaturation, relPos);
+ break;
default:
Q_ASSERT(false);
diff --git a/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_triangle.cpp \
b/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_triangle.cpp
index 3d55af7..6268d89 100644
--- a/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_triangle.cpp
+++ b/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_triangle.cpp
@@ -130,7 +130,7 @@ void KisColorSelectorTriangle::setColor(const KoColor &color)
// Workaround for Bug 287001
setLastMousePosition(tmp.x(), tmp.y());
- emit paramChanged(-1, s, v, -1, -1);
+ emit paramChanged(-1, s, v, -1, -1, -1, -1, -1, -1);
emit update();
}
diff --git a/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_wheel.cpp \
b/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_wheel.cpp \
index 86bf8e5..df15586 100644
--- a/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_wheel.cpp
+++ b/krita/plugins/extensions/dockers/advancedcolorselector/kis_color_selector_wheel.cpp
@@ -49,16 +49,28 @@ KoColor KisColorSelectorWheel::selectColor(int x, int y)
switch (m_parameter) {
case KisColorSelector::hsvSH:
- emit paramChanged(angle, radius, -1, -1, -1);
+ emit paramChanged(angle, radius, -1, -1, -1, -1, -1, -1, -1);
break;
case KisColorSelector::hslSH:
- emit paramChanged(angle, -1, -1, radius, -1);
+ emit paramChanged(angle, -1, -1, radius, -1, -1, -1, -1, -1);
+ break;
+ case KisColorSelector::hsiSH:
+ emit paramChanged(angle, -1, -1, -1, -1, radius, -1, -1, -1);
+ break;
+ case KisColorSelector::hsySH:
+ emit paramChanged(angle, -1, -1, -1, -1, -1, -1, radius, -1);
break;
case KisColorSelector::VH:
- emit paramChanged(angle, -1, radius, -1, -1);
+ emit paramChanged(angle, -1, radius, -1, -1, -1, -1, -1, -1);
break;
case KisColorSelector::LH:
- emit paramChanged(angle, -1, -1, -1, radius);
+ emit paramChanged(angle, -1, -1, -1, radius, -1, -1, -1, -1);
+ break;
+ case KisColorSelector::IH:
+ emit paramChanged(angle, -1, -1, -1, -1, -1, radius, -1, -1);
+ break;
+ case KisColorSelector::YH:
+ emit paramChanged(angle, -1, -1, -1, -1, -1, -1, -1, radius);
break;
default:
Q_ASSERT(false);
@@ -80,9 +92,16 @@ void KisColorSelectorWheel::setColor(const KoColor &color)
{
qreal hsvH, hsvS, hsvV;
qreal hslH, hslS, hslL;
+ qreal hsiH, hsiS, hsiI;
+ qreal hsyH, hsyS, hsyY;
m_parent->converter()->getHsvF(color, &hsvH, &hsvS, &hsvV);
m_parent->converter()->getHslF(color, &hslH, &hslS, &hslL);
+ m_parent->converter()->getHsiF(color, &hsiH, &hsiS, &hsiI);
+ m_parent->converter()->getHsyF(color, &hsyH, &hsyS, &hsyY);
+ //workaround, for some reason the HSI and HSY algorithms are fine, but they don't \
seem to update the selectors properly. + hsiH=hslH;
+ hsyH=hslH;
qreal angle = 0.0, radius = 0.0;
angle = hsvH;
@@ -90,21 +109,37 @@ void KisColorSelectorWheel::setColor(const KoColor &color)
angle -= M_PI;
switch (m_parameter) {
case KisColorSelector::LH:
- emit paramChanged(hslH, -1, -1, -1, hslL);
+ emit paramChanged(hslH, -1, -1, -1, hslL, -1, -1, -1, -1);
radius = hslL;
break;
case KisColorSelector::VH:
- emit paramChanged(hsvH, -1, hsvV, -1, -1);
+ emit paramChanged(hsvH, -1, hsvV, -1, -1, -1, -1, -1, -1);
radius = hsvV;
break;
+ case KisColorSelector::IH:
+ emit paramChanged(hslH, -1, -1, -1, -1, -1, hsiI, -1, -1);
+ radius = hsiI;
+ break;
+ case KisColorSelector::YH:
+ emit paramChanged(hsvH, -1, -1, -1, -1, -1, -1, -1, hsyY);
+ radius = hsyY;
+ break;
case KisColorSelector::hsvSH:
- emit paramChanged(hsvH, hsvS, -1, -1, -1);
+ emit paramChanged(hsvH, hsvS, -1, -1, -1, -1, -1, -1, -1);
radius = hsvS;
break;
case KisColorSelector::hslSH:
- emit paramChanged(hslH, -1, -1, hslS, -1);
+ emit paramChanged(hslH, -1, -1, hslS, -1, -1, -1, -1, -1);
radius = hslS;
break;
+ case KisColorSelector::hsiSH:
+ emit paramChanged(hsiH, -1, -1, -1, -1, hsiS, -1, -1, -1);
+ radius = hsiS;
+ break;
+ case KisColorSelector::hsySH:
+ emit paramChanged(hsyH, -1, -1, -1, -1, -1, -1, hsyS, -1);
+ radius = hsyS;
+ break;
default:
Q_ASSERT(false);
break;
@@ -198,12 +233,24 @@ KoColor KisColorSelectorWheel::colorAt(int x, int y, bool \
forceValid) case KisColorSelector::hslSH:
color = m_parent->converter()->fromHslF(angle, radius, m_lightness);
break;
+ case KisColorSelector::hsiSH:
+ color = m_parent->converter()->fromHsiF(angle, radius, m_intensity);
+ break;
+ case KisColorSelector::hsySH:
+ color = m_parent->converter()->fromHsyF(angle, radius, m_luma);
+ break;
case KisColorSelector::VH:
color = m_parent->converter()->fromHsvF(angle, m_hsvSaturation, radius);
break;
case KisColorSelector::LH:
color = m_parent->converter()->fromHslF(angle, m_hslSaturation, radius);
break;
+ case KisColorSelector::IH:
+ color = m_parent->converter()->fromHsiF(angle, m_hsiSaturation, radius);
+ break;
+ case KisColorSelector::YH:
+ color = m_parent->converter()->fromHsyF(angle, m_hsySaturation, radius);
+ break;
default:
Q_ASSERT(false);
diff --git a/krita/plugins/extensions/dockers/advancedcolorselector/kis_my_paint_shade_selector.cpp \
b/krita/plugins/extensions/dockers/advancedcolorselector/kis_my_paint_shade_selector.cpp
index 504ed2f..73c6c80 100644
--- a/krita/plugins/extensions/dockers/advancedcolorselector/kis_my_paint_shade_selector.cpp
+++ b/krita/plugins/extensions/dockers/advancedcolorselector/kis_my_paint_shade_selector.cpp
@@ -78,6 +78,9 @@ void KisMyPaintShadeSelector::paintEvent(QPaintEvent *) {
m_realPixelCache = new KisPaintDevice(this->colorSpace());
KisPaintDeviceSP realCircleBorder = new KisPaintDevice(this->colorSpace());
+ KConfigGroup cfg = KGlobal::config()->group("advancedColorSelector");
+ QString shadeMyPaintType=cfg.readEntry("shadeMyPaintType", "HSV");
+
int size = qMin(width(), height());
int s_radius = size/2.6;
@@ -147,9 +150,16 @@ void KisMyPaintShadeSelector::paintEvent(QPaintEvent *) {
fh -= floor(fh);
fs = qBound(qreal(0.0), fs, qreal(1.0));
- fv = qBound(qreal(0.1), fv, qreal(1.0));
-
- KoColor color = converter()->fromHsvF(fh, fs, fv);
+ fv = qBound(qreal(0.01), fv, qreal(1.0));
+ KoColor color;
+ //KoColor color = converter()->fromHsvF(fh, fs, fv);
+ if(shadeMyPaintType=="HSV"){color = converter()->fromHsvF(fh, fs, fv);}
+ else if(shadeMyPaintType=="HSL"){color = converter()->fromHslF(fh, fs, fv);}
+ else if(shadeMyPaintType=="HSI"){color = converter()->fromHsiF(fh, fs, fv);}
+ else if(shadeMyPaintType=="HSY"){color = converter()->fromHsyF(fh, fs, fv);}
+ else{qDebug()<<"MyPaint Color selector don't work right.";
+ color = converter()->fromHsvF(fh, fs, fv);}
+//qDebug()<<color->toQcolor();
color.setOpacity(aaFactor);
Acs::setColor(realCircleBorder, QPoint(x, y), color);
@@ -169,9 +179,16 @@ void KisMyPaintShadeSelector::paintEvent(QPaintEvent *) {
fh -= floor(fh);
fs = qBound(qreal(0.0), fs, qreal(1.0));
- fv = qBound(qreal(0.1), fv, qreal(1.0));
+ fv = qBound(qreal(0.01), fv, qreal(1.0));
+ KoColor color;
+ //KoColor color = converter()->fromHsvF(fh, fs, fv);
+ if(shadeMyPaintType=="HSV"){color = converter()->fromHsvF(fh, fs, fv);}
+ else if(shadeMyPaintType=="HSL"){color = converter()->fromHslF(fh, fs, fv);}
+ else if(shadeMyPaintType=="HSI"){color = converter()->fromHsiF(fh, fs, fv);}
+ else if(shadeMyPaintType=="HSY"){color = converter()->fromHsyF(fh, fs, fv);}
+ else{qDebug()<<"MyPaint Color selector don't work right.";
+ color = converter()->fromHsvF(fh, fs, fv);}
- KoColor color = converter()->fromHsvF(fh, fs, fv);
Acs::setColor(m_realPixelCache, QPoint(x, y), color);
}
}
@@ -233,7 +250,13 @@ KisColorSelectorBase* KisMyPaintShadeSelector::createPopup() \
const }
void KisMyPaintShadeSelector::setColor(const KoColor &color) {
- this->converter()->getHsvF(color, &m_colorH, &m_colorS, &m_colorV);
+
+ KConfigGroup cfg = KGlobal::config()->group("advancedColorSelector");
+ QString shadeMyPaintType=cfg.readEntry("shadeMyPaintType", "HSV");
+ if(shadeMyPaintType=="HSV"){this->converter()->getHsvF(color, &m_colorH, &m_colorS, \
&m_colorV);} + if(shadeMyPaintType=="HSL"){this->converter()->getHslF(color, \
&m_colorH, &m_colorS, &m_colorV);} \
+ if(shadeMyPaintType=="HSI"){this->converter()->getHsiF(color, &m_colorH, &m_colorS, \
&m_colorV);} + if(shadeMyPaintType=="HSY"){this->converter()->getHsyF(color, \
&m_colorH, &m_colorS, &m_colorV);} m_lastRealColor = color;
m_updateTimer->start();
diff --git a/krita/plugins/extensions/dockers/advancedcolorselector/wdg_color_selector_settings.ui \
b/krita/plugins/extensions/dockers/advancedcolorselector/wdg_color_selector_settings.ui
index d06a29a..dbe9070 100644
--- a/krita/plugins/extensions/dockers/advancedcolorselector/wdg_color_selector_settings.ui
+++ b/krita/plugins/extensions/dockers/advancedcolorselector/wdg_color_selector_settings.ui
@@ -6,15 +6,15 @@
<rect>
<x>0</x>
<y>0</y>
- <width>582</width>
- <height>385</height>
+ <width>650</width>
+ <height>469</height>
</rect>
</property>
<property name="windowTitle">
<string>Color Selector Settings</string>
</property>
- <layout class="QGridLayout" name="gridLayout_5">
- <item row="0" column="0">
+ <layout class="QVBoxLayout" name="verticalLayout_6">
+ <item>
<widget class="KTabWidget" name="tabWidget">
<property name="currentIndex">
<number>0</number>
@@ -301,6 +301,65 @@
</widget>
</item>
<item>
+ <widget class="QGroupBox" name="groupBox_8">
+ <property name="title">
+ <string>MyPaint Shade Selector</string>
+ </property>
+ <layout class="QHBoxLayout" name="horizontalLayout_13">
+ <item>
+ <widget class="QLabel" name="label_4">
+ <property name="text">
+ <string>Color-model type:</string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QRadioButton" name="MyPaint_HSV">
+ <property name="toolTip">
+ <string><html><head/><body><p>Use the Hue \
Saturation Value model.(Default)</p><p><br/></p><p>This \
model sets all the most saturated colours at the same level as white. Think value as \
a measure of pixel-brightness.</p></body></html></string> + \
</property> + <property name="text">
+ <string>HSV</string>
+ </property>
+ <property name="checked">
+ <bool>true</bool>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QRadioButton" name="MyPaint_HSL">
+ <property name="toolTip">
+ <string><html><head/><body><p>Use the Hue, \
Saturation, Lightness model.</p><p>This model sets all the most saturated \
colors at lightness 0.5</p></body></html></string> + \
</property> + <property name="text">
+ <string>HSL</string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QRadioButton" name="MyPaint_HSI">
+ <property name="toolTip">
+ <string><html><head/><body><p>Use the Hue, \
Saturation, Intensity model for the MyPaint Shade \
Selector</p><p>Intensity marks itself by measuring the sum of the r, g, b \
components. As such, yellow(1,1,0) is brighter than \
blue(0,0,1).</p></body></html></string> + </property>
+ <property name="text">
+ <string>HSI</string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QRadioButton" name="MyPaint_HSY">
+ <property name="toolTip">
+ <string><html><head/><body><p>Use the Hue, \
Saturation, Luma model for the MyPaint Shade Selector</p><p>Luma is \
similar to Intensity, except it weighs the red green and blue components before \
adding them together. As such, Yellow is brighter than Cyan. This model is exactly \
the same as MyPaint HCY'.</p></body></html></string> + \
</property> + <property name="text">
+ <string>HSY'</string>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </widget>
+ </item>
+ <item>
<widget class="QGroupBox" name="groupBox_7">
<property name="title">
<string>Minimal Shade Selector</string>
@@ -418,8 +477,8 @@
<rect>
<x>0</x>
<y>0</y>
- <width>321</width>
- <height>151</height>
+ <width>364</width>
+ <height>156</height>
</rect>
</property>
<layout class="QGridLayout" name="gridLayout_4">
diff --git a/krita/ui/canvas/kis_display_color_converter.cpp \
b/krita/ui/canvas/kis_display_color_converter.cpp index 2e0388e..19f1460 100644
--- a/krita/ui/canvas/kis_display_color_converter.cpp
+++ b/krita/ui/canvas/kis_display_color_converter.cpp
@@ -23,6 +23,7 @@
#include <KoColorSpaceMaths.h>
#include <KoColorSpaceRegistry.h>
#include <KoColorModelStandardIds.h>
+#include <KoColorConversions.h>
#include <KoCanvasResourceManager.h>
#include "kis_config_notifier.h"
@@ -562,4 +563,50 @@ void KisDisplayColorConverter::getHslF(const KoColor &srcColor, \
qreal *h, qreal color.getHslF(h, s, l, a);
}
+KoColor KisDisplayColorConverter::fromHsiF(qreal h, qreal s, qreal i)
+{
+ // generate HSI from sRGB!
+ qreal r=0.0;
+ qreal g=0.0;
+ qreal b=0.0;
+ qreal a=1.0;
+ HSIToRGB(h, s, i, &r, &g, &b);
+ QColor qcolor;
+ qcolor.setRgbF(r, g, b, a);
+ return m_d->approximateFromQColor(qcolor);
+}
+
+void KisDisplayColorConverter::getHsiF(const KoColor &srcColor, qreal *h, qreal *s, \
qreal *i) +{
+ // we are going through sRGB here!
+ QColor color = m_d->approximateToQColor(srcColor);
+ qreal r=color.redF();
+ qreal g=color.greenF();
+ qreal b=color.blueF();
+ RGBToHSI(r, g, b, h, s, i);
+}
+
+KoColor KisDisplayColorConverter::fromHsyF(qreal h, qreal s, qreal y)
+{
+ // generate HSL from sRGB!
+ qreal r=0.0;
+ qreal g=0.0;
+ qreal b=0.0;
+ qreal a=1.0;
+ HSYToRGB(h, s, y, &r, &g, &b);
+ QColor qcolor;
+ qcolor.setRgbF(r, g, b, a);
+ return m_d->approximateFromQColor(qcolor);
+}
+
+void KisDisplayColorConverter::getHsyF(const KoColor &srcColor, qreal *h, qreal *s, \
qreal *y) +{
+ // we are going through sRGB here!
+ QColor color = m_d->approximateToQColor(srcColor);
+ qreal r=color.redF();
+ qreal g=color.greenF();
+ qreal b=color.blueF();
+ RGBToHSY(r, g, b, h, s, y);
+}
+
#include "moc_kis_display_color_converter.cpp"
diff --git a/krita/ui/canvas/kis_display_color_converter.h \
b/krita/ui/canvas/kis_display_color_converter.h index ea6c049..9678376 100644
--- a/krita/ui/canvas/kis_display_color_converter.h
+++ b/krita/ui/canvas/kis_display_color_converter.h
@@ -74,10 +74,14 @@ public:
KoColor fromHsv(int h, int s, int v, int a = 255) const;
KoColor fromHsvF(qreal h, qreal s, qreal v, qreal a = 1.0);
KoColor fromHslF(qreal h, qreal s, qreal l, qreal a = 1.0);
+ KoColor fromHsiF(qreal h, qreal s, qreal i);
+ KoColor fromHsyF(qreal h, qreal s, qreal y);
void getHsv(const KoColor &srcColor, int *h, int *s, int *v, int *a = 0) const;
void getHsvF(const KoColor &srcColor, qreal *h, qreal *s, qreal *v, qreal *a = \
0);
void getHslF(const KoColor &srcColor, qreal *h, qreal *s, qreal *l, qreal *a = \
0); + void getHsiF(const KoColor &srcColor, qreal *h, qreal *s, qreal *i);
+ void getHsyF(const KoColor &srcColor, qreal *h, qreal *s, qreal *y);
static KoColorConversionTransformation::Intent renderingIntent();
static KoColorConversionTransformation::ConversionFlags conversionFlags();
diff --git a/libs/pigment/KoColorConversions.cpp \
b/libs/pigment/KoColorConversions.cpp index 148beb1..fc7954b 100644
--- a/libs/pigment/KoColorConversions.cpp
+++ b/libs/pigment/KoColorConversions.cpp
@@ -418,3 +418,595 @@ void HSLToRGB(float h, float sl, float l, float *r, float *g, \
float *b) }
}
}
+
+//functions for converting from and back to HSI
+void HSIToRGB(const qreal h,const qreal s, const qreal i, qreal *red, qreal *green, \
qreal *blue) +{//This function takes H, S and I values, which are converted to rgb.
+ qreal hue = 0.0;
+ qreal sat = 0.0;
+ qreal intensity = 0.0;
+ if (h>1.0 || h<0.0){hue=fmod(h, 1.0);} else {hue=h;}
+ if (s>1.0){sat=1.0;}
+ else if (s<0.0){sat=0.0;}
+ else {sat=s;}
+ if (i>1.0){intensity=1.0;}
+ else if (i<0.0){intensity=0.0;}
+ else {intensity=i;}
+
+ qreal segment = 0.166667;//1/6;
+ qreal r=0.0;
+ qreal g=0.0;
+ qreal b=0.0;
+//HSI weights by adding up the components, so in RGB hsi, you would have to divide \
by 3 to normalise it. + qreal onethird=1.0/3.0;
+//The intermediate variables for the weighted HSL forumala, based on the HSL in \
KoColorConversions. + qreal max_sat, m, fract, intensity_a, chroma, x;
+ if (hue >= 0.0 && hue < (segment) )
+ {
+ //need to treat this as a weighted hsl thingy.
+ //so first things first, at which intensity is the maximum saturation for this \
hue? + //between R and G+R (yellow)
+ max_sat = onethird + ( onethird*(hue*6) );
+ if (intensity<=max_sat){intensity_a = (intensity/max_sat)*0.5; \
chroma=sat*2*intensity_a;} + else {intensity_a = \
((intensity-max_sat)/(1-max_sat)*0.5)+0.5; chroma=sat*(2-2*intensity_a);} +
+ fract = hue*6.0;
+ x = (1-fabs(fmod(fract,2)-1))*chroma;
+ r = chroma; g=x; b=0;\
+ m = intensity-(onethird*(r+b+g));
+ r += m; g += m; b += m;
+
+
+ }
+ else if (hue >= (segment) && hue < (2.0*segment) )
+ {
+
+ max_sat = (onethird*2) - (onethird*(hue-segment)*6);
+ if (intensity<max_sat){intensity_a = (intensity/max_sat)*0.5; \
chroma=sat*(2*intensity_a);} + else {intensity_a = \
((intensity-max_sat)/(1-max_sat)*0.5)+0.5; chroma=sat*(2-2*intensity_a);} +
+ fract = hue*6.0;
+ x = (1-fabs(fmod(fract,2)-1) )*chroma;
+ r = x; g=chroma; b=0;
+ m = intensity-(onethird*(r+b+g));
+ r += m; g += m; b += m;
+
+
+ }
+ else if (hue >= (2.0*segment) && hue < (3.0*segment) )
+ {
+ max_sat = onethird + (onethird*(hue-2.0*segment)*6);
+ if (intensity<max_sat){intensity_a = (intensity/max_sat)*0.5; \
chroma=sat*(2*intensity_a);} + else {intensity_a = \
((intensity-max_sat)/(1-max_sat)*0.5)+0.5; chroma=sat*(2-2*intensity_a);} +
+ fract = hue*6.0;
+ x = (1-fabs(fmod(fract,2)-1) )*chroma;
+ r = 0; g=chroma; b=x;
+ m = intensity-(onethird*(r+b+g));
+ r += m; g += m; b += m;
+ }
+ else if (hue >= (3.0*segment) && hue < (4.0*segment) )
+ { max_sat = (onethird*2) - (onethird*(hue-3.0*segment)*6);
+ if (intensity<max_sat){intensity_a = (intensity/max_sat)*0.5; \
chroma=sat*(2*intensity_a);} + else {intensity_a = \
((intensity-max_sat)/(1-max_sat)*0.5)+0.5; chroma=sat*(2-2*intensity_a);} +
+ fract = hue*6.0;
+ x = (1-fabs(fmod(fract,2)-1) )*chroma;
+ r = 0; g=x; b=chroma;
+ m = intensity-(onethird*(r+b+g));
+ r += m; g += m; b += m;
+ }
+ else if (hue >= (4.0*segment) && hue < (5*segment) )
+ {
+ max_sat = onethird + (onethird*((hue-4.0*segment)*6));
+ if (intensity<max_sat){intensity_a = (intensity/max_sat)*0.5; \
chroma=sat*(2*intensity_a);} + else {intensity_a = \
((intensity-max_sat)/(1-max_sat)*0.5)+0.5; chroma=sat*(2-2*intensity_a);} +
+ fract = hue*6.0;
+ x = (1-fabs(fmod(fract,2)-1) )*chroma;
+ r = x; g=0; b=chroma;
+ m = intensity-(onethird*(r+b+g));
+ r += m; g += m; b += m;
+ }
+ else if (hue >= (5.0*segment) && hue <= 1.0)
+ {
+ max_sat = (onethird*2) - (onethird*(hue-5.0*segment)*6);
+ if (intensity<max_sat){intensity_a = (intensity/max_sat)*0.5; \
chroma=sat*(2*intensity_a);} + else {intensity_a = \
((intensity-max_sat)/(1-max_sat)*0.5)+0.5; chroma=sat*(2-2*intensity_a);} +
+ fract = hue*6.0;
+ x = (1-fabs(fmod(fract,2)-1) )*chroma;
+ r = chroma; g=0; b=x;
+ m = intensity-(onethird*(r+b+g));
+ r += m; g += m; b += m;
+ }
+ else
+ {
+ r=0.0;
+ g=0.0;
+ b=0.0;
+ }
+
+ //qDebug()<<"red: "<<r<<", green: "<<g<<", blue: "<<b;
+ if (r>1.0){r=1.0;}
+ if (g>1.0){g=1.0;}
+ if (b>1.0){b=1.0;}
+ if (r<0.0){r=0.0;}
+ if (g<0.0){g=0.0;}
+ if (b<0.0){b=0.0;}
+
+ *red=r;
+ *green=g;
+ *blue=b;
+}
+void RGBToHSI(qreal r,qreal g, qreal b, qreal *h, qreal *s, qreal *i)
+{
+//Using these RGB values, we calculate the H, S and I.
+ qreal red; qreal green; qreal blue;
+ if (r>1.0){red=1.0;} else if (r<0.0){red=0.0;} else {red=r;}
+ if (g>1.0){green=1.0;} else if (g<0.0){green=0.0;} else {green=g;}
+ if (b>1.0){blue=1.0;} else if (b<0.0){blue=0.0;} else {blue=b;}
+ qreal minval = qMin(r, qMin(g, b));
+ qreal maxval = qMax(r, qMax(g, b));
+ qreal hue = 0.0;
+ qreal sat = 0.0;
+ qreal intensity = 0.0;
+ qreal onethird=1.0/3.0;
+ intensity=onethird*(red+green+blue);
+ qreal intensity_a;//defined later
+ qreal chroma = maxval-minval;
+ qreal max_sat=0.5;
+ if(chroma==0)
+ {
+ hue = 0.0;
+ sat = 0.0;
+ }
+ else
+ {
+ //the following finds the hue
+
+ if(maxval==r)
+ {
+ hue = fmod(((g-b)/chroma), 6.0);
+ }
+ else if(maxval==g)
+ {
+ hue = (b-r)/chroma + 2.0;
+ }
+ else if(maxval==b)
+ {
+ hue = (r-g)/chroma + 4.0;
+ }
+ hue /=6.0;//this makes sure that hue is in the 0-1.0 range.
+ //This HSI formula tries to be a
+ //weighted HSL formula, where instead of 0.5, we search for a Max_Sat value, \
which is the I + //at which the saturation is maximum.
+ //This requires using the hue, and combining the weighting values accordingly.
+ qreal segment = 0.166667; //float for every 60 degrees of a 360 hue wheel.
+ if (hue>1.0 || hue<0.0){hue=fmod(hue, 1.0);}
+ if (hue>=0.0 && hue<segment)
+ {max_sat = onethird + onethird*(hue*6);}
+ else if (hue>=segment && hue<(2.0*segment))
+ {max_sat = (onethird*2) - onethird*((hue-segment)*6) ;}
+ else if (hue>=(2.0*segment) && hue<(3.0*segment))
+ {max_sat = onethird + onethird*((hue-2.0*segment)*6);}
+ else if (hue>=(3.0*segment) && hue<(4.0*segment))
+ {max_sat = (onethird*2) - onethird*((hue-3.0*segment)*6) ;}
+ else if (hue>=(4.0*segment) && hue<(5.0*segment))
+ {max_sat = (onethird) + onethird*((hue-4.0*segment)*6);}
+ else if (hue>=(5.0*segment) && hue<=1.0)
+ {max_sat = (onethird*2) - onethird*((hue-5.0*segment)*6) ;}
+ else
+ {max_sat=0.5;}
+
+ if(max_sat>1.0 || max_sat<0.0){
+ //this should not show up during normal use
+ max_sat=(fmod((max_sat*2.0),2.0))/2.0;} //If it does, it'll try to correct, but \
it's not good! + if (intensity <= max_sat){intensity_a = (intensity/max_sat)*0.5;}
+ else{intensity_a = ((intensity-max_sat)/(1-max_sat)*0.5)+0.5;}//This is weighting \
the intensity for the saturation. + if ((sat = chroma) > 0.0)
+ {sat = (intensity <= max_sat) ? (chroma/ (2*intensity_a) ) \
:(chroma/(2.0-(2*intensity_a) ) ) ; +
+ }
+ }
+
+ //if (hue>1.0){hue=1.0;}
+ if (sat>1.0){sat=1.0;}
+ if (sat<0.0){sat=0.0;}
+ //if (intensity>1.0){intensity=1.0;}
+ //if (intensity<0.0){intensity=0.0;}
+
+ *h=hue;
+ *s=sat;
+ *i=intensity;
+
+
+}
+//functions for converting from and back to hsy'
+void HSYToRGB(const qreal h,const qreal s, const qreal y, qreal *red, qreal *green, \
qreal *blue, qreal R, qreal G, qreal B) +{//This function takes H, S and Y values, \
which are converted to rgb. +//Those are then used to create a qcolor.
+ qreal hue = 0.0;
+ qreal sat = 0.0;
+ qreal luma = 0.0;
+ if (h>1.0 || h<0.0){hue=fmod(h, 1.0);} else {hue=h;}
+ if (s>1.0){sat=1.0;}
+ else if (s<0.0){sat=0.0;}
+ else {sat=s;}
+ if (y>1.0){luma=1.0;}
+ else if (y<0.0){luma=0.0;}
+ else {luma=y;}
+
+ qreal segment = 0.166667;//1/6;
+ qreal r=0.0;
+ qreal g=0.0;
+ qreal b=0.0;
+//weights for rgb to Y'(Luma), these are the same weights used in color space maths \
and the desaturate. +//This is not luminance or luminosity, it just quacks like it.
+ //qreal R=0.299;
+ //qreal G=0.587;
+ //qreal B=0.114;
+//The intermediary variables for the weighted HSL forumala, based on the HSL in \
KoColorConversions. + qreal max_sat, m, fract, luma_a, chroma, x;
+ if (hue >= 0.0 && hue < (segment) )
+ {
+ //need to treat this as a weighted hsl thingy.
+ //so first things first, at which luma is the maximum saturation for this hue?
+ //between R and G+R (yellow)
+ max_sat = R + ( G*(hue*6) );
+ if (luma<=max_sat){luma_a = (luma/max_sat)*0.5; chroma=sat*2*luma_a;}
+ else {luma_a = ((luma-max_sat)/(1-max_sat)*0.5)+0.5; chroma=sat*(2-2*luma_a);}
+
+ fract = hue*6.0;
+ x = (1-fabs(fmod(fract,2)-1))*chroma;
+ r = chroma; g=x; b=0;
+ m = luma-( (R*r)+(B*b)+(G*g) );
+ r += m; g += m; b += m;
+
+
+ }
+ else if (hue >= (segment) && hue < (2.0*segment) )
+ {
+
+ max_sat = (G+R) - (R*(hue-segment)*6);
+ if (luma<max_sat){luma_a = (luma/max_sat)*0.5; chroma=sat*(2*luma_a);}
+ else {luma_a = ((luma-max_sat)/(1-max_sat)*0.5)+0.5; chroma=sat*(2-2*luma_a);}
+
+ fract = hue*6.0;
+ x = (1-fabs(fmod(fract,2)-1) )*chroma;
+ r = x; g=chroma; b=0;
+ m = luma-( (R*r)+(B*b)+(G*g) );
+ r += m; g += m; b += m;
+
+
+ }
+ else if (hue >= (2.0*segment) && hue < (3.0*segment) )
+ {
+ max_sat = G + (B*(hue-2.0*segment)*6);
+ if (luma<max_sat){luma_a = (luma/max_sat)*0.5; chroma=sat*(2*luma_a);}
+ else {luma_a = ((luma-max_sat)/(1-max_sat)*0.5)+0.5; chroma=sat*(2-2*luma_a);}
+
+ fract = hue*6.0;
+ x = (1-fabs(fmod(fract,2)-1) )*chroma;
+ r = 0; g=chroma; b=x;
+ m = luma-( (R*r)+(B*b)+(G*g) );
+ r += m; g += m; b += m;
+ }
+ else if (hue >= (3.0*segment) && hue < (4.0*segment) )
+ { max_sat = (G+B) - (G*(hue-3.0*segment)*6);
+ if (luma<max_sat){luma_a = (luma/max_sat)*0.5; chroma=sat*(2*luma_a);}
+ else {luma_a = ((luma-max_sat)/(1-max_sat)*0.5)+0.5; chroma=sat*(2-2*luma_a);}
+
+ fract = hue*6.0;
+ x = (1-fabs(fmod(fract,2)-1) )*chroma;
+ r = 0; g=x; b=chroma;
+ m = luma-( (R*r)+(B*b)+(G*g) );
+ r += m; g += m; b += m;
+ }
+ else if (hue >= (4.0*segment) && hue < (5*segment) )
+ {
+ max_sat = B + (R*((hue-4.0*segment)*6));
+ if (luma<max_sat){luma_a = (luma/max_sat)*0.5; chroma=sat*(2*luma_a);}
+ else {luma_a = ((luma-max_sat)/(1-max_sat)*0.5)+0.5; chroma=sat*(2-2*luma_a);}
+
+ fract = hue*6.0;
+ x = (1-fabs(fmod(fract,2)-1) )*chroma;
+ r = x; g=0; b=chroma;
+ m = luma-( (R*r)+(B*b)+(G*g) );
+ r += m; g += m; b += m;
+ }
+ else if (hue >= (5.0*segment) && hue <= 1.0)
+ {
+ max_sat = (B+R) - (B*(hue-5.0*segment)*6);
+ if (luma<max_sat){luma_a = (luma/max_sat)*0.5; chroma=sat*(2*luma_a);}
+ else {luma_a = ((luma-max_sat)/(1-max_sat)*0.5)+0.5; chroma=sat*(2-2*luma_a);}
+
+ fract = hue*6.0;
+ x = (1-fabs(fmod(fract,2)-1) )*chroma;
+ r = chroma; g=0; b=x;
+ m = luma-( (R*r)+(B*b)+(G*g) );
+ r += m; g += m; b += m;
+ }
+ else
+ {
+ r=0.0;
+ g=0.0;
+ b=0.0;
+ }
+
+ //qDebug()<<"red: "<<r<<", green: "<<g<<", blue: "<<b;
+ if (r>1.0){r=1.0;}
+ if (g>1.0){g=1.0;}
+ if (b>1.0){b=1.0;}
+ if (r<0.0){r=0.0;}
+ if (g<0.0){g=0.0;}
+ if (b<0.0){b=0.0;}
+
+ *red=r;
+ *green=g;
+ *blue=b;
+}
+void RGBToHSY(const qreal r,const qreal g,const qreal b, qreal *h, qreal *s, qreal \
*y, qreal R, qreal G, qreal B) +{
+//This is LUMA btw, not Luminance.
+//Using these RGB values, we calculate the H, S and I.
+ qreal red; qreal green; qreal blue;
+ if (r>1.0){red=1.0;} else if (r<0.0){red=0.0;} else {red=r;}
+ if (g>1.0){green=1.0;} else if (g<0.0){green=0.0;} else {green=g;}
+ if (b>1.0){blue=1.0;} else if (b<0.0){blue=0.0;} else {blue=b;}
+
+ qreal minval = qMin(r, qMin(g, b));
+ qreal maxval = qMax(r, qMax(g, b));
+ qreal hue = 0.0;
+ qreal sat = 0.0;
+ qreal luma = 0.0;
+ //weights for rgb, these are the same weights used in color space maths and the \
desaturate. + //qreal R=0.299;
+ //qreal G=0.587;
+ //qreal B=0.114;
+ luma=(R*red+G*green+B*blue);
+ qreal luma_a=luma;//defined later
+ qreal chroma = maxval-minval;
+ qreal max_sat=0.5;
+ if(chroma==0)
+ {
+ hue = 0.0;
+ sat = 0.0;
+ }
+ else
+ {
+ //the following finds the hue
+
+ if(maxval==r)
+ {
+ hue = fmod(((g-b)/chroma), 6.0);
+ }
+ else if(maxval==g)
+ {
+ hue = (b-r)/chroma + 2.0;
+ }
+ else if(maxval==b)
+ {
+ hue = (r-g)/chroma + 4.0;
+ }
+ hue /=6.0;//this makes sure that hue is in the 0-1.0 range.
+ //Most HSY formula will tell you that Sat=Chroma. However, this HSY' formula \
tries to be a + //weighted HSL formula, where instead of 0.5, we search for a \
Max_Sat value, which is the Y' + //at which the saturation is maximum.
+ //This requires using the hue, and combining the weighting values accordingly.
+ qreal segment = 0.166667;
+ if (hue>1.0 || hue<0.0){hue=fmod(hue, 1.0);}
+
+ if (hue>=0.0 && hue<segment)
+ {max_sat = R + G*(hue*6);}
+ else if (hue>=segment && hue<(2.0*segment))
+ {max_sat = (G+R) - R*((hue-segment)*6) ;}
+ else if (hue>=(2.0*segment) && hue<(3.0*segment))
+ {max_sat = G + B*((hue-2.0*segment)*6);}
+ else if (hue>=(3.0*segment) && hue<(4.0*segment))
+ {max_sat = (B+G) - G*((hue-3.0*segment)*6) ;}
+ else if (hue>=(4.0*segment) && hue<(5.0*segment))
+ {max_sat = (B) + R*((hue-4.0*segment)*6);}
+ else if (hue>=(5.0*segment) && hue<=1.0)
+ {max_sat = (R+B) - B*((hue-5.0*segment)*6);}
+ else
+ {max_sat=0.5;}
+
+ if(max_sat>1.0 || max_sat<0.0){ //This debug message should not show up during \
normal use + max_sat=(fmod(max_sat,1.0));} //If it does, it'll try to correct, but \
it's not good! + if (luma <= max_sat){luma_a = (luma/max_sat)*0.5;}
+ else{luma_a = ((luma-max_sat)/(1-max_sat)*0.5)+0.5;}//This is weighting the luma \
for the saturation) + if ((sat = chroma) > 0.0)
+ {sat = (luma <= max_sat) ? (chroma/ (2*luma_a) ) :(chroma/(2.0-(2*luma_a) ) ) ;}
+ }
+
+ if (sat>1.0){sat=1.0;}
+ if (luma>1.0){luma=1.0;}
+ if (sat<0.0){sat=0.0;}
+ if (luma<0.0){luma=0.0;}
+
+ *h=hue;
+ *s=sat;
+ *y=luma;
+
+
+}
+//Extra: Functions for converting from and back to HCI. Where the HSI function is \
forced cylindrical, HCI is a +//double cone. This is for compatibility purposes, and \
of course, making future programmers who expect a double-cone +// function less sad. \
These algorithms were taken from wikipedia. +
+void HCIToRGB(const qreal h, const qreal c, const qreal i, qreal *red, qreal *green, \
qreal *blue) +{
+//This function may not be correct, but it's based on the HCY function on the basis \
of seeing HCI as similar +//to the weighted HCY, but assuming that the weights are \
the same(one-third). + qreal hue=0.0;
+ qreal chroma=0.0;
+ qreal intensity=0.0;
+ if (i>1.0){intensity = 1.0;} else if(i<0.0){intensity = 0.0;} else{intensity = i;}
+ if (h>1.0 || h<0.0){hue=fmod(h, 1.0);} else {hue=h;}
+ if (c>1.0){chroma = 1.0;} else if(c<0.0){chroma = 0.0;} else{chroma = c;}
+ const qreal onethird = 1.0/3.0;
+ qreal r=0.0;
+ qreal g=0.0;
+ qreal b=0.0;
+
+ int fract = static_cast<int>(hue*6.0);
+ qreal x = (1-fabs(fmod(fract,2)-1) )*chroma;
+ switch (fract) {
+ case 0:r = chroma; g=x; b=0;break;
+ case 1:r = x; g=chroma; b=0;break;
+ case 2:r = 0; g=chroma; b=x;break;
+ case 3:r = 0; g=x; b=chroma;break;
+ case 4:r = x; g=0; b=chroma;break;
+ case 5:r = chroma; g=0; b=x;break;
+ }
+ qreal m = intensity-( onethird*(r+g+b) );
+ r += m; g += m; b += m;
+
+ if (r>1.0){r=1.0;}
+ if (g>1.0){g=1.0;}
+ if (b>1.0){b=1.0;}
+ if (r<0.0){r=0.0;}
+ if (g<0.0){g=0.0;}
+ if (b<0.0){b=0.0;}
+
+ *red=r;
+ *green=g;
+ *blue=b;
+}
+
+void RGBToHCI(const qreal r,const qreal g,const qreal b, qreal *h, qreal *c, qreal \
*i) +{
+ qreal minval = qMin(r, qMin(g, b));
+ qreal maxval = qMax(r, qMax(g, b));
+ qreal hue = 0.0;
+ qreal sat = 0.0;
+ qreal intensity = 0.0;
+ intensity=(r+g+b)/3.0;
+ qreal chroma = maxval-minval;
+ if(chroma==0)
+ {
+ hue = 0.0;
+ sat = 0.0;
+ }
+ else
+ {
+ //the following finds the hue
+
+ if(maxval==r)
+ {
+ hue = fmod(((g-b)/chroma), 6.0);
+ }
+ else if(maxval==g)
+ {
+ hue = (b-r)/chroma + 2.0;
+ }
+ else if(maxval==b)
+ {
+ hue = (r-g)/chroma + 4.0;
+ }
+ hue /=6.0;//this makes sure that hue is in the 0-1.0 range.
+ sat= 1-(minval/intensity);
+ }
+ if (hue>1.0){hue=1.0;}
+ if (hue<0.0){hue=0.0;}
+ if (sat>1.0){sat=1.0;}
+ if (sat<0.0){sat=0.0;}
+ if (intensity>1.0){intensity=1.0;}
+ if (intensity<0.0){intensity=0.0;}
+
+ *h=hue;
+ *c=sat;
+ *i=intensity;
+
+}
+void HCYToRGB(const qreal h, const qreal c, const qreal y, qreal *red, qreal *green, \
qreal *blue, qreal R, qreal G, qreal B) +{
+ qreal hue=0.0;
+ qreal chroma=0.0;
+ qreal luma=0.0;
+ if (y>1.0){luma = 1.0;} else if(y<0.0){luma = 0.0;} else{luma = y;}
+ if (h>1.0 || h<0.0){hue=(fmod((h*2.0), 2.0))/2.0;} else {hue=h;}
+ if (c>1.0){chroma = 1.0;} else if(c<0.0){chroma = 0.0;} else{chroma = c;}
+ //const qreal R=0.299;
+ //const qreal G=0.587;
+ //const qreal B=0.114;
+ qreal r=0.0;
+ qreal g=0.0;
+ qreal b=0.0;
+
+ int fract =static_cast<int>(hue*6.0);
+ qreal x = (1-fabs(fmod(fract,2)-1) )*chroma;
+ switch (fract) {
+ case 0:r = chroma; g=x; b=0;break;
+ case 1:r = x; g=chroma; b=0;break;
+ case 2:r = 0; g=chroma; b=x;break;
+ case 3:r = 0; g=x; b=chroma;break;
+ case 4:r = x; g=0; b=chroma;break;
+ case 5:r = chroma; g=0; b=x;break;
+ }
+ qreal m = luma-( (R*r)+(B*b)+(G*g) );
+ r += m; g += m; b += m;
+
+ if (r>1.0){r=1.0;}
+ if (g>1.0){g=1.0;}
+ if (b>1.0){b=1.0;}
+ if (r<0.0){r=0.0;}
+ if (g<0.0){g=0.0;}
+ if (b<0.0){b=0.0;}
+
+ *red=r;
+ *green=g;
+ *blue=b;
+}
+
+void RGBToHCY(const qreal r,const qreal g,const qreal b, qreal *h, qreal *c, qreal \
*y, qreal R, qreal G, qreal B) +{
+ qreal minval = qMin(r, qMin(g, b));
+ qreal maxval = qMax(r, qMax(g, b));
+ qreal hue = 0.0;
+ qreal chroma = 0.0;
+ qreal luma = 0.0;
+ //weights for rgb, these are the same weights used in color space maths and the \
desaturate. + //qreal R=0.299;
+ //qreal G=0.587;
+ //qreal B=0.114;
+ luma=(R*r+G*g+B*b);
+ chroma = maxval-minval;
+
+ if(chroma==0)
+ {
+ hue = 0.0;
+ }
+ else
+ {
+ //the following finds the hue
+
+ if(maxval==r)
+ {
+ hue = fmod(((g-b)/chroma), 6.0);
+ }
+ else if(maxval==g)
+ {
+ hue = (b-r)/chroma + 2.0;
+ }
+ else if(maxval==b)
+ {
+ hue = (r-g)/chroma + 4.0;
+ }
+ hue /=6.0;//this makes sure that hue is in the 0-1.0 range.
+
+ }
+ if (hue>1.0){hue=1.0;}
+ if (hue<0.0){hue=0.0;}
+ if (chroma>1.0){chroma=1.0;}
+ if (luma>1.0){luma=1.0;}
+ if (chroma<0.0){chroma=0.0;}
+ if (luma<0.0){luma=0.0;}
+
+ *h=hue;
+ *c=chroma;
+ *y=luma;
+
+}
+
diff --git a/libs/pigment/KoColorConversions.h b/libs/pigment/KoColorConversions.h
index 91f4191..fd05d79 100644
--- a/libs/pigment/KoColorConversions.h
+++ b/libs/pigment/KoColorConversions.h
@@ -46,5 +46,28 @@ PIGMENTCMS_EXPORT void hls_to_rgb(float h, float l, float s, \
quint8 * r, quint8 PIGMENTCMS_EXPORT void rgb_to_hls(quint8 r, quint8 g, quint8 b, \
int * h, int * l, int * s); PIGMENTCMS_EXPORT void hls_to_rgb(int h, int l, int s, \
quint8 * r, quint8 * g, quint8 * b);
+//HSI and HSY' functions.
+//These are modified to calculate a cylliner, this is good for colour selectors \
sliders. +//All eight expect 0.0-1.0 for all parameters.
+//HSI measures the Tone, Intensity, by adding the r, g and b components and then \
normalising that. +PIGMENTCMS_EXPORT void HSIToRGB(const qreal h, const qreal s, \
const qreal i, qreal *red, qreal *green, qreal *blue); +PIGMENTCMS_EXPORT void \
RGBToHSI(qreal r, qreal g, qreal b, qreal *h, qreal *s, qreal *i); +
+//HSY' measures the tone, Luma, by weighting the r, g, and b components before \
adding them up. +//The R, G, B reffers to the weights, and defaults to the 601 rec \
for luma. +PIGMENTCMS_EXPORT void RGBToHSY( qreal r, qreal g, qreal b, qreal *h, \
qreal *s, qreal *y, qreal R=0.299, qreal G=0.587, qreal B=0.114); +PIGMENTCMS_EXPORT \
void HSYToRGB(const qreal h, const qreal s, const qreal y, qreal *red, qreal *green, \
qreal *blue, qreal R=0.299, qreal G=0.587, qreal B=0.114); +
+
+//HCI and HCY' functions.
+//These are the original conversion functions, producing cones. Put in for \
completion. +//There's HCI to RGB is based on the HCY to RGB one for now, it may not \
be correct. +PIGMENTCMS_EXPORT void HCIToRGB(const qreal h, const qreal s, const \
qreal i, qreal *red, qreal *green, qreal *blue); +PIGMENTCMS_EXPORT void \
RGBToHCI(const qreal r, const qreal g, const qreal b, qreal *h, qreal *c, qreal *i); \
+ +PIGMENTCMS_EXPORT void HCYToRGB(const qreal h, const qreal s, const qreal y, qreal \
*red, qreal *green, qreal *blue, qreal R=0.299, qreal G=0.587, qreal B=0.114); \
+PIGMENTCMS_EXPORT void RGBToHCY(const qreal r, const qreal g, const qreal b, qreal \
*h, qreal *c, qreal *y, qreal R=0.299, qreal G=0.587, qreal B=0.114); +
+
#endif // _KO_COLORCONVERSIONS_H_
[prev in list] [next in list] [prev in thread] [next in thread]
Configure |
About |
News |
Add a list |
Sponsored by KoreLogic