HSLColor.cpp

#include "HSLColor.h"

static const double D_EPSILON = 0.00000000000001;


////////////////////////////////////////////////////////////
HSL::HSL() :Hue(0), Saturation(0), Luminance(0) {}

////////////////////////////////////////////////////////////
HSL::HSL(int H, int S, int L)
{
	///Range control for Hue.
	if (H <= 360 && H >= 0) { Hue = H; }
	else
	{
		if (H > 360) { Hue = H % 360; }
		else if (H < 0 && H > -360) { Hue = -H; }
		else if (H < 0 && H < -360) { Hue = -(H % 360); }
	}

	///Range control for Saturation.
	if (S <= 100 && S >= 0) { Saturation = S; }
	else
	{
		if (S > 100) { Saturation = S % 100; }
		else if (S < 0 && S > -100) { Saturation = -S; }
		else if (S < 0 && S < -100) { Saturation = -(S % 100); }
	}

	///Range control for Luminance
	if (L <= 100 && L >= 0) { Luminance = L; }
	else
	{
		if (L > 100) { Luminance = L % 100; }
		if (L < 0 && L > -100) { Luminance = -L; }
		if (L < 0 && L < -100) { Luminance = -(L % 100); }
	}

}

////////////////////////////////////////////////////////////
double HSL::HueToRGB(double arg1, double arg2, double H)
{
	if (H < 0) H += 1;
	if (H > 1) H -= 1;
	if ((6 * H) < 1) { return (arg1 + (arg2 - arg1) * 6 * H); }
	if ((2 * H) < 1) { return arg2; }
	if ((3 * H) < 2) { return (arg1 + (arg2 - arg1) * ((2.0 / 3.0) - H) * 6); }
	return arg1;
}

////////////////////////////////////////////////////////////
sf::Color HSL::TurnToRGB()
{
	///Reconvert to range [0,1]
	double H = Hue / 360.0;
	double S = Saturation / 100.0;
	double L = Luminance / 100.0;

	float arg1, arg2;

	if (S <= D_EPSILON)
	{
		sf::Color C(static_cast<sf::Uint8>(L * 255), static_cast<sf::Uint8>(L * 255), static_cast<sf::Uint8>(L * 255));
		return C;
	}
	else
	{
		if (L < 0.5) { arg2 = static_cast<float>(L * (1 + S)); }
		else { arg2 = static_cast<float>((L + S) - (S * L)); }
		arg1 = static_cast<float>(2 * L - arg2);

		sf::Uint8 r = static_cast<sf::Uint8>(255 * HueToRGB(arg1, arg2, (H + 1.0 / 3.0)));
		sf::Uint8 g = static_cast<sf::Uint8>(255 * HueToRGB(arg1, arg2, H));
		sf::Uint8 b = static_cast<sf::Uint8>(255 * HueToRGB(arg1, arg2, (H - 1.0 / 3.0)));
		sf::Color C(r, g, b);
		return C;
	}

}

////////////////////////////////////////////////////////////
HSL HSL::TurnToHSL(const sf::Color& C)
{
	///Trivial cases.
	if (C == sf::Color::White)
	{
		return HSL(0, 0, 100);
	}

	if (C == sf::Color::Black)
	{
		return HSL(0, 0, 0);
	}

	if (C == sf::Color::Red)
	{
		return HSL(0, 100, 50);
	}

	if (C == sf::Color::Yellow)
	{
		return HSL(60, 100, 50);
	}

	if (C == sf::Color::Green)
	{
		return HSL(120, 100, 50);
	}

	if (C == sf::Color::Cyan)
	{
		return HSL(180, 100, 50);
	}

	if (C == sf::Color::Blue)
	{
		return HSL(240, 100, 50);
	}

	if (C == sf::Color::Cyan)
	{
		return HSL(300, 100, 50);
	}

	double R, G, B;
	R = C.r / 255.0;
	G = C.g / 255.0;
	B = C.b / 255.0;
	///Casos no triviales.
	double  l{ 0 }; 
	double s{0};

	///Maximos
	double max = std::max(std::max(R, G), B);

	///Minimos
	double min = std::min(std::min(R, G), B);


	HSL A;
	l = ((max + min) / 2.0);

	if (max - min <= D_EPSILON)
	{
		A.Hue = 0;
		A.Saturation = 0;
	}
	else
	{
		double diff = max - min;

		if (A.Luminance < 0.5)
		{
			s = diff / (max + min);
		}
		else
		{
			s = diff / (2 - max - min);
		}

		double diffR = (((max - R) * 60) + (diff / 2.0)) / diff;
		double diffG = (((max - G) * 60) + (diff / 2.0)) / diff;
		double diffB = (((max - B) * 60) + (diff / 2.0)) / diff;


		if (max - R <= D_EPSILON) { A.Hue = diffB - diffG; }
		else if (max - G <= D_EPSILON) { A.Hue = (1 * 360) / 3.0 + (diffR - diffB); }
		else if (max - B <= D_EPSILON) { A.Hue = (2 * 360) / 3.0 + (diffG - diffR); }

		if (A.Hue <= 0 || A.Hue >= 360) { A.Hue = fmod(A.Hue, 360); }

		s *= 100;
	}

	l *= 100;
	A.Saturation = s;
	A.Luminance = l;
	return A;
}