Merge branch 'multi_colortransform'

Conflicts:
	CMakeLists.txt
	config/hyperion.config.json

Former-commit-id: 43d42e4fed479f60333b35bc092f9a55cd2ad8e8

libsrc/hyperion/CMakeLists.txt

@@ -39,6 +39,8 @@ SET(Hyperion_HEADERS
 		${CURRENT_HEADER_DIR}/BlackBorderDetector.h
 		${CURRENT_HEADER_DIR}/BlackBorderProcessor.h
 
+		${CURRENT_SOURCE_DIR}/MultiColorTransform.h
+
 		${CURRENT_SOURCE_DIR}/device/LedSpiDevice.h
 		${CURRENT_SOURCE_DIR}/device/LedRs232Device.h
 		${CURRENT_SOURCE_DIR}/device/LedDeviceTest.h
@@ -60,6 +62,7 @@ SET(Hyperion_SOURCES
 		${CURRENT_SOURCE_DIR}/BlackBorderDetector.cpp
 		${CURRENT_SOURCE_DIR}/BlackBorderProcessor.cpp
 		${CURRENT_SOURCE_DIR}/ImageToLedsMap.cpp
+		${CURRENT_SOURCE_DIR}/MultiColorTransform.cpp
 		${CURRENT_SOURCE_DIR}/LinearColorSmoothing.cpp
 
 		${CURRENT_SOURCE_DIR}/device/LedSpiDevice.cpp

libsrc/hyperion/Hyperion.cpp

@@ -4,6 +4,9 @@
 
 // QT includes
 #include <QDateTime>
+#include <QRegExp>
+#include <QString>
+#include <QStringList>
 
 // JsonSchema include
 #include <utils/jsonschema/JsonFactory.h>
@@ -22,11 +25,9 @@
 #include "device/LedDeviceLightpack.h"
 #include "device/LedDeviceMultiLightpack.h"
 
+#include "MultiColorTransform.h"
 #include "LinearColorSmoothing.h"
 
-#include <utils/ColorTransform.h>
-#include <utils/HsvTransform.h>
-
 LedDevice* Hyperion::createDevice(const Json::Value& deviceConfig)
 {
 	std::cout << "Device configuration: " << deviceConfig << std::endl;
@@ -155,6 +156,98 @@ Hyperion::ColorOrder Hyperion::createColorOrder(const Json::Value &deviceConfig)
 	return ORDER_RGB;
 }
 
+ColorTransform * Hyperion::createColorTransform(const Json::Value & transformConfig)
+{
+	const std::string id = transformConfig.get("id", "default").asString();
+
+	RgbChannelTransform * redTransform   = createRgbChannelTransform(transformConfig["red"]);
+	RgbChannelTransform * greenTransform = createRgbChannelTransform(transformConfig["green"]);
+	RgbChannelTransform * blueTransform  = createRgbChannelTransform(transformConfig["blue"]);
+
+	HsvTransform * hsvTransform = createHsvTransform(transformConfig["hsv"]);
+
+	ColorTransform * transform = new ColorTransform();
+	transform->_id = id;
+	transform->_rgbRedTransform   = *redTransform;
+	transform->_rgbGreenTransform = *greenTransform;
+	transform->_rgbBlueTransform  = *blueTransform;
+	transform->_hsvTransform      = *hsvTransform;
+
+	// Cleanup the allocated individual transforms
+	delete redTransform;
+	delete greenTransform;
+	delete blueTransform;
+	delete hsvTransform;
+
+	return transform;
+}
+
+MultiColorTransform * Hyperion::createLedColorsTransform(const unsigned ledCnt, const Json::Value & colorConfig)
+{
+	// Create the result, the transforms are added to this
+	MultiColorTransform * transform = new MultiColorTransform(ledCnt);
+
+	const Json::Value transformConfig = colorConfig.get("transform", Json::nullValue);
+	if (transformConfig.isNull())
+	{
+		// Old style color transformation config (just one for all leds)
+		ColorTransform * colorTransform = createColorTransform(colorConfig);
+		transform->addTransform(colorTransform);
+		transform->setTransformForLed(colorTransform->_id, 0, ledCnt-1);
+	}
+	else if (!transformConfig.isArray())
+	{
+		ColorTransform * colorTransform = createColorTransform(transformConfig);
+		transform->addTransform(colorTransform);
+		transform->setTransformForLed(colorTransform->_id, 0, ledCnt-1);
+	}
+	else
+	{
+		const QRegExp overallExp("([0-9]+(\\-[0-9]+)?)(,[ ]*([0-9]+(\\-[0-9]+)?))*");
+
+		for (Json::UInt i = 0; i < transformConfig.size(); ++i)
+		{
+			const Json::Value & config = transformConfig[i];
+			ColorTransform * colorTransform = createColorTransform(config);
+			transform->addTransform(colorTransform);
+
+			const QString ledIndicesStr = config.get("leds", "").asCString();
+			if (!overallExp.exactMatch(ledIndicesStr))
+			{
+				std::cerr << "Given led indices " << i << " not correct format: " << ledIndicesStr.toStdString() << std::endl;
+				continue;
+			}
+
+			std::cout << "ColorTransform '" << colorTransform->_id << "' => [";
+
+			const QStringList ledIndexList = ledIndicesStr.split(",");
+			for (int i=0; i<ledIndexList.size(); ++i) {
+				if (i > 0)
+				{
+					std::cout << ", ";
+				}
+				if (ledIndexList[i].contains("-"))
+				{
+					QStringList ledIndices = ledIndexList[i].split("-");
+					int startInd = ledIndices[0].toInt();
+					int endInd   = ledIndices[1].toInt();
+
+					transform->setTransformForLed(colorTransform->_id, startInd, endInd);
+					std::cout << startInd << "-" << endInd;
+				}
+				else
+				{
+					int index = ledIndexList[i].toInt();
+					transform->setTransformForLed(colorTransform->_id, index, index);
+					std::cout << index;
+				}
+			}
+			std::cout << "]" << std::endl;
+		}
+	}
+	return transform;
+}
+
 HsvTransform * Hyperion::createHsvTransform(const Json::Value & hsvConfig)
 {
 	const double saturationGain = hsvConfig.get("saturationGain", 1.0).asDouble();
@@ -163,14 +256,14 @@ HsvTransform * Hyperion::createHsvTransform(const Json::Value & hsvConfig)
 	return new HsvTransform(saturationGain, valueGain);
 }
 
-ColorTransform* Hyperion::createColorTransform(const Json::Value& colorConfig)
+RgbChannelTransform* Hyperion::createRgbChannelTransform(const Json::Value& colorConfig)
 {
 	const double threshold  = colorConfig.get("threshold", 0.0).asDouble();
 	const double gamma      = colorConfig.get("gamma", 1.0).asDouble();
 	const double blacklevel = colorConfig.get("blacklevel", 0.0).asDouble();
 	const double whitelevel = colorConfig.get("whitelevel", 1.0).asDouble();
 
-	ColorTransform* transform = new ColorTransform(threshold, gamma, blacklevel, whitelevel);
+	RgbChannelTransform* transform = new RgbChannelTransform(threshold, gamma, blacklevel, whitelevel);
 	return transform;
 }
 
@@ -246,14 +339,15 @@ LedDevice * Hyperion::createColorSmoothing(const Json::Value & smoothingConfig,
 Hyperion::Hyperion(const Json::Value &jsonConfig) :
 	_ledString(createLedString(jsonConfig["leds"])),
 	_muxer(_ledString.leds().size()),
-	_hsvTransform(createHsvTransform(jsonConfig["color"]["hsv"])),
-	_redTransform(createColorTransform(jsonConfig["color"]["red"])),
-	_greenTransform(createColorTransform(jsonConfig["color"]["green"])),
-	_blueTransform(createColorTransform(jsonConfig["color"]["blue"])),
+	_raw2ledTransform(createLedColorsTransform(_ledString.leds().size(), jsonConfig["color"])),
 	_colorOrder(createColorOrder(jsonConfig["device"])),
 	_device(createDevice(jsonConfig["device"])),
 	_timer()
 {
+	if (!_raw2ledTransform->verifyTransforms())
+	{
+		throw std::runtime_error("Color transformation incorrectly set");
+	}
 	// initialize the image processor factory
 	ImageProcessorFactory::getInstance().init(_ledString, jsonConfig["blackborderdetector"].get("enable", true).asBool());
 
@@ -278,13 +372,8 @@ Hyperion::~Hyperion()
 	// Delete the Led-String
 	delete _device;
 
-	// delete he hsv transform
-	delete _hsvTransform;
-
-	// Delete the color-transform
-	delete _blueTransform;
-	delete _greenTransform;
-	delete _redTransform;
+	// delete the color transform
+	delete _raw2ledTransform;
 }
 
 unsigned Hyperion::getLedCount() const
@@ -319,55 +408,18 @@ void Hyperion::setColors(int priority, const std::vector<ColorRgb>& ledColors, c
 	}
 }
 
-void Hyperion::setTransform(Hyperion::Transform transform, Hyperion::Color color, double value)
+const std::vector<std::string> & Hyperion::getTransformIds() const
 {
-	// select the transform of the requested color
-	ColorTransform * t = nullptr;
-	switch (color)
-	{
-	case RED:
-		t = _redTransform;
-		break;
-	case GREEN:
-		t = _greenTransform;
-		break;
-	case BLUE:
-		t = _blueTransform;
-		break;
-	default:
-		break;
-	}
+	return _raw2ledTransform->getTransformIds();
+}
 
-	// set transform value
-	switch (transform)
-	{
-	case SATURATION_GAIN:
-		_hsvTransform->setSaturationGain(value);
-		break;
-	case VALUE_GAIN:
-		_hsvTransform->setValueGain(value);
-		break;
-	case THRESHOLD:
-		assert (t != nullptr);
-		t->setThreshold(value);
-		break;
-	case GAMMA:
-		assert (t != nullptr);
-		t->setGamma(value);
-		break;
-	case BLACKLEVEL:
-		assert (t != nullptr);
-		t->setBlacklevel(value);
-		break;
-	case WHITELEVEL:
-		assert (t != nullptr);
-		t->setWhitelevel(value);
-		break;
-	default:
-		assert(false);
-	}
+ColorTransform * Hyperion::getTransform(const std::string& id)
+{
+	return _raw2ledTransform->getTransform(id);
+}
 
-	// update the led output
+void Hyperion::transformsUpdated()
+{
 	update();
 }
 
@@ -393,51 +445,6 @@ void Hyperion::clearall()
 	update();
 }
 
-double Hyperion::getTransform(Hyperion::Transform transform, Hyperion::Color color) const
-{
-	// select the transform of the requested color
-	ColorTransform * t = nullptr;
-	switch (color)
-	{
-	case RED:
-		t = _redTransform;
-		break;
-	case GREEN:
-		t = _greenTransform;
-		break;
-	case BLUE:
-		t = _blueTransform;
-		break;
-	default:
-		break;
-	}
-
-	// set transform value
-	switch (transform)
-	{
-	case SATURATION_GAIN:
-		return _hsvTransform->getSaturationGain();
-	case VALUE_GAIN:
-		return _hsvTransform->getValueGain();
-	case THRESHOLD:
-		assert (t != nullptr);
-		return t->getThreshold();
-	case GAMMA:
-		assert (t != nullptr);
-		return t->getGamma();
-	case BLACKLEVEL:
-		assert (t != nullptr);
-		return t->getBlacklevel();
-	case WHITELEVEL:
-		assert (t != nullptr);
-		return t->getWhitelevel();
-	default:
-		assert(false);
-	}
-
-	return 999.0;
-}
-
 QList<int> Hyperion::getActivePriorities() const
 {
 	return _muxer.getPriorities();
@@ -458,14 +465,9 @@ void Hyperion::update()
 	const PriorityMuxer::InputInfo & priorityInfo  = _muxer.getInputInfo(priority);
 
 	// Apply the transform to each led and color-channel
-	std::vector<ColorRgb> ledColors(priorityInfo.ledColors);
+	std::vector<ColorRgb> ledColors = _raw2ledTransform->applyTransform(priorityInfo.ledColors);
 	for (ColorRgb& color : ledColors)
 	{
-		_hsvTransform->transform(color.red, color.green, color.blue);
-		color.red   = _redTransform->transform(color.red);
-		color.green = _greenTransform->transform(color.green);
-		color.blue  = _blueTransform->transform(color.blue);
-
 		// correct the color byte order
 		switch (_colorOrder)
 		{

libsrc/hyperion/ImageProcessor.cpp

@@ -4,8 +4,6 @@
 #include <hyperion/ImageToLedsMap.h>
 #include <hyperion/BlackBorderProcessor.h>
 
-#include <utils/ColorTransform.h>
-
 using namespace hyperion;
 
 ImageProcessor::ImageProcessor(const LedString& ledString, bool enableBlackBorderDetector) :

libsrc/hyperion/MultiColorTransform.cpp

@@ -0,0 +1,97 @@
+
+// STL includes
+#include <cassert>
+
+// Hyperion includes
+#include "MultiColorTransform.h"
+
+MultiColorTransform::MultiColorTransform(const unsigned ledCnt) :
+	_ledTransforms(ledCnt, nullptr)
+{
+}
+
+MultiColorTransform::~MultiColorTransform()
+{
+	// Clean up all the transforms
+	for (ColorTransform * transform : _transform)
+	{
+		delete transform;
+	}
+}
+
+void MultiColorTransform::addTransform(ColorTransform * transform)
+{
+	_transformIds.push_back(transform->_id);
+	_transform.push_back(transform);
+}
+
+void MultiColorTransform::setTransformForLed(const std::string& id, const unsigned startLed, const unsigned endLed)
+{
+	assert(startLed <= endLed);
+	assert(endLed < _ledTransforms.size());
+
+	// Get the identified transform (don't care if is nullptr)
+	ColorTransform * transform = getTransform(id);
+	for (unsigned iLed=startLed; iLed<=endLed; ++iLed)
+	{
+		_ledTransforms[iLed] = transform;
+	}
+}
+
+bool MultiColorTransform::verifyTransforms() const
+{
+	bool allLedsSet = true;
+	for (unsigned iLed=0; iLed<_ledTransforms.size(); ++iLed)
+	{
+		if (_ledTransforms[iLed] == nullptr)
+		{
+			std::cerr << "No transform set for " << iLed << std::endl;
+			allLedsSet = false;
+		}
+	}
+	return allLedsSet;
+}
+
+const std::vector<std::string> & MultiColorTransform::getTransformIds()
+{
+	return _transformIds;
+}
+
+ColorTransform* MultiColorTransform::getTransform(const std::string& id)
+{
+	// Iterate through the unique transforms until we find the one with the given id
+	for (ColorTransform* transform : _transform)
+	{
+		if (transform->_id == id)
+		{
+			return transform;
+		}
+	}
+
+	// The ColorTransform was not found
+	return nullptr;
+}
+
+std::vector<ColorRgb> MultiColorTransform::applyTransform(const std::vector<ColorRgb>& rawColors)
+{
+	// Create a copy, as we will do the rest of the transformation in place
+	std::vector<ColorRgb> ledColors(rawColors);
+
+	const size_t itCnt = std::min(_ledTransforms.size(), rawColors.size());
+	for (size_t i=0; i<itCnt; ++i)
+	{
+		ColorTransform* transform = _ledTransforms[i];
+		if (transform == nullptr)
+		{
+			// No transform set for this led (do nothing)
+			continue;
+		}
+		ColorRgb& color = ledColors[i];
+
+		transform->_hsvTransform.transform(color.red, color.green, color.blue);
+		color.red   = transform->_rgbRedTransform.transform(color.red);
+		color.green = transform->_rgbGreenTransform.transform(color.green);
+		color.blue  = transform->_rgbBlueTransform.transform(color.blue);
+	}
+	return ledColors;
+}

libsrc/hyperion/MultiColorTransform.h

@@ -0,0 +1,66 @@
+#pragma once
+
+// STL includes
+#include <vector>
+
+// Utils includes
+#include <utils/ColorRgb.h>
+
+// Hyperion includes
+#include <hyperion/ColorTransform.h>
+
+///
+/// The LedColorTransform is responsible for performing color transformation from 'raw' colors
+/// received as input to colors mapped to match the color-properties of the leds.
+///
+class MultiColorTransform
+{
+public:
+	MultiColorTransform(const unsigned ledCnt);
+	~MultiColorTransform();
+
+	/**
+	 * Adds a new ColorTransform to this MultiColorTransform
+	 *
+	 * @param transform The new ColorTransform (ownership is transfered)
+	 */
+	void addTransform(ColorTransform * transform);
+
+	void setTransformForLed(const std::string& id, const unsigned startLed, const unsigned endLed);
+
+	bool verifyTransforms() const;
+
+	///
+	/// Returns the identifier of all the unique ColorTransform
+	///
+	/// @return The list with unique id's of the ColorTransforms
+	const std::vector<std::string> & getTransformIds();
+
+	///
+	/// Returns the pointer to the ColorTransform with the given id
+	///
+	/// @param id The identifier of the ColorTransform
+	///
+	/// @return The ColorTransform with the given id (or nullptr if it does not exist)
+	///
+	ColorTransform* getTransform(const std::string& id);
+
+	///
+	/// Performs the color transoformation from raw-color to led-color
+	///
+	/// @param rawColors The list with raw colors
+	///
+	/// @return The list with led-colors
+	///
+	std::vector<ColorRgb> applyTransform(const std::vector<ColorRgb>& rawColors);
+
+private:
+	/// List with transform ids
+	std::vector<std::string> _transformIds;
+
+	/// List with unique ColorTransforms
+	std::vector<ColorTransform*> _transform;
+
+	/// List with a pointer to the ColorTransform for each individual led
+	std::vector<ColorTransform*> _ledTransforms;
+};