Added 'rainbow' boot sequence

Moved color transform to utils lib

libsrc/utils/CMakeLists.txt

@@ -6,9 +6,13 @@ SET(CURRENT_SOURCE_DIR ${CMAKE_SOURCE_DIR}/libsrc/utils)
 add_library(hyperion-utils
 		${CURRENT_HEADER_DIR}/RgbColor.h
 		${CURRENT_HEADER_DIR}/RgbImage.h
+		${CURRENT_HEADER_DIR}/ColorTransform.h
+		${CURRENT_HEADER_DIR}/HsvTransform.h
 
 		${CURRENT_SOURCE_DIR}/RgbColor.cpp
 		${CURRENT_SOURCE_DIR}/RgbImage.cpp
+		${CURRENT_SOURCE_DIR}/ColorTransform.cpp
+		${CURRENT_SOURCE_DIR}/HsvTransform.cpp
 
 		${CURRENT_HEADER_DIR}/jsonschema/JsonFactory.h
 		${CURRENT_HEADER_DIR}/jsonschema/JsonSchemaChecker.h

libsrc/utils/ColorTransform.cpp

@@ -0,0 +1,103 @@
+// STL includes
+#include <cmath>
+
+#include <utils/ColorTransform.h>
+
+ColorTransform::ColorTransform() :
+	_threshold(0),
+	_gamma(1.0),
+	_blacklevel(0.0),
+	_whitelevel(1.0)
+{
+	initializeMapping();
+}
+
+ColorTransform::ColorTransform(double threshold, double gamma, double blacklevel, double whitelevel) :
+	_threshold(threshold),
+	_gamma(gamma),
+	_blacklevel(blacklevel),
+	_whitelevel(whitelevel)
+{
+	initializeMapping();
+}
+
+ColorTransform::~ColorTransform()
+{
+}
+
+double ColorTransform::getThreshold() const
+{
+	return _threshold;
+}
+
+void ColorTransform::setThreshold(double threshold)
+{
+	_threshold = threshold;
+	initializeMapping();
+}
+
+double ColorTransform::getGamma() const
+{
+	return _gamma;
+}
+
+void ColorTransform::setGamma(double gamma)
+{
+	_gamma = gamma;
+	initializeMapping();
+}
+
+double ColorTransform::getBlacklevel() const
+{
+	return _blacklevel;
+}
+
+void ColorTransform::setBlacklevel(double blacklevel)
+{
+	_blacklevel = blacklevel;
+	initializeMapping();
+}
+
+double ColorTransform::getWhitelevel() const
+{
+	return _whitelevel;
+}
+
+void ColorTransform::setWhitelevel(double whitelevel)
+{
+	_whitelevel = whitelevel;
+	initializeMapping();
+}
+
+void ColorTransform::initializeMapping()
+{
+	// initialize the mapping as a linear array
+	for (int i = 0; i < 256; ++i)
+	{
+		double output = i / 255.0;
+
+		// apply linear transform
+		if (output < _threshold)
+		{
+			output = 0.0;
+		}
+
+		// apply gamma correction
+		output = std::pow(output, _gamma);
+
+		// apply blacklevel and whitelevel
+		output = _blacklevel + (_whitelevel - _blacklevel) * output;
+
+		// calc mapping
+		int mappingValue = output * 255;
+		if (mappingValue < 0)
+		{
+			mappingValue = 0;
+		}
+		else if (mappingValue > 255)
+		{
+			mappingValue = 255;
+		}
+		_mapping[i] = mappingValue;
+	}
+}

libsrc/utils/HsvTransform.cpp

@@ -0,0 +1,133 @@
+#include <utils/HsvTransform.h>
+
+HsvTransform::HsvTransform() :
+	_saturationGain(1.0),
+	_valueGain(1.0)
+{
+}
+
+HsvTransform::HsvTransform(double saturationGain, double valueGain) :
+	_saturationGain(saturationGain),
+	_valueGain(valueGain)
+{
+}
+
+HsvTransform::~HsvTransform()
+{
+}
+
+void HsvTransform::setSaturationGain(double saturationGain)
+{
+	_saturationGain = saturationGain;
+}
+
+double HsvTransform::getSaturationGain() const
+{
+	return _saturationGain;
+}
+
+void HsvTransform::setValueGain(double valueGain)
+{
+	_valueGain = valueGain;
+}
+
+double HsvTransform::getValueGain() const
+{
+	return _valueGain;
+}
+
+void HsvTransform::transform(uint8_t & red, uint8_t & green, uint8_t & blue) const
+{
+	if (_saturationGain != 1.0 || _valueGain != 1.0)
+	{
+		uint16_t hue;
+		uint8_t saturation, value;
+		rgb2hsv(red, green, blue, hue, saturation, value);
+
+		int s = saturation * _saturationGain;
+		if (s > 255)
+			saturation = 255;
+		else
+			saturation = s;
+
+		int v = value * _valueGain;
+		if (v > 255)
+			value = 255;
+		else
+			value = v;
+
+		hsv2rgb(hue, saturation, value, red, green, blue);
+	}
+}
+
+void HsvTransform::rgb2hsv(uint8_t red, uint8_t green, uint8_t blue, uint16_t & hue, uint8_t & saturation, uint8_t & value)
+{
+	uint8_t rgbMin, rgbMax;
+
+	rgbMin = red < green ? (red < blue ? red : blue) : (green < blue ? green : blue);
+	rgbMax = red > green ? (red > blue ? red : blue) : (green > blue ? green : blue);
+
+	value = rgbMax;
+	if (value == 0)
+	{
+		hue = 0;
+		saturation = 0;
+		return;
+	}
+
+	saturation = 255 * long(rgbMax - rgbMin) / value;
+	if (saturation == 0)
+	{
+		hue = 0;
+		return;
+	}
+
+	if (rgbMax == red)
+		hue = 0 + 60 * (green - blue) / (rgbMax - rgbMin);
+	else if (rgbMax == green)
+		hue = 120 + 60 * (blue - red) / (rgbMax - rgbMin);
+	else
+		hue = 240 + 60 * (red - green) / (rgbMax - rgbMin);
+}
+
+void HsvTransform::hsv2rgb(uint16_t hue, uint8_t saturation, uint8_t value, uint8_t & red, uint8_t & green, uint8_t & blue)
+{
+	uint8_t region, remainder, p, q, t;
+
+	if (saturation == 0)
+	{
+		red = value;
+		green = value;
+		blue = value;
+		return;
+	}
+
+	region = hue / 60;
+	remainder = (hue - (region * 60)) * 6;
+
+	p = (value * (255 - saturation)) >> 8;
+	q = (value * (255 - ((saturation * remainder) >> 8))) >> 8;
+	t = (value * (255 - ((saturation * (255 - remainder)) >> 8))) >> 8;
+
+	switch (region)
+	{
+		case 0:
+			red = value; green = t; blue = p;
+			break;
+		case 1:
+			red = q; green = value; blue = p;
+			break;
+		case 2:
+			red = p; green = value; blue = t;
+			break;
+		case 3:
+			red = p; green = q; blue = value;
+			break;
+		case 4:
+			red = t; green = p; blue = value;
+			break;
+		default:
+			red = value; green = p; blue = q;
+			break;
+	}
+}