openlayer feature request:

Hlsa( float hue, float lightness, float saturation, float alpha = 1.0)
{
   //returns an Rgba object or 32-bit packed pixel ???
   //therefore can be used anywhere Rgba(,,,) is used. :)
}

hsv_to_rgb
Click. You can use this function to convert HSV->RGB and then makecol or proper OpenLayer function to convert it to OpenLeyar color. It should work (unless you need exactly HSL and HSV isn't enough).

Well, just give me the equations and I'll implement it

That might be useful, but it requires a named constructor as the parameter types are the same as with the RGBA constructor.

Here you go:

http://www.easyrgb.com/math.php

I haven't read that page at all, but from memory all the ordinary colour conversions are just linear transforms so you could abstract it with a 3x3 matrix for every colour space conversion. Unless you want also to provide support for both linear and exponential scales, but that doesn't seem to be part of the request!

EDIT: completely off topic, but while you're here and because I've just been messing around on an OpenGL thingy myself - does OpenLayer prefer GL_ARB_texture_non_power_of_two to GL_ARB/EXT/NV_texture_rectangle where both are available?

This is not the case for HSV and HSL, as H is in fact an angle (0 is red, 0.33 is green, 0.67 is blue and 1 is red again).

Well, OpenLayer doesn't support the *_texture_rectangle extensions yet. But since the GL_ARB_texture_non_power_of_two extension doesn't require using an another texture target it sounds better... especially as no code has to be changed in order to support it. Performance wise I don't know.

Here is an implementation of RGB <-> HLS colourspace conversion code. This particular implementation uses the same scale of units as Allegro's RGB <-> HSV functions. This is to maintain consistency with Allegro's functions, but this could be speeded up by making it accept a hue in the range 0..6 instead of 0..360

hls_to_rgb:

rgb_to_hls:

If you want to convert a float value from 0..1 to an int value from 0..0xff, then use the following macro

#define ap01FTO0255INT(fl) ((int)(fl * 255.0f + 0.5f))

For converting a foat value from 0..360 to an int value from 0..0x600, use this:

#define ap0360FTO01536INT(fl) ((int)(fl * 1536.0f / 360.0f + 0.5f))  /* 0x600 = 1536 */

Note that because Hue is a cyclic paramater, the range of conversion is 0..0x600 rather than 0..0x5FF . However, due to the nature of the input values (the nature being that they are only 8-bit RGB values), no likely set of inputs to rgb_to_hls() (or for that matter, rgb_to_hsv()) is going to yield a value greater than 0x5FF. The hue wheel is divided into six segments, and each segment can produce 256 discrete values with 8-bit RGB colour. This means that ((256*6)-1) / (256*6) * 360 = 359.765625 (which is the maximum value of H that the function can yield for 8-bit RGB values), and plugging in 359.765625 to the macro above gives 1535.5, which when converted to a hexadecimal int, is rounded down to 0x5FF

I have implemented much faster versions of RGB <-> HLS and RGB <-> HSV, that takes the saturation and value as chars, and the hue as a short (no floats for the paramaters, but it still uses floats internally). This code can be found in the sourcecode of my ChromaPlas screensaver which also demonstrates a nice effect and shows the difference between HSV and HLS.

For further reading, see:
http://en.wikipedia.org/wiki/HSV_color_space
http://en.wikipedia.org/wiki/HSL_color_space

AE.

Woah there!
I'm not looking for a whole new object to maintain, Just a nice little one-way conversion utility-function.

int Hsva( float hue, float saturation, float value, float alpha = 1.0)
{
   int r,g,b = 0;
   hsv_to_rgb(hue, saturation, value, &r, &g, &b);

   return Rgba( r, g, b, int(alpha) * 255.0);  //I'm rusty with c++! Does this return an int?
}

int Hlsa( float hue, float lightness, float saturation, float alpha = 1.0)
{
   return Hsva( hue, saturation, lightness * 0.5f, alpha); //wrong wrong wrong wrong wrong!
}

It's a constructor call which creates a new Rgba object. So the return value should be Rgba.

yay

works!

I guess you mean:

int(alpha * 255)

Or otherwise the alpha would be rounded either to one or zero.

Thanks all!
Attached is the hue utility 1.0.