using std::max;
using std::min;
+ArdourCanvas::Color
+change_alpha (Color c, double a)
+{
+ return ((c & ~0xff) | (lrintf (a*255.0) & 0xff));
+}
+
void
ArdourCanvas::color_to_hsv (Color color, double& h, double& s, double& v)
{
double cmax;
double cmin;
double delta;
-
+
color_to_rgba (color, r, g, b, a);
-
+
if (r > g) {
cmax = max (r, b);
} else {
if (cmax == 0) {
// r = g = b == 0 ... v is undefined, s = 0
- s = 0.0;
+ s = 0.0;
h = 0.0;
return;
}
- if (delta != 0.0) {
+ if (delta != 0.0) {
if (cmax == r) {
h = fmod ((g - b)/delta, 6.0);
} else if (cmax == g) {
} else {
h = ((r - g)/delta) + 4;
}
-
+
h *= 60.0;
-
+
if (h < 0.0) {
/* negative values are legal but confusing, because
they alias positive values.
return rgba_to_color (x + m, m, c + m, a);
} else if (h >= 300.0 && h < 360.0) {
return rgba_to_color (c + m, m, x + m, a);
- }
+ }
return rgba_to_color (m, m, m, a);
}
}
// Inverse of sRGB "gamma" function.
-static inline double
-inv_gam_sRGB (double c)
+static inline double
+inv_gam_sRGB (double c)
{
if (c <= 0.04045) {
return c/12.92;
}
// sRGB "gamma" function
-static inline int
-gam_sRGB(double v)
+static inline int
+gam_sRGB(double v)
{
if (v <= 0.0031308) {
v *= 12.92;
return int (v*255+.5);
}
-static double
+static double
luminance (uint32_t c)
{
// sRGB luminance(Y) values
double r, g, b, a;
ArdourCanvas::color_to_rgba (c, r, g, b, a);
-
+
return (gam_sRGB (rY*inv_gam_sRGB(r) + gY*inv_gam_sRGB(g) + bY*inv_gam_sRGB(b))) / 255.0;
-}
+}
uint32_t
ArdourCanvas::contrasting_text_color (uint32_t c)
: h (0.0)
, s (1.0)
, v (1.0)
- , a (1.0)
+ , a (1.0)
{
}
: h (hh)
, s (ss)
, v (vv)
- , a (aa)
+ , a (aa)
{
if (h < 0.0) {
/* normalize negative hue values into positive range */
string
HSV::to_string () const
{
+ PBD::LocaleGuard lg;
stringstream ss;
ss << h << ' ';
ss << s << ' ';
HSV::shade (double factor) const
{
HSV hsv (*this);
-
+
/* algorithm derived from a google palette website
and analysis of their color palettes.
- basic rule: to make a color darker, increase its saturation
- until it reaches 88%, but then additionally reduce value/lightness
+ basic rule: to make a color darker, increase its saturation
+ until it reaches 88%, but then additionally reduce value/lightness
by a larger amount.
invert rule to make a color lighter.
if (factor > 1.0) {
if (s < 88) {
hsv.v += (hsv.v * (factor * 10.0));
- }
+ }
hsv.s *= factor;
} else {
if (s < 88) {
hsv.v -= (hsv.v * (factor * 10.0));
- }
+ }
hsv.s *= factor;
}
if (is_gray() && other.is_gray()) {
/* human color perception of achromatics generates about 450
distinct colors. By contrast, CIE94 could give a maximal
- perceptual distance of sqrt ((360^2) + 1 + 1) = 360. The 450
+ perceptual distance of sqrt ((360^2) + 1 + 1) = 360. The 450
are not evenly spread (Webers Law), so lets use 360 as an
approximation of the number of distinct achromatics.
-
+
So, scale up the achromatic difference to give about
a maximal distance between v = 1.0 and v = 0.0 of 360.
-
+
A difference of about 0.0055 will generate a return value of
2, which is roughly the limit of human perceptual
discrimination for chromatics.
double sL, sA, sB;
double oL, oA, oB;
double r, g, b, alpha; // Careful, "a" is a field of this
- Color c;
+ Color c;
c = hsva_to_color (h, s, v, a);
color_to_rgba (c, r, g, b, alpha);
const double whtL = 1.0;
const double whtC = 1.0;
- const double whtH = 1.0;
+ const double whtH = 1.0;
const double xC1 = sqrt ((sA * sA) + (sB * oB));
const double xC2 = sqrt ((oA * oA) + (oB * oB));
const double xDE = sqrt (((sL - oL) * (sL - oL))
+ ((sA - oA) * (sA - oA))
+ ((sB - oB) * (sB - oB)));
-
+
double xDH;
if (sqrt (xDE) > (sqrt (abs (xDL)) + sqrt (abs (xDC)))) {
xDL /= whtL;
xDC /= whtC * xSC;
xDH /= whtH * xSH;
-
+
return sqrt ((xDL * xDL) + (xDC * xDC) + (xDH * xDH));
}
SVAModifier::SVAModifier (string const &str)
: type (Add)
- , s (0)
- , v (0)
- , a (0)
+ , _s (0)
+ , _v (0)
+ , _a (0)
{
from_string (str);
}
switch (op) {
case '*':
type = Multiply;
+ /* no-op values for multiply */
+ _s = 1.0;
+ _v = 1.0;
+ _a = 1.0;
break;
case '+':
type = Add;
+ /* no-op values for add */
+ _s = 0.0;
+ _v = 0.0;
+ _a = 0.0;
break;
case '=':
type = Assign;
+ /* this will avoid assignment in operator() (see below) */
+ _s = -1.0;
+ _v = -1.0;
+ _a = -1.0;
break;
default:
throw failed_constructor ();
while (ss) {
ss >> mod;
if ((pos = mod.find ("alpha:")) != string::npos) {
- a = PBD::atoi (mod.substr (pos+6));
+ _a = PBD::atof (mod.substr (pos+6));
} else if ((pos = mod.find ("saturate:")) != string::npos) {
- s = PBD::atoi (mod.substr (pos+9));
+ _s = PBD::atof (mod.substr (pos+9));
} else if ((pos = mod.find ("darkness:")) != string::npos) {
- v = PBD::atoi (mod.substr (pos+9));
+ _v = PBD::atof (mod.substr (pos+9));
} else {
throw failed_constructor ();
}
string
SVAModifier::to_string () const
{
- PBD::LocaleGuard lg ("POSIX");
+ PBD::LocaleGuard lg;
stringstream ss;
switch (type) {
break;
}
- if (s > -1.0) {
- ss << " saturate:" << s;
+ if (_s >= 0.0) {
+ ss << " saturate:" << _s;
}
- if (v > -1.0) {
- ss << " darker:" << v;
+ if (_v >= 0.0) {
+ ss << " darker:" << _v;
}
- if (a > -1.0) {
- ss << " alpha:" << a;
+ if (_a >= 0.0) {
+ ss << " alpha:" << _a;
}
return ss.str();
SVAModifier::operator () (HSV& hsv) const
{
HSV r (hsv);
-
+
switch (type) {
case Add:
- r.s += s;
- r.v += v;
- r.a += a;
+ r.s += _s;
+ r.v += _v;
+ r.a += _a;
break;
case Multiply:
- r.s *= s;
- r.v *= v;
- r.a *= a;
+ r.s *= _s;
+ r.v *= _v;
+ r.a *= _a;
break;
case Assign:
- r.s = s;
- r.v = v;
- r.a = a;
+ if (_s >= 0.0) {
+ r.s = _s;
+ }
+ if (_v >= 0.) {
+ r.v = _v;
+ }
+ if (_a >= 0.0) {
+ r.a = _a;
+ }
break;
}
return r;
}
+ArdourCanvas::Color
+ArdourCanvas::color_at_alpha (ArdourCanvas::Color c, double a)
+{
+ double r, g, b, unused;
+ color_to_rgba (c, r, g, b, unused);
+ return rgba_to_color( r,g,b, a );
+}
projects / ardour.git / blobdiff