hsvmodel.h

矩阵编码和马尔可夫链的实现例程。实现类似黑客帝国数字屏保

/*
 Copyright (c) 2001 
 Author: Konstantin Boukreev 
 E-mail: [e-mail] 

 Created: 18.12.2001 18:11:45
 Version: 1.0.0

*/

#ifndef _HSVModel_b31b8ca2_5e53_11d3_9285_0080adb811c5
#define _HSVModel_b31b8ca2_5e53_11d3_9285_0080adb811c5

#if _MSC_VER > 1000 
#pragma once
#endif // _MSC_VER > 1000

class HSLModel
{
	BYTE m_hue;
	BYTE m_sat;
	BYTE m_lum;
	BYTE m_unused;

public:

	HSLModel ()
		: m_hue(0), m_sat(0), m_lum(0)  
	{}

	HSLModel (COLORREF clr) 
		: m_hue(0), m_sat(0), m_lum(0)
	{
		RGBtoHSL(GetRValue(clr), GetGValue(clr), GetBValue(clr), m_hue, m_sat, m_lum);
	}

	HSLModel (HSLModel& hsl) 
		: m_hue(hsl.m_hue), m_sat(hsl.m_sat), m_lum(hsl.m_lum)
	{}

	COLORREF rgb ()
	{
		BYTE r, g, b;
		HSLtoRGB(m_hue, m_sat, m_lum, r, g, b);
		return RGB(r, g, b);
	}

	void rgb (COLORREF clr)
	{
		RGBtoHSL(GetRValue(clr), GetGValue(clr), GetBValue(clr), m_hue, m_sat, m_lum);
	}
	
	/*
	A Fast HSL-to-RGB Transform
	by Ken Fishkin
	from "Graphics Gems", Academic Press, 1990
	*/
	
	static bool HSLtoRGB (BYTE bh, BYTE bsl, BYTE bl, BYTE& br, BYTE& bg, BYTE& bb)
	{
		bh	= min((BYTE)240, bh);
		bsl	= min((BYTE)240, bsl);
		bl	= min((BYTE)240, bl);

		double h  = bh  / 240.0;
		double sl = bsl / 240.0;
		double l  = bl  / 240.0;
			
		double b = .0; double r = .0; double g = .0;
		double v = .0;

		v = (l <= 0.5) ? (l * (1.0 + sl)) : (l + sl - l * sl);
		if (v <= 0.0) {
			r = g = b = 0.0;
		} else {
			double m;
			double sv;
			int sextant;
			double fract, vsf, mid1, mid2;
			m = l + l - v;
			sv = (v - m ) / v;
			h *= 6.0;
			sextant = (int)h;	
			fract = h - sextant;
			vsf = v * sv * fract;
			mid1 = m + vsf;
			mid2 = v - vsf;
			switch (sextant) {
				case 0: r = v;    g = mid1; b = m; break;
				case 1: r = mid2; g = v;    b = m; break;
				case 2: r = m;    g = v;    b = mid1; break;
				case 3: r = m;    g = mid2; b = v; break;
				case 4: r = mid1; g = m;    b = v; break;
				case 5: r = v;    g = m;    b = mid2; break;
				default:
					_ASSERTE(0);
			}
		}

		_ASSERTE (g <= 1.0 && g >= 0.0);
		_ASSERTE (r <= 1.0 && r >= 0.0);
		_ASSERTE (b <= 1.0 && b >= 0.0);

		br = (BYTE)(r * 255.9999); 
		bg = (BYTE)(g * 255.9999); 
		bb = (BYTE)(b * 255.9999);
		return true;
	}
		
	static bool RGBtoHSL (BYTE br, BYTE bg, BYTE bb, BYTE& bh, BYTE& bs, BYTE& bl)
	{
		_ASSERTE(br <= 255 && br >= 0);
		_ASSERTE(bg <= 255 && bg >= 0);
		_ASSERTE(bb <= 255 && bb >= 0);

		double r = br / 255.0;
		double g = bg / 255.0;
		double b = bb / 255.0;

		double h = 0; double s = 0; double l = 0;

		double v, m, vm;
		double r2, g2, b2;

		v = max(r,g);
		v = max(v,b);
		m = min(r,g);
		m = min(m,b);

	   if ((l = (m + v) / 2.0) <= 0.0) 
			goto exit;

	   if ((s = vm = v - m) > 0.0) {
		s /= ((l <= 0.5) ? (v + m ) : (2.0 - v - m));
	   } else
			goto exit;
		
	   r2 = (v - r) / vm;
	   g2 = (v - g) / vm;
	   b2 = (v - b) / vm;

	   if (r == v)
			h = (g == m ? 5.0 + b2 : 1.0 - g2);
	   else if (g == v)
			h = (b == m ? 1.0 + r2 : 3.0 - b2);
	   else
			h = (r == m ? 3.0 + g2 : 5.0 - r2);

	   h /= 6;

	exit:
		_ASSERTE (h <= 1.0 && h >= 0.0);
		_ASSERTE (l <= 1.0 && l >= 0.0);
		_ASSERTE (s <= 1.0 && s >= 0.0);

		bh = (BYTE)(h == 1.0 ? 0 : h * 240.9999); 
		bl = (BYTE)(l * 240.9999); 
		bs = (BYTE)(s * 240.9999);
		return true;
	}

	BYTE hue () const {return m_hue;}
	void hue (BYTE hue) {m_hue = hue;}
	BYTE saturation () const {return m_sat;}
	void saturation (BYTE sat) {m_sat = sat;}
	BYTE luminance () const {return m_lum;}
	void luminance (BYTE lum) {m_lum = lum;}
};

#endif //_HSVModel_b31b8ca2_5e53_11d3_9285_0080adb811c5