I was doing a bit more work on my DirectX-based .raw image viewer when I came across a nice mathematical overlap with three-phase motor control theory. It has to do with conversion from red/green/blue (RGB) to hue/saturation/lightness (HSL), two different ways of representing color. Most of the conversion methods are piecewise-linear, with max(), min(), and conditionals to break up the color space. But I figured motors are round and color wheels are round, so maybe I would try applying a motor phase transform to [R, G, B] to see what happens.

The transform of interest is the Clarke transform, which converts a three-phase signal into two orthogonal components (α and β) and a zero-sequence component (γ) that is just the average of the three phases. In motor control with symmetric three-phase signals, γ is usually zero. Applied to [R, G, B], it's just the intensity, one measure of lightness.

In motor control, it's common to find the phase and magnitude of the vector defined by α and β, for example to determine the amplitude and electrical angle of sinusoidal back EMF in a PMSM. It turns out the phase and magnitude are useful in color space as well, representing the hue and saturation, respectively. It might not be exactly adherent to the definition of these terms, but rather than rambling on about hexagons and circles, I'll just say it is close enough for me. (The Wikipedia article's alternate non-hexagon hue (H2) and chroma (C2) calculation is exactly the Clarke transform and magnitude/phase math.)

So I added this hue and saturation adjustment method to the raw viewer's pixel shader:

I'm particularly happy about the fact that it occupies barely 15 lines of HLSL code:

c_alpha = 0.6667f * tempcolor.r - 0.3333f * tempcolor.g - 0.3333f * tempcolor.b;

c_beta = 0.5774f * tempcolor.g - 0.5774f * tempcolor.b;

c_gamma = 0.3333f * tempcolor.r + 0.3333f * tempcolor.g + 0.3333f * tempcolor.b;

c_hue = atan2(c_beta, c_alpha);

c_sat = sqrt(pow(abs(c_alpha), 2) + pow(abs(c_beta), 2));

c_sat *= saturation;

c_hue += hue_shift;

c_alpha = c_sat * cos(c_hue);

c_beta = c_sat * sin(c_hue);

tempcolor.r = c_alpha + c_gamma;

tempcolor.g = -0.5f * c_alpha + 0.8660f * c_beta + c_gamma;

tempcolor.b = -0.5f * c_alpha - 0.8660f * c_beta + c_gamma;

I doubt it's the most computationally efficient way to do it (with the trig and all), but it does avoid a bunch of conditionals from the piecewise methods. And as I mentioned in the last post, the pixel shader is far from the performance bottleneck of the viewer right now.

**Updated HLSL Source:**debayercolor.fx

**Updated Viewer Source (VB 2012 Project):**RawView_v0_2.zip

Built for .NET 4.0 64-bit. Requires the SlimDX SDK.

And for fun, here's some 150fps video of a new kitchen appliance I just received and hope to put to good use soon: